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_manager.h"
16 #include "trigger_service.h"
17 #include "intell_voice_log.h"
18 #include "memory_guard.h"
19
20 #define LOG_TAG "TriggerManager"
21
22 namespace OHOS {
23 namespace IntellVoiceTrigger {
24 std::mutex TriggerManager::instanceMutex_;
25 std::shared_ptr<TriggerManager> TriggerManager::instance_ = nullptr;
26
TriggerManager()27 TriggerManager::TriggerManager()
28 {
29 OHOS::IntellVoiceUtils::MemoryGuard memoryGuard;
30 service_ = std::make_shared<TriggerService>();
31 if (service_ == nullptr) {
32 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
33 }
34 }
35
~TriggerManager()36 TriggerManager::~TriggerManager()
37 {
38 service_ = nullptr;
39 }
40
GetInstance()41 std::shared_ptr<TriggerManager> TriggerManager::GetInstance()
42 {
43 if (instance_ == nullptr) {
44 std::lock_guard<std::mutex> autoLock(instanceMutex_);
45 if (instance_ == nullptr) {
46 instance_ = std::shared_ptr<TriggerManager>(new (std::nothrow) TriggerManager());
47 }
48 }
49 return instance_;
50 }
51
UpdateModel(std::shared_ptr<GenericTriggerModel> model)52 void TriggerManager::UpdateModel(std::shared_ptr<GenericTriggerModel> model)
53 {
54 if (service_ == nullptr) {
55 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
56 return;
57 }
58 service_->UpdateGenericTriggerModel(model);
59 }
60
DeleteModel(int32_t uuid)61 void TriggerManager::DeleteModel(int32_t uuid)
62 {
63 if (service_ == nullptr) {
64 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
65 return;
66 }
67 service_->DeleteGenericTriggerModel(uuid);
68 }
69
GetModel(int32_t uuid)70 std::shared_ptr<GenericTriggerModel> TriggerManager::GetModel(int32_t uuid)
71 {
72 if (service_ == nullptr) {
73 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
74 return nullptr;
75 }
76 return service_->GetGenericTriggerModel(uuid);
77 }
78
CreateTriggerDetector(int32_t uuid,std::shared_ptr<IIntellVoiceTriggerDetectorCallback> callback)79 std::shared_ptr<TriggerDetector> TriggerManager::CreateTriggerDetector(
80 int32_t uuid, std::shared_ptr<IIntellVoiceTriggerDetectorCallback> callback)
81 {
82 OHOS::IntellVoiceUtils::MemoryGuard memoryGuard;
83 std::shared_ptr<TriggerDetector> detector = std::make_shared<TriggerDetector>(uuid, service_, callback);
84 if (detector == nullptr) {
85 INTELL_VOICE_LOG_ERROR("detector is nullptr");
86 return nullptr;
87 }
88
89 detectors_[uuid] = detector;
90 return detector;
91 }
92
ReleaseTriggerDetector(int32_t uuid)93 void TriggerManager::ReleaseTriggerDetector(int32_t uuid)
94 {
95 OHOS::IntellVoiceUtils::MemoryGuard memoryGuard;
96 auto it = detectors_.find(uuid);
97 if (it == detectors_.end()) {
98 return;
99 }
100
101 detectors_.erase(it);
102 }
103
SetParameter(const std::string & key,const std::string & value)104 int32_t TriggerManager::SetParameter(const std::string &key, const std::string &value)
105 {
106 if (service_ == nullptr) {
107 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
108 return -1;
109 }
110 return service_->SetParameter(key, value);
111 }
112
GetParameter(const std::string & key)113 std::string TriggerManager::GetParameter(const std::string &key)
114 {
115 if (service_ == nullptr) {
116 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
117 return "";
118 }
119 return service_->GetParameter(key);
120 }
121
122 #ifdef SUPPORT_TELEPHONY_SERVICE
AttachTelephonyObserver()123 void TriggerManager::AttachTelephonyObserver()
124 {
125 if (service_ == nullptr) {
126 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
127 return;
128 }
129 return service_->AttachTelephonyObserver();
130 }
131
DetachTelephonyObserver()132 void TriggerManager::DetachTelephonyObserver()
133 {
134 if (service_ == nullptr) {
135 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
136 return;
137 }
138 return service_->DetachTelephonyObserver();
139 }
140 #endif
141
AttachAudioCaptureListener()142 void TriggerManager::AttachAudioCaptureListener()
143 {
144 if (service_ == nullptr) {
145 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
146 return;
147 }
148 return service_->AttachAudioCaptureListener();
149 }
150
DetachAudioCaptureListener()151 void TriggerManager::DetachAudioCaptureListener()
152 {
153 if (service_ == nullptr) {
154 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
155 return;
156 }
157 return service_->DetachAudioCaptureListener();
158 }
159
AttachAudioRendererEventListener()160 void TriggerManager::AttachAudioRendererEventListener()
161 {
162 if (service_ == nullptr) {
163 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
164 return;
165 }
166 return service_->AttachAudioRendererEventListener();
167 }
168
DetachAudioRendererEventListener()169 void TriggerManager::DetachAudioRendererEventListener()
170 {
171 if (service_ == nullptr) {
172 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
173 return;
174 }
175 return service_->DetachAudioRendererEventListener();
176 }
177
AttachHibernateObserver()178 void TriggerManager::AttachHibernateObserver()
179 {
180 if (service_ == nullptr) {
181 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
182 return;
183 }
184 return service_->AttachHibernateObserver();
185 }
186
DetachHibernateObserver()187 void TriggerManager::DetachHibernateObserver()
188 {
189 if (service_ == nullptr) {
190 INTELL_VOICE_LOG_ERROR("service_ is nullptr");
191 return;
192 }
193 return service_->DetachHibernateObserver();
194 }
195
196 } // namespace IntellVoiceTrigger
197 } // namespace OHOS
198