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