1 /*
2 * Copyright (c) 2025-2025 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 "AudioSessionStateMonitor"
17
18 #include "audio_session_state_monitor.h"
19 #include "audio_policy_state_monitor.h"
20 #include "audio_policy_log.h"
21
22 namespace OHOS {
23 namespace AudioStandard {
24 constexpr time_t AUDIO_SESSION_TIME_OUT_DURATION_S = 60; // Audio session timeout duration : 60 seconds
25
26 class AudioSessionStateMonitorCallback : public AudioPolicyStateMonitorCallback {
27 public:
AudioSessionStateMonitorCallback(int32_t pid,const std::shared_ptr<AudioSessionStateMonitor> & stateMonitor)28 AudioSessionStateMonitorCallback(int32_t pid, const std::shared_ptr<AudioSessionStateMonitor> &stateMonitor)
29 : pid(pid), stateMonitor_(stateMonitor)
30 {}
31
OnTimeOut()32 void OnTimeOut() override
33 {
34 auto monitor = stateMonitor_.lock();
35 if (monitor == nullptr) {
36 AUDIO_ERR_LOG("stateMonitor_ is nullptr");
37 return;
38 }
39 monitor->OnAudioSessionTimeOut(pid);
40 monitor->RemoveFromMonitorMap(pid);
41 }
42
43 private:
44 int32_t pid;
45 std::weak_ptr<AudioSessionStateMonitor> stateMonitor_;
46 };
47
StartMonitor(int32_t pid)48 void AudioSessionStateMonitor::StartMonitor(int32_t pid)
49 {
50 std::unique_lock<std::mutex> lock(sessionMonitorMutex_);
51 if (pidCbIdMap_.count(pid) > 0) {
52 AUDIO_INFO_LOG("pid %{public}d monitor is already running", pid);
53 return;
54 }
55 lock.unlock();
56
57 auto cb = std::make_shared<AudioSessionStateMonitorCallback>(pid, GetSelfSharedPtr());
58 int32_t cbId = DelayedSingleton<AudioPolicyStateMonitor>::GetInstance()->RegisterCallback(
59 cb, AUDIO_SESSION_TIME_OUT_DURATION_S, CallbackType::ONE_TIME);
60 if (cbId == INVALID_CB_ID) {
61 AUDIO_ERR_LOG("Register AudioSessionStateMonitorCallback failed.");
62 } else {
63 std::unique_lock<std::mutex> lock(sessionMonitorMutex_);
64 pidCbIdMap_[pid] = cbId;
65 }
66 }
67
RemoveFromMonitorMap(int32_t pid)68 void AudioSessionStateMonitor::RemoveFromMonitorMap(int32_t pid)
69 {
70 std::unique_lock<std::mutex> lock(sessionMonitorMutex_);
71 if (pidCbIdMap_.count(pid) == 0) {
72 AUDIO_INFO_LOG("Can't not find pid %{public}d from monitor map", pid);
73 return;
74 }
75
76 pidCbIdMap_.erase(pid);
77 }
78
StopMonitor(int32_t pid)79 void AudioSessionStateMonitor::StopMonitor(int32_t pid)
80 {
81 std::unique_lock<std::mutex> lock(sessionMonitorMutex_);
82 if (pidCbIdMap_.count(pid) == 0) {
83 AUDIO_INFO_LOG("pid %{public}d monitor has stopped running", pid);
84 return;
85 }
86
87 int32_t cbId = pidCbIdMap_[pid];
88 pidCbIdMap_.erase(pid);
89 lock.unlock();
90
91 DelayedSingleton<AudioPolicyStateMonitor>::GetInstance()->UnRegisterCallback(cbId);
92 }
93
94 } // namespace AudioStandard
95 } // namespace OHOS
96