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 "form_provider_client.h"
17 
18 #include <cinttypes>
19 #include <memory>
20 #include <type_traits>
21 #include <unistd.h>
22 
23 #include "appexecfwk_errors.h"
24 #include "fms_log_wrapper.h"
25 #include "form_mgr_errors.h"
26 #include "form_caller_mgr.h"
27 #include "form_supply_proxy.h"
28 #include "ipc_skeleton.h"
29 #include "string_ex.h"
30 
31 namespace OHOS {
32 namespace AppExecFwk {
AcquireProviderFormInfo(const FormJsInfo & formJsInfo,const Want & want,const sptr<IRemoteObject> & callerToken)33 int FormProviderClient::AcquireProviderFormInfo(
34     const FormJsInfo &formJsInfo,
35     const Want &want,
36     const sptr<IRemoteObject> &callerToken)
37 {
38     HILOG_DEBUG("call");
39 
40     Want newWant(want);
41     newWant.SetParam(Constants::ACQUIRE_TYPE, want.GetIntParam(Constants::ACQUIRE_TYPE, 0));
42     newWant.SetParam(Constants::FORM_CONNECT_ID, want.GetIntParam(Constants::FORM_CONNECT_ID, 0));
43     newWant.SetParam(Constants::FORM_SUPPLY_INFO, want.GetStringParam(Constants::FORM_SUPPLY_INFO));
44     newWant.SetParam(Constants::PROVIDER_FLAG, true);
45     newWant.SetParam(Constants::PARAM_FORM_IDENTITY_KEY, std::to_string(formJsInfo.formId));
46     std::shared_ptr<Ability> ownerAbility = GetOwner();
47     if (ownerAbility == nullptr) {
48         HILOG_ERROR("null Owner");
49         FormProviderInfo formProviderInfo;
50         newWant.SetParam(Constants::PROVIDER_FLAG, ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY);
51         return HandleAcquire(formProviderInfo, newWant, callerToken);
52     }
53 
54     HILOG_INFO("AbilityName:%{public}s", ownerAbility->GetAbilityName().c_str());
55 
56     if (!CheckIsSystemApp()) {
57         HILOG_WARN("Permission denied");
58         FormProviderInfo formProviderInfo;
59         newWant.SetParam(Constants::PROVIDER_FLAG, ERR_APPEXECFWK_FORM_PERMISSION_DENY);
60         return HandleAcquire(formProviderInfo, newWant, callerToken);
61     }
62 
63     Want createWant(want);
64     createWant.SetParam(Constants::PARAM_FORM_IDENTITY_KEY, std::to_string(formJsInfo.formId));
65     createWant.RemoveParam(Constants::FORM_CONNECT_ID);
66     createWant.RemoveParam(Constants::ACQUIRE_TYPE);
67     createWant.RemoveParam(Constants::FORM_SUPPLY_INFO);
68     createWant.RemoveParam(Constants::PARAM_FORM_HOST_TOKEN);
69     createWant.RemoveParam(Constants::FORM_COMP_ID);
70     createWant.RemoveParam(Constants::FORM_DENSITY);
71     createWant.RemoveParam(Constants::FORM_PROCESS_ON_ADD_SURFACE);
72     createWant.RemoveParam(Constants::FORM_ALLOW_UPDATE);
73     if (!createWant.HasParameter(Constants::LAUNCH_REASON_KEY)) {
74         createWant.SetParam(Constants::LAUNCH_REASON_KEY, Constants::FORM_DEFAULT);
75     }
76     if (!createWant.HasParameter(Constants::PARAM_FORM_CUSTOMIZE_KEY)) {
77         std::vector<std::string> customizeData;
78         createWant.SetParam(Constants::PARAM_FORM_CUSTOMIZE_KEY, customizeData);
79     }
80     FormProviderInfo formProviderInfo = ownerAbility->OnCreate(createWant);
81     HILOG_DEBUG("formId:%{public}" PRId64 ", data: %{private}s", formJsInfo.formId,
82         formProviderInfo.GetFormDataString().c_str());
83     if (newWant.HasParameter(Constants::PARAM_FORM_HOST_TOKEN)) {
84         HandleRemoteAcquire(formJsInfo, formProviderInfo, newWant, AsObject());
85     }
86     return HandleAcquire(formProviderInfo, newWant, callerToken);
87 }
88 
NotifyFormDelete(const int64_t formId,const Want & want,const sptr<IRemoteObject> & callerToken)89 int FormProviderClient::NotifyFormDelete(const int64_t formId, const Want &want, const sptr<IRemoteObject> &callerToken)
90 {
91     HILOG_DEBUG("call");
92 
93     // The error code for business operation.
94     int errorCode = ERR_OK;
95     do {
96         auto hostToken = want.GetRemoteObject(Constants::PARAM_FORM_HOST_TOKEN);
97         if (hostToken != nullptr) {
98             FormCallerMgr::GetInstance().RemoveFormProviderCaller(formId, hostToken);
99             break;
100         }
101 
102         std::shared_ptr<Ability> ownerAbility = GetOwner();
103         if (ownerAbility == nullptr) {
104             HILOG_ERROR("null Owner");
105             errorCode = ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
106             break;
107         }
108 
109         if (!CheckIsSystemApp()) {
110             HILOG_WARN("Permission denied");
111             errorCode = ERR_APPEXECFWK_FORM_PERMISSION_DENY;
112             break;
113         }
114 
115         HILOG_INFO("AbilityName:%{public}s", ownerAbility->GetAbilityName().c_str());
116         ownerAbility->OnDelete(formId);
117     } while (false);
118 
119     return DCRtnHelper(errorCode, want, callerToken);
120 }
121 
NotifyFormsDelete(const std::vector<int64_t> & formIds,const Want & want,const sptr<IRemoteObject> & callerToken)122 int FormProviderClient::NotifyFormsDelete(
123     const std::vector<int64_t> &formIds,
124     const Want &want,
125     const sptr<IRemoteObject> &callerToken)
126 {
127     HILOG_DEBUG("call");
128 
129     // The error code for business operation.
130     int errorCode = ERR_OK;
131     do {
132         std::shared_ptr<Ability> ownerAbility = GetOwner();
133         if (ownerAbility == nullptr) {
134             HILOG_ERROR("null Owner");
135             errorCode = ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
136             break;
137         }
138         if (!CheckIsSystemApp()) {
139             HILOG_WARN("Permission denied");
140             errorCode = ERR_APPEXECFWK_FORM_PERMISSION_DENY;
141             break;
142         }
143 
144         HILOG_INFO("formIdsSize:%{public}zu, abilityName:%{public}s", formIds.size(),
145             ownerAbility->GetAbilityName().c_str());
146         for (int64_t formId : formIds) {
147             ownerAbility->OnDelete(formId);
148         }
149     } while (false);
150 
151     return DCRtnHelper(errorCode, want, callerToken);
152 }
153 
NotifyFormUpdate(const int64_t formId,const Want & want,const sptr<IRemoteObject> & callerToken)154 int FormProviderClient::NotifyFormUpdate(
155     const int64_t formId,
156     const Want &want,
157     const sptr<IRemoteObject> &callerToken)
158 {
159     HILOG_DEBUG("NotifyFormUpdate start");
160 
161     // The error code for business operation.
162     int errorCode = ERR_OK;
163     do {
164         std::shared_ptr<Ability> ownerAbility = GetOwner();
165         if (ownerAbility == nullptr) {
166             HILOG_ERROR("null Owner");
167             errorCode = ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
168             break;
169         }
170 
171         if (!CheckIsSystemApp() && !IsCallBySelfBundle()) {
172             HILOG_ERROR("Permission denied");
173             errorCode = ERR_APPEXECFWK_FORM_PERMISSION_DENY;
174             break;
175         }
176 
177         HILOG_INFO("AbilityName:%{public}s", ownerAbility->GetAbilityName().c_str());
178         ownerAbility->OnUpdate(formId, want.GetParams());
179     } while (false);
180 
181     if (!want.HasParameter(Constants::FORM_CONNECT_ID)) {
182         return errorCode;
183     }
184 
185     return DCRtnHelper(errorCode, want, callerToken);
186 }
187 
EventNotify(const std::vector<int64_t> & formIds,const int32_t formVisibleType,const Want & want,const sptr<IRemoteObject> & callerToken)188 int FormProviderClient::EventNotify(
189     const std::vector<int64_t> &formIds,
190     const int32_t formVisibleType, const Want &want,
191     const sptr<IRemoteObject> &callerToken)
192 {
193     HILOG_DEBUG("EventNotify start");
194 
195     // The error code for business operation.
196     int errorCode = ERR_OK;
197     do {
198         std::shared_ptr<Ability> ownerAbility = GetOwner();
199         if (ownerAbility == nullptr) {
200             HILOG_ERROR("null Owner");
201             errorCode = ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
202             break;
203         }
204 
205         if (!CheckIsSystemApp()) {
206             HILOG_WARN("Permission denied");
207             errorCode = ERR_APPEXECFWK_FORM_PERMISSION_DENY;
208             break;
209         }
210 
211         std::map<int64_t, int32_t> formEventsMap;
212         for (const auto &formId : formIds) {
213             formEventsMap.insert(std::make_pair(formId, formVisibleType));
214         }
215 
216         HILOG_INFO("AbilityName:%{public}s", ownerAbility->GetAbilityName().c_str());
217         ownerAbility->OnVisibilityChanged(formEventsMap);
218     } while (false);
219 
220     return DCRtnHelper(errorCode, want, callerToken);
221 }
222 
NotifyFormCastTempForm(const int64_t formId,const Want & want,const sptr<IRemoteObject> & callerToken)223 int FormProviderClient::NotifyFormCastTempForm(
224     const int64_t formId,
225     const Want &want,
226     const sptr<IRemoteObject> &callerToken)
227 {
228     HILOG_DEBUG("NotifyFormCastTempForm start");
229 
230     // The error code for business operation.
231     int errorCode = ERR_OK;
232     do {
233         std::shared_ptr<Ability> ownerAbility = GetOwner();
234         if (ownerAbility == nullptr) {
235             HILOG_ERROR("null Owner");
236             errorCode = ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
237             break;
238         }
239 
240         if (!CheckIsSystemApp()) {
241             HILOG_WARN("Permission denied");
242             errorCode = ERR_APPEXECFWK_FORM_PERMISSION_DENY;
243             break;
244         }
245 
246         HILOG_INFO("AbilityName:%{public}s", ownerAbility->GetAbilityName().c_str());
247         ownerAbility->OnCastTemptoNormal(formId);
248     } while (false);
249 
250     return DCRtnHelper(errorCode, want, callerToken);
251 }
252 
FireFormEvent(const int64_t formId,const std::string & message,const Want & want,const sptr<IRemoteObject> & callerToken)253 int FormProviderClient::FireFormEvent(
254     const int64_t formId,
255     const std::string &message,
256     const Want &want,
257     const sptr<IRemoteObject> &callerToken)
258 {
259     HILOG_DEBUG("FireFormEvent start");
260 
261     // The error code for business operation.
262     int errorCode = ERR_OK;
263     do {
264         std::shared_ptr<Ability> ownerAbility = GetOwner();
265         if (ownerAbility == nullptr) {
266             HILOG_ERROR("null Owner");
267             errorCode = ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
268             break;
269         }
270 
271         if (!CheckIsSystemApp() && !IsCallBySelfBundle()) {
272             HILOG_WARN("Permission denied");
273             errorCode = ERR_APPEXECFWK_FORM_PERMISSION_DENY;
274             break;
275         }
276 
277         HILOG_INFO("AbilityName:%{public}s", ownerAbility->GetAbilityName().c_str());
278         ownerAbility->OnTriggerEvent(formId, message);
279     } while (false);
280 
281     if (!want.HasParameter(Constants::FORM_CONNECT_ID)) {
282         return errorCode;
283     }
284 
285     return DCRtnHelper(errorCode, want, callerToken);
286 }
287 
AcquireState(const Want & wantArg,const std::string & provider,const Want & want,const sptr<IRemoteObject> & callerToken)288 int FormProviderClient::AcquireState(const Want &wantArg, const std::string &provider, const Want &want,
289                                      const sptr<IRemoteObject> &callerToken)
290 {
291     HILOG_DEBUG("call");
292 
293     // The error code for business operation.
294     int errorCode = ERR_OK;
295     FormState state = FormState::UNKNOWN;
296     do {
297         std::shared_ptr<Ability> ownerAbility = GetOwner();
298         if (ownerAbility == nullptr) {
299             HILOG_ERROR("null Owner");
300             errorCode = ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
301             break;
302         }
303         if (!CheckIsSystemApp()) {
304             HILOG_ERROR("Permission denied");
305             errorCode = ERR_APPEXECFWK_FORM_PERMISSION_DENY;
306             break;
307         }
308 
309         HILOG_INFO("AbilityName:%{public}s", ownerAbility->GetAbilityName().c_str());
310         state = ownerAbility->OnAcquireFormState(wantArg);
311     } while (false);
312 
313     HandleAcquireStateResult(state, provider, wantArg, want, callerToken);
314     return errorCode;
315 }
316 
SetOwner(const std::shared_ptr<Ability> ability)317 void FormProviderClient::SetOwner(const std::shared_ptr<Ability> ability)
318 {
319     if (ability == nullptr) {
320         return;
321     }
322 
323     std::lock_guard<std::mutex> lock(abilityMutex_);
324     owner_ = ability;
325 }
326 
ClearOwner(const std::shared_ptr<Ability> ability)327 void FormProviderClient::ClearOwner(const std::shared_ptr<Ability> ability)
328 {
329     if (ability == nullptr) {
330         return;
331     }
332 
333     std::lock_guard<std::mutex> lock(abilityMutex_);
334     if (!owner_.expired()) {
335         std::shared_ptr<Ability> ownerAbility = owner_.lock();
336         if (ability == ownerAbility) {
337             owner_.reset();
338         }
339     }
340 }
341 
GetOwner()342 std::shared_ptr<Ability> FormProviderClient::GetOwner()
343 {
344     std::shared_ptr<Ability> ownerAbility = nullptr;
345     std::lock_guard<std::mutex> lock(abilityMutex_);
346     if (!owner_.expired()) {
347         ownerAbility = owner_.lock();
348     }
349     return ownerAbility;
350 }
351 
CheckIsSystemApp() const352 bool FormProviderClient::CheckIsSystemApp() const
353 {
354     HILOG_DEBUG("call");
355 
356     int32_t callingUid = IPCSkeleton::GetCallingUid();
357     if (callingUid > Constants::MAX_SYSTEM_APP_UID) {
358         HILOG_WARN("callingUid is %{public}d, which is larger than %{public}d", callingUid,
359             Constants::MAX_SYSTEM_APP_UID);
360         return false;
361     }
362 
363     HILOG_DEBUG("callingUid is %{public}d", callingUid);
364     return true;
365 }
366 
HandleAcquire(const FormProviderInfo & formProviderInfo,const Want & newWant,const sptr<IRemoteObject> & callerToken)367 int FormProviderClient::HandleAcquire(
368     const FormProviderInfo &formProviderInfo,
369     const Want &newWant,
370     const sptr<IRemoteObject> &callerToken)
371 {
372     HILOG_INFO("ImageState:%{public}d", formProviderInfo.GetFormData().GetImageDataState());
373     sptr<IFormSupply> formSupplyClient = iface_cast<IFormSupply>(callerToken);
374     if (formSupplyClient == nullptr) {
375         HILOG_ERROR("null IFormSupply");
376         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
377     }
378 
379     formSupplyClient->OnAcquire(formProviderInfo, newWant);
380     return ERR_OK;
381 }
382 
DCRtnHelper(const int & errCode,const Want & want,const sptr<IRemoteObject> & callerToken)383 int FormProviderClient::DCRtnHelper(const int &errCode, const Want &want, const sptr<IRemoteObject> &callerToken)
384 {
385     // The error code for disconnect.
386     int disconnectErrorCode = HandleDisconnect(want, callerToken);
387     if (errCode != ERR_OK) {
388         // If errorCode is not ERR_OK，return errorCode.
389         return errCode;
390     }
391     return disconnectErrorCode;
392 }
393 
HandleDisconnect(const Want & want,const sptr<IRemoteObject> & callerToken)394 int  FormProviderClient::HandleDisconnect(const Want &want, const sptr<IRemoteObject> &callerToken)
395 {
396     HILOG_INFO("ConnectId:%{public}d", want.GetIntParam(Constants::FORM_CONNECT_ID, 0L));
397     sptr<IFormSupply> formSupplyClient = iface_cast<IFormSupply>(callerToken);
398     if (formSupplyClient == nullptr) {
399         HILOG_ERROR("null IFormSupply");
400         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
401     }
402 
403     formSupplyClient->OnEventHandle(want);
404     return ERR_OK;
405 }
406 
HandleAcquireStateResult(FormState state,const std::string & provider,const Want & wantArg,const Want & want,const sptr<IRemoteObject> & callerToken)407 int FormProviderClient::HandleAcquireStateResult(FormState state, const std::string &provider, const Want &wantArg,
408                                                  const Want &want, const sptr<IRemoteObject> &callerToken)
409 {
410     HILOG_INFO("FormState:%{public}d", state);
411     sptr<IFormSupply> formSupplyClient = iface_cast<IFormSupply>(callerToken);
412     if (formSupplyClient == nullptr) {
413         HILOG_ERROR("null IFormSupply");
414         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
415     }
416 
417     formSupplyClient->OnAcquireStateResult(state, provider, wantArg, want);
418     return ERR_OK;
419 }
420 
AcquireShareFormData(int64_t formId,const std::string & remoteDeviceId,const sptr<IRemoteObject> & formSupplyCallback,int64_t requestCode)421 int32_t FormProviderClient::AcquireShareFormData(int64_t formId, const std::string &remoteDeviceId,
422     const sptr<IRemoteObject> &formSupplyCallback, int64_t requestCode)
423 {
424     HILOG_DEBUG("call");
425     if (formId <= 0 || remoteDeviceId.empty() || formSupplyCallback == nullptr || requestCode <= 0) {
426         HILOG_ERROR("Abnormal parameters exist");
427         return ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
428     }
429 
430     std::shared_ptr<Ability> ownerAbility = GetOwner();
431     if (ownerAbility == nullptr) {
432         HILOG_ERROR("null Owner");
433         return ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
434     }
435 
436     HILOG_INFO("AbilityName:%{public}s", ownerAbility->GetAbilityName().c_str());
437     if (!CheckIsSystemApp()) {
438         HILOG_WARN("Permission denied");
439         return ERR_APPEXECFWK_FORM_PERMISSION_DENY;
440     }
441 
442     auto formCall = iface_cast<IFormSupply>(formSupplyCallback);
443     if (formCall == nullptr) {
444         HILOG_ERROR("null IFormSupply");
445         return ERR_APPEXECFWK_FORM_NO_SUCH_ABILITY;
446     }
447 
448     AAFwk::WantParams wantParams;
449     auto result = ownerAbility->OnShare(formId, wantParams);
450     formCall->OnShareAcquire(formId, remoteDeviceId, wantParams, requestCode, result);
451 
452     HILOG_DEBUG("end");
453     return ERR_OK;
454 }
455 
HandleRemoteAcquire(const FormJsInfo & formJsInfo,const FormProviderInfo & formProviderInfo,const Want & want,const sptr<IRemoteObject> & token)456 void FormProviderClient::HandleRemoteAcquire(const FormJsInfo &formJsInfo, const FormProviderInfo &formProviderInfo,
457     const Want &want, const sptr<IRemoteObject> &token)
458 {
459     HILOG_DEBUG("call");
460     auto hostToken = want.GetRemoteObject(Constants::PARAM_FORM_HOST_TOKEN);
461     if (hostToken == nullptr) {
462         HILOG_ERROR("null hostToken");
463         return;
464     }
465     FormCallerMgr::GetInstance().AddFormProviderCaller(formJsInfo, hostToken);
466 
467     std::vector<std::shared_ptr<FormProviderCaller>> formProviderCallers;
468     FormCallerMgr::GetInstance().GetFormProviderCaller(formJsInfo.formId, formProviderCallers);
469     for (const auto &formProviderCaller : formProviderCallers) {
470         formProviderCaller->OnAcquire(formProviderInfo, want, token);
471     }
472 }
473 
IsCallBySelfBundle()474 bool FormProviderClient::IsCallBySelfBundle()
475 {
476     uid_t callingUid = static_cast<uid_t>(IPCSkeleton::GetCallingUid());
477     return (getuid() == callingUid);
478 }
479 } // namespace AppExecFwk
480 } // namespace OHOS
481