1 /*
2 * Copyright (c) 2023 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 #include "trigger_helper.h"
16 #include "intell_voice_log.h"
17
18 #include "trigger_connector_mgr.h"
19 #ifdef SUPPORT_TELEPHONY_SERVICE
20 #include "telephony_observer_client.h"
21 #include "state_registry_errors.h"
22 #include "telephony_types.h"
23 #include "call_manager_inner_type.h"
24 #endif
25 #include "audio_policy_manager.h"
26 #include "power_mgr_client.h"
27
28 #undef LOG_TAG
29 #define LOG_TAG "TriggerHelper"
30
31 using namespace OHOS::HDI::IntelligentVoice::Trigger::V1_0;
32 using namespace OHOS::AudioStandard;
33 #ifdef SUPPORT_TELEPHONY_SERVICE
34 using namespace OHOS::Telephony;
35 #endif
36 using namespace OHOS::AudioStandard;
37 using namespace OHOS::PowerMgr;
38 using namespace std;
39
40 namespace OHOS {
41 namespace IntellVoiceTrigger {
42 #ifdef SUPPORT_TELEPHONY_SERVICE
43 static constexpr int32_t SIM_SLOT_ID_1 = DEFAULT_SIM_SLOT_ID + 1;
44 #endif
45
TriggerModelData(int32_t uuid)46 TriggerModelData::TriggerModelData(int32_t uuid)
47 {
48 uuid_ = uuid;
49 }
50
~TriggerModelData()51 TriggerModelData::~TriggerModelData()
52 {
53 }
54
SetCallback(std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback)55 void TriggerModelData::SetCallback(std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback)
56 {
57 if (callback == nullptr) {
58 INTELL_VOICE_LOG_ERROR("callback is nullptr");
59 return;
60 }
61 callback_ = callback;
62 }
63
GetCallback()64 std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> TriggerModelData::GetCallback()
65 {
66 return callback_;
67 }
68
SetModel(std::shared_ptr<GenericTriggerModel> model)69 void TriggerModelData::SetModel(std::shared_ptr<GenericTriggerModel> model)
70 {
71 if (SameModel(model)) {
72 INTELL_VOICE_LOG_INFO("same model not need to update");
73 return;
74 }
75 model_ = model;
76 model_->Print();
77 }
78
GetModel()79 shared_ptr<GenericTriggerModel> TriggerModelData::GetModel()
80 {
81 return model_;
82 }
83
SameModel(std::shared_ptr<GenericTriggerModel> model)84 bool TriggerModelData::SameModel(std::shared_ptr<GenericTriggerModel> model)
85 {
86 if (model == nullptr || model_ == nullptr) {
87 return false;
88 }
89 return model_->GetData() == model->GetData();
90 }
91
SetState(ModelState state)92 void TriggerModelData::SetState(ModelState state)
93 {
94 state_ = state;
95 }
96
GetState() const97 ModelState TriggerModelData::GetState() const
98 {
99 return state_;
100 }
101
SetModelHandle(int32_t handle)102 void TriggerModelData::SetModelHandle(int32_t handle)
103 {
104 modelHandle_ = handle;
105 }
106
GetModelHandle() const107 int32_t TriggerModelData::GetModelHandle() const
108 {
109 return modelHandle_;
110 }
111
SetRequested(bool requested)112 void TriggerModelData::SetRequested(bool requested)
113 {
114 requested_ = requested;
115 }
116
GetRequested() const117 bool TriggerModelData::GetRequested() const
118 {
119 return requested_;
120 }
121
Clear()122 void TriggerModelData::Clear()
123 {
124 callback_ = nullptr;
125 state_ = MODEL_NOTLOADED;
126 }
127
ClearCallback()128 void TriggerModelData::ClearCallback()
129 {
130 callback_ = nullptr;
131 }
132
TriggerHelper()133 TriggerHelper::TriggerHelper()
134 {
135 const auto &connectMgr = TriggerConnectorMgr::GetInstance();
136 if (connectMgr != nullptr) {
137 moduleDesc_ = connectMgr->ListConnectorModuleDescriptors();
138 }
139 }
140
~TriggerHelper()141 TriggerHelper::~TriggerHelper()
142 {
143 modelDataMap_.clear();
144 }
145
Create()146 std::shared_ptr<TriggerHelper> TriggerHelper::Create()
147 {
148 return std::shared_ptr<TriggerHelper>(new (std::nothrow) TriggerHelper());
149 }
150
StartGenericRecognition(int32_t uuid,std::shared_ptr<GenericTriggerModel> model,shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback)151 int32_t TriggerHelper::StartGenericRecognition(int32_t uuid, std::shared_ptr<GenericTriggerModel> model,
152 shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback)
153 {
154 INTELL_VOICE_LOG_INFO("enter");
155 lock_guard<std::mutex> lock(mutex_);
156
157 auto modelData = GetTriggerModelData(uuid);
158 if (modelData == nullptr) {
159 modelData = CreateTriggerModelData((uuid));
160 if (modelData == nullptr) {
161 INTELL_VOICE_LOG_ERROR("failed to create trigger model data");
162 return -1;
163 }
164 }
165
166 bool unload = !modelData->SameModel(model);
167 int32_t ret = InitRecognition(modelData, unload);
168 if (ret != 0) {
169 INTELL_VOICE_LOG_ERROR("failed to initialize recognition");
170 return -1;
171 }
172
173 modelData->SetModel(model);
174 modelData->SetCallback(callback);
175 modelData->SetRequested(true);
176
177 if (IsConflictSceneActive()) {
178 INTELL_VOICE_LOG_INFO("conflict state, no need to start");
179 return 0;
180 }
181
182 ret = PrepareForRecognition(modelData);
183 if (ret != 0) {
184 return ret;
185 }
186
187 return StartRecognition(modelData);
188 }
189
StopGenericRecognition(int32_t uuid,shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback)190 int32_t TriggerHelper::StopGenericRecognition(int32_t uuid, shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback)
191 {
192 INTELL_VOICE_LOG_INFO("enter");
193 lock_guard<std::mutex> lock(mutex_);
194 auto modelData = GetTriggerModelData(uuid);
195 if (modelData == nullptr) {
196 INTELL_VOICE_LOG_ERROR("failed to get trigger model data");
197 return -1;
198 }
199 modelData->SetRequested(false);
200 int32_t ret = StopRecognition(modelData);
201 if (ret != 0) {
202 return ret;
203 }
204 modelData->ClearCallback();
205 return ret;
206 }
207
UnloadGenericTriggerModel(int32_t uuid)208 void TriggerHelper::UnloadGenericTriggerModel(int32_t uuid)
209 {
210 INTELL_VOICE_LOG_INFO("enter");
211 lock_guard<std::mutex> lock(mutex_);
212 auto modelData = GetTriggerModelData(uuid);
213 if (modelData == nullptr) {
214 INTELL_VOICE_LOG_WARN("no trigger model data");
215 return;
216 }
217
218 if (modelData->GetState() == MODEL_NOTLOADED) {
219 INTELL_VOICE_LOG_INFO("model is not loaded");
220 return;
221 }
222 StopRecognition(modelData);
223 UnloadModel(modelData);
224 modelDataMap_.erase(uuid);
225 }
226
SetParameter(const std::string & key,const std::string & value)227 int32_t TriggerHelper::SetParameter(const std::string &key, const std::string &value)
228 {
229 INTELL_VOICE_LOG_INFO("enter");
230 lock_guard<std::mutex> lock(mutex_);
231 if (!GetModule()) {
232 return -1;
233 }
234
235 return module_->SetParams(key, value);
236 }
237
GetParameter(const std::string & key)238 std::string TriggerHelper::GetParameter(const std::string &key)
239 {
240 INTELL_VOICE_LOG_INFO("enter");
241 lock_guard<std::mutex> lock(mutex_);
242 if (!GetModule()) {
243 return "";
244 }
245
246 std::string value;
247 auto ret = module_->GetParams(key, value);
248 if (ret != 0) {
249 INTELL_VOICE_LOG_ERROR("failed to get parameter");
250 return "";
251 }
252
253 return value;
254 }
255
GetModule()256 bool TriggerHelper::GetModule()
257 {
258 if (module_ != nullptr) {
259 return true;
260 }
261 if (moduleDesc_.size() == 0) {
262 INTELL_VOICE_LOG_ERROR("moduleDesc_ is empty");
263 return false;
264 }
265 module_ = TriggerConnectorMgr::GetInstance()->GetConnectorModule(moduleDesc_[0].adapterName, shared_from_this());
266 if (module_ == nullptr) {
267 INTELL_VOICE_LOG_ERROR("failed to get connector module");
268 return false;
269 }
270 return true;
271 }
272
InitRecognition(std::shared_ptr<TriggerModelData> modelData,bool unload)273 int32_t TriggerHelper::InitRecognition(std::shared_ptr<TriggerModelData> modelData, bool unload)
274 {
275 INTELL_VOICE_LOG_INFO("enter");
276 if (modelData->GetState() == MODEL_NOTLOADED) {
277 return 0;
278 }
279 int32_t ret = StopRecognition(modelData);
280 if (unload) {
281 ret = UnloadModel(modelData);
282 modelData->Clear();
283 }
284
285 return ret;
286 }
287
PrepareForRecognition(std::shared_ptr<TriggerModelData> modelData)288 int32_t TriggerHelper::PrepareForRecognition(std::shared_ptr<TriggerModelData> modelData)
289 {
290 INTELL_VOICE_LOG_INFO("enter");
291 if (!GetModule()) {
292 return -1;
293 }
294
295 if (LoadModel(modelData) != 0) {
296 return -1;
297 }
298 return 0;
299 }
300
StartRecognition(shared_ptr<TriggerModelData> modelData)301 int32_t TriggerHelper::StartRecognition(shared_ptr<TriggerModelData> modelData)
302 {
303 if (modelData == nullptr) {
304 INTELL_VOICE_LOG_ERROR("modelData is nullptr");
305 return -1;
306 }
307 if (modelData->GetState() != MODEL_LOADED) {
308 return 0;
309 }
310 INTELL_VOICE_LOG_INFO("enter");
311 if (module_ == nullptr) {
312 INTELL_VOICE_LOG_ERROR("module_ is nullptr");
313 return -1;
314 }
315 auto ret = module_->Start(modelData->GetModelHandle());
316 if (ret != 0) {
317 INTELL_VOICE_LOG_ERROR("failed to start recognition");
318 return ret;
319 }
320 modelData->SetState(MODEL_STARTED);
321 return ret;
322 }
323
StopRecognition(shared_ptr<TriggerModelData> modelData)324 int32_t TriggerHelper::StopRecognition(shared_ptr<TriggerModelData> modelData)
325 {
326 if (modelData == nullptr) {
327 INTELL_VOICE_LOG_ERROR("modelData is nullptr");
328 return -1;
329 }
330 if (modelData->GetState() != MODEL_STARTED) {
331 return 0;
332 }
333 INTELL_VOICE_LOG_INFO("enter");
334 if (module_ == nullptr) {
335 INTELL_VOICE_LOG_ERROR("module_ is nullptr");
336 return -1;
337 }
338 auto ret = module_->Stop(modelData->GetModelHandle());
339 if (ret != 0) {
340 INTELL_VOICE_LOG_ERROR("failed to stop");
341 return ret;
342 }
343
344 modelData->SetState(MODEL_LOADED);
345 return ret;
346 }
347
LoadModel(shared_ptr<TriggerModelData> modelData)348 int32_t TriggerHelper::LoadModel(shared_ptr<TriggerModelData> modelData)
349 {
350 INTELL_VOICE_LOG_INFO("enter");
351 if (modelData == nullptr) {
352 INTELL_VOICE_LOG_ERROR("modelData is nullptr");
353 return -1;
354 }
355 if (modelData->GetState() != MODEL_NOTLOADED) {
356 INTELL_VOICE_LOG_WARN("model is already loaded");
357 return 0;
358 }
359
360 if (module_ == nullptr) {
361 INTELL_VOICE_LOG_ERROR("module_ is nullptr");
362 return -1;
363 }
364
365 int32_t handle;
366 auto ret = module_->LoadModel(modelData->GetModel(), handle);
367 if (ret != 0) {
368 INTELL_VOICE_LOG_WARN("failed to load model, ret: %{public}d", ret);
369 return ret;
370 }
371 modelData->SetModelHandle(handle);
372 modelData->SetState(MODEL_LOADED);
373 INTELL_VOICE_LOG_INFO("exit, handle: %{public}d", handle);
374 return ret;
375 }
376
UnloadModel(shared_ptr<TriggerModelData> modelData)377 int32_t TriggerHelper::UnloadModel(shared_ptr<TriggerModelData> modelData)
378 {
379 if (modelData == nullptr) {
380 INTELL_VOICE_LOG_ERROR("modelData is nullptr");
381 return -1;
382 }
383 if (modelData->GetState() != MODEL_LOADED) {
384 return 0;
385 }
386 INTELL_VOICE_LOG_INFO("enter");
387 if (module_ == nullptr) {
388 INTELL_VOICE_LOG_ERROR("module_ is nullptr");
389 return -1;
390 }
391 auto ret = module_->UnloadModel(modelData->GetModelHandle());
392 modelData->SetState(MODEL_NOTLOADED);
393 return ret;
394 }
395
GetTriggerModelData(int32_t uuid)396 shared_ptr<TriggerModelData> TriggerHelper::GetTriggerModelData(int32_t uuid)
397 {
398 INTELL_VOICE_LOG_INFO("enter, uuid is :%{public}d", uuid);
399 auto it = modelDataMap_.find(uuid);
400 if ((it == modelDataMap_.end()) || (it->second == nullptr)) {
401 return nullptr;
402 }
403
404 return it->second;
405 }
406
CreateTriggerModelData(int32_t uuid)407 shared_ptr<TriggerModelData> TriggerHelper::CreateTriggerModelData(int32_t uuid)
408 {
409 INTELL_VOICE_LOG_INFO("enter, uuid is :%{public}d", uuid);
410 auto modelData = std::make_shared<TriggerModelData>(uuid);
411 if (modelData == nullptr) {
412 INTELL_VOICE_LOG_INFO("modelData is nullptr");
413 return nullptr;
414 }
415 modelDataMap_.insert(std::make_pair(uuid, modelData));
416 return modelData;
417 }
418
OnRecognition(int32_t modelHandle,const IntellVoiceRecognitionEvent & event)419 void TriggerHelper::OnRecognition(int32_t modelHandle, const IntellVoiceRecognitionEvent &event)
420 {
421 INTELL_VOICE_LOG_INFO("enter, modelHandle:%{public}d", modelHandle);
422 lock_guard<std::mutex> lock(mutex_);
423 std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback = nullptr;
424 for (auto iter : modelDataMap_) {
425 if (iter.second == nullptr) {
426 INTELL_VOICE_LOG_ERROR("uuid: %{public}d, model data is nullptr", iter.first);
427 continue;
428 }
429
430 if (iter.second->GetModelHandle() == modelHandle) {
431 iter.second->SetState(MODEL_LOADED);
432 callback = iter.second->GetCallback();
433 break;
434 }
435 }
436
437 if (callback == nullptr) {
438 INTELL_VOICE_LOG_ERROR("trigger recognition callback is nullptr, modelHandle: %{public}d", modelHandle);
439 return;
440 }
441
442 auto genericEvent = std::make_shared<GenericTriggerEvent>();
443 if (genericEvent == nullptr) {
444 INTELL_VOICE_LOG_ERROR("genericEvent is nullptr");
445 return;
446 }
447 genericEvent->modelHandle_ = modelHandle;
448 callback->OnGenericTriggerDetected(genericEvent);
449 }
450
IsConflictSceneActive()451 bool TriggerHelper::IsConflictSceneActive()
452 {
453 INTELL_VOICE_LOG_INFO("callActive: %{public}d, audioCaptureActive: %{public}d, systemHibernate: %{public}d",
454 callActive_, audioCaptureActive_, systemHibernate_);
455 return (callActive_ || audioCaptureActive_ || systemHibernate_);
456 }
457
OnUpdateAllRecognitionState()458 void TriggerHelper::OnUpdateAllRecognitionState()
459 {
460 for (auto iter : modelDataMap_) {
461 if (iter.second == nullptr) {
462 INTELL_VOICE_LOG_ERROR("uuid: %{public}d, model data is nullptr", iter.first);
463 continue;
464 }
465 bool needStart =
466 (iter.second->GetRequested() && (!IsConflictSceneActive()));
467 if (needStart == (iter.second->GetState() == MODEL_STARTED)) {
468 INTELL_VOICE_LOG_INFO("no operation, needStart:%{public}d", needStart);
469 continue;
470 }
471 if (needStart) {
472 if (PrepareForRecognition(iter.second) != 0) {
473 return;
474 }
475 StartRecognition(iter.second);
476 } else {
477 StopRecognition(iter.second);
478 if (systemHibernate_) {
479 UnloadModel(iter.second);
480 }
481 }
482 }
483 }
484
485 #ifdef SUPPORT_TELEPHONY_SERVICE
AttachTelephonyObserver()486 void TriggerHelper::AttachTelephonyObserver()
487 {
488 INTELL_VOICE_LOG_INFO("enter");
489 std::lock_guard<std::mutex> lock(telephonyMutex_);
490 if (isTelephonyDetached_) {
491 INTELL_VOICE_LOG_INFO("telephony is already detached");
492 return;
493 }
494 telephonyObserver0_ = std::make_unique<TelephonyStateObserver>(shared_from_this()).release();
495 if (telephonyObserver0_ == nullptr) {
496 INTELL_VOICE_LOG_ERROR("telephonyObserver0_ is nullptr");
497 return;
498 }
499 auto res = TelephonyObserverClient::GetInstance().AddStateObserver(
500 telephonyObserver0_, DEFAULT_SIM_SLOT_ID, TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE, false);
501 if (res != TELEPHONY_SUCCESS) {
502 INTELL_VOICE_LOG_ERROR("telephonyObserver0_ add failed");
503 }
504
505 telephonyObserver1_ = std::make_unique<TelephonyStateObserver>(shared_from_this()).release();
506 if (telephonyObserver1_ == nullptr) {
507 INTELL_VOICE_LOG_ERROR("telephonyObserver1_ is nullptr");
508 return;
509 }
510 res = TelephonyObserverClient::GetInstance().AddStateObserver(
511 telephonyObserver1_, SIM_SLOT_ID_1, TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE, false);
512 if (res != TELEPHONY_SUCCESS) {
513 INTELL_VOICE_LOG_ERROR("telephonyObserver1_ add failed");
514 }
515 }
516
DetachTelephonyObserver()517 void TriggerHelper::DetachTelephonyObserver()
518 {
519 INTELL_VOICE_LOG_INFO("enter");
520 std::lock_guard<std::mutex> lock(telephonyMutex_);
521 isTelephonyDetached_ = true;
522
523 if (telephonyObserver0_ != nullptr) {
524 Telephony::TelephonyObserverClient::GetInstance().RemoveStateObserver(
525 DEFAULT_SIM_SLOT_ID, Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE);
526 telephonyObserver0_ = nullptr;
527 }
528
529 if (telephonyObserver1_ != nullptr) {
530 Telephony::TelephonyObserverClient::GetInstance().RemoveStateObserver(
531 SIM_SLOT_ID_1, Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE);
532 telephonyObserver1_ = nullptr;
533 }
534 }
535
OnCallStateUpdated(int32_t callState)536 void TriggerHelper::OnCallStateUpdated(int32_t callState)
537 {
538 lock_guard<std::mutex> lock(mutex_);
539 if (callState < static_cast<int32_t>(TelCallState::CALL_STATUS_UNKNOWN) ||
540 callState > static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE)) {
541 INTELL_VOICE_LOG_ERROR("callstate err: %{public}d", callState);
542 return;
543 }
544
545 bool curCallActive = (callState != static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED) &&
546 callState != static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE) &&
547 callState != static_cast<int32_t>(TelCallState::CALL_STATUS_UNKNOWN));
548 INTELL_VOICE_LOG_INFO("state: %{public}d, callActive: %{public}d, curCallActive: %{public}d",
549 callState,
550 callActive_,
551 curCallActive);
552 if (callActive_ == curCallActive) {
553 return;
554 }
555
556 callActive_ = curCallActive;
557 OnUpdateAllRecognitionState();
558 }
559
OnCallStateUpdated(int32_t slotId,int32_t callState,const std::u16string & phoneNumber)560 void TriggerHelper::TelephonyStateObserver::OnCallStateUpdated(
561 int32_t slotId, int32_t callState, const std::u16string &phoneNumber)
562 {
563 if (helper_ == nullptr) {
564 INTELL_VOICE_LOG_ERROR("helper is nullptr");
565 return;
566 }
567
568 helper_->OnCallStateUpdated(callState);
569 }
570 #endif
571
OnHibernateStateUpdated(bool isHibernate)572 void TriggerHelper::OnHibernateStateUpdated(bool isHibernate)
573 {
574 lock_guard<std::mutex> lock(mutex_);
575 if (systemHibernate_ == isHibernate) {
576 return;
577 }
578 systemHibernate_ = isHibernate;
579 OnUpdateAllRecognitionState();
580 }
581
AttachAudioCaptureListener()582 void TriggerHelper::AttachAudioCaptureListener()
583 {
584 INTELL_VOICE_LOG_INFO("enter");
585
586 audioCapturerSourceChangeCallback_ = std::make_shared<AudioCapturerSourceChangeCallback>(shared_from_this());
587 auto audioSystemManager = AudioSystemManager::GetInstance();
588 if (audioSystemManager != nullptr) {
589 audioSystemManager->SetAudioCapturerSourceCallback(audioCapturerSourceChangeCallback_);
590 } else {
591 INTELL_VOICE_LOG_ERROR("audioSystemManager is nullptr");
592 }
593 }
594
DetachAudioCaptureListener()595 void TriggerHelper::DetachAudioCaptureListener()
596 {
597 INTELL_VOICE_LOG_INFO("enter");
598
599 auto audioSystemManager = AudioSystemManager::GetInstance();
600 if (audioSystemManager != nullptr) {
601 audioSystemManager->SetAudioCapturerSourceCallback(nullptr);
602 } else {
603 INTELL_VOICE_LOG_ERROR("audioSystemManager is null");
604 }
605 }
606
OnCapturerStateChange(bool isActive)607 void TriggerHelper::OnCapturerStateChange(bool isActive)
608 {
609 lock_guard<std::mutex> lock(mutex_);
610 if (audioCaptureActive_ == isActive) {
611 return;
612 }
613
614 audioCaptureActive_ = isActive;
615 OnUpdateAllRecognitionState();
616 }
617
OnCapturerState(bool isActive)618 void TriggerHelper::AudioCapturerSourceChangeCallback::OnCapturerState(bool isActive)
619 {
620 INTELL_VOICE_LOG_INFO("OnCapturerState active: %{public}d", isActive);
621
622 if (helper_ == nullptr) {
623 INTELL_VOICE_LOG_ERROR("helper is nullptr");
624 return;
625 }
626
627 helper_->OnCapturerStateChange(isActive);
628 }
629
OnRendererStateChange(const std::vector<std::unique_ptr<AudioStandard::AudioRendererChangeInfo>> & audioRendererChangeInfos)630 void TriggerHelper::AudioRendererStateChangeCallbackImpl::OnRendererStateChange(
631 const std::vector<std::unique_ptr<AudioStandard::AudioRendererChangeInfo>> &audioRendererChangeInfos)
632 {
633 std::lock_guard<std::mutex> lock(mutex_);
634 if (helper_ == nullptr) {
635 INTELL_VOICE_LOG_ERROR("helper is nullptr");
636 return;
637 }
638 std::map<int32_t, bool> stateMap;
639 for (const auto &info : audioRendererChangeInfos) {
640 if (info == nullptr) {
641 INTELL_VOICE_LOG_ERROR("info is nullptr");
642 continue;
643 }
644 bool isPlaying = false;
645 if (info->rendererState == AudioStandard::RENDERER_RUNNING) {
646 isPlaying = true;
647 }
648
649 if (stateMap.count(info->rendererInfo.streamUsage) == 0 || !stateMap[info->rendererInfo.streamUsage]) {
650 stateMap[info->rendererInfo.streamUsage] = isPlaying;
651 }
652 }
653
654 for (auto iter : stateMap) {
655 std::string key = iter.second ? "start_stream" : "stop_stream";
656 if (rendererStateMap_.count(iter.first) == 0) {
657 rendererStateMap_[iter.first] = iter.second;
658 INTELL_VOICE_LOG_INFO("first change, usage:%{public}d, isPlaying:%{public}d",
659 iter.first, iter.second);
660 helper_->SetParameter(key, std::to_string(iter.first));
661 } else {
662 if (rendererStateMap_[iter.first] != iter.second) {
663 INTELL_VOICE_LOG_INFO("state change, usage:%{public}d, isPlaying:%{public}d",
664 iter.first, iter.second);
665 rendererStateMap_[iter.first] = iter.second;
666 helper_->SetParameter(key, std::to_string(iter.first));
667 }
668 }
669 }
670 }
671
OnSyncHibernate()672 void TriggerHelper::HibernateCallback::OnSyncHibernate()
673 {
674 if (helper_ == nullptr) {
675 INTELL_VOICE_LOG_ERROR("helper is nullptr");
676 return;
677 }
678
679 helper_->OnHibernateStateUpdated(true);
680 }
681
OnSyncWakeup()682 void TriggerHelper::HibernateCallback::OnSyncWakeup()
683 {
684 if (helper_ == nullptr) {
685 INTELL_VOICE_LOG_ERROR("helper is nullptr");
686 return;
687 }
688
689 helper_->OnHibernateStateUpdated(false);
690 }
691
OnSyncSleep(bool onForceSleep)692 void TriggerHelper::SleepCallback::OnSyncSleep(bool onForceSleep)
693 {
694 if (!onForceSleep) {
695 INTELL_VOICE_LOG_INFO("not onForceSleep");
696 return;
697 }
698
699 if (helper_ == nullptr) {
700 INTELL_VOICE_LOG_ERROR("helper is nullptr");
701 return;
702 }
703
704 helper_->OnHibernateStateUpdated(true);
705 }
706
OnSyncWakeup(bool onForceSleep)707 void TriggerHelper::SleepCallback::OnSyncWakeup(bool onForceSleep)
708 {
709 if (!onForceSleep) {
710 INTELL_VOICE_LOG_INFO("not onForceSleep");
711 return;
712 }
713
714 if (helper_ == nullptr) {
715 INTELL_VOICE_LOG_ERROR("helper is nullptr");
716 return;
717 }
718
719 helper_->OnHibernateStateUpdated(false);
720 }
721
AttachAudioRendererEventListener()722 void TriggerHelper::AttachAudioRendererEventListener()
723 {
724 INTELL_VOICE_LOG_INFO("enter");
725 std::lock_guard<std::mutex> lock(rendererMutex_);
726 if (isRendererDetached_) {
727 INTELL_VOICE_LOG_INFO("renderer event listener is already detached");
728 return;
729 }
730 audioRendererStateChangeCallback_ = std::make_shared<AudioRendererStateChangeCallbackImpl>(shared_from_this());
731 if (audioRendererStateChangeCallback_ == nullptr) {
732 INTELL_VOICE_LOG_ERROR("Memory Allocation Failed !!");
733 return;
734 }
735
736 int32_t ret = AudioStreamManager::GetInstance()->RegisterAudioRendererEventListener(getpid(),
737 audioRendererStateChangeCallback_);
738 if (ret != 0) {
739 INTELL_VOICE_LOG_ERROR("RegisterAudioRendererEventListener failed");
740 return;
741 }
742 INTELL_VOICE_LOG_INFO("RegisterAudioRendererEventListener success");
743
744 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
745 AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
746 audioRendererStateChangeCallback_->OnRendererStateChange(audioRendererChangeInfos);
747 }
748
DetachAudioRendererEventListener()749 void TriggerHelper::DetachAudioRendererEventListener()
750 {
751 INTELL_VOICE_LOG_INFO("enter");
752 std::lock_guard<std::mutex> lock(rendererMutex_);
753 isRendererDetached_ = true;
754 int32_t ret = AudioStreamManager::GetInstance()->UnregisterAudioRendererEventListener(getpid());
755 if (ret != 0) {
756 INTELL_VOICE_LOG_ERROR("UnregisterAudioRendererEventListener failed");
757 }
758 }
759
AttachHibernateObserver()760 void TriggerHelper::AttachHibernateObserver()
761 {
762 INTELL_VOICE_LOG_INFO("enter");
763 std::lock_guard<std::mutex> lock(hiberateMutex_);
764 if (isHibernateDetached_) {
765 INTELL_VOICE_LOG_INFO("system hibernate is already detached");
766 return;
767 }
768
769 hibernateCallback_ = std::make_unique<HibernateCallback>(shared_from_this()).release();
770 if (hibernateCallback_ == nullptr) {
771 INTELL_VOICE_LOG_ERROR("hibernateCallback_ is nullptr");
772 return;
773 }
774 auto res = PowerMgrClient::GetInstance().RegisterSyncHibernateCallback(hibernateCallback_);
775 if (!res) {
776 INTELL_VOICE_LOG_ERROR("hibernateCallback_ register failed");
777 }
778
779 sleepCallback_ = std::make_unique<SleepCallback>(shared_from_this()).release();
780 if (sleepCallback_ == nullptr) {
781 INTELL_VOICE_LOG_ERROR("sleepCallback_ is nullptr");
782 return;
783 }
784 res = PowerMgrClient::GetInstance().RegisterSyncSleepCallback(sleepCallback_, SleepPriority::DEFAULT);
785 if (!res) {
786 INTELL_VOICE_LOG_ERROR("sleepCallback_ register failed");
787 }
788 }
789
DetachHibernateObserver()790 void TriggerHelper::DetachHibernateObserver()
791 {
792 INTELL_VOICE_LOG_INFO("enter");
793 std::lock_guard<std::mutex> lock(hiberateMutex_);
794
795 isHibernateDetached_ = true;
796 if (hibernateCallback_ == nullptr) {
797 INTELL_VOICE_LOG_ERROR("hibernateCallback_ is nullptr");
798 return;
799 }
800 auto res = PowerMgrClient::GetInstance().UnRegisterSyncHibernateCallback(hibernateCallback_);
801 if (!res) {
802 INTELL_VOICE_LOG_ERROR("hibernateCallback_ unregister failed");
803 }
804
805 if (sleepCallback_ == nullptr) {
806 INTELL_VOICE_LOG_ERROR("sleepCallback_ is nullptr");
807 return;
808 }
809 res = PowerMgrClient::GetInstance().UnRegisterSyncSleepCallback(sleepCallback_);
810 if (!res) {
811 INTELL_VOICE_LOG_ERROR("sleepCallback_ unregister failed");
812 }
813 }
814 } // namespace IntellVoiceTrigger
815 } // namespace OHOS
816