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