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
16 #include "extension_ability_manager.h"
17
18 #include <string>
19 #include "message_parcel.h"
20 #include "hilog_wrapper.h"
21 #include "nlohmann/json.hpp"
22 #include "extension_manager_client.h"
23
24 namespace OHOS {
25 namespace Accessibility {
26
27 const int64_t WAIT_INTERVAL = 5000; // 5s
28 constexpr int32_t DEFAULT_USER_ID = -1;
29 const std::string SETTINGS_BUNDLE_NAME = "com.ohos.settings";
30 const std::string SERVICE_EXTENSION_ABILITY_NAME = "SettingsExtService";
31 const std::string METHOD_KEY = "method";
32 const std::string EXTRA_KEY = "extra";
33 const std::string METHOD_VOICE_RECOGNITION = "voiceRecognition";
34 const std::string EXTRA_VALUE_KEY = "soundType";
35 constexpr int32_t SETTINGS_VOICE_RECOGNITION_CODE = 7;
36
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int32_t resultCode)37 void ExtensionAbilityConnection::OnAbilityConnectDone(const AppExecFwk::ElementName &element,
38 const sptr<IRemoteObject> &remoteObject, int32_t resultCode)
39 {
40 HILOG_INFO("on ability connected done");
41 if (resultCode != ERR_OK) {
42 HILOG_ERROR("ability connect failed: %{public}d", resultCode);
43 return;
44 }
45 if (remoteObject == nullptr) {
46 HILOG_ERROR("remoteObject is null");
47 return;
48 }
49 HILOG_INFO("got remoteObject");
50 std::unique_lock<std::mutex> lock(mutex_);
51 remoteObject_ = remoteObject;
52 cv_.notify_all();
53 }
54
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int resultCode)55 void ExtensionAbilityConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode)
56 {
57 HILOG_INFO("on ability disconnected done");
58 std::unique_lock<std::mutex> lock(mutex_);
59 remoteObject_ = nullptr;
60 }
61
GetRemoteObject()62 sptr<IRemoteObject> ExtensionAbilityConnection::GetRemoteObject()
63 {
64 std::unique_lock<std::mutex> lock(mutex_);
65 if (!cv_.wait_for(lock, std::chrono::milliseconds(WAIT_INTERVAL), [this]() { return remoteObject_ != nullptr; })) {
66 HILOG_ERROR("wait for remote object timeout");
67 return nullptr;
68 }
69 return remoteObject_;
70 }
71
ExtensionAbilityManager()72 ExtensionAbilityManager::ExtensionAbilityManager()
73 {
74 connection_ = sptr<ExtensionAbilityConnection> (new (std::nothrow) ExtensionAbilityConnection());
75 }
76
GetInstance()77 ExtensionAbilityManager& ExtensionAbilityManager::GetInstance()
78 {
79 static ExtensionAbilityManager instance;
80 return instance;
81 }
82
VoiceRecognize(int32_t soundType)83 void ExtensionAbilityManager::VoiceRecognize(int32_t soundType)
84 {
85 HILOG_INFO("called, soundType=%{public}d", soundType);
86 sptr<IRemoteObject> remote = GetRemoteObject();
87 if (remote == nullptr) {
88 HILOG_ERROR("cannot get remote object");
89 return;
90 }
91 std::string message = CreateJsonMessage(soundType);
92 SendRequestToSetting(remote, message);
93 DisconnectSettingsExtService();
94 }
95
ConnectSettingsExtService()96 int32_t ExtensionAbilityManager::ConnectSettingsExtService()
97 {
98 HILOG_INFO("called");
99 AAFwk::Want want;
100 want.SetElementName(SETTINGS_BUNDLE_NAME, SERVICE_EXTENSION_ABILITY_NAME);
101 int32_t ret = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(want, connection_,
102 nullptr, DEFAULT_USER_ID);
103 return ret;
104 }
105
DisconnectSettingsExtService()106 void ExtensionAbilityManager::DisconnectSettingsExtService()
107 {
108 auto disconnectResult = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(connection_);
109 if (disconnectResult != ERR_OK) {
110 HILOG_ERROR("disconnect failed, ret=%{public}d", disconnectResult);
111 }
112 }
113
GetRemoteObject()114 sptr<IRemoteObject> ExtensionAbilityManager::GetRemoteObject()
115 {
116 int32_t connectResult = ConnectSettingsExtService();
117 if (connectResult != ERR_OK) {
118 HILOG_ERROR("connect failed, ret=%{public}d", connectResult);
119 return nullptr;
120 }
121 HILOG_INFO("connect success");
122 return connection_->GetRemoteObject();
123 }
124
CreateJsonMessage(int32_t soundType)125 std::string ExtensionAbilityManager::CreateJsonMessage(int32_t soundType)
126 {
127 nlohmann::json jsonMessageObj;
128 nlohmann::json jsonExtraValue;
129
130 jsonExtraValue[EXTRA_VALUE_KEY] = soundType;
131 jsonMessageObj[METHOD_KEY] = METHOD_VOICE_RECOGNITION;
132 jsonMessageObj[EXTRA_KEY] = jsonExtraValue;
133
134 return jsonMessageObj.dump();
135 }
136
SendRequestToSetting(const sptr<IRemoteObject> & remoteObject,const std::string & message)137 void ExtensionAbilityManager::SendRequestToSetting(const sptr<IRemoteObject> &remoteObject,
138 const std::string &message)
139 {
140 if (remoteObject == nullptr) {
141 HILOG_ERROR("remoteObject is nullptr!");
142 return;
143 }
144 if (message.empty()) {
145 HILOG_ERROR("send message is empty!");
146 return;
147 }
148 HILOG_INFO("send message=%{public}s", message.c_str());
149 MessageParcel data;
150 MessageParcel reply;
151 MessageOption option;
152
153 if (!data.WriteString16(Str8ToStr16(message))) {
154 HILOG_ERROR("write message failed!");
155 return;
156 }
157 int32_t ret = remoteObject->SendRequest(SETTINGS_VOICE_RECOGNITION_CODE, data, reply, option);
158 auto replyCode = reply.ReadInt32();
159 HILOG_INFO("sendRequest ret=%{public}d, replyCode=%{public}d", ret, replyCode);
160 }
161 } // namespace Accessibility
162 } // namespace OHOS
163