• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 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_sink_dev.h"
17 
18 #include <random>
19 
20 #include "daudio_constants.h"
21 #include "daudio_errorcode.h"
22 #include "daudio_log.h"
23 #include "daudio_sink_manager.h"
24 #include "daudio_util.h"
25 
26 #include "ohos_account_kits.h"
27 #include "os_account_manager.h"
28 #include "ipc_skeleton.h"
29 #include "token_setproc.h"
30 
31 #undef DH_LOG_TAG
32 #define DH_LOG_TAG "DAudioSinkDev"
33 
34 namespace OHOS {
35 namespace DistributedHardware {
DAudioSinkDev(const std::string & devId,const sptr<IDAudioSinkIpcCallback> & sinkCallback)36 DAudioSinkDev::DAudioSinkDev(const std::string &devId, const sptr<IDAudioSinkIpcCallback> &sinkCallback)
37     : devId_(devId), ipcSinkCallback_(sinkCallback)
38 {
39     DHLOGD("Distributed audio sink device constructed, devId: %{public}s.", GetAnonyString(devId).c_str());
40 }
41 
~DAudioSinkDev()42 DAudioSinkDev::~DAudioSinkDev()
43 {
44     SetDevLevelStatus(false);
45     DHLOGD("Distributed audio sink device destructed, devId: %{public}s.", GetAnonyString(devId_).c_str());
46 }
47 
AwakeAudioDev()48 int32_t DAudioSinkDev::AwakeAudioDev()
49 {
50     auto runner = AppExecFwk::EventRunner::Create(true);
51     CHECK_NULL_RETURN(runner, ERR_DH_AUDIO_NULLPTR);
52     handler_ = std::make_shared<DAudioSinkDev::SinkEventHandler>(runner, shared_from_this());
53     return DH_SUCCESS;
54 }
55 
SleepAudioDev()56 void DAudioSinkDev::SleepAudioDev()
57 {
58     DHLOGD("Sleep audio dev.");
59     CHECK_NULL_VOID(handler_);
60     while (!handler_->IsIdle()) {
61         DHLOGD("handler is running, wait for idle.");
62         usleep(WAIT_HANDLER_IDLE_TIME_US);
63     }
64     DHLOGI("Sleep audio dev over.");
65 }
66 
InitAVTransEngines(const ChannelState channelState,IAVEngineProvider * providerPtr)67 int32_t DAudioSinkDev::InitAVTransEngines(const ChannelState channelState, IAVEngineProvider *providerPtr)
68 {
69     DHLOGI("Init InitAVTransEngines.");
70     CHECK_NULL_RETURN(providerPtr, ERR_DH_AUDIO_FAILED);
71 
72     if (channelState == ChannelState::UNKNOWN) {
73         DHLOGE("The channel type is invalid.");
74         return ERR_DH_AUDIO_FAILED;
75     }
76     if (channelState == ChannelState::MIC_CONTROL_OPENED) {
77         // only supports normal audio channel mode
78         std::lock_guard<std::mutex> devLck(micClientMutex_);
79         micClientMap_[DEFAULT_CAPTURE_ID] = std::make_shared<DMicClient>(devId_, DEFAULT_CAPTURE_ID,
80             shared_from_this());
81         micClientMap_[DEFAULT_CAPTURE_ID]->InitSenderEngine(providerPtr);
82         micClientMap_[DEFAULT_CAPTURE_ID]->InitCtrlTrans();
83     }
84 
85     if (channelState == ChannelState::SPK_CONTROL_OPENED) {
86         std::lock_guard<std::mutex> devLck(spkClientMutex_);
87         spkClientMap_[DEFAULT_RENDER_ID] =
88             std::make_shared<DSpeakerClient>(devId_, DEFAULT_RENDER_ID, shared_from_this());
89         spkClientMap_[DEFAULT_RENDER_ID]->InitReceiverEngine(providerPtr);
90         spkClientMap_[DEFAULT_RENDER_ID]->InitCtrlTrans();
91         spkClientMap_[LOW_LATENCY_RENDER_ID] =
92             std::make_shared<DSpeakerClient>(devId_, LOW_LATENCY_RENDER_ID, shared_from_this());
93         spkClientMap_[LOW_LATENCY_RENDER_ID]->InitReceiverEngine(providerPtr);
94         spkClientMap_[LOW_LATENCY_RENDER_ID]->InitCtrlTrans();
95     }
96     return DH_SUCCESS;
97 }
98 
NotifyEvent(const AudioEvent & audioEvent)99 void DAudioSinkDev::NotifyEvent(const AudioEvent &audioEvent)
100 {
101     DHLOGD("Notify event, eventType: %{public}d.", (int32_t)audioEvent.type);
102     if ((int32_t)audioEvent.type == DISABLE_DEVICE) {
103         TaskDisableDevice(audioEvent.content);
104         return;
105     }
106     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
107     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
108     CHECK_NULL_VOID(handler_);
109     if (handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) {
110         DHLOGD("Send event success.");
111     }
112 }
113 
TaskDisableDevice(const std::string & args)114 int32_t DAudioSinkDev::TaskDisableDevice(const std::string &args)
115 {
116     if (args.find(OWNER_NAME_D_SPEAKER) != args.npos) {
117         isSpkInUse_.store(false);
118     }
119     if (args.find(OWNER_NAME_D_MIC) != args.npos) {
120         isMicInUse_.store(false);
121     }
122     JudgeDeviceStatus();
123     return DH_SUCCESS;
124 }
125 
TaskOpenDSpeaker(const std::string & args)126 int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args)
127 {
128     DHLOGI("Open speaker device");
129     if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) {
130         return ERR_DH_AUDIO_SA_PARAM_INVALID;
131     }
132     cJSON *jParam = cJSON_Parse(args.c_str());
133     CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR);
134     CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM }), ERR_DH_AUDIO_FAILED,
135         jParam, "Not found the keys.");
136     int32_t dhId = ConvertString2Int(std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring));
137     CHECK_AND_FREE_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, jParam, "Parse dhId error.");
138     std::shared_ptr<ISpkClient> speakerClient = nullptr;
139     {
140         std::lock_guard<std::mutex> devLck(spkClientMutex_);
141         speakerClient = spkClientMap_[dhId];
142     }
143     cJSON *audioParamJson = cJSON_GetObjectItem(jParam, KEY_AUDIO_PARAM);
144     AudioParam audioParam;
145     int32_t ret = from_json(audioParamJson, audioParam);
146     CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ret, jParam,
147         "Get audio param from cjson failed, error code %{public}d.", ret);
148     cJSON_Delete(jParam);
149     CHECK_AND_RETURN_RET_LOG(!CheckAclRight(), ERR_DH_AUDIO_FAILED, "ACL check failed.");
150     CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR);
151     ret = speakerClient->SetUp(audioParam);
152     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Setup speaker failed, ret: %{public}d.", ret);
153     isSpkInUse_.store(true);
154     return ret;
155 }
156 
TaskCloseDSpeaker(const std::string & args)157 int32_t DAudioSinkDev::TaskCloseDSpeaker(const std::string &args)
158 {
159     DHLOGI("Close speaker device.");
160     int32_t dhId = ParseDhidFromEvent(args);
161     if (dhId == ERR_DH_AUDIO_FAILED) {
162         DHLOGE("Failed to parse dhardware id.");
163         return ERR_DH_AUDIO_FAILED;
164     }
165     std::lock_guard<std::mutex> devLck(spkClientMutex_);
166     auto speakerClient = spkClientMap_[dhId];
167     CHECK_NULL_RETURN(speakerClient, DH_SUCCESS);
168 
169     int32_t ret = speakerClient->StopRender();
170     if (ret != DH_SUCCESS) {
171         DHLOGE("Stop speaker client failed, ret: %{public}d.", ret);
172     }
173     ret = speakerClient->Release();
174     if (ret != DH_SUCCESS) {
175         DHLOGE("Release speaker client failed, ret: %{public}d.", ret);
176     }
177     spkClientMap_.erase(dhId);
178     DHLOGI("Close speaker device task excute success.");
179     return DH_SUCCESS;
180 }
181 
ParseDhidFromEvent(std::string args)182 int32_t DAudioSinkDev::ParseDhidFromEvent(std::string args)
183 {
184     DHLOGI("ParseDhidFromEvent");
185     cJSON *jParam = cJSON_Parse(args.c_str());
186     CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_FAILED);
187 
188     if (!CJsonParamCheck(jParam, { KEY_DH_ID })) {
189         DHLOGE("Not found the keys of dhId.");
190         cJSON_Delete(jParam);
191         return ERR_DH_AUDIO_FAILED;
192     }
193     cJSON *dhIdItem = cJSON_GetObjectItem(jParam, KEY_DH_ID);
194     if (dhIdItem == NULL || !cJSON_IsString(dhIdItem)) {
195         DHLOGE("Not found the keys of dhId.");
196         cJSON_Delete(jParam);
197         return ERR_DH_AUDIO_FAILED;
198     }
199     int32_t dhId = ConvertString2Int(std::string(dhIdItem->valuestring));
200     cJSON_Delete(jParam);
201     DHLOGI("Parsed dhId is: %{public}d.", dhId);
202     return dhId;
203 }
204 
ParseResultFromEvent(std::string args)205 int32_t DAudioSinkDev::ParseResultFromEvent(std::string args)
206 {
207     DHLOGD("ParseResultFrom args : %{public}s", args.c_str());
208     cJSON *jParam = cJSON_Parse(args.c_str());
209     CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_FAILED);
210 
211     if (!CJsonParamCheck(jParam, { KEY_RESULT })) {
212         DHLOGE("Not found the keys of result.");
213         cJSON_Delete(jParam);
214         return -1;
215     }
216     cJSON *retItem = cJSON_GetObjectItem(jParam, KEY_RESULT);
217     if (retItem == NULL || !cJSON_IsNumber(retItem)) {
218         DHLOGE("Not found the keys of result.");
219         cJSON_Delete(jParam);
220         return ERR_DH_AUDIO_FAILED;
221     }
222     int32_t ret = retItem->valueint;
223     cJSON_Delete(jParam);
224     DHLOGI("Parsed result is: %{public}d.", ret);
225     return ret;
226 }
227 
ParseValueFromEvent(std::string args,std::string key)228 int32_t DAudioSinkDev::SinkEventHandler::ParseValueFromEvent(std::string args, std::string key)
229 {
230     DHLOGD("ParseValueFromEvent");
231     cJSON *jParam = cJSON_Parse(args.c_str());
232     CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_FAILED);
233     CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { key }), ERR_DH_AUDIO_FAILED, jParam, "Not found key");
234     cJSON *retItem = cJSON_GetObjectItem(jParam, key.c_str());
235     CHECK_AND_FREE_RETURN_RET_LOG(retItem == NULL || !cJSON_IsNumber(retItem),
236         ERR_DH_AUDIO_FAILED, jParam, "Not found key result");
237     int32_t ret = retItem->valueint;
238     cJSON_Delete(jParam);
239     return ret;
240 }
241 
ParseStringFromEvent(std::string args,std::string key)242 std::string DAudioSinkDev::SinkEventHandler::ParseStringFromEvent(std::string args, std::string key)
243 {
244     DHLOGD("ParseStringFromEvent");
245     cJSON *jParam = cJSON_Parse(args.c_str());
246     CHECK_NULL_RETURN(jParam, "");
247 
248     CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { key }), "", jParam, "Not found key");
249     cJSON *retItem = cJSON_GetObjectItem(jParam, key.c_str());
250     CHECK_AND_FREE_RETURN_RET_LOG(retItem == NULL || !cJSON_IsString(retItem), "", jParam, "Not found key result");
251     auto ret = std::string(retItem->valuestring);
252     cJSON_Delete(jParam);
253     return ret;
254 }
255 
TaskStartRender(const std::string & args)256 int32_t DAudioSinkDev::TaskStartRender(const std::string &args)
257 {
258     int32_t dhId = ParseDhidFromEvent(args);
259     if (dhId == ERR_DH_AUDIO_FAILED) {
260         DHLOGE("Failed to parse dhardware id.");
261         return ERR_DH_AUDIO_FAILED;
262     }
263     std::shared_ptr<ISpkClient> speakerClient = nullptr;
264     {
265         std::lock_guard<std::mutex> devLck(spkClientMutex_);
266         speakerClient = spkClientMap_[dhId];
267     }
268     CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR);
269 
270     int32_t ret = speakerClient->StartRender();
271     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret,
272         "Start render failed. ret: %{public}d.", ret);
273     DHLOGI("Start render success.");
274     return DH_SUCCESS;
275 }
276 
TaskOpenDMic(const std::string & args)277 int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args)
278 {
279     DHLOGI("Open mic device.");
280     if (!isDevLevelStatus_) {
281         DHLOGI("Dev security level status is false.");
282         return ERR_DH_AUDIO_FAILED;
283     }
284     if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) {
285         return ERR_DH_AUDIO_SA_PARAM_INVALID;
286     }
287     cJSON *jParam = cJSON_Parse(args.c_str());
288     CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR);
289     CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM }), ERR_DH_AUDIO_FAILED,
290         jParam, "Not found the keys.");
291     AudioParam audioParam;
292     cJSON *audioParamJson = cJSON_GetObjectItem(jParam, KEY_AUDIO_PARAM);
293     int32_t ret = from_json(audioParamJson, audioParam);
294     CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ret, jParam,
295         "Get audio param from cjson failed, error code %{public}d.", ret);
296     int32_t dhId = ParseDhidFromEvent(args);
297     CHECK_AND_FREE_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, jParam,
298         "%{public}s", "Parse dhId error.");
299     cJSON_Delete(jParam);
300     micDhId_ = std::to_string(dhId);
301     std::shared_ptr<DMicClient> micClient = nullptr;
302     {
303         std::lock_guard<std::mutex> devLck(micClientMutex_);
304         micClient = micClientMap_[dhId];
305     }
306     CHECK_AND_RETURN_RET_LOG(!CheckAclRight(), ERR_DH_AUDIO_FAILED, "ACL check failed.");
307     CHECK_NULL_RETURN(micClient, ERR_DH_AUDIO_NULLPTR);
308     ret = micClient->SetUp(audioParam);
309     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, "Set up mic failed, ret: %{public}d.", ret);
310     ret = micClient->StartCapture();
311     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, "Start capture failed, ret: %{public}d.", ret);
312     isMicInUse_.store(true);
313     return ret;
314 }
315 
TaskCloseDMic(const std::string & args)316 int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args)
317 {
318     DHLOGI("Close mic device.");
319     int32_t dhId = ParseDhidFromEvent(args);
320     if (dhId == ERR_DH_AUDIO_FAILED) {
321         DHLOGE("Failed to parse dhardware id.");
322         return ERR_DH_AUDIO_FAILED;
323     }
324     std::lock_guard<std::mutex> devLck(micClientMutex_);
325     std::shared_ptr<DMicClient> micClient = micClientMap_[dhId];
326     CHECK_NULL_RETURN(micClient, DH_SUCCESS);
327 
328     int32_t ret = micClient->StopCapture();
329     CHECK_AND_LOG(ret != DH_SUCCESS, "Stop mic client failed, ret: %{public}d.", ret);
330     ret = micClient->Release();
331     CHECK_AND_LOG(ret != DH_SUCCESS, "Release mic client failed, ret: %{public}d.", ret);
332     micClientMap_.erase(dhId);
333     DHLOGI("Close mic device task excute success.");
334     return DH_SUCCESS;
335 }
336 
TaskSetParameter(const std::string & args)337 int32_t DAudioSinkDev::TaskSetParameter(const std::string &args)
338 {
339     DHLOGD("Set audio param.");
340     AudioEvent event(AudioEventType::EVENT_UNKNOWN, args);
341     int32_t dhId = ParseDhidFromEvent(args);
342     if (dhId == ERR_DH_AUDIO_FAILED) {
343         DHLOGE("Failed to parse dhardware id.");
344         return ERR_DH_AUDIO_FAILED;
345     }
346     std::shared_ptr<ISpkClient> speakerClient = nullptr;
347     {
348         std::lock_guard<std::mutex> devLck(spkClientMutex_);
349         speakerClient = spkClientMap_[dhId];
350     }
351     CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR);
352     return speakerClient->SetAudioParameters(event);
353 }
354 
TaskSetVolume(const std::string & args)355 int32_t DAudioSinkDev::TaskSetVolume(const std::string &args)
356 {
357     DHLOGD("Set audio volume.");
358     int32_t dhId = 0;
359     if (GetAudioParamInt(args, "dhId", dhId) != DH_SUCCESS) {
360         DHLOGE("Get key of dhId failed.");
361         return ERR_DH_AUDIO_FAILED;
362     }
363     std::shared_ptr<ISpkClient> speakerClient = nullptr;
364     {
365         std::lock_guard<std::mutex> devLck(spkClientMutex_);
366         speakerClient = spkClientMap_[dhId];
367     }
368     CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR);
369 
370     AudioEvent event(AudioEventType::VOLUME_SET, args);
371     int32_t ret = speakerClient->SetAudioParameters(event);
372     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret,
373         "Volume set failed, ret: %{public}d.", ret);
374     DHLOGD("Set audio volume success.");
375     return DH_SUCCESS;
376 }
377 
TaskSetMute(const std::string & args)378 int32_t DAudioSinkDev::TaskSetMute(const std::string &args)
379 {
380     DHLOGD("Set audio mute.");
381     int dhId = 0;
382     if (GetAudioParamInt(args, "dhId", dhId) != DH_SUCCESS) {
383         DHLOGE("Get key of dhId failed.");
384         return ERR_DH_AUDIO_FAILED;
385     }
386     std::shared_ptr<ISpkClient> speakerClient = nullptr;
387     {
388         std::lock_guard<std::mutex> devLck(spkClientMutex_);
389         speakerClient = spkClientMap_[dhId];
390     }
391     CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR);
392 
393     AudioEvent event(AudioEventType::VOLUME_MUTE_SET, args);
394     int32_t ret = speakerClient->SetMute(event);
395     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret,
396         "Set mute failed, ret: %{public}d.", ret);
397     DHLOGD("Set mute success.");
398     return DH_SUCCESS;
399 }
400 
TaskVolumeChange(const std::string & args)401 int32_t DAudioSinkDev::TaskVolumeChange(const std::string &args)
402 {
403     DHLOGD("Audio volume changed.");
404     AudioEvent event(AudioEventType::VOLUME_CHANGE, args);
405     return SendAudioEventToRemote(event);
406 }
407 
TaskFocusChange(const std::string & args)408 int32_t DAudioSinkDev::TaskFocusChange(const std::string &args)
409 {
410     DHLOGD("Audio focus changed.");
411     AudioEvent event(AudioEventType::AUDIO_FOCUS_CHANGE, args);
412     return SendAudioEventToRemote(event);
413 }
414 
TaskRenderStateChange(const std::string & args)415 int32_t DAudioSinkDev::TaskRenderStateChange(const std::string &args)
416 {
417     DHLOGD("Audio render state changed.");
418     AudioEvent event(AudioEventType::AUDIO_RENDER_STATE_CHANGE, args);
419     return SendAudioEventToRemote(event);
420 }
421 
TaskPlayStatusChange(const std::string & args)422 int32_t DAudioSinkDev::TaskPlayStatusChange(const std::string &args)
423 {
424     DHLOGD("Play status change, content: %{public}s.", args.c_str());
425     int32_t dhId = ParseDhidFromEvent(args);
426     if (dhId == ERR_DH_AUDIO_FAILED) {
427         DHLOGE("Failed to parse dhardware id.");
428         return ERR_DH_AUDIO_FAILED;
429     }
430     std::shared_ptr<ISpkClient> speakerClient = nullptr;
431     {
432         std::lock_guard<std::mutex> devLck(spkClientMutex_);
433         speakerClient = spkClientMap_[dhId];
434     }
435     CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR);
436     speakerClient->PlayStatusChange(args);
437     DHLOGD("Play status change success.");
438     return DH_SUCCESS;
439 }
440 
SendAudioEventToRemote(const AudioEvent & event)441 int32_t DAudioSinkDev::SendAudioEventToRemote(const AudioEvent &event)
442 {
443     // because: type: VOLUME_CHANGE / AUDIO_FOCUS_CHANGE / AUDIO_RENDER_STATE_CHANGE
444     // so speakerClient
445     int32_t dhId = ParseDhidFromEvent(event.content);
446     if (dhId == ERR_DH_AUDIO_FAILED) {
447         DHLOGE("Failed to parse dhardware id.");
448         return ERR_DH_AUDIO_FAILED;
449     }
450     std::shared_ptr<ISpkClient> speakerClient = nullptr;
451     {
452         std::lock_guard<std::mutex> devLck(spkClientMutex_);
453         speakerClient = spkClientMap_[dhId];
454     }
455     CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR);
456 
457     int32_t ret = speakerClient->SendMessage(static_cast<uint32_t>(event.type),
458         event.content, devId_);
459     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_NULLPTR,
460         "%{public}s", "Task send message to remote failed.");
461     return DH_SUCCESS;
462 }
463 
JudgeDeviceStatus()464 void DAudioSinkDev::JudgeDeviceStatus()
465 {
466     DHLOGD("Checking device's status.");
467     if (isSpkInUse_.load() || isMicInUse_.load()) {
468         DHLOGI("Device contain periperials in using, speaker status: %{public}d, mic status: %{public}d.",
469             isSpkInUse_.load(), isMicInUse_.load());
470         return;
471     }
472     DAudioSinkManager::GetInstance().OnSinkDevReleased(devId_);
473 }
474 
SetDevLevelStatus(bool checkStatus)475 void DAudioSinkDev::SetDevLevelStatus(bool checkStatus)
476 {
477     isDevLevelStatus_ = checkStatus;
478 }
479 
ConvertString2Int(std::string val)480 int32_t DAudioSinkDev::ConvertString2Int(std::string val)
481 {
482     if (!CheckIsNum(val)) {
483         DHLOGE("String is not number. str:%{public}s.", val.c_str());
484         return ERR_DH_AUDIO_FAILED;
485     }
486     return std::atoi(val.c_str());
487 }
488 
PullUpPage()489 void DAudioSinkDev::PullUpPage()
490 {
491     bool isSensitive = false;
492     bool isSameAccount = false;
493     if (ipcSinkCallback_ != nullptr) {
494         ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_PULL_UP_PAGE, SUBTYPE, devId_,
495             isSensitive, isSameAccount);
496         isPageStatus_.store(true);
497     }
498 }
499 
NotifySourceDev(const AudioEventType type,const std::string dhId,const int32_t result)500 void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string dhId, const int32_t result)
501 {
502     std::random_device rd;
503     const uint32_t randomTaskCode = rd();
504     cJSON *jEvent = cJSON_CreateObject();
505     CHECK_NULL_VOID(jEvent);
506     cJSON_AddStringToObject(jEvent, KEY_DH_ID, dhId.c_str());
507     cJSON_AddNumberToObject(jEvent, KEY_RESULT, result);
508     cJSON_AddNumberToObject(jEvent, KEY_EVENT_TYPE, static_cast<int32_t>(type));
509     cJSON_AddStringToObject(jEvent, KEY_RANDOM_TASK_CODE, std::to_string(randomTaskCode).c_str());
510 
511     DHLOGI("Notify source dev, new engine, random task code:%{public}s", std::to_string(randomTaskCode).c_str());
512     int32_t dhIdInt = ConvertString2Int(dhId);
513     if (dhIdInt == -1) {
514         DHLOGE("Parse dhId error.");
515         cJSON_Delete(jEvent);
516         return;
517     }
518     char *data = cJSON_PrintUnformatted(jEvent);
519     if (data == nullptr) {
520         DHLOGE("Failed to create JSON data.");
521         cJSON_Delete(jEvent);
522         return;
523     }
524     std::string message(data);
525 
526     std::shared_ptr<ISpkClient> speakerClient = nullptr;
527     {
528         std::lock_guard<std::mutex> devLck(spkClientMutex_);
529         speakerClient = spkClientMap_[dhIdInt];
530     }
531     if (speakerClient != nullptr) {
532         speakerClient->SendMessage(static_cast<uint32_t>(type), message, devId_);
533     }
534     std::shared_ptr<DMicClient> micClient = nullptr;
535     {
536         std::lock_guard<std::mutex> devLck(micClientMutex_);
537         micClient = micClientMap_[dhIdInt];
538     }
539     if (micClient != nullptr) {
540         micClient->SendMessage(static_cast<uint32_t>(type), message, devId_);
541     }
542     cJSON_Delete(jEvent);
543     cJSON_free(data);
544 }
545 
GetParamValue(const cJSON * j,const char * key,int32_t & value)546 int32_t DAudioSinkDev::GetParamValue(const cJSON *j, const char* key, int32_t &value)
547 {
548     cJSON *paramValue = cJSON_GetObjectItemCaseSensitive(j, key);
549     if (paramValue == nullptr || !cJSON_IsNumber(paramValue)) {
550         return ERR_DH_AUDIO_FAILED;
551     }
552     value = paramValue->valueint;
553     return DH_SUCCESS;
554 }
555 
GetCJsonObjectItems(const cJSON * j,AudioParam & audioParam)556 int32_t DAudioSinkDev::GetCJsonObjectItems(const cJSON *j, AudioParam &audioParam)
557 {
558     int32_t ret = 0;
559     ret = GetParamValue(j, KEY_SAMPLING_RATE, reinterpret_cast<int32_t&>(audioParam.comParam.sampleRate));
560     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
561     ret = GetParamValue(j, KEY_CHANNELS, reinterpret_cast<int32_t&>(audioParam.comParam.channelMask));
562     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
563     ret = GetParamValue(j, KEY_FORMAT, reinterpret_cast<int32_t&>(audioParam.comParam.bitFormat));
564     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
565     ret = GetParamValue(j, KEY_FRAMESIZE, reinterpret_cast<int32_t&>(audioParam.comParam.frameSize));
566     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
567     ret = GetParamValue(j, KEY_SOURCE_TYPE, reinterpret_cast<int32_t&>(audioParam.captureOpts.sourceType));
568     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
569     ret = GetParamValue(j, KEY_CONTENT_TYPE, reinterpret_cast<int32_t&>(audioParam.renderOpts.contentType));
570     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
571     ret = GetParamValue(j, KEY_STREAM_USAGE, reinterpret_cast<int32_t&>(audioParam.renderOpts.streamUsage));
572     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
573     ret = GetParamValue(j, KEY_RENDER_FLAGS, reinterpret_cast<int32_t&>(audioParam.renderOpts.renderFlags));
574     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
575     ret = GetParamValue(j, KEY_CAPTURE_FLAGS, reinterpret_cast<int32_t&>(audioParam.captureOpts.capturerFlags));
576     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
577 
578     if (CJsonParamCheck(j, { KEY_CODEC_TYPE })) {
579         ret = GetParamValue(j, KEY_CODEC_TYPE, reinterpret_cast<int32_t&>(audioParam.comParam.codecType));
580         CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%{public}s", "Get param value error.");
581     }
582     DHLOGD("codecType: %{public}d", static_cast<int32_t>(audioParam.comParam.codecType));
583     return ret;
584 }
585 
from_json(const cJSON * j,AudioParam & audioParam)586 int32_t DAudioSinkDev::from_json(const cJSON  *j, AudioParam &audioParam)
587 {
588     if (!CJsonParamCheck(j, { KEY_SAMPLING_RATE, KEY_CHANNELS, KEY_FORMAT,
589         KEY_SOURCE_TYPE, KEY_CONTENT_TYPE, KEY_STREAM_USAGE })) {
590         DHLOGE("Not found the keys of dhId");
591         return ERR_DH_AUDIO_FAILED;
592     }
593     if (GetCJsonObjectItems(j, audioParam) != DH_SUCCESS) {
594         DHLOGE("Get Cjson Object Items failed.");
595         return ERR_DH_AUDIO_FAILED;
596     }
597     return DH_SUCCESS;
598 }
599 
HandleEngineMessage(uint32_t type,std::string content,std::string devId)600 int32_t DAudioSinkDev::HandleEngineMessage(uint32_t type, std::string content, std::string devId)
601 {
602     DHLOGI("HandleEngineMessage enter.");
603     return DAudioSinkManager::GetInstance().HandleDAudioNotify(devId, devId, static_cast<int32_t>(type), content);
604 }
605 
SinkEventHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner,const std::shared_ptr<DAudioSinkDev> & dev)606 DAudioSinkDev::SinkEventHandler::SinkEventHandler(const std::shared_ptr<AppExecFwk::EventRunner> &runner,
607     const std::shared_ptr<DAudioSinkDev> &dev) : AppExecFwk::EventHandler(runner), sinkDev_(dev)
608 {
609     DHLOGD("Event handler is constructing.");
610     mapEventFuncs_[static_cast<uint32_t>(CTRL_OPENED)] = &DAudioSinkDev::SinkEventHandler::NotifyCtrlOpened;
611     mapEventFuncs_[static_cast<uint32_t>(CTRL_CLOSED)] = &DAudioSinkDev::SinkEventHandler::NotifyCtrlClosed;
612     mapEventFuncs_[static_cast<uint32_t>(OPEN_SPEAKER)] = &DAudioSinkDev::SinkEventHandler::NotifyOpenSpeaker;
613     mapEventFuncs_[static_cast<uint32_t>(CLOSE_SPEAKER)] = &DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker;
614     mapEventFuncs_[static_cast<uint32_t>(SPEAKER_OPENED)] = &DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened;
615     mapEventFuncs_[static_cast<uint32_t>(SPEAKER_CLOSED)] = &DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed;
616     mapEventFuncs_[static_cast<uint32_t>(OPEN_MIC)] = &DAudioSinkDev::SinkEventHandler::NotifyOpenMic;
617     mapEventFuncs_[static_cast<uint32_t>(CLOSE_MIC)] = &DAudioSinkDev::SinkEventHandler::NotifyCloseMic;
618     mapEventFuncs_[static_cast<uint32_t>(MIC_OPENED)] = &DAudioSinkDev::SinkEventHandler::NotifyMicOpened;
619     mapEventFuncs_[static_cast<uint32_t>(MIC_CLOSED)] = &DAudioSinkDev::SinkEventHandler::NotifyMicClosed;
620     mapEventFuncs_[static_cast<uint32_t>(VOLUME_SET)] = &DAudioSinkDev::SinkEventHandler::NotifySetVolume;
621     mapEventFuncs_[static_cast<uint32_t>(VOLUME_CHANGE)] = &DAudioSinkDev::SinkEventHandler::NotifyVolumeChange;
622     mapEventFuncs_[static_cast<uint32_t>(SET_PARAM)] = &DAudioSinkDev::SinkEventHandler::NotifySetParam;
623     mapEventFuncs_[static_cast<uint32_t>(VOLUME_MUTE_SET)] = &DAudioSinkDev::SinkEventHandler::NotifySetMute;
624     mapEventFuncs_[static_cast<uint32_t>(AUDIO_FOCUS_CHANGE)] = &DAudioSinkDev::SinkEventHandler::NotifyFocusChange;
625     mapEventFuncs_[static_cast<uint32_t>(AUDIO_RENDER_STATE_CHANGE)] =
626         &DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange;
627     mapEventFuncs_[static_cast<uint32_t>(CHANGE_PLAY_STATUS)] =
628         &DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange;
629 }
630 
~SinkEventHandler()631 DAudioSinkDev::SinkEventHandler::~SinkEventHandler() {}
632 
ProcessEventInner(const AppExecFwk::InnerEvent::Pointer & event)633 void DAudioSinkDev::SinkEventHandler::ProcessEventInner(const AppExecFwk::InnerEvent::Pointer &event)
634 {
635     CHECK_NULL_VOID(event);
636     switch (event->GetInnerEventId()) {
637         case OPEN_MIC:
638             NotifyOpenMic(event);
639             break;
640         case CLOSE_MIC:
641             NotifyCloseMic(event);
642             break;
643         case MIC_OPENED:
644             NotifyMicOpened(event);
645             break;
646         case MIC_CLOSED:
647             NotifyMicClosed(event);
648             break;
649         case VOLUME_SET:
650             NotifySetVolume(event);
651             break;
652         case VOLUME_CHANGE:
653             NotifyVolumeChange(event);
654             break;
655         case SET_PARAM:
656             NotifySetParam(event);
657             break;
658         case VOLUME_MUTE_SET:
659             NotifySetMute(event);
660             break;
661         case AUDIO_FOCUS_CHANGE:
662             NotifyFocusChange(event);
663             break;
664         case AUDIO_RENDER_STATE_CHANGE:
665             NotifyRenderStateChange(event);
666             break;
667         case CHANGE_PLAY_STATUS:
668             NotifyPlayStatusChange(event);
669             break;
670         default:
671             break;
672     }
673 }
674 
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)675 void DAudioSinkDev::SinkEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
676 {
677     CHECK_NULL_VOID(event);
678     DHLOGD("Event Id=%{public}d", event->GetInnerEventId());
679     switch (event->GetInnerEventId()) {
680         case CTRL_OPENED:
681             NotifyCtrlOpened(event);
682             break;
683         case CTRL_CLOSED:
684             NotifyCtrlClosed(event);
685             break;
686         case OPEN_SPEAKER:
687             NotifyOpenSpeaker(event);
688             break;
689         case CLOSE_SPEAKER:
690             NotifyCloseSpeaker(event);
691             break;
692         case SPEAKER_OPENED:
693             NotifySpeakerOpened(event);
694             break;
695         case SPEAKER_CLOSED:
696             NotifySpeakerClosed(event);
697             break;
698         case OPEN_MIC:
699         case CLOSE_MIC:
700         case MIC_OPENED:
701         case MIC_CLOSED:
702         case VOLUME_SET:
703         case VOLUME_CHANGE:
704         case SET_PARAM:
705         case VOLUME_MUTE_SET:
706         case AUDIO_FOCUS_CHANGE:
707         case AUDIO_RENDER_STATE_CHANGE:
708         case CHANGE_PLAY_STATUS:
709             ProcessEventInner(event);
710             break;
711         default:
712             DHLOGE("Event Id is invaild. %{public}d", event->GetInnerEventId());
713             break;
714     }
715 }
716 
NotifyCtrlOpened(const AppExecFwk::InnerEvent::Pointer & event)717 void DAudioSinkDev::SinkEventHandler::NotifyCtrlOpened(const AppExecFwk::InnerEvent::Pointer &event)
718 {
719     DHLOGI("Ctrl channel is opened. begin to init dev, then to notify source dev.");
720     std::string eventParam;
721     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
722         DHLOGE("Failed to get event parameters.");
723         return;
724     }
725     auto sinkDevObj = sinkDev_.lock();
726     CHECK_NULL_VOID(sinkDevObj);
727 
728     int32_t dhId = sinkDevObj->ParseDhidFromEvent(eventParam);
729     CHECK_AND_RETURN_LOG(dhId == -1, "%{public}s", "Parse dhId error.");
730     int32_t ret = sinkDevObj->ParseResultFromEvent(eventParam);
731     sinkDevObj->NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, std::to_string(dhId), ret);
732     DHLOGI("Init sink device task end, notify source ret %{public}d.", ret);
733     CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%{public}s", "Init sink device failed.");
734 }
735 
NotifyCtrlClosed(const AppExecFwk::InnerEvent::Pointer & event)736 void DAudioSinkDev::SinkEventHandler::NotifyCtrlClosed(const AppExecFwk::InnerEvent::Pointer &event)
737 {
738     DHLOGI("Notify ctrl closed.");
739     (void)event;
740 }
741 
NotifyOpenSpeaker(const AppExecFwk::InnerEvent::Pointer & event)742 void DAudioSinkDev::SinkEventHandler::NotifyOpenSpeaker(const AppExecFwk::InnerEvent::Pointer &event)
743 {
744     std::string eventParam;
745     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
746         DHLOGE("Failed to get event parameters.");
747         return;
748     }
749     auto sinkDevObj = sinkDev_.lock();
750     CHECK_NULL_VOID(sinkDevObj);
751 
752     int32_t dhId = sinkDevObj->ParseDhidFromEvent(eventParam);
753     CHECK_AND_RETURN_LOG(dhId == -1, "%{public}s", "Parse dhId error.");
754     sinkDevObj->SetUserId(ParseValueFromEvent(eventParam, KEY_USERID));
755     sinkDevObj->SetTokenId(ParseValueFromEvent(eventParam, KEY_TOKENID));
756     sinkDevObj->SetAccountId(ParseStringFromEvent(eventParam, KEY_ACCOUNTID));
757     int32_t ret = sinkDevObj->TaskOpenDSpeaker(eventParam);
758     sinkDevObj->NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, std::to_string(dhId), ret);
759     DHLOGI("Open speaker device task end, notify source ret %{public}d.", ret);
760     CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%{public}s", "Open speaker failed.");
761 }
762 
SetUserId(int32_t value)763 void DAudioSinkDev::SetUserId(int32_t value)
764 {
765     userId_ = value;
766 }
767 
SetTokenId(int32_t value)768 void DAudioSinkDev::SetTokenId(int32_t value)
769 {
770     tokenId_ = static_cast<uint64_t>(value);
771 }
772 
SetAccountId(string value)773 void DAudioSinkDev::SetAccountId(string value)
774 {
775     accountId_ = value;
776 }
777 
CheckAclRight()778 bool DAudioSinkDev::CheckAclRight()
779 {
780     CHECK_AND_RETURN_RET_LOG(userId_ == -1, true, "ACL not support");
781     std::string sinkDevId;
782     int32_t ret = GetLocalDeviceNetworkId(sinkDevId);
783     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "GetLocalDeviceNetworkId failed, ret: %{public}d", ret);
784 #ifdef OS_ACCOUNT_PART
785     std::vector<int32_t> ids;
786     ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids);
787     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "Get userId fail, ret: %{public}d", ret);
788     int32_t userId = -1;
789     userId = ids.empty() ? 0 : ids[0];
790     AccountSA::OhosAccountInfo osAccountInfo;
791     ret = AccountSA::OhosAccountKits::GetInstance().GetOhosAccountInfo(osAccountInfo);
792     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "Get accountId fail, ret: %{public}d", ret);
793     std::string accountId = osAccountInfo.uid_;
794 #endif
795     std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DeviceInitCallback>();
796     ret = DeviceManager::GetInstance().InitDeviceManager(PKG_NAME, initCallback);
797     CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "InitDeviceManager failed ret = %{public}d", ret);
798 
799     DmAccessCaller dmSrcCaller;
800     dmSrcCaller.accountId = accountId_;
801     dmSrcCaller.pkgName = PKG_NAME;
802     dmSrcCaller.networkId = devId_;
803     dmSrcCaller.userId = userId_;
804     dmSrcCaller.tokenId = tokenId_;
805 
806     DmAccessCallee dmDstCallee;
807     dmDstCallee.accountId = accountId;
808     dmDstCallee.networkId = sinkDevId;
809     dmDstCallee.pkgName = PKG_NAME;
810     dmDstCallee.userId = userId;
811     dmDstCallee.tokenId = sinkTokenId_;
812     DHLOGI("CheckAclRight srcDevId: %{public}s, accountId: %{public}s, sinkDevId: %{public}s",
813         GetAnonyString(devId_).c_str(), GetAnonyString(accountId).c_str(), GetAnonyString(sinkDevId).c_str());
814     return DeviceManager::GetInstance().CheckSinkAccessControl(dmSrcCaller, dmDstCallee);
815 }
816 
NotifyCloseSpeaker(const AppExecFwk::InnerEvent::Pointer & event)817 void DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker(const AppExecFwk::InnerEvent::Pointer &event)
818 {
819     std::string eventParam;
820     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
821         DHLOGE("Failed to get event parameters.");
822         return;
823     }
824     auto sinkDevObj = sinkDev_.lock();
825     CHECK_NULL_VOID(sinkDevObj);
826     CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS,
827         "%{public}s", "close speaker failed.");
828 }
829 
NotifySpeakerOpened(const AppExecFwk::InnerEvent::Pointer & event)830 void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::InnerEvent::Pointer &event)
831 {
832     DHLOGD("Starting render.");
833     std::string eventParam;
834     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
835         DHLOGE("Failed to get event parameters.");
836         return;
837     }
838     auto sinkDevObj = sinkDev_.lock();
839     CHECK_NULL_VOID(sinkDevObj);
840     CHECK_AND_RETURN_LOG(sinkDevObj->TaskStartRender(eventParam) != DH_SUCCESS,
841         "%{public}s", "Speaker client start failed.");
842     CHECK_AND_RETURN_LOG(sinkDevObj->TaskVolumeChange(eventParam) != DH_SUCCESS,
843         "%{public}s", "Notify pimary volume to source device failed.");
844 }
845 
NotifySpeakerClosed(const AppExecFwk::InnerEvent::Pointer & event)846 void DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed(const AppExecFwk::InnerEvent::Pointer &event)
847 {
848     std::string eventParam;
849     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
850         DHLOGE("Failed to get event parameters.");
851         return;
852     }
853     auto sinkDevObj = sinkDev_.lock();
854     CHECK_NULL_VOID(sinkDevObj);
855     CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS,
856         "%{public}s", "Close speaker failed.");
857 }
858 
NotifyOpenMic(const AppExecFwk::InnerEvent::Pointer & event)859 void DAudioSinkDev::SinkEventHandler::NotifyOpenMic(const AppExecFwk::InnerEvent::Pointer &event)
860 {
861     std::string eventParam;
862     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
863         DHLOGE("Failed to get event parameters.");
864         return;
865     }
866     auto sinkDevObj = sinkDev_.lock();
867     CHECK_NULL_VOID(sinkDevObj);
868 
869     cJSON *jParam = cJSON_Parse(eventParam.c_str());
870     CHECK_NULL_VOID(jParam);
871     if (!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) {
872         DHLOGE("Json param check failed.");
873         cJSON_Delete(jParam);
874         return;
875     }
876     sinkDevObj->SetUserId(ParseValueFromEvent(eventParam, KEY_USERID));
877     sinkDevObj->SetTokenId(ParseValueFromEvent(eventParam, KEY_TOKENID));
878     sinkDevObj->SetAccountId(ParseStringFromEvent(eventParam, KEY_ACCOUNTID));
879     int32_t ret = sinkDevObj->TaskOpenDMic(eventParam);
880     sinkDevObj->NotifySourceDev(NOTIFY_OPEN_MIC_RESULT,
881         std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring), ret);
882     DHLOGI("Open mic device task end, notify source ret %{public}d.", ret);
883     CHECK_AND_FREE_RETURN_LOG(ret != DH_SUCCESS, jParam, "%{public}s", "Open mic failed.");
884     cJSON_Delete(jParam);
885 }
886 
NotifyCloseMic(const AppExecFwk::InnerEvent::Pointer & event)887 void DAudioSinkDev::SinkEventHandler::NotifyCloseMic(const AppExecFwk::InnerEvent::Pointer &event)
888 {
889     std::string eventParam;
890     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
891         DHLOGE("Failed to get event parameters.");
892         return;
893     }
894     auto sinkDevObj = sinkDev_.lock();
895     CHECK_NULL_VOID(sinkDevObj);
896     CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS,
897         "%{public}s", "Close mic failed.");
898 }
899 
NotifyMicOpened(const AppExecFwk::InnerEvent::Pointer & event)900 void DAudioSinkDev::SinkEventHandler::NotifyMicOpened(const AppExecFwk::InnerEvent::Pointer &event)
901 {
902     DHLOGI("Notify mic is opened.");
903     (void)event;
904 }
905 
NotifyMicClosed(const AppExecFwk::InnerEvent::Pointer & event)906 void DAudioSinkDev::SinkEventHandler::NotifyMicClosed(const AppExecFwk::InnerEvent::Pointer &event)
907 {
908     std::string eventParam;
909     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
910         DHLOGE("Failed to get event parameters.");
911         return;
912     }
913     auto sinkDevObj = sinkDev_.lock();
914     CHECK_NULL_VOID(sinkDevObj);
915     CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS,
916         "%{public}s", "Close mic failed.");
917 }
918 
NotifySetVolume(const AppExecFwk::InnerEvent::Pointer & event)919 void DAudioSinkDev::SinkEventHandler::NotifySetVolume(const AppExecFwk::InnerEvent::Pointer &event)
920 {
921     std::string eventParam;
922     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
923         DHLOGE("Failed to get event parameters.");
924         return;
925     }
926     auto sinkDevObj = sinkDev_.lock();
927     CHECK_NULL_VOID(sinkDevObj);
928     CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetVolume(eventParam) != DH_SUCCESS,
929         "%{public}s", "Set volume failed.");
930 }
931 
NotifyVolumeChange(const AppExecFwk::InnerEvent::Pointer & event)932 void DAudioSinkDev::SinkEventHandler::NotifyVolumeChange(const AppExecFwk::InnerEvent::Pointer &event)
933 {
934     std::string eventParam;
935     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
936         DHLOGE("Failed to get event parameters.");
937         return;
938     }
939     auto sinkDevObj = sinkDev_.lock();
940     CHECK_NULL_VOID(sinkDevObj);
941     CHECK_AND_RETURN_LOG(sinkDevObj->TaskVolumeChange(eventParam) != DH_SUCCESS,
942         "%{public}s", "Notify volume change status to source device failed.");
943 }
944 
NotifySetParam(const AppExecFwk::InnerEvent::Pointer & event)945 void DAudioSinkDev::SinkEventHandler::NotifySetParam(const AppExecFwk::InnerEvent::Pointer &event)
946 {
947     std::string eventParam;
948     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
949         DHLOGE("Failed to get event parameters.");
950         return;
951     }
952     auto sinkDevObj = sinkDev_.lock();
953     CHECK_NULL_VOID(sinkDevObj);
954     CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetParameter(eventParam) != DH_SUCCESS,
955         "%{public}s", "Set parameters failed.");
956 }
957 
NotifySetMute(const AppExecFwk::InnerEvent::Pointer & event)958 void DAudioSinkDev::SinkEventHandler::NotifySetMute(const AppExecFwk::InnerEvent::Pointer &event)
959 {
960     std::string eventParam;
961     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
962         DHLOGE("Failed to get event parameters.");
963         return;
964     }
965     auto sinkDevObj = sinkDev_.lock();
966     CHECK_NULL_VOID(sinkDevObj);
967     CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetMute(eventParam) != DH_SUCCESS,
968         "%{public}s", "Set mute failed.");
969 }
970 
NotifyFocusChange(const AppExecFwk::InnerEvent::Pointer & event)971 void DAudioSinkDev::SinkEventHandler::NotifyFocusChange(const AppExecFwk::InnerEvent::Pointer &event)
972 {
973     std::string eventParam;
974     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
975         DHLOGE("Failed to get event parameters.");
976         return;
977     }
978     auto sinkDevObj = sinkDev_.lock();
979     CHECK_NULL_VOID(sinkDevObj);
980     CHECK_AND_RETURN_LOG(sinkDevObj->TaskFocusChange(eventParam) != DH_SUCCESS,
981         "%{public}s", "Handle focus change event failed.");
982 }
983 
NotifyRenderStateChange(const AppExecFwk::InnerEvent::Pointer & event)984 void DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange(const AppExecFwk::InnerEvent::Pointer &event)
985 {
986     std::string eventParam;
987     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
988         DHLOGE("Failed to get event parameters.");
989         return;
990     }
991     auto sinkDevObj = sinkDev_.lock();
992     CHECK_NULL_VOID(sinkDevObj);
993     CHECK_AND_RETURN_LOG(sinkDevObj->TaskRenderStateChange(eventParam) != DH_SUCCESS,
994         "%{public}s", "Handle render state change failed.");
995 }
996 
NotifyPlayStatusChange(const AppExecFwk::InnerEvent::Pointer & event)997 void DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange(const AppExecFwk::InnerEvent::Pointer &event)
998 {
999     std::string eventParam;
1000     if (GetEventParam(event, eventParam) != DH_SUCCESS) {
1001         DHLOGE("Failed to get event parameters.");
1002         return;
1003     }
1004     auto sinkDevObj = sinkDev_.lock();
1005     CHECK_NULL_VOID(sinkDevObj);
1006     CHECK_AND_RETURN_LOG(sinkDevObj->TaskPlayStatusChange(eventParam) != DH_SUCCESS,
1007         "%{public}s", "Handle play status change event failed.");
1008 }
1009 
GetEventParam(const AppExecFwk::InnerEvent::Pointer & event,std::string & eventParam)1010 int32_t DAudioSinkDev::SinkEventHandler::GetEventParam(const AppExecFwk::InnerEvent::Pointer &event,
1011     std::string &eventParam)
1012 {
1013     CHECK_NULL_RETURN(event, ERR_DH_AUDIO_NULLPTR);
1014     std::shared_ptr<AudioEvent> paramObj = event->GetSharedObject<AudioEvent>();
1015     CHECK_NULL_RETURN(paramObj, ERR_DH_AUDIO_NULLPTR);
1016     eventParam = paramObj->content;
1017     return DH_SUCCESS;
1018 }
1019 
PauseDistributedHardware(const std::string & networkId)1020 int32_t DAudioSinkDev::PauseDistributedHardware(const std::string &networkId)
1021 {
1022     DHLOGI("DAudioSinkDev PauseDistributedHardware.");
1023     int32_t dhId = ConvertString2Int(micDhId_);
1024     std::shared_ptr<DMicClient> micClient = nullptr;
1025     {
1026         std::lock_guard<std::mutex> devLck(micClientMutex_);
1027         micClient = micClientMap_[dhId];
1028     }
1029 
1030     CHECK_NULL_RETURN(micClient, ERR_DH_AUDIO_NULLPTR);
1031     int32_t ret = micClient->PauseCapture();
1032     CHECK_AND_LOG(ret != DH_SUCCESS, "Pause mic client failed, ret: %{public}d.", ret);
1033     return ret;
1034 }
1035 
ResumeDistributedHardware(const std::string & networkId)1036 int32_t DAudioSinkDev::ResumeDistributedHardware(const std::string &networkId)
1037 {
1038     DHLOGI("DAudioSinkDev ResumeDistributedHardware.");
1039     int32_t dhId = ConvertString2Int(micDhId_);
1040     std::shared_ptr<DMicClient> micClient = nullptr;
1041     {
1042         std::lock_guard<std::mutex> devLck(micClientMutex_);
1043         micClient = micClientMap_[dhId];
1044     }
1045 
1046     CHECK_NULL_RETURN(micClient, ERR_DH_AUDIO_NULLPTR);
1047     int32_t ret = micClient->ResumeCapture();
1048     CHECK_AND_LOG(ret != DH_SUCCESS, "Resume mic client failed, ret: %{public}d.", ret);
1049     return ret;
1050 }
1051 
StopDistributedHardware(const std::string & networkId)1052 int32_t DAudioSinkDev::StopDistributedHardware(const std::string &networkId)
1053 {
1054     DHLOGI("DAudioSinkDev StopDistributedHardware.");
1055     isPageStatus_.store(false);
1056     NotifySourceDev(CLOSE_MIC, micDhId_, DH_SUCCESS);
1057     return DH_SUCCESS;
1058 }
1059 
SetSinkTokenId(uint64_t value)1060 void DAudioSinkDev::SetSinkTokenId(uint64_t value)
1061 {
1062     sinkTokenId_ = value;
1063 }
1064 } // namespace DistributedHardware
1065 } // namespace OHOS
1066