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 "form_provider_mgr.h"
17 
18 #include <cinttypes>
19 
20 #include "fms_log_wrapper.h"
21 #include "form_ams_helper.h"
22 #include "form_batch_delete_connection.h"
23 #include "form_cache_mgr.h"
24 #include "form_constants.h"
25 #include "form_data_mgr.h"
26 #include "form_delete_connection.h"
27 #include "form_mgr_errors.h"
28 #include "form_msg_event_connection.h"
29 #include "form_record.h"
30 #include "form_refresh_connection.h"
31 #include "form_timer_mgr.h"
32 #include "form_report.h"
33 #include "form_record_report.h"
34 #ifdef SUPPORT_POWER
35 #include "power_mgr_client.h"
36 #endif
37 namespace OHOS {
38 namespace AppExecFwk {
FormProviderMgr()39 FormProviderMgr::FormProviderMgr() {}
~FormProviderMgr()40 FormProviderMgr::~FormProviderMgr() {}
41 /**
42  * @brief handle for acquire back from ams.
43  * @param formId The id of the form.
44  * @param formProviderInfo provider form info.
45  * @return Returns ERR_OK on success, others on failure.
46  */
AcquireForm(const int64_t formId,const FormProviderInfo & formProviderInfo)47 ErrCode FormProviderMgr::AcquireForm(const int64_t formId, const FormProviderInfo &formProviderInfo)
48 {
49     HILOG_DEBUG("formId:%{public}" PRId64 "", formId);
50 
51     if (formId <= 0) {
52         HILOG_ERROR("formId not greater than 0");
53         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
54     }
55 
56     FormRecord formRecord;
57     bool isGetFormRecord = FormDataMgr::GetInstance().GetFormRecord(formId, formRecord);
58     if (!isGetFormRecord) {
59         HILOG_ERROR("not exist such form, formId:%{public}" PRId64 "", formId);
60         return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
61     }
62 
63     std::vector<FormHostRecord> clientHosts;
64     FormDataMgr::GetInstance().GetFormHostRecord(formId, clientHosts);
65     if (clientHosts.empty()) {
66         HILOG_ERROR("empty clientHosst");
67         return ERR_APPEXECFWK_FORM_COMMON_CODE;
68     }
69 
70     if (formRecord.isInited) {
71         if (IsFormCached(formRecord)) {
72             formRecord.formProviderInfo = formProviderInfo;
73             for (auto &iter : clientHosts) {
74                 iter.OnAcquire(formId, formRecord);
75             }
76         } else {
77             Want want;
78             RefreshForm(formId, want, true);
79         }
80         return ERR_OK;
81     }
82     formRecord.isInited = true;
83     formRecord.needRefresh = false;
84     FormDataMgr::GetInstance().SetFormCacheInited(formId, true);
85 
86     formRecord.formProviderInfo = formProviderInfo;
87     for (auto &iter : clientHosts) {
88         iter.OnAcquire(formId, formRecord);
89     }
90 
91     if (formProviderInfo.NeedCache()) {
92         HILOG_WARN("acquire js card,cache the card");
93         FormCacheMgr::GetInstance().AddData(formId, formProviderInfo.GetFormData());
94     }
95     return ERR_OK;
96 }
97 
98 /**
99  * @brief Refresh form.
100  *
101  * @param formId The form id.
102  * @param want The want of the form to request.
103  * @param isVisibleToFresh The form is visible to fresh.
104  * @return Returns ERR_OK on success, others on failure.
105  */
RefreshForm(const int64_t formId,const Want & want,bool isVisibleToFresh)106 ErrCode FormProviderMgr::RefreshForm(const int64_t formId, const Want &want, bool isVisibleToFresh)
107 {
108     FormRecord record;
109     ErrCode result = RefreshCheck(record, formId, want);
110     if (result != ERR_OK) {
111         return result;
112     }
113     HILOG_INFO("FormProviderMgr::RefreshForm, formId:%{public}" PRId64 "., record.enableForm = %{public}d",
114         formId, record.enableForm);
115     if (!record.enableForm) {
116         FormDataMgr::GetInstance().SetRefreshDuringDisableForm(formId, true);
117         return ERR_APPEXECFWK_FORM_DISABLE_REFRESH;
118     }
119     bool isCountTimerRefresh = want.GetBoolParam(Constants::KEY_IS_TIMER, false);
120     Want newWant(want);
121     newWant.RemoveParam(Constants::KEY_IS_TIMER);
122 
123     if (isCountTimerRefresh) {
124         FormDataMgr::GetInstance().SetCountTimerRefresh(formId, true);
125     }
126 
127     bool isTimerRefresh = want.GetBoolParam(Constants::KEY_TIMER_REFRESH, false);
128     newWant.RemoveParam(Constants::KEY_TIMER_REFRESH);
129 
130     if (isTimerRefresh) {
131         FormDataMgr::GetInstance().SetTimerRefresh(formId, true);
132         bool isFormVisible = record.formVisibleNotifyState == Constants::FORM_VISIBLE;
133         if (!isFormVisible) {
134             HILOG_DEBUG("form is invisible");
135             FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
136             FormRecordReport::GetInstance().IncreaseUpdateTimes(formId, HiSysEventPointType::TYPE_INVISIBLE_INTERCEPT);
137             return ERR_OK;
138         }
139     }
140 
141 #ifdef SUPPORT_POWER
142     bool isFormProviderUpdate = want.GetBoolParam(Constants::FORM_ENABLE_UPDATE_REFRESH_KEY, false);
143     newWant.RemoveParam(Constants::FORM_ENABLE_UPDATE_REFRESH_KEY);
144     bool screenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsScreenOn();
145     bool collaborationScreenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsCollaborationScreenOn();
146     if (!screenOnFlag && !collaborationScreenOnFlag && !isFormProviderUpdate) {
147         FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
148         HILOG_DEBUG("screen off, set refresh flag, do not refresh now");
149         return ERR_OK;
150     }
151 #endif
152 
153     bool needRefresh = IsNeedToFresh(record, formId, isVisibleToFresh);
154     if (!needRefresh) {
155         FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
156         HILOG_ERROR("no one needReresh, set refresh flag, do not refresh now");
157         return ERR_OK;
158     }
159 
160     FormRecord refreshRecord = GetFormAbilityInfo(record);
161     refreshRecord.isCountTimerRefresh = isCountTimerRefresh;
162     refreshRecord.isTimerRefresh = isTimerRefresh;
163     return ConnectAmsForRefresh(formId, refreshRecord, newWant, isCountTimerRefresh);
164 }
165 
RefreshCheck(FormRecord & record,const int64_t formId,const Want & want)166 ErrCode FormProviderMgr::RefreshCheck(FormRecord &record, const int64_t formId, const Want &want)
167 {
168     bool bGetRecord = FormDataMgr::GetInstance().GetFormRecord(formId, record);
169     if (!bGetRecord) {
170         HILOG_ERROR("not exist such form:%{public}" PRId64 "", formId);
171         return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
172     }
173 
174     // get current userId
175     int32_t currentActiveUserId = want.GetIntParam(Constants::PARAM_FORM_USER_ID, Constants::DEFAULT_PROVIDER_USER_ID);
176     if (currentActiveUserId != record.providerUserId) {
177         FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
178         HILOG_ERROR("not current user, just set refresh flag, userId:%{public}d",
179             record.providerUserId);
180         return ERR_APPEXECFWK_FORM_OPERATION_NOT_SELF;
181     }
182 
183     bool addFormFinish = false;
184     FormReport::GetInstance().GetAddFormFinish(formId, addFormFinish);
185     if (!addFormFinish) {
186         HILOG_ERROR("form is adding form:%{public}" PRId64 "", formId);
187         return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
188     }
189 
190     return ERR_OK;
191 }
192 
193 /**
194  * @brief Connect ams for refresh form
195  *
196  * @param formId The form id.
197  * @param record Form data.
198  * @param want The want of the form.
199  * @param isTimerRefresh The flag of timer refresh.
200  * @return Returns ERR_OK on success, others on failure.
201  */
ConnectAmsForRefresh(const int64_t formId,const FormRecord & record,const Want & want,const bool isCountTimerRefresh)202 ErrCode FormProviderMgr::ConnectAmsForRefresh(const int64_t formId,
203     const FormRecord &record, const Want &want, const bool isCountTimerRefresh)
204 {
205     HILOG_DEBUG("bundleName:%{public}s, abilityName:%{public}s, needFreeInstall:%{public}d",
206         record.bundleName.c_str(), record.abilityName.c_str(), record.needFreeInstall);
207 
208     sptr<IAbilityConnection> formRefreshConnection = new (std::nothrow) FormRefreshConnection(formId, want,
209         record.bundleName, record.abilityName, record.needFreeInstall);
210     if (formRefreshConnection == nullptr) {
211         HILOG_ERROR("create FormRefreshConnection failed");
212         return ERR_APPEXECFWK_FORM_COMMON_CODE;
213     }
214     Want connectWant;
215     connectWant.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
216     connectWant.SetElementName(record.bundleName, record.abilityName);
217 
218     if (record.needFreeInstall) {
219         return RebindByFreeInstall(record, connectWant, formRefreshConnection);
220     }
221 
222     if (isCountTimerRefresh) {
223         if (!FormTimerMgr::GetInstance().IsLimiterEnableRefresh(formId)) {
224             HILOG_ERROR("timer refresh,already limit");
225             return ERR_APPEXECFWK_FORM_PROVIDER_DEL_FAIL;
226         }
227     }
228 
229     ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(connectWant, formRefreshConnection);
230     if (errorCode != ERR_OK) {
231         HILOG_ERROR("ConnectServiceAbility failed");
232         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
233     }
234 
235     if (record.isCountTimerRefresh) {
236         IncreaseTimerRefreshCount(formId);
237     }
238 
239     if (record.isTimerRefresh) {
240         FormDataMgr::GetInstance().SetTimerRefresh(formId, false);
241     }
242 
243     return ERR_OK;
244 }
245 
246 /**
247  * @brief Connect ability manager service for refresh app permission
248  *
249  * @param formId The form id.
250  * @param want The want of the form.
251  * @return Returns ERR_OK on success, others on failure.
252  */
ConnectAmsForRefreshPermission(const int64_t formId,Want & want)253 ErrCode FormProviderMgr::ConnectAmsForRefreshPermission(const int64_t formId, Want &want)
254 {
255     HILOG_DEBUG("ConnectAmsForRefreshPermission start, form id:%{public}" PRId64 "", formId);
256     if (!want.HasParameter(Constants::FORM_PERMISSION_NAME_KEY) ||
257         !want.HasParameter(Constants::FORM_PERMISSION_GRANTED_KEY)) {
258         HILOG_ERROR("permissionInfo not exist,form:%{public}" PRId64 "", formId);
259         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
260     }
261     FormRecord record;
262     bool result = FormDataMgr::GetInstance().GetFormRecord(formId, record);
263     if (!result) {
264         HILOG_ERROR("not exist such form:%{public}" PRId64 "", formId);
265         return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
266     }
267     want.RemoveParam(Constants::KEY_IS_TIMER);
268     want.RemoveParam(Constants::KEY_TIMER_REFRESH);
269 
270     sptr<IAbilityConnection> formRefreshConnection = new (std::nothrow) FormRefreshConnection(formId, want,
271         record.bundleName, record.abilityName, record.needFreeInstall);
272     if (formRefreshConnection == nullptr) {
273         HILOG_ERROR("create FormRefreshConnection failed");
274         return ERR_APPEXECFWK_FORM_COMMON_CODE;
275     }
276 
277     Want connectWant;
278     connectWant.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
279     connectWant.SetElementName(record.bundleName, record.abilityName);
280 
281     if (record.needFreeInstall) {
282         connectWant.AddFlags(Want::FLAG_INSTALL_ON_DEMAND | Want::FLAG_INSTALL_WITH_BACKGROUND_MODE);
283         connectWant.SetModuleName(record.moduleName);
284     }
285 
286     ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(connectWant, formRefreshConnection);
287     if (errorCode != ERR_OK) {
288         HILOG_ERROR("ConnectServiceAbility failed");
289         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
290     }
291 
292     return ERR_OK;
293 }
294 
295 /**
296  * @brief Notify provider form delete.
297  * @param formId The form id.
298  * @param record Form information.
299  * @return Function result and has other host flag.
300  */
NotifyProviderFormDelete(const int64_t formId,const FormRecord & formRecord)301 ErrCode FormProviderMgr::NotifyProviderFormDelete(const int64_t formId, const FormRecord &formRecord)
302 {
303     if (formRecord.abilityName.empty()) {
304         HILOG_ERROR("empty formRecord.abilityName");
305         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
306     }
307 
308     if (formRecord.bundleName.empty()) {
309         HILOG_ERROR("empty formRecord.bundleName");
310         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
311     }
312 
313     HILOG_DEBUG("connectAbility,bundleName:%{public}s, abilityName:%{public}s",
314         formRecord.bundleName.c_str(), formRecord.abilityName.c_str());
315     sptr<IAbilityConnection> formDeleteConnection = new (std::nothrow) FormDeleteConnection(formId,
316         formRecord.bundleName, formRecord.abilityName);
317     if (formDeleteConnection == nullptr) {
318         HILOG_ERROR("create FormDeleteConnection failed");
319         return ERR_APPEXECFWK_FORM_COMMON_CODE;
320     }
321     Want want;
322     want.SetElementName(formRecord.bundleName, formRecord.abilityName);
323     want.SetFlags(Want::FLAG_ABILITY_FORM_ENABLED);
324 
325     ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(want, formDeleteConnection);
326     if (errorCode != ERR_OK) {
327         HILOG_ERROR("ConnectServiceAbility failed");
328         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
329     }
330     return ERR_OK;
331 }
332 
333 /**
334  * @brief Notify provider forms batch delete.
335  * @param bundleName BundleName.
336  * @param bundleName AbilityName.
337  * @param formIds form id list.
338  * @return Returns ERR_OK on success, others on failure.
339  */
NotifyProviderFormsBatchDelete(const std::string & bundleName,const std::string & abilityName,const std::set<int64_t> & formIds)340 ErrCode FormProviderMgr::NotifyProviderFormsBatchDelete(const std::string &bundleName,
341     const std::string &abilityName, const std::set<int64_t> &formIds)
342 {
343     if (abilityName.empty()) {
344         HILOG_ERROR("empty abilityName");
345         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
346     }
347 
348     if (bundleName.empty()) {
349         HILOG_ERROR("empty bundleName");
350         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
351     }
352 
353     HILOG_DEBUG("bundleName:%{public}s, abilityName:%{public}s",
354         bundleName.c_str(), abilityName.c_str());
355     sptr<IAbilityConnection> batchDeleteConnection = new FormBatchDeleteConnection(formIds, bundleName, abilityName);
356     if (batchDeleteConnection == nullptr) {
357         HILOG_ERROR("create FormBatchDeleteConnection failed");
358         return ERR_APPEXECFWK_FORM_COMMON_CODE;
359     }
360     Want want;
361     want.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
362     want.SetElementName(bundleName, abilityName);
363 
364     ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(want, batchDeleteConnection);
365     if (errorCode != ERR_OK) {
366         HILOG_ERROR("ConnectServiceAbility failed");
367         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
368     }
369     return ERR_OK;
370 }
371 /**
372  * @brief Update form.
373  * @param formId The form's id.
374  * @param formProviderData form provider data.
375  * @return Returns ERR_OK on success, others on failure.
376  */
UpdateForm(const int64_t formId,const FormProviderInfo & formProviderInfo)377 ErrCode FormProviderMgr::UpdateForm(const int64_t formId, const FormProviderInfo &formProviderInfo)
378 {
379     // check exist and get the formRecord
380     FormRecord formRecord;
381     if (!FormDataMgr::GetInstance().GetFormRecord(formId, formRecord)) {
382         HILOG_ERROR("not exist such form:%{public}" PRId64 ".", formId);
383         return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
384     }
385     return UpdateForm(formId, formRecord, formProviderInfo.GetFormData());
386 }
387 /**
388  * handle for update form event from provider.
389  *
390  * @param formId The id of the form.
391  * @param formRecord The form's record.
392  * @param formProviderData provider form info.
393  * @return Returns ERR_OK on success, others on failure.
394  */
UpdateForm(const int64_t formId,FormRecord & formRecord,const FormProviderData & formProviderData)395 ErrCode FormProviderMgr::UpdateForm(const int64_t formId,
396     FormRecord &formRecord, const FormProviderData &formProviderData)
397 {
398     HILOG_INFO("imageDateState is %{public}d", formProviderData.GetImageDataState());
399     if (formRecord.versionUpgrade) {
400         formRecord.formProviderInfo.SetFormData(formProviderData);
401         formRecord.formProviderInfo.SetUpgradeFlg(true);
402     } else {
403         nlohmann::json addJsonData = formProviderData.GetData();
404         formRecord.formProviderInfo.MergeData(addJsonData);
405         // merge image
406         auto formData = formRecord.formProviderInfo.GetFormData();
407         formData.SetImageDataState(formProviderData.GetImageDataState());
408         formData.SetImageDataMap(formProviderData.GetImageDataMap());
409         formRecord.formProviderInfo.SetFormData(formData);
410     }
411 
412     // formRecord init
413     formRecord.isInited = true;
414     formRecord.needRefresh = false;
415     FormDataMgr::GetInstance().SetFormCacheInited(formId, true);
416 
417     // update form for host clients
418     FormDataMgr::GetInstance().UpdateHostNeedRefresh(formId, true);
419 
420 #ifdef SUPPORT_POWER
421     bool screenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsScreenOn();
422     if (screenOnFlag) {
423         if (FormDataMgr::GetInstance().UpdateHostForm(formId, formRecord)) {
424             FormDataMgr::GetInstance().SetVersionUpgrade(formId, false);
425             formRecord.formProviderInfo.SetUpgradeFlg(false);
426         }
427     }
428     HILOG_DEBUG("screenOn:%{public}d", screenOnFlag);
429 #endif
430 
431     if (formRecord.formProviderInfo.NeedCache()) {
432         HILOG_INFO("updateJsForm, data is less than 1k, cache data");
433         FormCacheMgr::GetInstance().AddData(formId, formRecord.formProviderInfo.GetFormData());
434     } else {
435         FormCacheMgr::GetInstance().DeleteData(formId);
436     }
437 
438     // the update form is successfully
439     return ERR_OK;
440 }
441 /**
442  * @brief Process js message event.
443  * @param formId Indicates the unique id of form.
444  * @param record Form record.
445  * @param want information passed to supplier.
446  * @return Returns true if execute success, false otherwise.
447  */
MessageEvent(const int64_t formId,const FormRecord & record,const Want & want)448 int FormProviderMgr::MessageEvent(const int64_t formId, const FormRecord &record, const Want &want)
449 {
450     HILOG_INFO("formId:%{public}" PRId64, formId);
451 
452 #ifdef SUPPORT_POWER
453     bool screenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsScreenOn();
454     bool collaborationScreenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsCollaborationScreenOn();
455     if (!screenOnFlag && !collaborationScreenOnFlag) {
456         HILOG_WARN("screen off now");
457         return ERR_APPEXECFWK_FORM_COMMON_CODE;
458     }
459 #endif
460 
461     sptr<IAbilityConnection> formMsgEventConnection = new (std::nothrow) FormMsgEventConnection(formId, want,
462         record.bundleName, record.abilityName);
463     if (formMsgEventConnection == nullptr) {
464         HILOG_ERROR("create FormMsgEventConnection failed");
465         return ERR_APPEXECFWK_FORM_COMMON_CODE;
466     }
467     Want connectWant;
468     connectWant.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
469     connectWant.SetElementName(record.bundleName, record.abilityName);
470 
471     ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(connectWant, formMsgEventConnection);
472     if (errorCode != ERR_OK) {
473         HILOG_ERROR("ConnectServiceAbility failed");
474         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
475     }
476 
477     return ERR_OK;
478 }
479 
480 /**
481  * @brief Increase the timer refresh count.
482  *
483  * @param formId The form id.
484  */
IncreaseTimerRefreshCount(const int64_t formId)485 void FormProviderMgr::IncreaseTimerRefreshCount(const int64_t formId)
486 {
487     FormRecord record;
488     if (!FormDataMgr::GetInstance().GetFormRecord(formId, record)) {
489         HILOG_ERROR("not exist such form:%{public}" PRId64 ".", formId);
490         return;
491     }
492 
493     if (record.isCountTimerRefresh) {
494         FormDataMgr::GetInstance().SetCountTimerRefresh(formId, false);
495         FormTimerMgr::GetInstance().IncreaseRefreshCount(formId);
496     }
497 }
498 
499 /**
500  * @brief Acquire form state.
501  * @param state form state.
502  * @param provider provider info.
503  * @param wantArg The want of onAcquireFormState.
504  * @return Returns ERR_OK on success, others on failure.
505  */
AcquireFormStateBack(FormState state,const std::string & provider,const Want & wantArg)506 ErrCode FormProviderMgr::AcquireFormStateBack(FormState state, const std::string& provider, const Want &wantArg)
507 {
508     HILOG_DEBUG("AcquireFormState start:%{public}d, provider:%{public}s", state, provider.c_str());
509     FormDataMgr::GetInstance().AcquireFormStateBack(state, provider, wantArg);
510     return ERR_OK;
511 }
512 
AcquireFormDataBack(const AAFwk::WantParams & wantParams,int64_t requestCode)513 ErrCode FormProviderMgr::AcquireFormDataBack(const AAFwk::WantParams &wantParams,
514     int64_t requestCode)
515 {
516     HILOG_DEBUG("start");
517     FormDataMgr::GetInstance().AcquireFormDataBack(wantParams, requestCode);
518     return ERR_OK;
519 }
520 
IsNeedToFresh(FormRecord & record,int64_t formId,bool isVisibleToFresh)521 bool FormProviderMgr::IsNeedToFresh(FormRecord &record, int64_t formId, bool isVisibleToFresh)
522 {
523     bool isEnableRefresh = FormDataMgr::GetInstance().IsEnableRefresh(formId);
524     HILOG_DEBUG("isEnableRefresh is %{public}d", isEnableRefresh);
525     if (isEnableRefresh) {
526         return true;
527     }
528 
529     HILOG_DEBUG("isVisibleToFresh is %{public}d, record.isVisible is %{public}d", isVisibleToFresh, record.isVisible);
530     if (isVisibleToFresh) {
531         if (!record.isVisible) {
532             FormRecordReport::GetInstance().IncreaseUpdateTimes(formId, HiSysEventPointType::TYPE_INVISIBLE_INTERCEPT);
533         }
534         return record.isVisible;
535     }
536 
537     bool isEnableUpdate = FormDataMgr::GetInstance().IsEnableUpdate(formId);
538     HILOG_DEBUG("isEnableUpdate is %{public}d", isEnableUpdate);
539     return isEnableUpdate;
540 }
541 
GetFormAbilityInfo(const FormRecord & record) const542 FormRecord FormProviderMgr::GetFormAbilityInfo(const FormRecord &record) const
543 {
544     FormRecord newRecord;
545     newRecord.bundleName = record.bundleName;
546     newRecord.moduleName = record.moduleName;
547     newRecord.abilityName = record.abilityName;
548     newRecord.isInited = record.isInited;
549     newRecord.versionUpgrade = record.versionUpgrade;
550     newRecord.needFreeInstall = record.needFreeInstall;
551     return newRecord;
552 }
553 
IsFormCached(const FormRecord & record)554 bool FormProviderMgr::IsFormCached(const FormRecord &record)
555 {
556     if (record.versionUpgrade) {
557         return false;
558     }
559     return FormCacheMgr::GetInstance().NeedAcquireProviderData(record.formId);
560 }
561 
RebindByFreeInstall(const FormRecord & record,Want & want,const sptr<AAFwk::IAbilityConnection> formRefreshConnection)562 ErrCode FormProviderMgr::RebindByFreeInstall(const FormRecord &record, Want &want,
563     const sptr<AAFwk::IAbilityConnection> formRefreshConnection)
564 {
565     HILOG_INFO("start");
566     want.AddFlags(Want::FLAG_INSTALL_ON_DEMAND | Want::FLAG_INSTALL_WITH_BACKGROUND_MODE);
567     want.SetModuleName(record.moduleName);
568     ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(want, formRefreshConnection);
569     if (errorCode != ERR_OK) {
570         HILOG_ERROR("ConnectServiceAbility failed, err:%{public}d", errorCode);
571         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
572     }
573     return ERR_OK;
574 }
575 }  // namespace AppExecFwk
576 }  // namespace OHOS
577