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_source_handler.h"
17
18 #include "if_system_ability_manager.h"
19 #include "iservice_registry.h"
20
21 #include "daudio_constants.h"
22 #include "daudio_errorcode.h"
23 #include "daudio_hdf_operate.h"
24 #include "daudio_hisysevent.h"
25 #include "daudio_hitrace.h"
26 #include "daudio_log.h"
27 #include "daudio_radar.h"
28 #include "daudio_util.h"
29 #include "daudio_source_load_callback.h"
30
31 #undef DH_LOG_TAG
32 #define DH_LOG_TAG "DAudioSourceHandler"
33
34 namespace OHOS {
35 namespace DistributedHardware {
36 IMPLEMENT_SINGLE_INSTANCE(DAudioSourceHandler);
DAudioSourceHandler()37 DAudioSourceHandler::DAudioSourceHandler()
38 {
39 DHLOGD("Audio source handler constructed.");
40 if (!sourceSvrRecipient_) {
41 sourceSvrRecipient_ = sptr<DAudioSourceSvrRecipient>(new DAudioSourceSvrRecipient());
42 }
43
44 if (!dAudioIpcCallback_) {
45 dAudioIpcCallback_ = sptr<DAudioIpcCallback>(new DAudioIpcCallback());
46 }
47 }
48
~DAudioSourceHandler()49 DAudioSourceHandler::~DAudioSourceHandler()
50 {
51 DHLOGD("Audio source handler destructed.");
52 }
53
InitSource(const std::string & params)54 int32_t DAudioSourceHandler::InitSource(const std::string ¶ms)
55 {
56 DHLOGI("Init source handler.");
57 if (dAudioSourceProxy_ == nullptr) {
58 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
59 CHECK_NULL_RETURN(samgr, ERR_DH_AUDIO_NULLPTR);
60 sptr<DAudioSourceLoadCallback> loadCallback = sptr<DAudioSourceLoadCallback>(
61 new DAudioSourceLoadCallback(params));
62 int32_t ret = samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, loadCallback);
63 DaudioRadar::GetInstance().ReportDaudioInit("LoadSystemAbility", AudioInit::SERVICE_INIT,
64 BizState::BIZ_STATE_START, ret);
65 if (ret != ERR_OK) {
66 DHLOGE("Failed to Load systemAbility, ret code: %{public}d", ret);
67 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL,
68 DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, ERR_DH_AUDIO_SA_LOAD_FAILED,
69 "daudio source LoadSystemAbility call failed.");
70 return ERR_DH_AUDIO_SA_LOAD_FAILED;
71 }
72 }
73
74 std::unique_lock<std::mutex> lock(sourceProxyMutex_);
75 auto waitStatus = sourceProxyConVar_.wait_for(lock, std::chrono::milliseconds(AUDIO_LOADSA_TIMEOUT_MS),
76 [this]() { return dAudioSourceProxy_ != nullptr; });
77 if (!waitStatus) {
78 DHLOGE("Load audio SA timeout.");
79 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL, DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID,
80 ERR_DH_AUDIO_SA_LOAD_FAILED, "daudio source sa load timeout.");
81 return ERR_DH_AUDIO_SA_LOAD_FAILED;
82 }
83 return DH_SUCCESS;
84 }
85
ReleaseSource()86 int32_t DAudioSourceHandler::ReleaseSource()
87 {
88 DHLOGI("Release source handler.");
89 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
90 if (dAudioSourceProxy_ == nullptr) {
91 DHLOGE("Daudio source proxy not init.");
92 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL, DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID,
93 ERR_DH_AUDIO_SA_PROXY_NOT_INIT, "daudio source proxy not init.");
94 return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
95 }
96
97 int32_t ret = dAudioSourceProxy_->ReleaseSource();
98 dAudioSourceProxy_ = nullptr;
99 return ret;
100 }
101
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const EnableParam & param,std::shared_ptr<RegisterCallback> callback)102 int32_t DAudioSourceHandler::RegisterDistributedHardware(const std::string &devId, const std::string &dhId,
103 const EnableParam ¶m, std::shared_ptr<RegisterCallback> callback)
104 {
105 DHLOGI("Register distributed hardware, devId: %{public}s, dhId: %{public}s.",
106 GetAnonyString(devId).c_str(), dhId.c_str());
107 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
108 CHECK_NULL_RETURN(dAudioSourceProxy_, ERR_DH_AUDIO_SA_PROXY_NOT_INIT);
109 CHECK_NULL_RETURN(dAudioIpcCallback_, ERR_DH_AUDIO_NULLPTR);
110 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
111 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
112 }
113
114 std::string reqId = GetRandomID();
115 dAudioIpcCallback_->PushRegisterCallback(reqId, callback);
116 std::string reduceDhId = dhId;
117 return dAudioSourceProxy_->RegisterDistributedHardware(devId, reduceDhId, param, reqId);
118 }
119
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,std::shared_ptr<UnregisterCallback> callback)120 int32_t DAudioSourceHandler::UnregisterDistributedHardware(const std::string &devId, const std::string &dhId,
121 std::shared_ptr<UnregisterCallback> callback)
122 {
123 DHLOGI("Unregister distributed hardware, devId: %{public}s, dhId: %{public}s.",
124 GetAnonyString(devId).c_str(), dhId.c_str());
125 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
126 CHECK_NULL_RETURN(dAudioSourceProxy_, ERR_DH_AUDIO_SA_PROXY_NOT_INIT);
127 CHECK_NULL_RETURN(dAudioIpcCallback_, ERR_DH_AUDIO_NULLPTR);
128 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
129 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
130 }
131
132 std::string reqId = GetRandomID();
133 dAudioIpcCallback_->PushUnregisterCallback(reqId, callback);
134 std::string reduceDhId = dhId;
135 return dAudioSourceProxy_->UnregisterDistributedHardware(devId, reduceDhId, reqId);
136 }
137
ConfigDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & key,const std::string & value)138 int32_t DAudioSourceHandler::ConfigDistributedHardware(const std::string &devId, const std::string &dhId,
139 const std::string &key, const std::string &value)
140 {
141 DHLOGI("Config distributed hardware, devId: %{public}s, dhId: %{public}s.",
142 GetAnonyString(devId).c_str(), dhId.c_str());
143 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
144 CHECK_NULL_RETURN(dAudioSourceProxy_, ERR_DH_AUDIO_SA_PROXY_NOT_INIT);
145 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
146 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
147 }
148 std::string reduceDhId = dhId;
149 return dAudioSourceProxy_->ConfigDistributedHardware(devId, reduceDhId, key, value);
150 }
151
RegisterDistributedHardwareStateListener(std::shared_ptr<DistributedHardwareStateListener> listener)152 void DAudioSourceHandler::RegisterDistributedHardwareStateListener(
153 std::shared_ptr<DistributedHardwareStateListener> listener)
154 {
155 CHECK_AND_RETURN_LOG(dAudioIpcCallback_ == nullptr, "%{public}s", "ipc callback is null.");
156 dAudioIpcCallback_->RegisterStateListener(listener);
157 }
158
UnregisterDistributedHardwareStateListener()159 void DAudioSourceHandler::UnregisterDistributedHardwareStateListener()
160 {
161 CHECK_AND_RETURN_LOG(dAudioIpcCallback_ == nullptr, "%{public}s", "ipc callback is null.");
162 dAudioIpcCallback_->UnRegisterStateListener();
163 }
164
RegisterDataSyncTriggerListener(std::shared_ptr<DataSyncTriggerListener> listener)165 void DAudioSourceHandler::RegisterDataSyncTriggerListener(std::shared_ptr<DataSyncTriggerListener> listener)
166 {
167 CHECK_AND_RETURN_LOG(dAudioIpcCallback_ == nullptr, "%{public}s", "ipc callback is null.");
168 dAudioIpcCallback_->RegisterTriggerListener(listener);
169 }
170
UnregisterDataSyncTriggerListener()171 void DAudioSourceHandler::UnregisterDataSyncTriggerListener()
172 {
173 CHECK_AND_RETURN_LOG(dAudioIpcCallback_ == nullptr, "%{public}s", "ipc callback is null.");
174 dAudioIpcCallback_->UnRegisterTriggerListener();
175 }
176
LoadDistributedHDF(std::shared_ptr<HdfDeathCallback> callback)177 int32_t DAudioSourceHandler::LoadDistributedHDF(std::shared_ptr<HdfDeathCallback> callback)
178 {
179 return DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(callback);
180 }
181
UnLoadDistributedHDF()182 int32_t DAudioSourceHandler::UnLoadDistributedHDF()
183 {
184 return DaudioHdfOperate::GetInstance().UnLoadDaudioHDFImpl();
185 }
186
OnRemoteSourceSvrDied(const wptr<IRemoteObject> & remote)187 void DAudioSourceHandler::OnRemoteSourceSvrDied(const wptr<IRemoteObject> &remote)
188 {
189 DHLOGI("The daudio source service died.");
190 sptr<IRemoteObject> remoteObject = remote.promote();
191 if (!remoteObject) {
192 DHLOGE("OnRemoteDied remote promoted failed");
193 return;
194 }
195 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
196 if ((dAudioSourceProxy_ != nullptr) && (dAudioSourceProxy_->AsObject() != nullptr)) {
197 dAudioSourceProxy_->AsObject()->RemoveDeathRecipient(sourceSvrRecipient_);
198 dAudioSourceProxy_ = nullptr;
199 }
200 }
201
FinishStartSA(const std::string & param,const sptr<IRemoteObject> & remoteObject)202 void DAudioSourceHandler::FinishStartSA(const std::string ¶m, const sptr<IRemoteObject> &remoteObject)
203 {
204 DHLOGI("Finish start SA.");
205 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
206 if (remoteObject != nullptr) {
207 remoteObject->AddDeathRecipient(sourceSvrRecipient_);
208 }
209 dAudioSourceProxy_ = iface_cast<IDAudioSource>(remoteObject);
210 if ((dAudioSourceProxy_ == nullptr) || (!dAudioSourceProxy_->AsObject())) {
211 DHLOGE("Failed to get daudio source proxy.");
212 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL, DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID,
213 ERR_DH_AUDIO_SA_PROXY_NOT_INIT, "daudio source get proxy failed.");
214 return;
215 }
216 DaudioRadar::GetInstance().ReportDaudioInitProgress("InitSource", AudioInit::SOURCE_AUDIO_INIT, DH_SUCCESS);
217 dAudioSourceProxy_->InitSource(param, dAudioIpcCallback_);
218 sourceProxyConVar_.notify_one();
219 DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_INIT, "daudio source sa load success.");
220 }
221
OnRemoteDied(const wptr<IRemoteObject> & remote)222 void DAudioSourceHandler::DAudioSourceSvrRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
223 {
224 DAudioSourceHandler::GetInstance().OnRemoteSourceSvrDied(remote);
225 }
226
GetSourceHardwareHandler()227 IDistributedHardwareSource *GetSourceHardwareHandler()
228 {
229 DHLOGI("Get source hardware handler.");
230 return &DAudioSourceHandler::GetInstance();
231 }
232 } // namespace DistributedHardware
233 } // namespace OHOS
234