1 /*
2 * Copyright (c) 2021-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 "ams_mgr_proxy.h"
17 #include "ipc_types.h"
18 #include "iremote_object.h"
19 #include "string_ex.h"
20
21 #include "appexecfwk_errors.h"
22 #include "hilog_wrapper.h"
23
24 namespace OHOS {
25 namespace AppExecFwk {
AmsMgrProxy(const sptr<IRemoteObject> & impl)26 AmsMgrProxy::AmsMgrProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IAmsMgr>(impl)
27 {}
28
WriteInterfaceToken(MessageParcel & data)29 bool AmsMgrProxy::WriteInterfaceToken(MessageParcel &data)
30 {
31 if (!data.WriteInterfaceToken(AmsMgrProxy::GetDescriptor())) {
32 HILOG_ERROR("write interface token failed");
33 return false;
34 }
35 return true;
36 }
37
LoadAbility(const sptr<IRemoteObject> & token,const sptr<IRemoteObject> & preToken,const std::shared_ptr<AbilityInfo> & abilityInfo,const std::shared_ptr<ApplicationInfo> & appInfo,const std::shared_ptr<AAFwk::Want> & want)38 void AmsMgrProxy::LoadAbility(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &preToken,
39 const std::shared_ptr<AbilityInfo> &abilityInfo, const std::shared_ptr<ApplicationInfo> &appInfo,
40 const std::shared_ptr<AAFwk::Want> &want)
41 {
42 HILOG_DEBUG("start");
43 if (!abilityInfo || !appInfo) {
44 HILOG_ERROR("param error");
45 return;
46 }
47
48 MessageParcel data;
49 MessageParcel reply;
50 MessageOption option(MessageOption::TF_SYNC);
51 if (!WriteInterfaceToken(data)) {
52 return;
53 }
54
55 if (token) {
56 if (!data.WriteBool(true) || !data.WriteRemoteObject(token)) {
57 HILOG_ERROR("Failed to write flag and token");
58 return;
59 }
60 } else {
61 if (!data.WriteBool(false)) {
62 HILOG_ERROR("Failed to write flag");
63 return;
64 }
65 }
66
67 if (preToken) {
68 if (!data.WriteBool(true) || !data.WriteRemoteObject(preToken)) {
69 HILOG_ERROR("Failed to write flag and preToken");
70 return;
71 }
72 } else {
73 if (!data.WriteBool(false)) {
74 HILOG_ERROR("Failed to write flag");
75 return;
76 }
77 }
78
79 data.WriteParcelable(abilityInfo.get());
80 data.WriteParcelable(appInfo.get());
81 if (!data.WriteParcelable(want.get())) {
82 HILOG_ERROR("Write data want failed.");
83 return;
84 }
85 sptr<IRemoteObject> remote = Remote();
86 if (remote == nullptr) {
87 HILOG_ERROR("Remote() is NULL");
88 return;
89 }
90 int32_t ret = remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::LOAD_ABILITY), data, reply, option);
91 if (ret != NO_ERROR) {
92 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
93 }
94 HILOG_DEBUG("end");
95 }
96
TerminateAbility(const sptr<IRemoteObject> & token,bool clearMissionFlag)97 void AmsMgrProxy::TerminateAbility(const sptr<IRemoteObject> &token, bool clearMissionFlag)
98 {
99 HILOG_DEBUG("start");
100 MessageParcel data;
101 MessageParcel reply;
102 MessageOption option(MessageOption::TF_SYNC);
103 if (!WriteInterfaceToken(data)) {
104 return;
105 }
106 if (!data.WriteRemoteObject(token.GetRefPtr())) {
107 HILOG_ERROR("Failed to write token");
108 return;
109 }
110 if (!data.WriteBool(clearMissionFlag)) {
111 HILOG_ERROR("Failed to write clearMissionFlag");
112 return;
113 }
114 sptr<IRemoteObject> remote = Remote();
115 if (remote == nullptr) {
116 HILOG_ERROR("Remote() is NULL");
117 return;
118 }
119 int32_t ret =
120 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::TERMINATE_ABILITY), data, reply, option);
121 if (ret != NO_ERROR) {
122 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
123 }
124 HILOG_DEBUG("end");
125 }
126
UpdateAbilityState(const sptr<IRemoteObject> & token,const AbilityState state)127 void AmsMgrProxy::UpdateAbilityState(const sptr<IRemoteObject> &token, const AbilityState state)
128 {
129 HILOG_DEBUG("start");
130 MessageParcel data;
131 MessageParcel reply;
132 MessageOption option(MessageOption::TF_SYNC);
133 if (!WriteInterfaceToken(data)) {
134 return;
135 }
136 if (!data.WriteRemoteObject(token.GetRefPtr())) {
137 HILOG_ERROR("Failed to write token");
138 return;
139 }
140 data.WriteInt32(static_cast<int32_t>(state));
141 sptr<IRemoteObject> remote = Remote();
142 if (remote == nullptr) {
143 HILOG_ERROR("Remote() is NULL");
144 return;
145 }
146 int32_t ret =
147 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::UPDATE_ABILITY_STATE), data, reply, option);
148 if (ret != NO_ERROR) {
149 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
150 }
151 HILOG_DEBUG("end");
152 }
153
UpdateExtensionState(const sptr<IRemoteObject> & token,const ExtensionState state)154 void AmsMgrProxy::UpdateExtensionState(const sptr<IRemoteObject> &token, const ExtensionState state)
155 {
156 HILOG_DEBUG("UpdateExtensionState start");
157 MessageParcel data;
158 MessageParcel reply;
159 MessageOption option(MessageOption::TF_SYNC);
160 if (!WriteInterfaceToken(data)) {
161 return;
162 }
163 if (!data.WriteRemoteObject(token.GetRefPtr())) {
164 HILOG_ERROR("Failed to write token");
165 return;
166 }
167 data.WriteInt32(static_cast<int32_t>(state));
168 sptr<IRemoteObject> remote = Remote();
169 if (remote == nullptr) {
170 HILOG_ERROR("Remote() is NULL");
171 return;
172 }
173 int32_t ret =
174 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::UPDATE_EXTENSION_STATE), data, reply, option);
175 if (ret != NO_ERROR) {
176 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
177 }
178 HILOG_DEBUG("end");
179 }
180
RegisterAppStateCallback(const sptr<IAppStateCallback> & callback)181 void AmsMgrProxy::RegisterAppStateCallback(const sptr<IAppStateCallback> &callback)
182 {
183 HILOG_DEBUG("start");
184 if (!callback) {
185 HILOG_ERROR("callback is nullptr");
186 return;
187 }
188
189 MessageParcel data;
190 MessageParcel reply;
191 MessageOption option(MessageOption::TF_SYNC);
192 if (!WriteInterfaceToken(data)) {
193 return;
194 }
195
196 if (callback->AsObject()) {
197 if (!data.WriteBool(true) || !data.WriteRemoteObject(callback->AsObject())) {
198 HILOG_ERROR("Failed to write flag and callback");
199 return;
200 }
201 } else {
202 if (!data.WriteBool(false)) {
203 HILOG_ERROR("Failed to write flag");
204 return;
205 }
206 }
207
208 sptr<IRemoteObject> remote = Remote();
209 if (remote == nullptr) {
210 HILOG_ERROR("Remote() is nullptr");
211 return;
212 }
213 int32_t ret = remote->SendRequest(
214 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_APP_STATE_CALLBACK), data, reply, option);
215 if (ret != NO_ERROR) {
216 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
217 }
218 HILOG_DEBUG("end");
219 }
220
AbilityBehaviorAnalysis(const sptr<IRemoteObject> & token,const sptr<IRemoteObject> & preToken,const int32_t visibility,const int32_t perceptibility,const int32_t connectionState)221 void AmsMgrProxy::AbilityBehaviorAnalysis(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &preToken,
222 const int32_t visibility, const int32_t perceptibility, const int32_t connectionState)
223 {
224 HILOG_DEBUG("start");
225 MessageParcel data;
226 MessageParcel reply;
227 MessageOption option(MessageOption::TF_SYNC);
228 if (!WriteInterfaceToken(data)) {
229 return;
230 }
231
232 if (!data.WriteRemoteObject(token.GetRefPtr())) {
233 HILOG_ERROR("Failed to write token");
234 return;
235 }
236
237 if (preToken) {
238 if (!data.WriteBool(true) || !data.WriteRemoteObject(preToken.GetRefPtr())) {
239 HILOG_ERROR("Failed to write flag and preToken");
240 return;
241 }
242 } else {
243 if (!data.WriteBool(false)) {
244 HILOG_ERROR("Failed to write flag");
245 return;
246 }
247 }
248
249 data.WriteInt32(static_cast<int32_t>(visibility));
250 data.WriteInt32(static_cast<int32_t>(perceptibility));
251 data.WriteInt32(static_cast<int32_t>(connectionState));
252 sptr<IRemoteObject> remote = Remote();
253 if (remote == nullptr) {
254 HILOG_ERROR("Remote() is NULL");
255 return;
256 }
257 int32_t ret =
258 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::ABILITY_BEHAVIOR_ANALYSIS), data, reply, option);
259 if (ret != NO_ERROR) {
260 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
261 }
262 HILOG_DEBUG("end");
263 }
264
KillProcessByAbilityToken(const sptr<IRemoteObject> & token)265 void AmsMgrProxy::KillProcessByAbilityToken(const sptr<IRemoteObject> &token)
266 {
267 HILOG_DEBUG("start");
268 MessageParcel data;
269 MessageParcel reply;
270 MessageOption option(MessageOption::TF_SYNC);
271 if (!WriteInterfaceToken(data)) {
272 return;
273 }
274 if (!data.WriteRemoteObject(token.GetRefPtr())) {
275 HILOG_ERROR("Failed to write token");
276 return;
277 }
278 sptr<IRemoteObject> remote = Remote();
279 if (remote == nullptr) {
280 HILOG_ERROR("Remote() is NULL");
281 return;
282 }
283 int32_t ret = remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::KILL_PEOCESS_BY_ABILITY_TOKEN),
284 data, reply, option);
285 if (ret != NO_ERROR) {
286 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
287 }
288 HILOG_DEBUG("end");
289 }
290
KillProcessesByUserId(int32_t userId)291 void AmsMgrProxy::KillProcessesByUserId(int32_t userId)
292 {
293 HILOG_DEBUG("start");
294 MessageParcel data;
295 MessageParcel reply;
296 MessageOption option(MessageOption::TF_SYNC);
297 if (!WriteInterfaceToken(data)) {
298 return;
299 }
300 if (!data.WriteInt32(userId)) {
301 HILOG_ERROR("parcel WriteInt32 failed");
302 return;
303 }
304 sptr<IRemoteObject> remote = Remote();
305 if (remote == nullptr) {
306 HILOG_ERROR("Remote() is NULL");
307 return;
308 }
309 int32_t ret =
310 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::KILL_PROCESSES_BY_USERID), data, reply, option);
311 if (ret != NO_ERROR) {
312 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
313 }
314 HILOG_DEBUG("end");
315 }
316
KillProcessWithAccount(const std::string & bundleName,const int accountId)317 int32_t AmsMgrProxy::KillProcessWithAccount(const std::string &bundleName, const int accountId)
318 {
319 HILOG_DEBUG("start");
320
321 MessageParcel data;
322 MessageParcel reply;
323 MessageOption option(MessageOption::TF_SYNC);
324 if (!WriteInterfaceToken(data)) {
325 return ERR_INVALID_DATA;
326 }
327
328 sptr<IRemoteObject> remote = Remote();
329 if (remote == nullptr) {
330 HILOG_ERROR("Remote() is NULL");
331 return ERR_NULL_OBJECT;
332 }
333
334 if (!data.WriteString(bundleName)) {
335 HILOG_ERROR("parcel WriteString failed");
336 return ERR_FLATTEN_OBJECT;
337 }
338
339 if (!data.WriteInt32(accountId)) {
340 HILOG_ERROR("parcel WriteInt32 failed");
341 return ERR_FLATTEN_OBJECT;
342 }
343
344 int32_t ret =
345 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::KILL_PROCESS_WITH_ACCOUNT), data, reply, option);
346 if (ret != NO_ERROR) {
347 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
348 return ret;
349 }
350
351 HILOG_DEBUG("end");
352
353 return reply.ReadInt32();
354 }
355
KillApplication(const std::string & bundleName)356 int32_t AmsMgrProxy::KillApplication(const std::string &bundleName)
357 {
358 HILOG_DEBUG("start");
359 MessageParcel data;
360 MessageParcel reply;
361 MessageOption option(MessageOption::TF_SYNC);
362 if (!WriteInterfaceToken(data)) {
363 return ERR_INVALID_DATA;
364 }
365 sptr<IRemoteObject> remote = Remote();
366 if (remote == nullptr) {
367 HILOG_ERROR("Remote() is NULL");
368 return ERR_NULL_OBJECT;
369 }
370 if (!data.WriteString(bundleName)) {
371 HILOG_ERROR("parcel WriteString failed");
372 return ERR_FLATTEN_OBJECT;
373 }
374 int32_t ret =
375 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::KILL_APPLICATION), data, reply, option);
376 if (ret != NO_ERROR) {
377 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
378 return ret;
379 }
380 return reply.ReadInt32();
381 }
382
UpdateApplicationInfoInstalled(const std::string & bundleName,const int uid)383 int32_t AmsMgrProxy::UpdateApplicationInfoInstalled(const std::string &bundleName, const int uid)
384 {
385 HILOG_DEBUG("start");
386 MessageParcel data;
387 MessageParcel reply;
388 MessageOption option(MessageOption::TF_SYNC);
389 if (!WriteInterfaceToken(data)) {
390 return ERR_INVALID_DATA;
391 }
392 sptr<IRemoteObject> remote = Remote();
393 if (remote == nullptr) {
394 HILOG_ERROR("Remote() is NULL");
395 return ERR_NULL_OBJECT;
396 }
397 if (!data.WriteString(bundleName)) {
398 HILOG_ERROR("parcel WriteString failed");
399 return ERR_FLATTEN_OBJECT;
400 }
401 if (!data.WriteInt32(uid)) {
402 HILOG_ERROR("uid write failed.");
403 return ERR_FLATTEN_OBJECT;
404 }
405 int32_t ret =
406 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::UPDATE_APPLICATION_INFO_INSTALLED),
407 data, reply, option);
408 if (ret != NO_ERROR) {
409 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
410 return ret;
411 }
412 return reply.ReadInt32();
413 }
414
KillApplicationByUid(const std::string & bundleName,const int uid)415 int32_t AmsMgrProxy::KillApplicationByUid(const std::string &bundleName, const int uid)
416 {
417 HILOG_DEBUG("start");
418 MessageParcel data;
419 MessageParcel reply;
420 MessageOption option(MessageOption::TF_SYNC);
421 if (!WriteInterfaceToken(data)) {
422 return ERR_INVALID_DATA;
423 }
424 sptr<IRemoteObject> remote = Remote();
425 if (remote == nullptr) {
426 HILOG_ERROR("Remote() is NULL");
427 return ERR_NULL_OBJECT;
428 }
429 if (!data.WriteString(bundleName)) {
430 HILOG_ERROR("parcel WriteString failed");
431 return ERR_FLATTEN_OBJECT;
432 }
433 if (!data.WriteInt32(uid)) {
434 HILOG_ERROR("uid write failed.");
435 return ERR_FLATTEN_OBJECT;
436 }
437 int32_t ret =
438 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::KILL_APPLICATION_BYUID), data, reply, option);
439 if (ret != NO_ERROR) {
440 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
441 return ret;
442 }
443 return reply.ReadInt32();
444 }
445
KillApplicationSelf()446 int32_t AmsMgrProxy::KillApplicationSelf()
447 {
448 MessageParcel data;
449 MessageParcel reply;
450 MessageOption option(MessageOption::TF_SYNC);
451 if (!WriteInterfaceToken(data)) {
452 return ERR_INVALID_DATA;
453 }
454 sptr<IRemoteObject> remote = Remote();
455 if (remote == nullptr) {
456 HILOG_ERROR("Remote is NULL");
457 return ERR_NULL_OBJECT;
458 }
459 int32_t ret =
460 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::KILL_APPLICATION_SELF), data, reply, option);
461 if (ret != NO_ERROR) {
462 HILOG_ERROR("SendRequest is failed, error code: %{public}d", ret);
463 return ret;
464 }
465 return reply.ReadInt32();
466 }
467
AbilityAttachTimeOut(const sptr<IRemoteObject> & token)468 void AmsMgrProxy::AbilityAttachTimeOut(const sptr<IRemoteObject> &token)
469 {
470 HILOG_DEBUG("start");
471 MessageParcel data;
472 MessageParcel reply;
473 MessageOption option(MessageOption::TF_SYNC);
474 if (!WriteInterfaceToken(data)) {
475 return;
476 }
477 if (!data.WriteRemoteObject(token.GetRefPtr())) {
478 HILOG_ERROR("Failed to write token");
479 return;
480 }
481 sptr<IRemoteObject> remote = Remote();
482 if (remote == nullptr) {
483 HILOG_ERROR("Remote() is NULL");
484 return;
485 }
486 int32_t ret =
487 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::ABILITY_ATTACH_TIMEOUT), data, reply, option);
488 if (ret != NO_ERROR) {
489 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
490 }
491 HILOG_DEBUG("end");
492 }
493
PrepareTerminate(const sptr<IRemoteObject> & token)494 void AmsMgrProxy::PrepareTerminate(const sptr<IRemoteObject> &token)
495 {
496 HILOG_DEBUG("start");
497 MessageParcel data;
498 MessageParcel reply;
499 MessageOption option(MessageOption::TF_SYNC);
500 if (!WriteInterfaceToken(data)) {
501 return;
502 }
503 if (!data.WriteRemoteObject(token.GetRefPtr())) {
504 HILOG_ERROR("Failed to write token");
505 return;
506 }
507 sptr<IRemoteObject> remote = Remote();
508 if (remote == nullptr) {
509 HILOG_ERROR("Remote() is NULL");
510 return;
511 }
512 int32_t ret =
513 remote->SendRequest(static_cast<uint32_t>(IAmsMgr::Message::PREPARE_TERMINATE_ABILITY),
514 data, reply, option);
515 if (ret != NO_ERROR) {
516 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
517 }
518 HILOG_DEBUG("end");
519 }
520
GetRunningProcessInfoByToken(const sptr<IRemoteObject> & token,AppExecFwk::RunningProcessInfo & info)521 void AmsMgrProxy::GetRunningProcessInfoByToken(
522 const sptr<IRemoteObject> &token, AppExecFwk::RunningProcessInfo &info)
523 {
524 MessageParcel data;
525 MessageParcel reply;
526 MessageOption option(MessageOption::TF_SYNC);
527 if (!WriteInterfaceToken(data)) {
528 return;
529 }
530
531 if (!data.WriteRemoteObject(token.GetRefPtr())) {
532 return;
533 }
534
535 auto remote = Remote();
536 if (remote == nullptr) {
537 HILOG_ERROR("Remote() is NULL");
538 return;
539 }
540 auto ret = remote->SendRequest(
541 static_cast<uint32_t>(IAmsMgr::Message::GET_RUNNING_PROCESS_INFO_BY_TOKEN), data, reply, option);
542 if (ret != NO_ERROR) {
543 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
544 return;
545 }
546
547 std::unique_ptr<AppExecFwk::RunningProcessInfo> processInfo(reply.ReadParcelable<AppExecFwk::RunningProcessInfo>());
548 if (processInfo == nullptr) {
549 HILOG_ERROR("recv process info faild");
550 return;
551 }
552
553 info = *processInfo;
554 }
555
GetRunningProcessInfoByPid(const pid_t pid,OHOS::AppExecFwk::RunningProcessInfo & info)556 void AmsMgrProxy::GetRunningProcessInfoByPid(const pid_t pid, OHOS::AppExecFwk::RunningProcessInfo &info)
557 {
558 MessageParcel data;
559 MessageParcel reply;
560 MessageOption option(MessageOption::TF_SYNC);
561 if (!WriteInterfaceToken(data)) {
562 return;
563 }
564
565 if (!data.WriteInt32(static_cast<int32_t>(pid))) {
566 HILOG_ERROR("parcel WriteInt32 failed");
567 return;
568 }
569
570 auto remote = Remote();
571 if (remote == nullptr) {
572 HILOG_ERROR("Remote() is NULL");
573 return;
574 }
575 auto ret = remote->SendRequest(
576 static_cast<uint32_t>(IAmsMgr::Message::GET_RUNNING_PROCESS_INFO_BY_PID), data, reply, option);
577 if (ret != NO_ERROR) {
578 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
579 return;
580 }
581
582 std::unique_ptr<AppExecFwk::RunningProcessInfo> processInfo(reply.ReadParcelable<AppExecFwk::RunningProcessInfo>());
583 if (processInfo == nullptr) {
584 HILOG_ERROR("recv process info faild");
585 return;
586 }
587
588 info = *processInfo;
589 }
590
StartSpecifiedAbility(const AAFwk::Want & want,const AppExecFwk::AbilityInfo & abilityInfo)591 void AmsMgrProxy::StartSpecifiedAbility(const AAFwk::Want &want, const AppExecFwk::AbilityInfo &abilityInfo)
592
593 {
594 MessageParcel data;
595 MessageParcel reply;
596 MessageOption option(MessageOption::TF_SYNC);
597 if (!WriteInterfaceToken(data)) {
598 return;
599 }
600
601 if (!data.WriteParcelable(&want) || !data.WriteParcelable(&abilityInfo)) {
602 HILOG_ERROR("Write data failed.");
603 return;
604 }
605
606 sptr<IRemoteObject> remote = Remote();
607 if (remote == nullptr) {
608 HILOG_ERROR("Remote is nullptr.");
609 return;
610 }
611 auto ret = remote->SendRequest(
612 static_cast<uint32_t>(IAmsMgr::Message::START_SPECIFIED_ABILITY), data, reply, option);
613 if (ret != NO_ERROR) {
614 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
615 }
616 }
617
RegisterStartSpecifiedAbilityResponse(const sptr<IStartSpecifiedAbilityResponse> & response)618 void AmsMgrProxy::RegisterStartSpecifiedAbilityResponse(const sptr<IStartSpecifiedAbilityResponse> &response)
619 {
620 HILOG_DEBUG("Register multi instances response by proxy.");
621 if (!response) {
622 HILOG_ERROR("response is nullptr");
623 return;
624 }
625
626 MessageParcel data;
627 MessageParcel reply;
628 MessageOption option(MessageOption::TF_SYNC);
629 if (!WriteInterfaceToken(data)) {
630 return;
631 }
632 if (!data.WriteRemoteObject(response->AsObject())) {
633 HILOG_ERROR("Failed to write remote object.");
634 return;
635 }
636
637 sptr<IRemoteObject> remote = Remote();
638 if (remote == nullptr) {
639 HILOG_ERROR("Remote is nullptr.");
640 return;
641 }
642 int32_t ret = remote->SendRequest(
643 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_START_SPECIFIED_ABILITY_RESPONSE), data, reply, option);
644 if (ret != NO_ERROR) {
645 HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
646 }
647 }
648
GetApplicationInfoByProcessID(const int pid,AppExecFwk::ApplicationInfo & application,bool & debug)649 int AmsMgrProxy::GetApplicationInfoByProcessID(const int pid, AppExecFwk::ApplicationInfo &application, bool &debug)
650 {
651 MessageParcel data;
652 MessageParcel reply;
653 MessageOption option(MessageOption::TF_SYNC);
654 if (!WriteInterfaceToken(data)) {
655 HILOG_ERROR("token write error.");
656 return ERR_FLATTEN_OBJECT;
657 }
658 sptr<IRemoteObject> remote = Remote();
659 if (remote == nullptr) {
660 HILOG_ERROR("Remote is nullptr.");
661 return ERR_NULL_OBJECT;
662 }
663 data.WriteInt32(pid);
664 int32_t ret = remote->SendRequest(
665 static_cast<uint32_t>(IAmsMgr::Message::GET_APPLICATION_INFO_BY_PROCESS_ID), data, reply, option);
666 if (ret != NO_ERROR) {
667 HILOG_ERROR("send request fail.");
668 return ret;
669 }
670 auto result = reply.ReadInt32();
671 if (result != NO_ERROR) {
672 HILOG_ERROR("reply result false");
673 return result;
674 }
675 std::unique_ptr<AppExecFwk::ApplicationInfo> info(reply.ReadParcelable<AppExecFwk::ApplicationInfo>());
676 if (!info) {
677 HILOG_ERROR("readParcelableInfo failed");
678 return ERR_NAME_NOT_FOUND;
679 }
680 application = *info;
681 debug = reply.ReadBool();
682 HILOG_DEBUG("get parcelable info success");
683 return NO_ERROR;
684 }
685 } // namespace AppExecFwk
686 } // namespace OHOS
687