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_policy_log.h"
21 #include "audio_errors.h"
22 #include "audio_session_state_monitor.h"
23
24 namespace OHOS {
25 namespace AudioStandard {
AudioSession(const int32_t callerPid,const AudioSessionStrategy & strategy,const std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor)26 AudioSession::AudioSession(const int32_t callerPid, const AudioSessionStrategy &strategy,
27 const std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor)
28 {
29 AUDIO_INFO_LOG("AudioSession()");
30 callerPid_ = callerPid;
31 strategy_ = strategy;
32 audioSessionStateMonitor_ = audioSessionStateMonitor;
33 state_ = AudioSessionState::SESSION_NEW;
34 }
35
~AudioSession()36 AudioSession::~AudioSession()
37 {
38 AUDIO_ERR_LOG("~AudioSession()");
39 }
40
Activate()41 int32_t AudioSession::Activate()
42 {
43 std::lock_guard<std::mutex> lock(sessionMutex_);
44 state_ = AudioSessionState::SESSION_ACTIVE;
45 AUDIO_INFO_LOG("Audio session state change: pid %{public}d, state %{public}d",
46 callerPid_, static_cast<int32_t>(state_));
47 return SUCCESS;
48 }
49
Deactivate()50 int32_t AudioSession::Deactivate()
51 {
52 std::lock_guard<std::mutex> lock(sessionMutex_);
53 state_ = AudioSessionState::SESSION_DEACTIVE;
54 interruptMap_.clear();
55 AUDIO_INFO_LOG("Audio session state change: pid %{public}d, state %{public}d",
56 callerPid_, static_cast<int32_t>(state_));
57 return SUCCESS;
58 }
59
GetSessionState()60 AudioSessionState AudioSession::GetSessionState()
61 {
62 std::lock_guard<std::mutex> lock(sessionMutex_);
63 AUDIO_INFO_LOG("pid %{public}d, state %{public}d", callerPid_, static_cast<int32_t>(state_));
64 return state_;
65 }
66
SetSessionStrategy(const AudioSessionStrategy strategy)67 void AudioSession::SetSessionStrategy(const AudioSessionStrategy strategy)
68 {
69 std::lock_guard<std::mutex> lock(sessionMutex_);
70 strategy_ = strategy;
71 }
72
GetSessionStrategy()73 AudioSessionStrategy AudioSession::GetSessionStrategy()
74 {
75 std::lock_guard<std::mutex> lock(sessionMutex_);
76 AUDIO_INFO_LOG("GetSessionStrategy: pid %{public}d, strategy_.concurrencyMode %{public}d",
77 callerPid_, static_cast<int32_t>(strategy_.concurrencyMode));
78 return strategy_;
79 }
80
AddAudioInterrpt(const std::pair<AudioInterrupt,AudioFocuState> interruptPair)81 int32_t AudioSession::AddAudioInterrpt(const std::pair<AudioInterrupt, AudioFocuState> interruptPair)
82 {
83 uint32_t streamId = interruptPair.first.streamId;
84 AUDIO_INFO_LOG("AddAudioInterrpt: streamId %{public}u", streamId);
85
86 std::lock_guard<std::mutex> lock(sessionMutex_);
87 if (interruptMap_.count(streamId) != 0) {
88 AUDIO_WARNING_LOG("The streamId has been added. The old interrupt will be coverd.");
89 }
90 interruptMap_[streamId] = interruptPair;
91 auto monitor = audioSessionStateMonitor_.lock();
92 if (monitor != nullptr) {
93 monitor->StopMonitor(callerPid_);
94 }
95 return SUCCESS;
96 }
97
RemoveAudioInterrpt(const std::pair<AudioInterrupt,AudioFocuState> interruptPair)98 int32_t AudioSession::RemoveAudioInterrpt(const std::pair<AudioInterrupt, AudioFocuState> interruptPair)
99 {
100 uint32_t streamId = interruptPair.first.streamId;
101 AUDIO_INFO_LOG("RemoveAudioInterrpt: streamId %{public}u", streamId);
102
103 std::lock_guard<std::mutex> lock(sessionMutex_);
104 if (interruptMap_.count(streamId) == 0) {
105 AUDIO_WARNING_LOG("The streamId has been removed.");
106 return SUCCESS;
107 }
108 interruptMap_.erase(streamId);
109
110 auto monitor = audioSessionStateMonitor_.lock();
111 if (interruptMap_.empty() && monitor != nullptr) {
112 monitor->StartMonitor(callerPid_);
113 }
114 return SUCCESS;
115 }
116
RemoveAudioInterrptByStreamId(const uint32_t & streamId)117 int32_t AudioSession::RemoveAudioInterrptByStreamId(const uint32_t &streamId)
118 {
119 AUDIO_INFO_LOG("RemoveAudioInterrptByStreamId: streamId %{public}u", streamId);
120
121 std::lock_guard<std::mutex> lock(sessionMutex_);
122 if (interruptMap_.count(streamId) == 0) {
123 AUDIO_WARNING_LOG("The streamId has been removed.");
124 return SUCCESS;
125 }
126 interruptMap_.erase(streamId);
127
128 auto monitor = audioSessionStateMonitor_.lock();
129 if (interruptMap_.empty() && monitor != nullptr) {
130 monitor->StartMonitor(callerPid_);
131 }
132
133 return SUCCESS;
134 }
135
IsAudioSessionEmpty()136 bool AudioSession::IsAudioSessionEmpty()
137 {
138 std::lock_guard<std::mutex> lock(sessionMutex_);
139 return interruptMap_.size() == 0;
140 }
141
IsAudioRendererEmpty()142 bool AudioSession::IsAudioRendererEmpty()
143 {
144 std::lock_guard<std::mutex> lock(sessionMutex_);
145 for (const auto &iter : interruptMap_) {
146 if (iter.second.first.audioFocusType.streamType != STREAM_DEFAULT) {
147 return false;
148 }
149 }
150 return true;
151 }
152 } // namespace AudioStandard
153 } // namespace OHOS
154