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
16 #include "accessibility_short_key_dialog.h"
17 #include "hilog_wrapper.h"
18
19 #include <algorithm>
20 #include "ability_connection.h"
21 #include "ability_connect_callback.h"
22 #include "bool_wrapper.h"
23 #include "double_wrapper.h"
24 #include "extension_manager_client.h"
25 #include "int_wrapper.h"
26 #include "ipc_skeleton.h"
27 #include "refbase.h"
28 #include "string_wrapper.h"
29 #include "want_params_wrapper.h"
30 #include "nlohmann/json.hpp"
31
32 constexpr int32_t SHORTKEY_DIALOG_PARAM_NUM = 3;
33 constexpr int32_t DEFAULT_VALUE_MINUS_ONE = -1;
34 constexpr int32_t SYS_DIALOG_Z_ORDER_ON_LOCK_SCREEN = 2;
35
36 namespace OHOS {
37 namespace Accessibility {
38 // ability_connection
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int32_t resultCode)39 void ShortkeyAbilityConnection::OnAbilityConnectDone(const AppExecFwk::ElementName &element,
40 const sptr<IRemoteObject> &remoteObject, int32_t resultCode)
41 {
42 HILOG_DEBUG("on ability connected");
43 MessageParcel data;
44 MessageParcel reply;
45 MessageOption option;
46 data.WriteInt32(SHORTKEY_DIALOG_PARAM_NUM);
47 data.WriteString16(u"bundleName");
48 data.WriteString16(u"com.ohos.settings");
49 data.WriteString16(u"abilityName");
50 data.WriteString16(u"AccessibilityShortKeyDialog");
51 data.WriteString16(u"parameters");
52 data.WriteString16(Str8ToStr16(GetCommandString()));
53
54 if (!data.WriteParcelable(&element)) {
55 HILOG_ERROR("Connect done element error.");
56 return;
57 }
58
59 if (!data.WriteRemoteObject(remoteObject)) {
60 HILOG_ERROR("Connect done remote object error.");
61 return;
62 }
63
64 if (!data.WriteInt32(resultCode)) {
65 HILOG_ERROR("Connect done result code error.");
66 return;
67 }
68
69 int32_t errCode = remoteObject->SendRequest(
70 AAFwk::IAbilityConnection::ON_ABILITY_CONNECT_DONE, data, reply, option);
71 HILOG_DEBUG("AbilityConnectionWrapperProxy::OnAbilityConnectDone result %{public}d", errCode);
72 }
73
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int32_t resultCode)74 void ShortkeyAbilityConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element,
75 int32_t resultCode)
76 {
77 HILOG_DEBUG("on ability disconnected");
78 }
79
GetCommandString()80 std::string ShortkeyAbilityConnection::GetCommandString()
81 {
82 return commandStr_;
83 }
84
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int32_t resultCode)85 void ReConfirmAbilityConnection::OnAbilityConnectDone(const AppExecFwk::ElementName &element,
86 const sptr<IRemoteObject> &remoteObject, int32_t resultCode)
87 {
88 HILOG_DEBUG("on ability connected");
89 MessageParcel data;
90 MessageParcel reply;
91 MessageOption option;
92 data.WriteInt32(SHORTKEY_DIALOG_PARAM_NUM);
93 data.WriteString16(u"bundleName");
94 data.WriteString16(u"com.ohos.settings");
95 data.WriteString16(u"abilityName");
96 data.WriteString16(u"AccessibilityReConfirmDialog");
97 data.WriteString16(u"parameters");
98 data.WriteString16(Str8ToStr16(GetCommandString()));
99
100 if (!data.WriteParcelable(&element)) {
101 HILOG_ERROR("Connect done element error.");
102 return;
103 }
104
105 if (!data.WriteRemoteObject(remoteObject)) {
106 HILOG_ERROR("Connect done remote object error.");
107 return;
108 }
109
110 if (!data.WriteInt32(resultCode)) {
111 HILOG_ERROR("Connect done result code error.");
112 return;
113 }
114
115 int32_t errCode = remoteObject->SendRequest(
116 AAFwk::IAbilityConnection::ON_ABILITY_CONNECT_DONE, data, reply, option);
117 HILOG_DEBUG("AbilityConnectionWrapperProxy::OnAbilityConnectDone result %{public}d", errCode);
118 }
119
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int32_t resultCode)120 void ReConfirmAbilityConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element,
121 int32_t resultCode)
122 {
123 HILOG_DEBUG("on ability disconnected");
124 }
125
GetCommandString()126 std::string ReConfirmAbilityConnection::GetCommandString()
127 {
128 return commandStr_;
129 }
130
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int32_t resultCode)131 void ExclusiveAbilityConnection::OnAbilityConnectDone(const AppExecFwk::ElementName &element,
132 const sptr<IRemoteObject> &remoteObject, int32_t resultCode)
133 {
134 HILOG_DEBUG("on ability connected");
135 MessageParcel data;
136 MessageParcel reply;
137 MessageOption option;
138 data.WriteInt32(SHORTKEY_DIALOG_PARAM_NUM);
139 data.WriteString16(u"bundleName");
140 data.WriteString16(u"com.ohos.settings");
141 data.WriteString16(u"abilityName");
142 data.WriteString16(u"AccessibilityIgnoreConfirmDialog");
143 data.WriteString16(u"parameters");
144 data.WriteString16(Str8ToStr16(GetCommandString()));
145
146 if (!data.WriteParcelable(&element)) {
147 HILOG_ERROR("Connect done element error.");
148 return;
149 }
150
151 if (!data.WriteRemoteObject(remoteObject)) {
152 HILOG_ERROR("Connect done remote object error.");
153 return;
154 }
155
156 if (!data.WriteInt32(resultCode)) {
157 HILOG_ERROR("Connect done result code error.");
158 return;
159 }
160
161 int32_t errCode = remoteObject->SendRequest(
162 AAFwk::IAbilityConnection::ON_ABILITY_CONNECT_DONE, data, reply, option);
163 HILOG_DEBUG("AbilityConnectionWrapperProxy::OnAbilityConnectDone result %{public}d", errCode);
164 }
165
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int32_t resultCode)166 void ExclusiveAbilityConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element,
167 int32_t resultCode)
168 {
169 HILOG_DEBUG("on ability disconnected");
170 }
171
GetCommandString()172 std::string ExclusiveAbilityConnection::GetCommandString()
173 {
174 return commandStr_;
175 }
176
177 // dialog
AccessibilityShortkeyDialog()178 AccessibilityShortkeyDialog::AccessibilityShortkeyDialog() {}
179
~AccessibilityShortkeyDialog()180 AccessibilityShortkeyDialog::~AccessibilityShortkeyDialog()
181 {
182 HILOG_DEBUG("release AccessibilityShortkeyDialog");
183 }
184
ConnectDialog(ShortKeyDialogType dialogType)185 bool AccessibilityShortkeyDialog::ConnectDialog(ShortKeyDialogType dialogType)
186 {
187 HILOG_DEBUG("AccessibilityShortkeyDialog dialog");
188 if (!ConnectExtension(dialogType)) {
189 HILOG_ERROR("failed to connect dialog.");
190 return false;
191 }
192 return true;
193 }
194
ConnectExtensionAbility(const AAFwk::Want & want,const std::string commandStr,ShortKeyDialogType dialogType)195 bool AccessibilityShortkeyDialog::ConnectExtensionAbility(const AAFwk::Want &want, const std::string commandStr,
196 ShortKeyDialogType dialogType)
197 {
198 // reset current callingIdentify
199 std::string identity = IPCSkeleton::ResetCallingIdentity();
200 int32_t ret = ERR_OK;
201
202 if (dialogType == ShortKeyDialogType::FUNCTION_SELECT) {
203 functionSelectConn_ = new(std::nothrow) ShortkeyAbilityConnection(commandStr);
204 if (functionSelectConn_ == nullptr) {
205 HILOG_ERROR("connection_ is nullptr.");
206 return false;
207 }
208 ret = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(want,
209 functionSelectConn_, nullptr, DEFAULT_VALUE_MINUS_ONE);
210 } else if (dialogType == ShortKeyDialogType::READER_EXCLUSIVE) {
211 readerExclusiveConn_ = new(std::nothrow) ExclusiveAbilityConnection(commandStr);
212 if (readerExclusiveConn_ == nullptr) {
213 HILOG_ERROR("connection_ is nullptr.");
214 return false;
215 }
216 ret = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(want,
217 readerExclusiveConn_, nullptr, DEFAULT_VALUE_MINUS_ONE);
218 } else {
219 reConfirmConn_ = new(std::nothrow) ReConfirmAbilityConnection(commandStr);
220 if (reConfirmConn_ == nullptr) {
221 HILOG_ERROR("connection_ is nullptr.");
222 return false;
223 }
224 ret = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(want,
225 reConfirmConn_, nullptr, DEFAULT_VALUE_MINUS_ONE);
226 }
227 HILOG_DEBUG("ret is: %{public}d.", ret);
228 // set current callingIdentify back.
229 IPCSkeleton::SetCallingIdentity(identity);
230 if (ret != ERR_OK) {
231 HILOG_ERROR("ret isn't ERR_OK");
232 return false;
233 }
234 return true;
235 }
236
ConnectExtension(ShortKeyDialogType dialogType)237 bool AccessibilityShortkeyDialog::ConnectExtension(ShortKeyDialogType dialogType)
238 {
239 std::string tmp = BuildStartCommand();
240 HILOG_DEBUG("start command: %{public}s", tmp.c_str());
241
242 AAFwk::Want want;
243 std::string bundleName = "com.ohos.systemui";
244 std::string abilityName = "com.ohos.systemui.dialog";
245 want.SetElementName(bundleName, abilityName);
246 bool ret = ConnectExtensionAbility(want, tmp, dialogType);
247 if (!ret) {
248 HILOG_ERROR("ConnectExtensionAbility failed.");
249 return false;
250 }
251 HILOG_DEBUG("ConnectExtensionAbility successed.");
252 return true;
253 }
254
DisconnectExtension(ShortKeyDialogType dialogType) const255 bool AccessibilityShortkeyDialog::DisconnectExtension(ShortKeyDialogType dialogType) const
256 {
257 if (dialogType == ShortKeyDialogType::FUNCTION_SELECT) {
258 if (functionSelectConn_ == nullptr) {
259 return true;
260 }
261 ErrCode ret = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(functionSelectConn_);
262 if (ret != ERR_OK) {
263 HILOG_ERROR("disconnect extension ability failed ret: %{public}d.", ret);
264 return false;
265 }
266 return true;
267 } else if (dialogType == ShortKeyDialogType::READER_EXCLUSIVE) {
268 if (readerExclusiveConn_ == nullptr) {
269 return true;
270 }
271 ErrCode ret = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(readerExclusiveConn_);
272 if (ret != ERR_OK) {
273 HILOG_ERROR("disconnect extension ability failed ret: %{public}d.", ret);
274 return false;
275 }
276 return true;
277 } else {
278 if (reConfirmConn_ == nullptr) {
279 return true;
280 }
281 ErrCode ret = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(reConfirmConn_);
282 if (ret != ERR_OK) {
283 HILOG_ERROR("disconnect extension ability failed ret: %{public}d.", ret);
284 return false;
285 }
286 return true;
287 }
288 }
289
BuildStartCommand()290 std::string AccessibilityShortkeyDialog::BuildStartCommand()
291 {
292 nlohmann::json root;
293 std::string tmp = "sysDialog/common";
294 root["ability.want.params.uiExtensionType"] = tmp;
295 root["sysDialogZOrder"] = SYS_DIALOG_Z_ORDER_ON_LOCK_SCREEN;
296 std::string cmdData = root.dump();
297 HILOG_DEBUG("cmdData is: %{public}s.", cmdData.c_str());
298 return cmdData;
299 }
300 } // namespace Accessibility
301 } // namespace OHOS