1 /*
2  * Copyright (c) 2022-2024 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 "want_agent_client.h"
17 
18 #include "ability_runtime_error_util.h"
19 #include "ability_manager_errors.h"
20 #include "ability_manager_interface.h"
21 #include "ability_util.h"
22 #include "hilog_tag_wrapper.h"
23 #include "hitrace_meter.h"
24 #include "if_system_ability_manager.h"
25 #include "iservice_registry.h"
26 #include "system_ability_definition.h"
27 
28 using namespace OHOS::AbilityRuntime;
29 namespace OHOS {
30 namespace AAFwk {
GetInstance()31 WantAgentClient &WantAgentClient::GetInstance()
32 {
33     static WantAgentClient client;
34     return client;
35 }
36 
WantAgentClient()37 WantAgentClient::WantAgentClient() {}
38 
~WantAgentClient()39 WantAgentClient::~WantAgentClient() {}
40 
GetWantSender(const WantSenderInfo & wantSenderInfo,const sptr<IRemoteObject> & callerToken,sptr<IWantSender> & wantSender,int32_t uid)41 ErrCode WantAgentClient::GetWantSender(
42     const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken, sptr<IWantSender> &wantSender,
43     int32_t uid)
44 {
45     auto abms = GetAbilityManager();
46     CHECK_POINTER_AND_RETURN(abms, ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY);
47     MessageParcel data;
48     MessageParcel reply;
49     MessageOption option;
50     if (!WriteInterfaceToken(data)) {
51         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
52     }
53     if (!data.WriteParcelable(&wantSenderInfo)) {
54         TAG_LOGE(AAFwkTag::WANTAGENT, "write failed");
55         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
56     }
57     if (callerToken) {
58         if (!data.WriteBool(true) || !data.WriteRemoteObject(callerToken)) {
59             TAG_LOGE(AAFwkTag::WANTAGENT, "flag and callerToken write failed");
60             return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
61         }
62     } else {
63         if (!data.WriteBool(false)) {
64             TAG_LOGE(AAFwkTag::WANTAGENT, "flag write failed");
65             return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
66         }
67     }
68 
69     if (!data.WriteInt32(uid)) {
70         TAG_LOGE(AAFwkTag::ABILITYMGR, "uid write fail");
71         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
72     }
73 
74     auto error = abms->SendRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_SENDER),
75         data, reply, option);
76     if (error != NO_ERROR) {
77         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
78     }
79     wantSender = iface_cast<IWantSender>(reply.ReadRemoteObject());
80     return ERR_OK;
81 }
82 
SendWantSender(sptr<IWantSender> target,const SenderInfo & senderInfo)83 ErrCode WantAgentClient::SendWantSender(sptr<IWantSender> target, const SenderInfo &senderInfo)
84 {
85     CHECK_POINTER_AND_RETURN(target, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
86     auto abms = GetAbilityManager();
87     CHECK_POINTER_AND_RETURN(abms, ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY);
88     MessageParcel data;
89     MessageParcel reply;
90     MessageOption option;
91     if (!WriteInterfaceToken(data)) {
92         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
93     }
94     if (target == nullptr || !data.WriteRemoteObject(target->AsObject())) {
95         TAG_LOGE(AAFwkTag::WANTAGENT, "target write failed");
96         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
97     }
98     if (!data.WriteParcelable(&senderInfo)) {
99         TAG_LOGE(AAFwkTag::WANTAGENT, "senderInfo write failed");
100         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
101     }
102 
103     auto error = abms->SendRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_PENDING_WANT_SENDER),
104         data, reply, option);
105     if (error != NO_ERROR) {
106         return ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_TIMEOUT;
107     }
108     return reply.ReadInt32();
109 }
110 
CancelWantSender(const sptr<IWantSender> & sender,uint32_t flags)111 ErrCode WantAgentClient::CancelWantSender(const sptr<IWantSender> &sender, uint32_t flags)
112 {
113     CHECK_POINTER_AND_RETURN(sender, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
114     auto abms = GetAbilityManager();
115     CHECK_POINTER_AND_RETURN(abms, ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY);
116     ErrCode error;
117     MessageParcel data;
118     MessageParcel reply;
119     MessageOption option;
120     if (!WriteInterfaceToken(data)) {
121         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
122     }
123 
124     if (!data.WriteRemoteObject(sender->AsObject())) {
125         TAG_LOGE(AAFwkTag::WANTAGENT, "sender write failed");
126         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT;
127     }
128 
129     if (!data.WriteUint32(flags)) {
130         TAG_LOGE(AAFwkTag::WANTAGENT, "flags write failed");
131         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
132     }
133 
134     error = abms->SendRequest(static_cast<int32_t>(AbilityManagerInterfaceCode::CANCEL_PENDING_WANT_SENDER),
135         data, reply, option);
136     if (error != NO_ERROR) {
137         return ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY;
138     }
139 
140     return ERR_OK;
141 }
142 
GetPendingWantUid(const sptr<IWantSender> & target,int32_t & uid)143 ErrCode WantAgentClient::GetPendingWantUid(const sptr<IWantSender> &target, int32_t &uid)
144 {
145     CHECK_POINTER_AND_RETURN(target, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
146     auto abms = GetAbilityManager();
147     CHECK_POINTER_AND_RETURN(abms, ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY);
148     ErrCode error;
149     MessageParcel reply;
150     if (!SendRequest(static_cast<int32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_UID),
151         abms, target->AsObject(), reply, error)) {
152         return error;
153     }
154     uid = reply.ReadInt32();
155     return ERR_OK;
156 }
157 
GetPendingWantUserId(const sptr<IWantSender> & target,int32_t & userId)158 ErrCode WantAgentClient::GetPendingWantUserId(const sptr<IWantSender> &target, int32_t &userId)
159 {
160     CHECK_POINTER_AND_RETURN(target, INVALID_PARAMETERS_ERR);
161     auto abms = GetAbilityManager();
162     CHECK_POINTER_AND_RETURN(abms, ABILITY_SERVICE_NOT_CONNECTED);
163     ErrCode error;
164     MessageParcel reply;
165     if (!SendRequest(static_cast<int32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_USERID),
166         abms, target->AsObject(), reply, error)) {
167         return error;
168     }
169     userId = reply.ReadInt32();
170     return ERR_OK;
171 }
172 
GetPendingWantBundleName(const sptr<IWantSender> & target,std::string & bundleName)173 ErrCode WantAgentClient::GetPendingWantBundleName(const sptr<IWantSender> &target, std::string &bundleName)
174 {
175     CHECK_POINTER_AND_RETURN(target, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
176     auto abms = GetAbilityManager();
177     CHECK_POINTER_AND_RETURN(abms, ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY);
178     ErrCode error;
179     MessageParcel reply;
180     if (!SendRequest(static_cast<int32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_BUNDLENAME),
181         abms, target->AsObject(), reply, error)) {
182         return error;
183     }
184     bundleName = Str16ToStr8(reply.ReadString16());
185     return ERR_OK;
186 }
187 
GetPendingWantCode(const sptr<IWantSender> & target,int32_t & code)188 ErrCode WantAgentClient::GetPendingWantCode(const sptr<IWantSender> &target, int32_t &code)
189 {
190     CHECK_POINTER_AND_RETURN(target, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
191     auto abms = GetAbilityManager();
192     CHECK_POINTER_AND_RETURN(abms, ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY);
193     ErrCode error;
194     MessageParcel reply;
195     if (!SendRequest(static_cast<int32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_CODE),
196         abms, target->AsObject(), reply, error)) {
197         return ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_TIMEOUT;
198     }
199     code = reply.ReadInt32();
200     return ERR_OK;
201 }
202 
GetPendingWantType(sptr<IWantSender> target,int32_t & type)203 ErrCode WantAgentClient::GetPendingWantType(sptr<IWantSender> target, int32_t &type)
204 {
205     CHECK_POINTER_AND_RETURN(target, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
206     auto abms = GetAbilityManager();
207     CHECK_POINTER_AND_RETURN(abms, ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY);
208     ErrCode error;
209     MessageParcel reply;
210     if (!SendRequest(static_cast<int32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_TYPE),
211         abms, target->AsObject(), reply, error)) {
212         return ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_TIMEOUT;
213     }
214     type = reply.ReadInt32();
215     type < 0 ? type = 0 : type;
216     return ERR_OK;
217 }
218 
RegisterCancelListener(const sptr<IWantSender> & sender,const sptr<IWantReceiver> & receiver)219 void WantAgentClient::RegisterCancelListener(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver)
220 {
221     if (!CheckSenderAndRecevier(sender, receiver)) {
222         return;
223     }
224     auto abms = GetAbilityManager();
225     if (!abms) {
226         TAG_LOGE(AAFwkTag::WANTAGENT, "ability proxy is nullptr");
227         return;
228     }
229     MessageParcel data;
230     MessageParcel reply;
231     MessageOption option;
232     if (!WriteInterfaceToken(data)) {
233         return;
234     }
235     if (!data.WriteRemoteObject(sender->AsObject())) {
236         TAG_LOGE(AAFwkTag::WANTAGENT, "sender write failed");
237         return;
238     }
239     if (!data.WriteRemoteObject(receiver->AsObject())) {
240         TAG_LOGE(AAFwkTag::WANTAGENT, "receiver write failed");
241         return;
242     }
243     auto error = abms->SendRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_CANCEL_LISTENER),
244         data, reply, option);
245     if (error != NO_ERROR) {
246         return;
247     }
248 }
249 
UnregisterCancelListener(const sptr<IWantSender> & sender,const sptr<IWantReceiver> & receiver)250 void WantAgentClient::UnregisterCancelListener(
251     const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver)
252 {
253     if (!CheckSenderAndRecevier(sender, receiver)) {
254         return;
255     }
256     auto abms = GetAbilityManager();
257     if (!abms) {
258         TAG_LOGE(AAFwkTag::WANTAGENT, "ability proxy is nullptr");
259         return;
260     }
261     MessageParcel data;
262     MessageParcel reply;
263     MessageOption option;
264     if (!WriteInterfaceToken(data)) {
265         return;
266     }
267     if (!data.WriteRemoteObject(sender->AsObject())) {
268         TAG_LOGE(AAFwkTag::WANTAGENT, "sender write failed");
269         return;
270     }
271     if (!data.WriteRemoteObject(receiver->AsObject())) {
272         TAG_LOGE(AAFwkTag::WANTAGENT, "receiver write failed");
273         return;
274     }
275     auto error = abms->SendRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_CANCEL_LISTENER),
276         data, reply, option);
277     if (error != NO_ERROR) {
278         return;
279     }
280 }
281 
GetPendingRequestWant(const sptr<IWantSender> & target,std::shared_ptr<Want> & want)282 ErrCode WantAgentClient::GetPendingRequestWant(const sptr<IWantSender> &target, std::shared_ptr<Want> &want)
283 {
284     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
285     CHECK_POINTER_AND_RETURN(target, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
286     CHECK_POINTER_AND_RETURN(want, INVALID_PARAMETERS_ERR);
287     auto abms = GetAbilityManager();
288     CHECK_POINTER_AND_RETURN(abms, ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY);
289     MessageParcel data;
290     MessageParcel reply;
291     MessageOption option;
292     if (!WriteInterfaceToken(data)) {
293         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
294     }
295 
296     sptr<IRemoteObject> obj = target->AsObject();
297     if (obj == nullptr) {
298         TAG_LOGE(AAFwkTag::WANTAGENT, "Input Param target is invalid");
299         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
300     }
301 
302     if (!data.WriteRemoteObject(obj)) {
303         TAG_LOGE(AAFwkTag::WANTAGENT, "target write failed");
304         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
305     }
306     if (!data.WriteParcelable(want.get())) {
307         TAG_LOGE(AAFwkTag::WANTAGENT, "want write failed");
308         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
309     }
310     auto error = abms->SendRequest(static_cast<int32_t>(AbilityManagerInterfaceCode::GET_PENDING_REQUEST_WANT),
311         data, reply, option);
312     if (error != NO_ERROR) {
313         TAG_LOGE(AAFwkTag::WANTAGENT, "Send request error: %{public}d", error);
314         return ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_TIMEOUT;
315     }
316     std::unique_ptr<Want> wantInfo(reply.ReadParcelable<Want>());
317     if (!wantInfo) {
318         TAG_LOGE(AAFwkTag::WANTAGENT, "ReadParcelable failed");
319         return ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
320     }
321     want = std::move(wantInfo);
322 
323     return NO_ERROR;
324 }
325 
GetWantSenderInfo(const sptr<IWantSender> & target,std::shared_ptr<WantSenderInfo> & info)326 ErrCode WantAgentClient::GetWantSenderInfo(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info)
327 {
328     CHECK_POINTER_AND_RETURN(target, INVALID_PARAMETERS_ERR);
329     CHECK_POINTER_AND_RETURN(info, INVALID_PARAMETERS_ERR);
330     auto abms = GetAbilityManager();
331     CHECK_POINTER_AND_RETURN(abms, ABILITY_SERVICE_NOT_CONNECTED);
332     MessageParcel data;
333     MessageParcel reply;
334     MessageOption option;
335     if (!WriteInterfaceToken(data)) {
336         return INNER_ERR;
337     }
338     if (!data.WriteRemoteObject(target->AsObject())) {
339         TAG_LOGE(AAFwkTag::WANTAGENT, "target write failed");
340         return INNER_ERR;
341     }
342     if (!data.WriteParcelable(info.get())) {
343         TAG_LOGE(AAFwkTag::WANTAGENT, "info write failed");
344         return INNER_ERR;
345     }
346     auto error = abms->SendRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_SENDER_INFO),
347         data, reply, option);
348     if (error != NO_ERROR) {
349         TAG_LOGE(AAFwkTag::WANTAGENT, "Send request error: %{public}d", error);
350         return error;
351     }
352     std::unique_ptr<WantSenderInfo> wantSenderInfo(reply.ReadParcelable<WantSenderInfo>());
353     if (!wantSenderInfo) {
354         TAG_LOGE(AAFwkTag::WANTAGENT, "readParcelable Info failed");
355         return INNER_ERR;
356     }
357     info = std::move(wantSenderInfo);
358 
359     return NO_ERROR;
360 }
361 
GetAbilityManager()362 sptr<IRemoteObject> WantAgentClient::GetAbilityManager()
363 {
364     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
365     std::lock_guard<std::mutex> lock(mutex_);
366     if (proxy_ == nullptr) {
367         auto systemManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
368         if (systemManager == nullptr) {
369             TAG_LOGE(AAFwkTag::WANTAGENT, "Fail to get registry");
370             return nullptr;
371         }
372         auto remoteObj = systemManager->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
373         if (remoteObj == nullptr) {
374             TAG_LOGE(AAFwkTag::WANTAGENT, "Fail to connect ability manager service");
375             return nullptr;
376         }
377 
378         deathRecipient_ = sptr<IRemoteObject::DeathRecipient>(new (std::nothrow) WantAgentDeathRecipient());
379         if (deathRecipient_ == nullptr) {
380             TAG_LOGE(AAFwkTag::WANTAGENT, "Failed to create DeathRecipient");
381             return nullptr;
382         }
383         if (!remoteObj->AddDeathRecipient(deathRecipient_)) {
384             TAG_LOGE(AAFwkTag::WANTAGENT, "Add death recipient to failed");
385         }
386         proxy_ = remoteObj;
387     }
388 
389     return proxy_;
390 }
391 
OnRemoteDied(const wptr<IRemoteObject> & remote)392 void WantAgentClient::WantAgentDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
393 {
394     TAG_LOGI(AAFwkTag::WANTAGENT, "call");
395     WantAgentClient::GetInstance().ResetProxy(remote);
396 }
397 
ResetProxy(const wptr<IRemoteObject> & remote)398 void WantAgentClient::ResetProxy(const wptr<IRemoteObject>& remote)
399 {
400     std::lock_guard<std::mutex> lock(mutex_);
401     if (!proxy_) {
402         return;
403     }
404     if (proxy_ == remote.promote()) {
405         proxy_->RemoveDeathRecipient(deathRecipient_);
406     }
407     proxy_ = nullptr;
408 }
409 
WriteInterfaceToken(MessageParcel & data)410 bool WantAgentClient::WriteInterfaceToken(MessageParcel &data)
411 {
412     if (!data.WriteInterfaceToken(IAbilityManager::GetDescriptor())) {
413         TAG_LOGE(AAFwkTag::WANTAGENT, "write interface token failed");
414         return false;
415     }
416     return true;
417 }
418 
CheckSenderAndRecevier(const sptr<IWantSender> & sender,const sptr<IWantReceiver> & receiver)419 bool WantAgentClient::CheckSenderAndRecevier(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver)
420 {
421     if (sender == nullptr) {
422         TAG_LOGE(AAFwkTag::WANTAGENT, "sender is nullptr");
423         return false;
424     }
425     if (receiver == nullptr) {
426         TAG_LOGE(AAFwkTag::WANTAGENT, "receiver is nullptr");
427         return false;
428     }
429 
430     return true;
431 }
432 
SendRequest(int32_t operation,const sptr<IRemoteObject> & abms,const sptr<IRemoteObject> & remoteObject,MessageParcel & reply,ErrCode & error)433 bool WantAgentClient::SendRequest(int32_t operation, const sptr<IRemoteObject> &abms,
434     const sptr<IRemoteObject> &remoteObject, MessageParcel &reply, ErrCode &error)
435 {
436     MessageParcel data;
437     MessageOption option;
438     if (!WriteInterfaceToken(data)) {
439         error = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
440         return false;
441     }
442     if (!data.WriteRemoteObject(remoteObject)) {
443         TAG_LOGE(AAFwkTag::WANTAGENT, "write failed");
444         error = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
445         return false;
446     }
447     error = abms->SendRequest(operation, data, reply, option);
448     if (error != NO_ERROR) {
449         error = ERR_ABILITY_RUNTIME_EXTERNAL_SERVICE_BUSY;
450         return false;
451     }
452 
453     return true;
454 }
455 }  // namespace AAFwk
456 }  // namespace OHOS
457