1 /*
2 * Copyright (C) 2022 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 "accessible_ability_connection.h"
17
18 #include <hitrace_meter.h>
19
20 #include "ability_manager_client.h"
21 #include "accessible_ability_manager_service.h"
22 #include "hilog_wrapper.h"
23 #include "utils.h"
24
25 namespace OHOS {
26 namespace Accessibility {
AccessibleAbilityConnection(int32_t accountId,int32_t connectionId,AccessibilityAbilityInfo & abilityInfo)27 AccessibleAbilityConnection::AccessibleAbilityConnection(int32_t accountId, int32_t connectionId,
28 AccessibilityAbilityInfo &abilityInfo)
29 : accountId_(accountId), connectionId_(connectionId), abilityInfo_(abilityInfo)
30 {
31 eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(
32 Singleton<AccessibleAbilityManagerService>::GetInstance().GetMainRunner());
33 }
34
~AccessibleAbilityConnection()35 AccessibleAbilityConnection::~AccessibleAbilityConnection()
36 {
37 HILOG_DEBUG();
38 if (abilityClient_ && abilityClient_->AsObject()) {
39 abilityClient_->AsObject()->RemoveDeathRecipient(deathRecipient_);
40 abilityClient_ = nullptr;
41 }
42 }
43
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int32_t resultCode)44 void AccessibleAbilityConnection::OnAbilityConnectDone(const AppExecFwk::ElementName &element,
45 const sptr<IRemoteObject> &remoteObject, int32_t resultCode)
46 {
47 HILOG_INFO();
48 if (!eventHandler_) {
49 HILOG_ERROR("eventHandler_ is nullptr.");
50 return;
51 }
52
53 eventHandler_->PostTask(std::bind([element, remoteObject, resultCode](int32_t accountId) -> void {
54 HILOG_DEBUG("ResultCode is %{public}d", resultCode);
55 FinishAsyncTrace(HITRACE_TAG_ACCESSIBILITY_MANAGER, "AccessibleAbilityConnect",
56 static_cast<int32_t>(TraceTaskId::ACCESSIBLE_ABILITY_CONNECT));
57 std::string bundleName = element.GetBundleName();
58 std::string abilityName = element.GetAbilityName();
59 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(accountId);
60 if (!accountData) {
61 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
62 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
63 HILOG_ERROR("accountData is nullptr.");
64 return;
65 }
66
67 if (resultCode != NO_ERROR) {
68 accountData->RemoveEnabledAbility(Utils::GetUri(element));
69 accountData->RemoveConnectingA11yAbility(Utils::GetUri(element));
70 accountData->UpdateAbilities();
71 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
72 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
73 return;
74 }
75
76 if (!remoteObject) {
77 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
78 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
79 HILOG_ERROR("AccessibleAbilityConnection::OnAbilityConnectDone get remoteObject failed");
80 return;
81 }
82
83 sptr<AccessibleAbilityConnection> connection = accountData->GetConnectingA11yAbility(Utils::GetUri(element));
84 if (!connection) {
85 HILOG_ERROR("connection is nullptr");
86 return;
87 }
88
89 accountData->AddConnectedAbility(connection);
90 accountData->RemoveConnectingA11yAbility(Utils::GetUri(element));
91 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
92 connection->InitAbilityClient(remoteObject);
93 }, accountId_), "OnAbilityConnectDone");
94 }
95
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int32_t resultCode)96 void AccessibleAbilityConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int32_t resultCode)
97 {
98 HILOG_INFO("resultCode[%{public}d]", resultCode);
99 }
100
OnAccessibilityEvent(AccessibilityEventInfo & eventInfo)101 void AccessibleAbilityConnection::OnAccessibilityEvent(AccessibilityEventInfo &eventInfo)
102 {
103 HILOG_DEBUG();
104 if (!abilityClient_) {
105 HILOG_ERROR("OnAccessibilityEvent failed");
106 return;
107 }
108
109 std::vector<std::string> filterBundleNames = abilityInfo_.GetFilterBundleNames();
110 if (IsWantedEvent(eventInfo.GetEventType()) && (filterBundleNames.empty() || find(filterBundleNames.begin(),
111 filterBundleNames.end(), eventInfo.GetBundleName()) != filterBundleNames.end())) {
112 abilityClient_->OnAccessibilityEvent(eventInfo);
113 HILOG_INFO("windowId[%{public}d] evtType[%{public}d] windowChangeType[%{public}d] GestureId[%{public}d]",
114 eventInfo.GetWindowId(), eventInfo.GetEventType(), eventInfo.GetWindowChangeTypes(),
115 eventInfo.GetGestureType());
116 }
117 }
118
OnKeyPressEvent(const MMI::KeyEvent & keyEvent,const int32_t sequence)119 bool AccessibleAbilityConnection::OnKeyPressEvent(const MMI::KeyEvent &keyEvent, const int32_t sequence)
120 {
121 if (!abilityClient_) {
122 HILOG_ERROR("OnKeyPressEvent failed");
123 return false;
124 }
125
126 if (!(abilityInfo_.GetCapabilityValues() & Capability::CAPABILITY_KEY_EVENT_OBSERVER)) {
127 HILOG_ERROR("Capability failed");
128 return false;
129 }
130
131 abilityClient_->OnKeyPressEvent(keyEvent, sequence);
132 return true;
133 }
134
SetAbilityInfoTargetBundleName(const std::vector<std::string> & targetBundleNames)135 void AccessibleAbilityConnection::SetAbilityInfoTargetBundleName(const std::vector<std::string> &targetBundleNames)
136 {
137 HILOG_DEBUG();
138 abilityInfo_.SetFilterBundleNames(targetBundleNames);
139 }
140
IsWantedEvent(int32_t eventType)141 bool AccessibleAbilityConnection::IsWantedEvent(int32_t eventType)
142 {
143 uint32_t type = static_cast<uint32_t>(eventType);
144 if ((type & abilityInfo_.GetEventTypes()) != type) {
145 HILOG_DEBUG("EventType(%{public}d) is not wanted", type);
146 return false;
147 }
148 return true;
149 }
150
CreateWant(AppExecFwk::ElementName & element)151 AAFwk::Want CreateWant(AppExecFwk::ElementName& element)
152 {
153 AAFwk::Want want;
154 want.SetElement(element);
155
156 return want;
157 }
158
Disconnect()159 void AccessibleAbilityConnection::Disconnect()
160 {
161 HILOG_DEBUG();
162
163 if (accountId_ == Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId()) {
164 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
165 }
166
167 if (!abilityClient_) {
168 HILOG_ERROR("abilityClient is nullptr");
169 return;
170 }
171 abilityClient_->Disconnect(connectionId_);
172
173 auto abilityManagerClient = AAFwk::AbilityManagerClient::GetInstance();
174 if (!abilityManagerClient) {
175 HILOG_ERROR("abilityManagerClient is nullptr");
176 return;
177 }
178 if (abilityManagerClient->DisconnectAbility(this) != ERR_OK) {
179 HILOG_ERROR("Disconnect failed!");
180 return;
181 }
182 }
183
Connect(const AppExecFwk::ElementName & element)184 void AccessibleAbilityConnection::Connect(const AppExecFwk::ElementName &element)
185 {
186 HILOG_DEBUG();
187 StartAsyncTrace(HITRACE_TAG_ACCESSIBILITY_MANAGER, "AccessibleAbilityConnect",
188 static_cast<int32_t>(TraceTaskId::ACCESSIBLE_ABILITY_CONNECT));
189 std::string bundleName = element.GetBundleName();
190 std::string abilityName = element.GetAbilityName();
191
192 elementName_ = element;
193 HILOG_DEBUG("bundleName[%{public}s], abilityName [%{public}s], accountId [%{public}d]",
194 bundleName.c_str(), abilityName.c_str(), accountId_);
195
196 auto bundleMgr = Singleton<AccessibleAbilityManagerService>::GetInstance().GetBundleMgrProxy();
197 if (!bundleMgr) {
198 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
199 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
200 HILOG_ERROR("get bundleMgr failed");
201 return;
202 }
203 int uid = bundleMgr->GetUidByBundleName(bundleName, accountId_);
204 HILOG_DEBUG("uid is %{public}d ", uid);
205
206 auto abilityManagerClient = AAFwk::AbilityManagerClient::GetInstance();
207 if (!abilityManagerClient) {
208 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
209 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
210 HILOG_ERROR("abilityManagerClient is nullptr");
211 return;
212 }
213 AAFwk::Want want = CreateWant(elementName_);
214 if (abilityManagerClient->ConnectAbility(want, this, nullptr, uid / UID_MASK) != ERR_OK) {
215 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
216 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
217 HILOG_ERROR("ConnectAbility failed!");
218 return;
219 }
220 }
221
GetChannelId()222 int32_t AccessibleAbilityConnection::GetChannelId()
223 {
224 HILOG_DEBUG("connectionId_ is %{public}d", connectionId_);
225 return connectionId_;
226 }
227
OnAbilityConnectDoneSync(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject)228 void AccessibleAbilityConnection::OnAbilityConnectDoneSync(const AppExecFwk::ElementName &element,
229 const sptr<IRemoteObject> &remoteObject)
230 {
231 HILOG_DEBUG();
232 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(accountId_);
233 if (!accountData) {
234 HILOG_ERROR("accountData is nullptr.");
235 return;
236 }
237 if (!remoteObject) {
238 HILOG_ERROR("AccessibleAbilityConnection::OnAbilityConnectDone get remoteObject failed");
239 return;
240 }
241 elementName_ = element;
242
243 sptr<AccessibleAbilityConnection> pointer = this;
244 accountData->AddConnectedAbility(pointer);
245 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
246 InitAbilityClient(remoteObject);
247 }
248
OnAbilityDisconnectDoneSync(const AppExecFwk::ElementName & element)249 void AccessibleAbilityConnection::OnAbilityDisconnectDoneSync(const AppExecFwk::ElementName &element)
250 {
251 HILOG_DEBUG();
252
253 if (accountId_ == Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId()) {
254 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
255 }
256
257 if (!abilityClient_) {
258 HILOG_ERROR("abilityClient_ is nullptr");
259 return;
260 }
261 abilityClient_->Disconnect(connectionId_);
262 }
263
InitAbilityClient(const sptr<IRemoteObject> & remoteObject)264 void AccessibleAbilityConnection::InitAbilityClient(const sptr<IRemoteObject> &remoteObject)
265 {
266 std::string bundleName = elementName_.GetBundleName();
267 std::string abilityName = elementName_.GetAbilityName();
268 abilityClient_ = new(std::nothrow) AccessibleAbilityClientProxy(remoteObject);
269 if (!abilityClient_) {
270 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
271 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
272 HILOG_ERROR("abilityClient_ is null");
273 return;
274 }
275
276 if (!deathRecipient_) {
277 deathRecipient_ = new(std::nothrow) AccessibleAbilityConnectionDeathRecipient(
278 accountId_, elementName_, eventHandler_);
279 if (!deathRecipient_) {
280 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
281 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
282 HILOG_ERROR("deathRecipient_ is null");
283 return;
284 }
285 }
286
287 if (!abilityClient_->AsObject() || !abilityClient_->AsObject()->AddDeathRecipient(deathRecipient_)) {
288 HILOG_ERROR("Failed to add death recipient");
289 }
290
291 channel_ = new(std::nothrow) AccessibleAbilityChannel(accountId_, abilityInfo_.GetId());
292 if (!channel_) {
293 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
294 A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
295 HILOG_ERROR("channel_ is null");
296 return;
297 }
298 abilityClient_->Init(channel_, connectionId_);
299 }
300
OnRemoteDied(const wptr<IRemoteObject> & remote)301 void AccessibleAbilityConnection::AccessibleAbilityConnectionDeathRecipient::OnRemoteDied(
302 const wptr<IRemoteObject> &remote)
303 {
304 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
305 A11yError::ERROR_A11Y_APPLICATION_DISCONNECT_ABNORMALLY,
306 recipientElementName_.GetBundleName(), recipientElementName_.GetAbilityName());
307 if (!handler_) {
308 HILOG_ERROR("handler_ is nullptr");
309 return;
310 }
311 handler_->PostTask(std::bind([](int32_t accountId, AppExecFwk::ElementName &elementName) -> void {
312 HILOG_DEBUG();
313
314 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
315 auto accountData = aams.GetAccountData(accountId);
316 if (!accountData) {
317 HILOG_ERROR("accountData is null.");
318 return;
319 }
320
321 std::string uri = Utils::GetUri(elementName);
322 sptr<AccessibleAbilityConnection> connection = accountData->GetAccessibleAbilityConnection(uri);
323 if (!connection) {
324 HILOG_ERROR("There is no connection for %{public}s.", uri.c_str());
325 return;
326 }
327 accountData->RemoveConnectedAbility(elementName);
328 accountData->RemoveEnabledAbility(uri);
329
330 std::string uiTestUri = Utils::GetUri("ohos.uitest", "uitestability");
331 if (uri == uiTestUri) {
332 accountData->RemoveInstalledAbility("ohos.uitest");
333 }
334
335 accountData->UpdateAbilities();
336 aams.UpdateAccessibilityManagerService();
337 }, accountId_, recipientElementName_), "OnRemoteDied");
338 }
339 } // namespace Accessibility
340 } // namespace OHOS