1 /*
2 * Copyright (c) 2025 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 "only_first_wakeup_engine.h"
16 #include "only_first_engine_manager.h"
17 #include "only_first_wakeup_engine_impl.h"
18 #include "intell_voice_log.h"
19 #include "engine_callback_message.h"
20 #include "intell_voice_util.h"
21
22 #define LOG_TAG "OnlyFirstWakeupEngine"
23
24 using namespace OHOS::IntellVoiceUtils;
25
26 namespace OHOS {
27 namespace IntellVoiceEngine {
28 static const std::string SINGLE_WAKEUP_RECORD_START = "record_start";
29
OnlyFirstWakeupEngine()30 OnlyFirstWakeupEngine::OnlyFirstWakeupEngine()
31 {
32 INTELL_VOICE_LOG_INFO("enter");
33 }
34
~OnlyFirstWakeupEngine()35 OnlyFirstWakeupEngine::~OnlyFirstWakeupEngine()
36 {
37 INTELL_VOICE_LOG_INFO("enter");
38 }
39
HandleCapturerMsg(StateMsg & msg)40 int32_t OnlyFirstWakeupEngine::HandleCapturerMsg(StateMsg &msg)
41 {
42 return ROLE(OnlyFirstWakeupEngineImpl).Handle(msg);
43 }
44
OnDetected(int32_t uuid)45 void OnlyFirstWakeupEngine::OnDetected(int32_t uuid)
46 {
47 INTELL_VOICE_LOG_INFO("enter, uuid is %{public}d", uuid);
48 StateMsg msg(START_RECOGNIZE, &uuid, sizeof(int32_t));
49 if (HandleCapturerMsg(msg) != 0) {
50 INTELL_VOICE_LOG_WARN("start failed");
51 EngineCallbackMessage::CallFunc(HANDLE_CLOSE_WAKEUP_SOURCE, true);
52 }
53 }
54
Init(const std::string &,bool reEnroll)55 bool OnlyFirstWakeupEngine::Init(const std::string & /* param */, bool reEnroll)
56 {
57 StateMsg msg(INIT);
58 if (HandleCapturerMsg(msg) != 0) {
59 return false;
60 }
61 return true;
62 }
63
StartCapturer(int32_t channels)64 int32_t OnlyFirstWakeupEngine::StartCapturer(int32_t channels)
65 {
66 StateMsg msg(START_CAPTURER, &channels, sizeof(int32_t));
67 return HandleCapturerMsg(msg);
68 }
69
Read(std::vector<uint8_t> & data)70 int32_t OnlyFirstWakeupEngine::Read(std::vector<uint8_t> &data)
71 {
72 CapturerData capturerData;
73 StateMsg msg(READ, nullptr, 0, reinterpret_cast<void *>(&capturerData));
74 int32_t ret = HandleCapturerMsg(msg);
75 if (ret != 0) {
76 INTELL_VOICE_LOG_ERROR("read failed, ret:%{public}d", ret);
77 return -1;
78 }
79
80 data.swap(capturerData.data);
81 return 0;
82 }
83
StopCapturer()84 int32_t OnlyFirstWakeupEngine::StopCapturer()
85 {
86 StateMsg msg(STOP_CAPTURER);
87 return HandleCapturerMsg(msg);
88 }
89
Detach(void)90 int32_t OnlyFirstWakeupEngine::Detach(void)
91 {
92 StateMsg msg(RELEASE);
93 return HandleCapturerMsg(msg);
94 }
95
SetParameter(const std::string & keyValueList)96 int32_t OnlyFirstWakeupEngine::SetParameter(const std::string &keyValueList)
97 {
98 std::map<std::string, std::string> kvpairs;
99
100 IntellVoiceUtil::SplitStringToKVPair(keyValueList, kvpairs);
101 for (auto it : kvpairs) {
102 if (it.first == SINGLE_WAKEUP_RECORD_START) {
103 ResetSingleLevelWakeup(it.second);
104 } else {
105 INTELL_VOICE_LOG_INFO("no need to process, key:%{public}s, value:%{public}s",
106 it.first.c_str(), it.second.c_str());
107 }
108 }
109
110 return 0;
111 }
112
GetParameter(const std::string & key)113 std::string OnlyFirstWakeupEngine::GetParameter(const std::string &key)
114 {
115 StringParam keyParam(key);
116 StringParam valueParam;
117 StateMsg msg(GET_PARAM, &keyParam, sizeof(keyParam), &valueParam);
118 if (HandleCapturerMsg(msg) != 0) {
119 INTELL_VOICE_LOG_ERROR("failed to get parameter, key:%{public}s", key.c_str());
120 return "";
121 }
122
123 return valueParam.strParam;
124 }
125
ReleaseAdapter()126 void OnlyFirstWakeupEngine::ReleaseAdapter()
127 {
128 StateMsg msg(RELEASE);
129 HandleCapturerMsg(msg);
130 }
131
ResetSingleLevelWakeup(const std::string & value)132 void OnlyFirstWakeupEngine::ResetSingleLevelWakeup(const std::string &value)
133 {
134 int32_t recordStart = -1;
135 INTELL_VOICE_LOG_INFO("record_start:%{public}s", value.c_str());
136 if (value != std::string("true") && value != std::string("false")) {
137 return;
138 }
139
140 recordStart = (value == std::string("true")) ? 1 : 0;
141 StateMsg msg(RECORD_START, &recordStart, sizeof(int32_t));
142 HandleCapturerMsg(msg);
143 }
144 } // namespace IntellVoiceEngine
145 } // namespace OHOS
146