1 /*
2 * Copyright (c) 2022-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
16 #include "daudio_ipc_callback.h"
17
18 #include "daudio_constants.h"
19 #include "daudio_errorcode.h"
20 #include "daudio_log.h"
21 #include "daudio_util.h"
22
23 #undef DH_LOG_TAG
24 #define DH_LOG_TAG "DAudioIpcCallback"
25
26 namespace OHOS {
27 namespace DistributedHardware {
28 namespace {
29 constexpr uint32_t DUAIO_IPC_CALLBACK_MAX_ALLOW_SIZE = 64;
30 }
31
OnNotifyRegResult(const std::string & devId,const std::string & dhId,const std::string & reqId,int32_t status,const std::string & resultData)32 int32_t DAudioIpcCallback::OnNotifyRegResult(const std::string &devId, const std::string &dhId,
33 const std::string &reqId, int32_t status, const std::string &resultData)
34 {
35 DHLOGI("On notify the registration result, devId: %{public}s, dhId: %{public}s, status: %{public}d, "
36 "resultData: %{public}s, reqId: %{public}s", GetAnonyString(devId).c_str(), dhId.c_str(),
37 status, resultData.c_str(), reqId.c_str());
38
39 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN ||
40 reqId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
41 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
42 }
43 std::lock_guard<std::mutex> registerLck(registerMapMtx_);
44 auto iter = registerCallbackMap_.find(reqId);
45 if (iter != registerCallbackMap_.end()) {
46 std::string reduceDhId = dhId;
47 if (iter->second != nullptr) {
48 iter->second->OnRegisterResult(devId, reduceDhId, status, resultData);
49 }
50 registerCallbackMap_.erase(reqId);
51 return DH_SUCCESS;
52 }
53
54 return ERR_DH_AUDIO_SA_REGISTERCALLBACK_NOT_FOUND;
55 }
56
OnNotifyUnregResult(const std::string & devId,const std::string & dhId,const std::string & reqId,int32_t status,const std::string & resultData)57 int32_t DAudioIpcCallback::OnNotifyUnregResult(const std::string &devId, const std::string &dhId,
58 const std::string &reqId, int32_t status, const std::string &resultData)
59 {
60 DHLOGI("On notify the unregistration result, devId: %{public}s, dhId: %{public}s, status: %{public}d, "
61 "resultData: %{public}s, reqId: %{public}s", GetAnonyString(devId).c_str(), dhId.c_str(),
62 status, resultData.c_str(), reqId.c_str());
63
64 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN ||
65 reqId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
66 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
67 }
68 std::lock_guard<std::mutex> registerLck(unregisterMapMtx_);
69 auto iter = unregisterCallbackMap_.find(reqId);
70 if (iter != unregisterCallbackMap_.end()) {
71 std::string reduceDhId = dhId;
72 if (iter->second != nullptr) {
73 iter->second->OnUnregisterResult(devId, reduceDhId, status, resultData);
74 }
75 unregisterCallbackMap_.erase(reqId);
76 return DH_SUCCESS;
77 }
78 return ERR_DH_AUDIO_SA_UNREGISTERCALLBACK_NOT_FOUND;
79 }
80
OnHardwareStateChanged(const std::string & devId,const std::string & dhId,int32_t status)81 int32_t DAudioIpcCallback::OnHardwareStateChanged(const std::string &devId, const std::string &dhId, int32_t status)
82 {
83 DHLOGI("On hardware state changed, devId: %{public}s, dhId: %{public}s, status: %{public}d",
84 GetAnonyString(devId).c_str(), dhId.c_str(), status);
85
86 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
87 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
88 }
89 std::lock_guard<std::mutex> stateLck(stateListenerMtx_);
90 if (stateListener_ == nullptr) {
91 DHLOGE("State listener is null.");
92 return ERR_DH_AUDIO_NULLPTR;
93 }
94 BusinessState currentState = static_cast<BusinessState>(status);
95 stateListener_->OnStateChanged(devId, dhId, currentState);
96 return DH_SUCCESS;
97 }
98
OnDataSyncTrigger(const std::string & devId)99 int32_t DAudioIpcCallback::OnDataSyncTrigger(const std::string &devId)
100 {
101 DHLOGI("On data sync trigger, devId: %{public}s", GetAnonyString(devId).c_str());
102
103 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
104 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
105 }
106 std::lock_guard<std::mutex> triggerLck(triggerListenerMtx_);
107 if (triggerListener_ == nullptr) {
108 DHLOGE("Trigger listener is null.");
109 return ERR_DH_AUDIO_NULLPTR;
110 }
111 triggerListener_->OnDataSyncTrigger(devId);
112 return DH_SUCCESS;
113 }
114
PushRegisterCallback(const std::string & reqId,const std::shared_ptr<RegisterCallback> & callback)115 void DAudioIpcCallback::PushRegisterCallback(const std::string &reqId,
116 const std::shared_ptr<RegisterCallback> &callback)
117 {
118 DHLOGD("Push register callback, reqId: %{public}s", reqId.c_str());
119 std::lock_guard<std::mutex> registerLck(registerMapMtx_);
120 if (registerCallbackMap_.size() >= DUAIO_IPC_CALLBACK_MAX_ALLOW_SIZE) {
121 DHLOGE("Callback map is full, not allow to insert anymore.");
122 return;
123 }
124 registerCallbackMap_.emplace(reqId, callback);
125 }
126
PopRegisterCallback(const std::string & reqId)127 void DAudioIpcCallback::PopRegisterCallback(const std::string &reqId)
128 {
129 DHLOGD("Pop register callback, reqId: %{public}s", reqId.c_str());
130 std::lock_guard<std::mutex> registerLck(registerMapMtx_);
131 registerCallbackMap_.erase(reqId);
132 }
133
PushUnregisterCallback(const std::string & reqId,const std::shared_ptr<UnregisterCallback> & callback)134 void DAudioIpcCallback::PushUnregisterCallback(const std::string &reqId,
135 const std::shared_ptr<UnregisterCallback> &callback)
136 {
137 DHLOGD("Push unregister callback, reqId: %{public}s", reqId.c_str());
138 std::lock_guard<std::mutex> registerLck(unregisterMapMtx_);
139 unregisterCallbackMap_.emplace(reqId, callback);
140 }
141
PopUnregisterCallback(const std::string & reqId)142 void DAudioIpcCallback::PopUnregisterCallback(const std::string &reqId)
143 {
144 DHLOGD("Pop unregister callback, reqId: %{public}s", reqId.c_str());
145 std::lock_guard<std::mutex> registerLck(unregisterMapMtx_);
146 unregisterCallbackMap_.erase(reqId);
147 }
148
RegisterStateListener(const std::shared_ptr<DistributedHardwareStateListener> & listener)149 void DAudioIpcCallback::RegisterStateListener(const std::shared_ptr<DistributedHardwareStateListener> &listener)
150 {
151 DHLOGD("Register state listener.");
152 std::lock_guard<std::mutex> stateLck(stateListenerMtx_);
153 stateListener_ = listener;
154 }
155
UnRegisterStateListener()156 void DAudioIpcCallback::UnRegisterStateListener()
157 {
158 DHLOGD("UnRegister state listener.");
159 std::lock_guard<std::mutex> stateLck(stateListenerMtx_);
160 stateListener_ = nullptr;
161 }
162
RegisterTriggerListener(const std::shared_ptr<DataSyncTriggerListener> & listener)163 void DAudioIpcCallback::RegisterTriggerListener(const std::shared_ptr<DataSyncTriggerListener> &listener)
164 {
165 DHLOGD("Register trigger listener.");
166 std::lock_guard<std::mutex> triggerLck(triggerListenerMtx_);
167 triggerListener_ = listener;
168 }
169
UnRegisterTriggerListener()170 void DAudioIpcCallback::UnRegisterTriggerListener()
171 {
172 DHLOGD("UnRegister trigger listener.");
173 std::lock_guard<std::mutex> triggerLck(triggerListenerMtx_);
174 triggerListener_ = nullptr;
175 }
176 } // DistributedHardware
177 } // OHOS