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