1 /*
2 * Copyright (c) 2022 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_hisysevent.h"
24 #include "daudio_hitrace.h"
25 #include "daudio_log.h"
26 #include "daudio_util.h"
27 #include "daudio_source_load_callback.h"
28
29 #undef DH_LOG_TAG
30 #define DH_LOG_TAG "DAudioSourceHandler"
31
32 namespace OHOS {
33 namespace DistributedHardware {
34 IMPLEMENT_SINGLE_INSTANCE(DAudioSourceHandler);
DAudioSourceHandler()35 DAudioSourceHandler::DAudioSourceHandler()
36 {
37 DHLOGD("Audio source handler constructed.");
38 if (!sourceSvrRecipient_) {
39 sourceSvrRecipient_ = new DAudioSourceSvrRecipient();
40 }
41
42 if (!dAudioIpcCallback_) {
43 dAudioIpcCallback_ = new DAudioIpcCallback();
44 }
45 }
46
~DAudioSourceHandler()47 DAudioSourceHandler::~DAudioSourceHandler()
48 {
49 DHLOGD("Audio source handler destructed.");
50 }
51
InitSource(const std::string & params)52 int32_t DAudioSourceHandler::InitSource(const std::string ¶ms)
53 {
54 DHLOGI("Init source handler.");
55 DAUDIO_SYNC_TRACE(DAUDIO_SOURCE_LOAD_SYSTEM_ABILITY);
56 if (dAudioSourceProxy_ == nullptr) {
57 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
58 if (samgr == nullptr) {
59 DHLOGE("Failed to get system ability mgr.");
60 return ERR_DH_AUDIO_SA_GET_SAMGR_FAILED;
61 }
62 sptr<DAudioSourceLoadCallback> loadCallback = new DAudioSourceLoadCallback(params);
63 int32_t ret = samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, loadCallback);
64 if (ret != ERR_OK) {
65 DHLOGE("Failed to Load systemAbility, ret code: %d", ret);
66 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL,
67 DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, ERR_DH_AUDIO_SA_LOAD_FAILED,
68 "daudio source LoadSystemAbility call failed.");
69 return ERR_DH_AUDIO_SA_LOAD_FAILED;
70 }
71 }
72
73 std::unique_lock<std::mutex> lock(sourceProxyMutex_);
74 auto waitStatus = sourceProxyConVar_.wait_for(lock, std::chrono::milliseconds(AUDIO_LOADSA_TIMEOUT_MS),
75 [this]() { return dAudioSourceProxy_ != nullptr; });
76 if (!waitStatus) {
77 DHLOGE("Load audio SA timeout.");
78 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL, DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID,
79 ERR_DH_AUDIO_SA_LOAD_TIMEOUT, "daudio source sa load timeout.");
80 return ERR_DH_AUDIO_SA_LOAD_TIMEOUT;
81 }
82 return DH_SUCCESS;
83 }
84
ReleaseSource()85 int32_t DAudioSourceHandler::ReleaseSource()
86 {
87 DHLOGI("Release source handler.");
88 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
89 if (dAudioSourceProxy_ == nullptr) {
90 DHLOGE("Daudio source proxy not init.");
91 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL, DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID,
92 ERR_DH_AUDIO_SA_PROXY_NOT_INIT, "daudio source proxy not init.");
93 return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
94 }
95
96 int32_t ret = dAudioSourceProxy_->ReleaseSource();
97 dAudioSourceProxy_ = nullptr;
98 return ret;
99 }
100
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const EnableParam & param,std::shared_ptr<RegisterCallback> callback)101 int32_t DAudioSourceHandler::RegisterDistributedHardware(const std::string &devId, const std::string &dhId,
102 const EnableParam ¶m, std::shared_ptr<RegisterCallback> callback)
103 {
104 DHLOGI("Register distributed hardware, devId: %s, dhId: %s.", GetAnonyString(devId).c_str(), dhId.c_str());
105 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
106 if (dAudioSourceProxy_ == nullptr) {
107 DHLOGE("Daudio source proxy not init.");
108 return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
109 }
110 if (dAudioIpcCallback_ == nullptr) {
111 DHLOGE("Daudio ipc callback is null.");
112 return ERR_DH_AUDIO_SA_IPCCALLBACK_NOT_INIT;
113 }
114 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
115 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
116 }
117
118 DaudioStartAsyncTrace(DAUDIO_REGISTER_AUDIO, DAUDIO_REGISTER_AUDIO_TASKID);
119 std::string reqId = GetRandomID();
120 dAudioIpcCallback_->PushRegisterCallback(reqId, callback);
121 return dAudioSourceProxy_->RegisterDistributedHardware(devId, dhId, param, reqId);
122 }
123
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,std::shared_ptr<UnregisterCallback> callback)124 int32_t DAudioSourceHandler::UnregisterDistributedHardware(const std::string &devId, const std::string &dhId,
125 std::shared_ptr<UnregisterCallback> callback)
126 {
127 DHLOGI("Unregister distributed hardware, devId: %s, dhId: %s.", GetAnonyString(devId).c_str(), dhId.c_str());
128 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
129 if (dAudioSourceProxy_ == nullptr) {
130 DHLOGE("Daudio source proxy not init.");
131 return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
132 }
133 if (dAudioIpcCallback_ == nullptr) {
134 DHLOGE("Daudio ipc callback is null.");
135 return ERR_DH_AUDIO_SA_IPCCALLBACK_NOT_INIT;
136 }
137 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
138 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
139 }
140
141 DaudioStartAsyncTrace(DAUDIO_UNREGISTER_AUDIO, DAUDIO_UNREGISTER_AUDIO_TASKID);
142 std::string reqId = GetRandomID();
143 dAudioIpcCallback_->PushUnregisterCallback(reqId, callback);
144 return dAudioSourceProxy_->UnregisterDistributedHardware(devId, dhId, reqId);
145 }
146
ConfigDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & key,const std::string & value)147 int32_t DAudioSourceHandler::ConfigDistributedHardware(const std::string &devId, const std::string &dhId,
148 const std::string &key, const std::string &value)
149 {
150 DHLOGI("Config distributed hardware, devId: %s, dhId: %s.", GetAnonyString(devId).c_str(), dhId.c_str());
151 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
152 if (dAudioSourceProxy_ == nullptr) {
153 DHLOGE("Daudio source proxy not init.");
154 return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
155 }
156 if (devId.length() > DAUDIO_MAX_DEVICE_ID_LEN || dhId.length() > DAUDIO_MAX_DEVICE_ID_LEN) {
157 return ERR_DH_AUDIO_SA_DEVID_ILLEGAL;
158 }
159 return dAudioSourceProxy_->ConfigDistributedHardware(devId, dhId, key, value);
160 }
161
OnRemoteSourceSvrDied(const wptr<IRemoteObject> & remote)162 void DAudioSourceHandler::OnRemoteSourceSvrDied(const wptr<IRemoteObject> &remote)
163 {
164 DHLOGI("The daudio source service died.");
165 sptr<IRemoteObject> remoteObject = remote.promote();
166 if (!remoteObject) {
167 DHLOGE("OnRemoteDied remote promoted failed");
168 return;
169 }
170 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
171 if (dAudioSourceProxy_ != nullptr) {
172 dAudioSourceProxy_->AsObject()->RemoveDeathRecipient(sourceSvrRecipient_);
173 dAudioSourceProxy_ = nullptr;
174 }
175 }
176
FinishStartSA(const std::string & param,const sptr<IRemoteObject> & remoteObject)177 void DAudioSourceHandler::FinishStartSA(const std::string ¶m, const sptr<IRemoteObject> &remoteObject)
178 {
179 DHLOGI("Finish start SA.");
180 std::lock_guard<std::mutex> lock(sourceProxyMutex_);
181 remoteObject->AddDeathRecipient(sourceSvrRecipient_);
182 dAudioSourceProxy_ = iface_cast<IDAudioSource>(remoteObject);
183 if ((dAudioSourceProxy_ == nullptr) || (!dAudioSourceProxy_->AsObject())) {
184 DHLOGE("Failed to get daudio source proxy.");
185 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL, DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID,
186 ERR_DH_AUDIO_SA_PROXY_NOT_INIT, "daudio source get proxy failed.");
187 return;
188 }
189 dAudioSourceProxy_->InitSource(param, dAudioIpcCallback_);
190 sourceProxyConVar_.notify_one();
191 DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_INIT, "daudio source sa load success.");
192 }
193
OnRemoteDied(const wptr<IRemoteObject> & remote)194 void DAudioSourceHandler::DAudioSourceSvrRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
195 {
196 DAudioSourceHandler::GetInstance().OnRemoteSourceSvrDied(remote);
197 }
198
GetSourceHardwareHandler()199 IDistributedHardwareSource *GetSourceHardwareHandler()
200 {
201 DHLOGI("Get source hardware handler.");
202 return &DAudioSourceHandler::GetInstance();
203 }
204 } // namespace DistributedHardware
205 } // namespace OHOS
206