1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #undef LOG_TAG
16 #define LOG_TAG "AudioSession"
17
18 #include "audio_session.h"
19
20 #include "audio_log.h"
21 #include "audio_errors.h"
22
23 namespace OHOS {
24 namespace AudioStandard {
AudioSession(const int32_t callerPid,const AudioSessionStrategy & strategy,const std::shared_ptr<AudioSessionTimer> sessionTimer)25 AudioSession::AudioSession(const int32_t callerPid, const AudioSessionStrategy &strategy,
26 const std::shared_ptr<AudioSessionTimer> sessionTimer)
27 {
28 AUDIO_INFO_LOG("AudioSession()");
29 callerPid_ = callerPid;
30 strategy_ = strategy;
31 sessionTimer_ = sessionTimer;
32 state_ = AudioSessionState::SESSION_NEW;
33 }
34
~AudioSession()35 AudioSession::~AudioSession()
36 {
37 AUDIO_ERR_LOG("~AudioSession()");
38 }
39
Activate()40 int32_t AudioSession::Activate()
41 {
42 std::lock_guard<std::mutex> lock(sessionMutex_);
43 state_ = AudioSessionState::SESSION_ACTIVE;
44 AUDIO_INFO_LOG("Audio session state change: pid %{public}d, state %{public}d",
45 callerPid_, static_cast<int32_t>(state_));
46 return SUCCESS;
47 }
48
Deactivate()49 int32_t AudioSession::Deactivate()
50 {
51 std::lock_guard<std::mutex> lock(sessionMutex_);
52 state_ = AudioSessionState::SESSION_DEACTIVE;
53 interruptMap_.clear();
54 AUDIO_INFO_LOG("Audio session state change: pid %{public}d, state %{public}d",
55 callerPid_, static_cast<int32_t>(state_));
56 return SUCCESS;
57 }
58
GetSessionState()59 AudioSessionState AudioSession::GetSessionState()
60 {
61 std::lock_guard<std::mutex> lock(sessionMutex_);
62 AUDIO_INFO_LOG("pid %{public}d, state %{public}d", callerPid_, static_cast<int32_t>(state_));
63 return state_;
64 }
65
SetSessionStrategy(const AudioSessionStrategy strategy)66 void AudioSession::SetSessionStrategy(const AudioSessionStrategy strategy)
67 {
68 std::lock_guard<std::mutex> lock(sessionMutex_);
69 strategy_ = strategy;
70 }
71
GetSessionStrategy()72 AudioSessionStrategy AudioSession::GetSessionStrategy()
73 {
74 std::lock_guard<std::mutex> lock(sessionMutex_);
75 AUDIO_INFO_LOG("GetSessionStrategy: pid %{public}d, strategy_.concurrencyMode %{public}d",
76 callerPid_, static_cast<int32_t>(strategy_.concurrencyMode));
77 return strategy_;
78 }
79
AddAudioInterrpt(const std::pair<AudioInterrupt,AudioFocuState> interruptPair)80 int32_t AudioSession::AddAudioInterrpt(const std::pair<AudioInterrupt, AudioFocuState> interruptPair)
81 {
82 uint32_t streamId = interruptPair.first.sessionId;
83 AUDIO_INFO_LOG("AddAudioInterrpt: streamId %{public}u", streamId);
84
85 std::lock_guard<std::mutex> lock(sessionMutex_);
86 if (interruptMap_.count(streamId) != 0) {
87 AUDIO_WARNING_LOG("The streamId has been added. The old interrupt will be coverd.");
88 }
89 interruptMap_[streamId] = interruptPair;
90 if (sessionTimer_ != nullptr && sessionTimer_->IsSessionTimerRunning(callerPid_)) {
91 sessionTimer_->StopTimer(callerPid_);
92 }
93 return SUCCESS;
94 }
95
RemoveAudioInterrpt(const std::pair<AudioInterrupt,AudioFocuState> interruptPair)96 int32_t AudioSession::RemoveAudioInterrpt(const std::pair<AudioInterrupt, AudioFocuState> interruptPair)
97 {
98 uint32_t streamId = interruptPair.first.sessionId;
99 AUDIO_INFO_LOG("RemoveAudioInterrpt: streamId %{public}u", streamId);
100
101 std::lock_guard<std::mutex> lock(sessionMutex_);
102 if (interruptMap_.count(streamId) == 0) {
103 AUDIO_WARNING_LOG("The streamId has been removed.");
104 return SUCCESS;
105 }
106 interruptMap_.erase(streamId);
107 if (interruptMap_.empty() && sessionTimer_ != nullptr && !sessionTimer_->IsSessionTimerRunning(callerPid_)) {
108 sessionTimer_->StartTimer(callerPid_);
109 }
110 return SUCCESS;
111 }
112
RemoveAudioInterrptByStreamId(const uint32_t & streamId)113 int32_t AudioSession::RemoveAudioInterrptByStreamId(const uint32_t &streamId)
114 {
115 AUDIO_INFO_LOG("RemoveAudioInterrptByStreamId: streamId %{public}u", streamId);
116
117 std::lock_guard<std::mutex> lock(sessionMutex_);
118 if (interruptMap_.count(streamId) == 0) {
119 AUDIO_WARNING_LOG("The streamId has been removed.");
120 return SUCCESS;
121 }
122 interruptMap_.erase(streamId);
123 if (interruptMap_.empty() && sessionTimer_ != nullptr && !sessionTimer_->IsSessionTimerRunning(callerPid_)) {
124 sessionTimer_->StartTimer(callerPid_);
125 }
126 return SUCCESS;
127 }
128
IsAudioSessionEmpty()129 bool AudioSession::IsAudioSessionEmpty()
130 {
131 std::lock_guard<std::mutex> lock(sessionMutex_);
132 return interruptMap_.size() == 0;
133 }
134
IsAudioRendererEmpty()135 bool AudioSession::IsAudioRendererEmpty()
136 {
137 std::lock_guard<std::mutex> lock(sessionMutex_);
138 for (const auto &iter : interruptMap_) {
139 if (iter.second.first.audioFocusType.streamType != STREAM_DEFAULT) {
140 return false;
141 }
142 }
143 return true;
144 }
145 } // namespace AudioStandard
146 } // namespace OHOS
147