1 /*
2 * Copyright (c) 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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioManagerListenerStubImpl"
17 #endif
18
19 #include "audio_errors.h"
20 #include "audio_manager_listener_stub_impl.h"
21 #include "audio_service_log.h"
22
23 using namespace std;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 namespace {
28 constexpr int32_t MAX_REGISTER_COUNT = 10;
29 }
30
SetParameterCallback(const std::weak_ptr<AudioParameterCallback> & callback)31 void AudioManagerListenerStubImpl::SetParameterCallback(const std::weak_ptr<AudioParameterCallback>& callback)
32 {
33 callback_ = callback;
34 }
35
SetWakeupSourceCallback(const std::weak_ptr<WakeUpSourceCallback> & callback)36 void AudioManagerListenerStubImpl::SetWakeupSourceCallback(const std::weak_ptr<WakeUpSourceCallback>& callback)
37 {
38 wakeUpCallback_ = callback;
39 }
40
OnAudioParameterChange(const std::string & networkId,int32_t key,const std::string & condition,const std::string & value)41 int32_t AudioManagerListenerStubImpl::OnAudioParameterChange(const std::string &networkId, int32_t key,
42 const std::string& condition, const std::string& value)
43 {
44 std::shared_ptr<AudioParameterCallback> cb = callback_.lock();
45 if (cb != nullptr) {
46 cb->OnAudioParameterChange(networkId, static_cast<AudioParamKey>(key), condition, value);
47 } else {
48 AUDIO_WARNING_LOG("AudioRingerModeUpdateListenerStub: callback_ is nullptr");
49 }
50 return SUCCESS;
51 }
52
OnCapturerState(bool isActive)53 int32_t AudioManagerListenerStubImpl::OnCapturerState(bool isActive)
54 {
55 std::shared_ptr<WakeUpSourceCallback> cb = wakeUpCallback_.lock();
56 if (cb != nullptr) {
57 cb->OnCapturerState(isActive);
58 } else {
59 AUDIO_WARNING_LOG("OnCapturerState error");
60 }
61 return SUCCESS;
62 }
63
OnWakeupClose()64 int32_t AudioManagerListenerStubImpl::OnWakeupClose()
65 {
66 std::shared_ptr<WakeUpSourceCallback> cb = wakeUpCallback_.lock();
67 if (cb != nullptr) {
68 cb->OnWakeupClose();
69 } else {
70 AUDIO_WARNING_LOG("OnWakeupClose error");
71 }
72 return SUCCESS;
73 }
74
OnDataTransferStateChange(int32_t callbackId,const AudioRendererDataTransferStateChangeInfo & info)75 int32_t AudioManagerListenerStubImpl::OnDataTransferStateChange(int32_t callbackId,
76 const AudioRendererDataTransferStateChangeInfo &info)
77 {
78 std::shared_ptr<AudioRendererDataTransferStateChangeCallback> callback = nullptr;
79 std::unique_lock<std::mutex> lock(stateChangeMutex_);
80 if (stateChangeCallbackMap_.count(callbackId) > 0) {
81 callback = stateChangeCallbackMap_[callbackId].second;
82 }
83 lock.unlock();
84 if (callback) {
85 callback->OnDataTransferStateChange(info);
86 }
87 return SUCCESS;
88 }
89
OnMuteStateChange(int32_t callbackId,int32_t uid,uint32_t sessionId,bool isMuted)90 int32_t AudioManagerListenerStubImpl::OnMuteStateChange(int32_t callbackId, int32_t uid,
91 uint32_t sessionId, bool isMuted)
92 {
93 std::shared_ptr<AudioRendererDataTransferStateChangeCallback> callback = nullptr;
94 std::unique_lock<std::mutex> lock(stateChangeMutex_);
95 auto it = stateChangeCallbackMap_.find(callbackId);
96 CHECK_AND_RETURN_RET(it != stateChangeCallbackMap_.end(), SUCCESS);
97 callback = stateChangeCallbackMap_[callbackId].second;
98 lock.unlock();
99 CHECK_AND_RETURN_RET(callback != nullptr, SUCCESS);
100 callback->OnMuteStateChange(uid, sessionId, isMuted);
101
102 return SUCCESS;
103 }
104
AddDataTransferStateChangeCallback(const DataTransferMonitorParam & param,std::shared_ptr<AudioRendererDataTransferStateChangeCallback> cb)105 int32_t AudioManagerListenerStubImpl::AddDataTransferStateChangeCallback(const DataTransferMonitorParam ¶m,
106 std::shared_ptr<AudioRendererDataTransferStateChangeCallback> cb)
107 {
108 std::lock_guard<std::mutex> lock(stateChangeMutex_);
109 if (stateChangeCallbackMap_.size() >= MAX_REGISTER_COUNT) {
110 return -1;
111 }
112
113 for (auto it = stateChangeCallbackMap_.begin(); it != stateChangeCallbackMap_.end(); ++it) {
114 if (it->second.first == param && it->second.second == cb) {
115 return it->first;
116 }
117 }
118
119 ++callbackId_;
120 stateChangeCallbackMap_[callbackId_] = std::make_pair(param, cb);
121 return callbackId_;
122 }
123
RemoveDataTransferStateChangeCallback(std::shared_ptr<AudioRendererDataTransferStateChangeCallback> cb)124 std::vector<int32_t> AudioManagerListenerStubImpl::RemoveDataTransferStateChangeCallback(
125 std::shared_ptr<AudioRendererDataTransferStateChangeCallback> cb)
126 {
127 std::lock_guard<std::mutex> lock(stateChangeMutex_);
128 std::vector<int32_t> callbackIds;
129 for (auto it = stateChangeCallbackMap_.begin(); it != stateChangeCallbackMap_.end();) {
130 if (it->second.second == cb) {
131 callbackIds.push_back(it->first);
132 it = stateChangeCallbackMap_.erase(it);
133 } else {
134 ++it;
135 }
136 }
137
138 return callbackIds;
139 }
140
141 } // namespace AudioStandard
142 } // namespace OHOS
143