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_CONNECTOR_H
16 #define INTELL_VOICE_TRIGGER_CONNECTOR_H
17 
18 #include <memory>
19 #include <set>
20 #include <map>
21 #include <atomic>
22 #include <mutex>
23 #include <iservmgr_hdi.h>
24 #include "i_intell_voice_trigger_adapter_listener.h"
25 #include "i_intell_voice_trigger_connector_module.h"
26 #include "i_intell_voice_trigger_connector_callback.h"
27 #include "msg_handle_thread.h"
28 #include "task_executor.h"
29 #include "trigger_host_manager.h"
30 
31 namespace OHOS {
32 namespace IntellVoiceTrigger {
33 using OHOS::HDI::ServiceManager::V1_0::ServiceStatus;
34 using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub;
35 
36 using OHOS::HDI::IntelligentVoice::Trigger::V1_0::IIntellVoiceTriggerCallback;
37 using OHOS::HDI::IntelligentVoice::Trigger::V1_0::IntellVoiceRecognitionEvent;
38 using OHOS::HDI::IntelligentVoice::Trigger::V1_0::IntellVoiceTriggerAdapterDsecriptor;
39 using OHOS::HDI::IntelligentVoice::Trigger::V1_0::IntellVoiceTriggerProperties;
40 
41 using OnServiceStartCb = std::function<void(const IntellVoiceTriggerAdapterDsecriptor &desc)>;
42 
43 class TriggerConnector : public ServStatListenerStub, private TriggerHostManager {
44 public:
45     TriggerConnector(OnServiceStartCb cb, const IntellVoiceTriggerAdapterDsecriptor &desc);
46     ~TriggerConnector() override;
47     std::shared_ptr<IIntellVoiceTriggerConnectorModule> GetModule(
48         std::shared_ptr<IIntellVoiceTriggerConnectorCallback> callback);
49     IntellVoiceTriggerProperties GetProperties();
50     void OnReceive(const ServiceStatus &serviceStatus) override;
51     void onServiceStart();
52 
53 private:
54     bool LoadHdiAdapter();
55 
56 private:
57     class TriggerSession : public IIntellVoiceTriggerConnectorModule, private OHOS::IntellVoiceUtils::TaskExecutor {
58     public:
59         TriggerSession(TriggerConnector *connector, std::shared_ptr<IIntellVoiceTriggerConnectorCallback> callback,
60             uint32_t threadId);
61         ~TriggerSession() override;
GetTriggerConnector()62         TriggerConnector* GetTriggerConnector()
63         {
64             return connector_;
65         }
GetCallback()66         std::shared_ptr<IIntellVoiceTriggerConnectorCallback> GetCallback()
67         {
68             return callback_;
69         }
70         int32_t LoadModel(std::shared_ptr<GenericTriggerModel> model, int32_t &modelHandle) override;
71         int32_t UnloadModel(int32_t modelHandle) override;
72         int32_t Start(int32_t modelHandle) override;
73         int32_t Stop(int32_t modelHandle) override;
74         int32_t SetParams(const std::string &key, const std::string &value) override;
75         int32_t GetParams(const std::string& key, std::string &value) override;
76 
77         void HandleRecognitionHdiEvent(std::shared_ptr<IntellVoiceRecognitionEvent> event, int32_t modelHandle);
78 
79     private:
80         class Model : public IIntellVoiceTriggerAdapterListener, public std::enable_shared_from_this<Model> {
81         public:
82             static std::shared_ptr<Model> Create(TriggerSession *session);
83             int32_t Load(std::shared_ptr<GenericTriggerModel> model, int32_t &modelHandle);
84             int32_t Unload();
85             int32_t Start();
86             int32_t Stop();
87 #ifdef TRIGGER_MANAGER_TEST
88             void TriggerManagerCallbackTest();
89 #endif
90         public:
91             void OnRecognitionHdiEvent(const IntellVoiceRecognitionEvent &event, int32_t cookie) override;
92 
93             enum ModelState {
94                 IDLE,
95                 LOADED,
96                 ACTIVE,
97             };
GetState()98             ModelState GetState()
99             {
100                 return state_.load();
101             }
102 
SetState(ModelState state)103             void SetState(ModelState state)
104             {
105                 state_.store(state);
106             }
107 
108         private:
Model(TriggerSession * session)109             explicit Model(TriggerSession *session) : session_(session)
110             {}
111             sptr<Ashmem> CreateAshmemFromModelData(const std::vector<uint8_t> &modelData);
112             int32_t handle_ = 0;
113             std::atomic<ModelState> state_ = IDLE;
114             TriggerSession *session_ = nullptr;
115             sptr<IIntellVoiceTriggerCallback> callback_ = nullptr;
116         };  // Model
117 
118     private:
119         void ProcessRecognitionHdiEvent(std::shared_ptr<IntellVoiceRecognitionEvent> event, int32_t modelHandle);
120 
121     private:
122         TriggerConnector *connector_ = nullptr;
123         std::shared_ptr<IIntellVoiceTriggerConnectorCallback> callback_ = nullptr;
124         std::map<int32_t, std::shared_ptr<Model>> loadedModels_;
125     };  // TriggerSession
126 
127 private:
128     std::mutex mutex_ {};
129     uint16_t serviceState_ = HDI::ServiceManager::V1_0::SERVIE_STATUS_MAX;
130     bool getModuleFail_ = false;
131     OnServiceStartCb cb_;
132     IntellVoiceTriggerAdapterDsecriptor desc_;
133     std::set<std::shared_ptr<TriggerSession>> activeSessions_;
134 };
135 }  // namespace IntellVoiceTrigger
136 }  // namespace OHOS
137 #endif