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 #ifndef INTELL_VOICE_TRIGGER_HELPER_H
16 #define INTELL_VOICE_TRIGGER_HELPER_H
17 
18 #include <cstdint>
19 #include <map>
20 #include "msg_handle_thread.h"
21 #include "trigger_base_type.h"
22 #include "i_intell_voice_trigger_recognition_callback.h"
23 #include "i_intell_voice_trigger_connector_module.h"
24 #include "i_intell_voice_trigger_connector_callback.h"
25 #include "trigger_connector_common_type.h"
26 #ifdef SUPPORT_TELEPHONY_SERVICE
27 #include "telephony_observer.h"
28 #endif
29 #include "audio_system_manager.h"
30 #include "audio_stream_manager.h"
31 #include "audio_info.h"
32 #include "sync_hibernate_callback_stub.h"
33 #include "sync_sleep_callback_stub.h"
34 
35 namespace OHOS {
36 namespace IntellVoiceTrigger {
37 using OHOS::AudioStandard::AudioCapturerSourceCallback;
38 using OHOS::AudioStandard::AudioRendererStateChangeCallback;
39 using OHOS::AudioStandard::AudioRendererChangeInfo;
40 
41 enum ModelState { MODEL_NOTLOADED, MODEL_LOADED, MODEL_STARTED, MODEL_STATE_BUT };
42 
43 class TriggerModelData {
44 public:
45     explicit TriggerModelData(int32_t uuid);
46     ~TriggerModelData();
47     void SetCallback(std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback);
48     std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> GetCallback();
49     void SetModel(std::shared_ptr<GenericTriggerModel> model);
50     std::shared_ptr<GenericTriggerModel> GetModel();
51     void SetState(ModelState state);
52     ModelState GetState() const;
53     void SetModelHandle(int32_t handle);
54     int32_t GetModelHandle() const;
55     void SetRequested(bool requested);
56     bool GetRequested() const;
57 
58     bool SameModel(std::shared_ptr<GenericTriggerModel> model);
59     void Clear();
60     void ClearCallback();
61 
62 public:
63     int32_t uuid_ = -1;
64 
65 private:
66     ModelState state_ = MODEL_NOTLOADED;
67     std::shared_ptr<GenericTriggerModel> model_ = nullptr;
68     std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback_ = nullptr;
69     int32_t modelHandle_ = 0;
70     bool requested_ = false;
71 };
72 
73 class TriggerHelper : public IIntellVoiceTriggerConnectorCallback, public std::enable_shared_from_this<TriggerHelper> {
74 public:
75     ~TriggerHelper();
76 
77     static std::shared_ptr<TriggerHelper> Create();
78 
79     int32_t StartGenericRecognition(int32_t uuid, std::shared_ptr<GenericTriggerModel> model,
80         std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback);
81     int32_t StopGenericRecognition(int32_t uuid, std::shared_ptr<IIntellVoiceTriggerRecognitionCallback> callback);
82     void UnloadGenericTriggerModel(int32_t uuid);
83     int32_t SetParameter(const std::string &key, const std::string &value);
84     std::string GetParameter(const std::string &key);
85     void AttachAudioCaptureListener();
86     void DetachAudioCaptureListener();
87     void AttachAudioRendererEventListener();
88     void DetachAudioRendererEventListener();
89 #ifdef SUPPORT_TELEPHONY_SERVICE
90     void AttachTelephonyObserver();
91     void DetachTelephonyObserver();
92 #endif
93     void AttachHibernateObserver();
94     void DetachHibernateObserver();
95 
96 private:
97     TriggerHelper();
98     bool GetModule();
99     std::shared_ptr<TriggerModelData> GetTriggerModelData(int32_t uuid);
100     std::shared_ptr<TriggerModelData> CreateTriggerModelData(int32_t uuid);
101     int32_t InitRecognition(std::shared_ptr<TriggerModelData> modelData, bool unload);
102     int32_t PrepareForRecognition(std::shared_ptr<TriggerModelData> modelData);
103     int32_t StartRecognition(std::shared_ptr<TriggerModelData> modelData);
104     int32_t StopRecognition(std::shared_ptr<TriggerModelData> modelData);
105     int32_t LoadModel(std::shared_ptr<TriggerModelData> modelData);
106     int32_t UnloadModel(std::shared_ptr<TriggerModelData> modelData);
107     void OnUpdateAllRecognitionState();
108     bool IsConflictSceneActive();
109 
110     void OnRecognition(int32_t modelHandle, const IntellVoiceRecognitionEvent &event) override;
111     void OnCapturerStateChange(bool isActive);
112     void OnUpdateRendererState(int32_t streamUsage, bool isPlaying);
113     void OnHibernateStateUpdated(bool isHibernate);
114 #ifdef SUPPORT_TELEPHONY_SERVICE
115     void OnCallStateUpdated(int32_t callState);
116     class TelephonyStateObserver : public Telephony::TelephonyObserver {
117     public:
TelephonyStateObserver(const std::shared_ptr<TriggerHelper> helper)118         explicit TelephonyStateObserver(const std::shared_ptr<TriggerHelper> helper) : helper_(helper)
119         {}
~TelephonyStateObserver()120         ~TelephonyStateObserver()
121         {
122             helper_ = nullptr;
123         }
124         void OnCallStateUpdated(int32_t slotId, int32_t callState, const std::u16string &phoneNumber) override;
125 
126     public:
127         std::shared_ptr<TriggerHelper> helper_ = nullptr;
128     };
129 
130 private:
131     sptr<TelephonyStateObserver> telephonyObserver0_ = nullptr;
132     sptr<TelephonyStateObserver> telephonyObserver1_ = nullptr;
133 #endif
134 
135     class AudioCapturerSourceChangeCallback : public AudioCapturerSourceCallback {
136     public:
AudioCapturerSourceChangeCallback(const std::shared_ptr<TriggerHelper> helper)137         explicit AudioCapturerSourceChangeCallback(const std::shared_ptr<TriggerHelper> helper) : helper_(helper)
138         {}
~AudioCapturerSourceChangeCallback()139         ~AudioCapturerSourceChangeCallback()
140         {
141             helper_ = nullptr;
142         }
143         void OnCapturerState(bool isActive) override;
144 
145     public:
146         std::shared_ptr<TriggerHelper> helper_ = nullptr;
147     };
148 
149     class AudioRendererStateChangeCallbackImpl : public AudioRendererStateChangeCallback {
150     public:
AudioRendererStateChangeCallbackImpl(const std::shared_ptr<TriggerHelper> helper)151         explicit AudioRendererStateChangeCallbackImpl(const std::shared_ptr<TriggerHelper> helper)
152             : helper_(helper)
153         {}
~AudioRendererStateChangeCallbackImpl()154         ~AudioRendererStateChangeCallbackImpl()
155         {
156             helper_ = nullptr;
157             rendererStateMap_.clear();
158         }
159 
160         void OnRendererStateChange(
161            const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override;
162     private:
163         std::mutex mutex_;
164         std::shared_ptr<TriggerHelper> helper_ = nullptr;
165         std::map<int32_t, bool> rendererStateMap_;
166     };
167 
168     class HibernateCallback : public PowerMgr::SyncHibernateCallbackStub {
169     public:
HibernateCallback(const std::shared_ptr<TriggerHelper> helper)170         explicit HibernateCallback(const std::shared_ptr<TriggerHelper> helper)
171             : helper_(helper)
172         {}
~HibernateCallback()173         ~HibernateCallback()
174         {
175             helper_ = nullptr;
176         }
177 
178         void OnSyncHibernate();
179         void OnSyncWakeup();
180 
181     private:
182         std::shared_ptr<TriggerHelper> helper_ = nullptr;
183     };
184 
185     class SleepCallback : public PowerMgr::SyncSleepCallbackStub {
186     public:
SleepCallback(const std::shared_ptr<TriggerHelper> helper)187         explicit SleepCallback(const std::shared_ptr<TriggerHelper> helper)
188             : helper_(helper)
189         {}
~SleepCallback()190         ~SleepCallback()
191         {
192             helper_ = nullptr;
193         }
194 
195         void OnSyncSleep(bool onForceSleep);
196         void OnSyncWakeup(bool onForceSleep);
197 
198     private:
199         std::shared_ptr<TriggerHelper> helper_ = nullptr;
200     };
201 
202 private:
203     std::mutex mutex_;
204     std::mutex telephonyMutex_;
205     std::mutex rendererMutex_;
206     std::mutex hiberateMutex_;
207 
208     std::map<int32_t, std::shared_ptr<TriggerModelData>> modelDataMap_;
209     std::shared_ptr<IIntellVoiceTriggerConnectorModule> module_ = nullptr;
210     std::vector<TriggerConnectorModuleDesc> moduleDesc_;
211     std::shared_ptr<AudioCapturerSourceChangeCallback> audioCapturerSourceChangeCallback_ = nullptr;
212     std::shared_ptr<AudioRendererStateChangeCallbackImpl> audioRendererStateChangeCallback_ = nullptr;
213     sptr<HibernateCallback> hibernateCallback_ = nullptr;
214     sptr<SleepCallback> sleepCallback_ = nullptr;
215     bool callActive_ = false;
216     bool systemHibernate_ = false;
217     bool audioCaptureActive_ = false;
218 #ifdef SUPPORT_TELEPHONY_SERVICE
219     bool isTelephonyDetached_ = false;
220 #endif
221     bool isRendererDetached_ = false;
222     bool isHibernateDetached_ = false;
223 };
224 }  // namespace IntellVoiceTrigger
225 }  // namespace OHOS
226 #endif