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/form_provider_mgr.h"
17
18 #include <cinttypes>
19
20 #include "fms_log_wrapper.h"
21 #include "ams_mgr/form_ams_helper.h"
22 #include "form_provider/connection/form_batch_delete_connection.h"
23 #include "data_center/form_cache_mgr.h"
24 #include "form_constants.h"
25 #include "data_center/form_data_mgr.h"
26 #include "form_provider/connection/form_delete_connection.h"
27 #include "form_mgr_errors.h"
28 #include "form_provider/connection/form_msg_event_connection.h"
29 #include "data_center/form_record/form_record.h"
30 #include "form_provider/connection/form_refresh_connection.h"
31 #include "form_provider/connection/form_location_connection.h"
32 #include "form_provider/connection/form_configuration_update_connection.h"
33 #include "form_provider/connection/form_update_size_connection.h"
34 #include "common/timer_mgr/form_timer_mgr.h"
35 #include "common/util/form_report.h"
36 #include "data_center/form_record/form_record_report.h"
37 #include "form_mgr/form_mgr_adapter.h"
38 #ifdef SUPPORT_POWER
39 #include "power_mgr_client.h"
40 #endif
41 #include "form_mgr/form_mgr_queue.h"
42 #include "form_mgr/form_mgr_queue.h"
43 #include "common/util/form_task_common.h"
44 #include "common/event/form_event_report.h"
45
46 namespace OHOS {
47 namespace AppExecFwk {
48 namespace {
49 const std::string HICAR_FORM = "phone_hicar";
50 }
FormProviderMgr()51 FormProviderMgr::FormProviderMgr() {}
~FormProviderMgr()52 FormProviderMgr::~FormProviderMgr() {}
53 /**
54 * @brief handle for acquire back from ams.
55 * @param formId The id of the form.
56 * @param formProviderInfo provider form info.
57 * @return Returns ERR_OK on success, others on failure.
58 */
AcquireForm(const int64_t formId,const FormProviderInfo & formProviderInfo)59 ErrCode FormProviderMgr::AcquireForm(const int64_t formId, const FormProviderInfo &formProviderInfo)
60 {
61 HILOG_DEBUG("formId:%{public}" PRId64 "", formId);
62
63 if (formId <= 0) {
64 HILOG_ERROR("formId not greater than 0");
65 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
66 }
67
68 FormRecord formRecord;
69 bool isGetFormRecord = FormDataMgr::GetInstance().GetFormRecord(formId, formRecord);
70 if (!isGetFormRecord) {
71 HILOG_ERROR("not exist such form, formId:%{public}" PRId64 "", formId);
72 return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
73 }
74
75 std::vector<FormHostRecord> clientHosts;
76 FormDataMgr::GetInstance().GetFormHostRecord(formId, clientHosts);
77 if (clientHosts.empty()) {
78 HILOG_ERROR("empty clientHosst");
79 return ERR_APPEXECFWK_FORM_COMMON_CODE;
80 }
81
82 if (formRecord.isInited) {
83 if (IsFormCached(formRecord)) {
84 formRecord.formProviderInfo = formProviderInfo;
85 for (auto &iter : clientHosts) {
86 iter.OnAcquire(formId, formRecord);
87 }
88 } else {
89 Want want;
90 RefreshForm(formId, want, true);
91 }
92 return ERR_OK;
93 }
94 formRecord.isInited = true;
95 formRecord.needRefresh = false;
96 FormDataMgr::GetInstance().SetFormCacheInited(formId, true);
97
98 formRecord.formProviderInfo = formProviderInfo;
99 for (auto &iter : clientHosts) {
100 iter.OnAcquire(formId, formRecord);
101 }
102
103 if (formProviderInfo.NeedCache()) {
104 HILOG_WARN("acquire js card,cache the card");
105 FormCacheMgr::GetInstance().AddData(formId, formProviderInfo.GetFormData());
106 }
107 return ERR_OK;
108 }
109
MergeWant(const Want & newWant,Want & oldWant)110 void FormProviderMgr::MergeWant(const Want &newWant, Want &oldWant)
111 {
112 std::map<std::string, sptr<IInterface>> newWantMap;
113 WantParams newWantParams = newWant.GetParams();
114 WantParams oldWantParams = oldWant.GetParams();
115 newWantMap = newWantParams.GetParams();
116 for (auto it = newWantMap.begin(); it != newWantMap.end(); it++) {
117 oldWantParams.SetParam(it->first, it->second);
118 }
119 oldWant.SetParams(oldWantParams);
120 }
121
UpdateWant(const int64_t formId,const Want & want,FormRecord & record)122 void FormProviderMgr::UpdateWant(const int64_t formId, const Want &want, FormRecord &record)
123 {
124 if (record.wantCacheMap.size() != 0) {
125 MergeWant(want, record.wantCacheMap[formId]);
126 return;
127 }
128 record.wantCacheMap[formId] = want;
129 }
130
DataProxyUpdate(const int64_t formId,const FormRecord & record,bool isFormProviderUpdate)131 void FormProviderMgr::DataProxyUpdate(const int64_t formId, const FormRecord &record, bool isFormProviderUpdate)
132 {
133 if (isFormProviderUpdate && record.isDataProxy) {
134 FormProviderData formProviderData;
135 std::string cacheData;
136 std::map<std::string, std::pair<sptr<FormAshmem>, int32_t>> imageDataMap;
137 if (FormCacheMgr::GetInstance().GetData(formId, cacheData, imageDataMap)) {
138 formProviderData.SetDataString(cacheData);
139 formProviderData.SetImageDataMap(imageDataMap);
140 FormMgrAdapter::GetInstance().UpdateForm(formId, record.uid, formProviderData);
141 }
142 HILOG_INFO("Upgrade APP data agent card update, cacheData: %{public}zu, formId:%{public}" PRId64,
143 cacheData.size(), formId);
144 }
145 }
146
147 /**
148 * @brief Refresh form.
149 *
150 * @param formId The form id.
151 * @param want The want of the form to request.
152 * @param isVisibleToFresh The form is visible to fresh.
153 * @return Returns ERR_OK on success, others on failure.
154 */
RefreshForm(const int64_t formId,const Want & want,bool isVisibleToFresh)155 ErrCode FormProviderMgr::RefreshForm(const int64_t formId, const Want &want, bool isVisibleToFresh)
156 {
157 FormRecord record;
158 ErrCode result = RefreshCheck(record, formId, want);
159 if (result != ERR_OK) {
160 return result;
161 }
162 HILOG_BRIEF("FormProviderMgr::RefreshForm, formId:%{public}" PRId64 "., record.enableForm = %{public}d",
163 formId, record.enableForm);
164 if (!record.enableForm) {
165 FormDataMgr::GetInstance().SetRefreshDuringDisableForm(formId, true);
166 FormRecordReport::GetInstance().IncreaseUpdateTimes(formId,
167 HiSysEventPointType::TYPE_DISABLE_FORM_INTERCEPT);
168 return ERR_APPEXECFWK_FORM_DISABLE_REFRESH;
169 }
170 bool isCountTimerRefresh = want.GetBoolParam(Constants::KEY_IS_TIMER, false);
171 Want newWant(want);
172 newWant.RemoveParam(Constants::KEY_IS_TIMER);
173
174 bool isTimerRefresh = want.GetBoolParam(Constants::KEY_TIMER_REFRESH, false);
175 bool isConnectRefresh = want.GetBoolParam(Constants::KEY_CONNECT_REFRESH, false);
176 newWant.RemoveParam(Constants::KEY_TIMER_REFRESH);
177 newWant.RemoveParam(Constants::KEY_CONNECT_REFRESH);
178
179 int refreshType = newWant.GetIntParam(Constants::PARAM_FORM_REFRESH_TYPE, Constants::REFRESHTYPE_DEFAULT);
180
181 if (isTimerRefresh || isConnectRefresh) {
182 FormDataMgr::GetInstance().SetTimerRefresh(formId, true);
183 bool isFormVisible = record.formVisibleNotifyState == Constants::FORM_VISIBLE;
184 if (!isFormVisible) {
185 HILOG_INFO("form is invisible, formId:%{public}" PRId64, formId);
186 FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
187 FormDataMgr::GetInstance().SetRefreshType(formId, refreshType);
188 FormRecordReport::GetInstance().IncreaseUpdateTimes(formId, HiSysEventPointType::TYPE_INVISIBLE_INTERCEPT);
189 return ERR_OK;
190 }
191 }
192
193 if (refreshType == Constants::REFRESHTYPE_VISIABLE) {
194 FormDataMgr::GetInstance().GetRefreshType(formId, refreshType);
195 HILOG_INFO("refreshType:%{public}d", refreshType);
196 if (refreshType == Constants::REFRESHTYPE_NETWORKCHANGED) {
197 isCountTimerRefresh = false;
198 }
199 }
200
201 if (record.isSystemApp && refreshType != Constants::REFRESHTYPE_DEFAULT
202 && refreshType != Constants::REFRESHTYPE_VISIABLE) {
203 newWant.SetParam(Constants::PARAM_FORM_REFRESH_TYPE, refreshType);
204 } else {
205 newWant.RemoveParam(Constants::PARAM_FORM_REFRESH_TYPE);
206 }
207
208 if (isCountTimerRefresh) {
209 FormDataMgr::GetInstance().SetCountTimerRefresh(formId, true);
210 }
211 bool isFormProviderUpdate = want.GetBoolParam(Constants::FORM_ENABLE_UPDATE_REFRESH_KEY, false);
212 DataProxyUpdate(formId, record, isFormProviderUpdate);
213 #ifdef SUPPORT_POWER
214 newWant.RemoveParam(Constants::FORM_ENABLE_UPDATE_REFRESH_KEY);
215 bool screenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsScreenOn();
216 bool collaborationScreenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsCollaborationScreenOn();
217 bool isHicar = (record.moduleName == HICAR_FORM);
218 if (!screenOnFlag && !collaborationScreenOnFlag && !isFormProviderUpdate && !isHicar) {
219 UpdateWant(formId, want, record);
220 FormDataMgr::GetInstance().UpdateFormRecord(formId, record);
221 FormDataMgr::GetInstance().SetHostRefresh(formId, true);
222 FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
223 HILOG_INFO("screen off, set refresh flag, do not refresh now, formId:%{public}" PRId64 ".", formId);
224 return ERR_OK;
225 }
226 #endif
227
228 bool needRefresh = IsNeedToFresh(record, formId, isVisibleToFresh);
229 if (!needRefresh) {
230 FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
231 HILOG_ERROR("no one needReresh, set refresh flag, do not refresh now");
232 return ERR_OK;
233 }
234
235 FormRecord refreshRecord = FormDataMgr::GetInstance().GetFormAbilityInfo(record);
236 refreshRecord.isCountTimerRefresh = isCountTimerRefresh;
237 refreshRecord.isTimerRefresh = isTimerRefresh;
238 refreshRecord.isHostRefresh = record.isHostRefresh;
239 return ConnectAmsForRefresh(formId, refreshRecord, newWant);
240 }
241
RefreshCheck(FormRecord & record,const int64_t formId,const Want & want)242 ErrCode FormProviderMgr::RefreshCheck(FormRecord &record, const int64_t formId, const Want &want)
243 {
244 bool bGetRecord = FormDataMgr::GetInstance().GetFormRecord(formId, record);
245 if (!bGetRecord) {
246 HILOG_ERROR("not exist such form:%{public}" PRId64 "", formId);
247 return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
248 }
249
250 // get current userId
251 int32_t currentActiveUserId = want.GetIntParam(Constants::PARAM_FORM_USER_ID, Constants::DEFAULT_PROVIDER_USER_ID);
252 if (currentActiveUserId != record.providerUserId) {
253 FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
254 HILOG_ERROR("not current user, just set refresh flag, userId:%{public}d",
255 record.providerUserId);
256 return ERR_APPEXECFWK_FORM_OPERATION_NOT_SELF;
257 }
258
259 bool addFormFinish = false;
260 FormReport::GetInstance().GetAddFormFinish(formId, addFormFinish);
261 if (!addFormFinish) {
262 HILOG_ERROR("form is adding form:%{public}" PRId64 "", formId);
263 return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
264 }
265
266 return ERR_OK;
267 }
268
269 /**
270 * @brief Connect provider ability for notify configuration changed.
271 *
272 * @param configuration The form id.
273 * @param record Form data.
274 * @param want The want of the form.
275 * @return Returns ERR_OK on success, others on failure.
276 */
ConnectForConfigUpdate(const AppExecFwk::Configuration & configuration,const FormRecord & record,const Want & want)277 ErrCode FormProviderMgr::ConnectForConfigUpdate(const AppExecFwk::Configuration &configuration,
278 const FormRecord &record, const Want &want)
279 {
280 HILOG_INFO("bundleName:%{public}s, abilityName:%{public}s",
281 record.bundleName.c_str(), record.abilityName.c_str());
282 sptr<IAbilityConnection> abilityConnection = new (std::nothrow) ConfigurationUpdateConnection(record.formId, want,
283 record.bundleName, record.abilityName, configuration);
284 if (abilityConnection == nullptr) {
285 HILOG_ERROR("create FormRefreshConnection failed");
286 return ERR_APPEXECFWK_FORM_COMMON_CODE;
287 }
288 Want connectWant;
289 connectWant.SetElementName(record.bundleName, record.abilityName);
290
291 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(connectWant, abilityConnection);
292 if (errorCode != ERR_OK) {
293 HILOG_ERROR("ConnectServiceAbility failed");
294 if (errorCode == ERR_ECOLOGICAL_CONTROL_STATUS) {
295 return ERR_APPEXECFWK_FORM_GET_AMSCONNECT_FAILED;
296 }
297 return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
298 }
299
300 return ERR_OK;
301 }
302
303 /**
304 * @brief Connect ams for refresh form
305 *
306 * @param formId The form id.
307 * @param record Form data.
308 * @param want The want of the form.
309 * @return Returns ERR_OK on success, others on failure.
310 */
ConnectAmsForRefresh(const int64_t formId,const FormRecord & record,const Want & want)311 ErrCode FormProviderMgr::ConnectAmsForRefresh(const int64_t formId, const FormRecord &record, const Want &want)
312 {
313 HILOG_INFO("formId:%{public} " PRId64 ", bundleName:%{public}s, abilityName:%{public}s, "
314 "needFreeInstall:%{public}d, isCountTimerRefresh:%{public}d, userId:%{public}d", formId,
315 record.bundleName.c_str(), record.abilityName.c_str(), record.needFreeInstall, record.isCountTimerRefresh,
316 record.providerUserId);
317
318 sptr<IAbilityConnection> formRefreshConnection = new (std::nothrow) FormRefreshConnection(formId, want,
319 record.bundleName, record.abilityName, record.needFreeInstall);
320 if (formRefreshConnection == nullptr) {
321 HILOG_ERROR("create FormRefreshConnection failed");
322 return ERR_APPEXECFWK_FORM_COMMON_CODE;
323 }
324 Want connectWant;
325 connectWant.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
326 connectWant.SetElementName(record.bundleName, record.abilityName);
327
328 if (record.needFreeInstall) {
329 return RebindByFreeInstall(record, connectWant, formRefreshConnection);
330 }
331
332 if (record.isCountTimerRefresh) {
333 if (!FormTimerMgr::GetInstance().IsLimiterEnableRefresh(formId)) {
334 HILOG_ERROR("timer refresh,already limit");
335 return ERR_APPEXECFWK_FORM_PROVIDER_DEL_FAIL;
336 }
337 }
338
339 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbilityWithUserId(connectWant, formRefreshConnection,
340 record.providerUserId);
341 if (errorCode != ERR_OK) {
342 errorCode = (errorCode == ERR_ECOLOGICAL_CONTROL_STATUS) ?
343 ERR_APPEXECFWK_FORM_GET_AMSCONNECT_FAILED : ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
344 HILOG_ERROR("ConnectServiceAbility failed, errorCode:%{public}d", errorCode);
345 FormEventReport::SendFormFailedEvent(FormEventName::CONNECT_FORM_ABILITY_FAILED, formId,
346 record.bundleName, "", static_cast<int32_t>(ConnectFormAbilityErrorType::UPDATE_FORM_FAILED), errorCode);
347 return errorCode;
348 }
349
350 if (record.isCountTimerRefresh) {
351 IncreaseTimerRefreshCount(formId);
352 }
353
354 if (record.isTimerRefresh) {
355 FormDataMgr::GetInstance().SetTimerRefresh(formId, false);
356 }
357
358 return ERR_OK;
359 }
360
361 /**
362 * @brief Connect ability manager service for refresh app permission
363 *
364 * @param formId The form id.
365 * @param want The want of the form.
366 * @return Returns ERR_OK on success, others on failure.
367 */
ConnectAmsForRefreshPermission(const int64_t formId,Want & want)368 ErrCode FormProviderMgr::ConnectAmsForRefreshPermission(const int64_t formId, Want &want)
369 {
370 HILOG_DEBUG("ConnectAmsForRefreshPermission start, form id:%{public}" PRId64 "", formId);
371 if (!want.HasParameter(Constants::FORM_PERMISSION_NAME_KEY) ||
372 !want.HasParameter(Constants::FORM_PERMISSION_GRANTED_KEY)) {
373 HILOG_ERROR("permissionInfo not exist,form:%{public}" PRId64 "", formId);
374 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
375 }
376 FormRecord record;
377 bool result = FormDataMgr::GetInstance().GetFormRecord(formId, record);
378 if (!result) {
379 HILOG_ERROR("not exist such form:%{public}" PRId64 "", formId);
380 return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
381 }
382 want.RemoveParam(Constants::KEY_IS_TIMER);
383 want.RemoveParam(Constants::KEY_TIMER_REFRESH);
384
385 sptr<IAbilityConnection> formRefreshConnection = new (std::nothrow) FormRefreshConnection(formId, want,
386 record.bundleName, record.abilityName, record.needFreeInstall);
387 if (formRefreshConnection == nullptr) {
388 HILOG_ERROR("create FormRefreshConnection failed");
389 return ERR_APPEXECFWK_FORM_COMMON_CODE;
390 }
391
392 Want connectWant;
393 connectWant.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
394 connectWant.SetElementName(record.bundleName, record.abilityName);
395
396 if (record.needFreeInstall) {
397 connectWant.AddFlags(Want::FLAG_INSTALL_ON_DEMAND | Want::FLAG_INSTALL_WITH_BACKGROUND_MODE);
398 connectWant.SetModuleName(record.moduleName);
399 }
400
401 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(connectWant, formRefreshConnection);
402 if (errorCode != ERR_OK) {
403 HILOG_ERROR("ConnectServiceAbility failed");
404 return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
405 }
406
407 return ERR_OK;
408 }
409
410 /**
411 * @brief Notify provider form delete.
412 * @param formId The form id.
413 * @param record Form information.
414 * @return Function result and has other host flag.
415 */
NotifyProviderFormDelete(const int64_t formId,const FormRecord & formRecord)416 ErrCode FormProviderMgr::NotifyProviderFormDelete(const int64_t formId, const FormRecord &formRecord)
417 {
418 if (formRecord.abilityName.empty()) {
419 HILOG_ERROR("empty formRecord.abilityName");
420 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
421 }
422
423 if (formRecord.bundleName.empty()) {
424 HILOG_ERROR("empty formRecord.bundleName");
425 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
426 }
427
428 HILOG_DEBUG("connectAbility,bundleName:%{public}s, abilityName:%{public}s",
429 formRecord.bundleName.c_str(), formRecord.abilityName.c_str());
430 sptr<IAbilityConnection> formDeleteConnection = new (std::nothrow) FormDeleteConnection(formId,
431 formRecord.bundleName, formRecord.abilityName);
432 if (formDeleteConnection == nullptr) {
433 HILOG_ERROR("create FormDeleteConnection failed");
434 return ERR_APPEXECFWK_FORM_COMMON_CODE;
435 }
436 Want want;
437 want.SetElementName(formRecord.bundleName, formRecord.abilityName);
438 want.SetFlags(Want::FLAG_ABILITY_FORM_ENABLED);
439
440 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(want, formDeleteConnection);
441 if (errorCode != ERR_OK) {
442 HILOG_ERROR("ConnectServiceAbility failed");
443 return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
444 }
445 return ERR_OK;
446 }
447
448 /**
449 * @brief Notify provider forms batch delete.
450 * @param bundleName BundleName.
451 * @param bundleName AbilityName.
452 * @param formIds form id list.
453 * @return Returns ERR_OK on success, others on failure.
454 */
NotifyProviderFormsBatchDelete(const std::string & bundleName,const std::string & abilityName,const std::set<int64_t> & formIds)455 ErrCode FormProviderMgr::NotifyProviderFormsBatchDelete(const std::string &bundleName,
456 const std::string &abilityName, const std::set<int64_t> &formIds)
457 {
458 if (abilityName.empty()) {
459 HILOG_ERROR("empty abilityName");
460 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
461 }
462
463 if (bundleName.empty()) {
464 HILOG_ERROR("empty bundleName");
465 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
466 }
467
468 HILOG_DEBUG("bundleName:%{public}s, abilityName:%{public}s",
469 bundleName.c_str(), abilityName.c_str());
470 sptr<IAbilityConnection> batchDeleteConnection = new FormBatchDeleteConnection(formIds, bundleName, abilityName);
471 if (batchDeleteConnection == nullptr) {
472 HILOG_ERROR("create FormBatchDeleteConnection failed");
473 return ERR_APPEXECFWK_FORM_COMMON_CODE;
474 }
475 Want want;
476 want.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
477 want.SetElementName(bundleName, abilityName);
478
479 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(want, batchDeleteConnection);
480 if (errorCode != ERR_OK) {
481 HILOG_ERROR("ConnectServiceAbility failed");
482 return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
483 }
484 return ERR_OK;
485 }
486 /**
487 * @brief Update form.
488 * @param formId The form's id.
489 * @param formProviderData form provider data.
490 * @return Returns ERR_OK on success, others on failure.
491 */
UpdateForm(const int64_t formId,const FormProviderInfo & formProviderInfo)492 ErrCode FormProviderMgr::UpdateForm(const int64_t formId, const FormProviderInfo &formProviderInfo)
493 {
494 // check exist and get the formRecord
495 FormRecord formRecord;
496 if (!FormDataMgr::GetInstance().GetFormRecord(formId, formRecord)) {
497 HILOG_ERROR("not exist such form:%{public}" PRId64 ".", formId);
498 return ERR_APPEXECFWK_FORM_NOT_EXIST_ID;
499 }
500 return UpdateForm(formId, formRecord, formProviderInfo.GetFormData());
501 }
502 /**
503 * handle for update form event from provider.
504 *
505 * @param formId The id of the form.
506 * @param formRecord The form's record.
507 * @param formProviderData provider form info.
508 * @return Returns ERR_OK on success, others on failure.
509 */
UpdateForm(const int64_t formId,FormRecord & formRecord,const FormProviderData & formProviderData)510 ErrCode FormProviderMgr::UpdateForm(const int64_t formId,
511 FormRecord &formRecord, const FormProviderData &formProviderData)
512 {
513 HILOG_INFO("imageDateState is %{public}d", formProviderData.GetImageDataState());
514 if (formRecord.versionUpgrade) {
515 formRecord.formProviderInfo.SetFormData(formProviderData);
516 formRecord.formProviderInfo.SetUpgradeFlg(true);
517 } else {
518 nlohmann::json addJsonData = formProviderData.GetData();
519 formRecord.formProviderInfo.MergeData(addJsonData);
520 // merge image
521 auto formData = formRecord.formProviderInfo.GetFormData();
522 formData.SetImageDataState(formProviderData.GetImageDataState());
523 formData.SetImageDataMap(formProviderData.GetImageDataMap());
524 formRecord.formProviderInfo.SetFormData(formData);
525 }
526
527 // formRecord init
528 formRecord.isInited = true;
529 formRecord.needRefresh = false;
530 FormDataMgr::GetInstance().SetFormCacheInited(formId, true);
531
532 // update form for host clients
533 FormDataMgr::GetInstance().UpdateHostNeedRefresh(formId, true);
534
535 #ifdef SUPPORT_POWER
536 bool screenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsScreenOn();
537 if (screenOnFlag) {
538 if (FormDataMgr::GetInstance().UpdateHostForm(formId, formRecord)) {
539 FormDataMgr::GetInstance().SetVersionUpgrade(formId, false);
540 formRecord.formProviderInfo.SetUpgradeFlg(false);
541 }
542 }
543 HILOG_DEBUG("screenOn:%{public}d", screenOnFlag);
544 #endif
545
546 if (formRecord.formProviderInfo.NeedCache()) {
547 HILOG_INFO("updateJsForm, data is less than 1k, cache data");
548 FormCacheMgr::GetInstance().AddData(formId, formRecord.formProviderInfo.GetFormData());
549 } else {
550 FormCacheMgr::GetInstance().DeleteData(formId);
551 }
552
553 // the update form is successfully
554 return ERR_OK;
555 }
556 /**
557 * @brief Process js message event.
558 * @param formId Indicates the unique id of form.
559 * @param record Form record.
560 * @param want information passed to supplier.
561 * @return Returns true if execute success, false otherwise.
562 */
MessageEvent(const int64_t formId,const FormRecord & record,const Want & want)563 int FormProviderMgr::MessageEvent(const int64_t formId, const FormRecord &record, const Want &want)
564 {
565 HILOG_INFO("formId:%{public}" PRId64, formId);
566
567 #ifdef SUPPORT_POWER
568 bool screenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsScreenOn();
569 bool collaborationScreenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsCollaborationScreenOn();
570 bool isHicar = (record.moduleName == HICAR_FORM);
571 if (!screenOnFlag && !collaborationScreenOnFlag && !isHicar) {
572 HILOG_WARN("screen off now");
573 return ERR_APPEXECFWK_FORM_COMMON_CODE;
574 }
575 #endif
576
577 sptr<IAbilityConnection> formMsgEventConnection = new (std::nothrow) FormMsgEventConnection(formId, want,
578 record.bundleName, record.abilityName);
579 if (formMsgEventConnection == nullptr) {
580 HILOG_ERROR("create FormMsgEventConnection failed");
581 return ERR_APPEXECFWK_FORM_COMMON_CODE;
582 }
583 Want connectWant;
584 connectWant.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
585 connectWant.SetElementName(record.bundleName, record.abilityName);
586
587 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(connectWant, formMsgEventConnection);
588 if (errorCode != ERR_OK) {
589 HILOG_ERROR("ConnectServiceAbility failed");
590 return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
591 }
592
593 return ERR_OK;
594 }
595
596 /**
597 * @brief Connect ams for refresh form
598 *
599 * @param formId The form id.
600 * @param record Form data.
601 * @param want The want of the form.
602 * @return Returns ERR_OK on success, others on failure.
603 */
ConnectAmsChangeLocation(const int64_t formId,const FormRecord & record,const Want & want)604 ErrCode FormProviderMgr::ConnectAmsChangeLocation(const int64_t formId, const FormRecord &record,
605 const Want &want)
606 {
607 HILOG_INFO("formId:%{public} " PRId64 ", bundleName:%{public}s, abilityName:%{public}s", formId,
608 record.bundleName.c_str(), record.abilityName.c_str());
609
610 sptr<IAbilityConnection> formLocationConnection = new (std::nothrow) FormLocationConnection(formId, want,
611 record.bundleName, record.abilityName);
612 if (formLocationConnection == nullptr) {
613 HILOG_ERROR("create FormLocationConnection failed");
614 return ERR_APPEXECFWK_FORM_COMMON_CODE;
615 }
616 Want connectWant;
617 connectWant.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
618 connectWant.SetElementName(record.bundleName, record.abilityName);
619 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(connectWant, formLocationConnection);
620 if (errorCode != ERR_OK) {
621 HILOG_ERROR("ConnectServiceAbility failed");
622 if (errorCode == ERR_ECOLOGICAL_CONTROL_STATUS) {
623 return ERR_APPEXECFWK_FORM_GET_AMSCONNECT_FAILED;
624 }
625 return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
626 }
627 return ERR_OK;
628 }
629
630 /**
631 * @brief Increase the timer refresh count.
632 *
633 * @param formId The form id.
634 */
IncreaseTimerRefreshCount(const int64_t formId)635 void FormProviderMgr::IncreaseTimerRefreshCount(const int64_t formId)
636 {
637 FormRecord record;
638 if (!FormDataMgr::GetInstance().GetFormRecord(formId, record)) {
639 HILOG_ERROR("not exist such form:%{public}" PRId64 ".", formId);
640 return;
641 }
642
643 if (record.isCountTimerRefresh) {
644 FormDataMgr::GetInstance().SetCountTimerRefresh(formId, false);
645 FormTimerMgr::GetInstance().IncreaseRefreshCount(formId);
646 }
647 }
648
649 /**
650 * @brief Acquire form state.
651 * @param state form state.
652 * @param provider provider info.
653 * @param wantArg The want of onAcquireFormState.
654 * @return Returns ERR_OK on success, others on failure.
655 */
AcquireFormStateBack(FormState state,const std::string & provider,const Want & wantArg)656 ErrCode FormProviderMgr::AcquireFormStateBack(FormState state, const std::string& provider, const Want &wantArg)
657 {
658 HILOG_DEBUG("AcquireFormState start:%{public}d, provider:%{public}s", state, provider.c_str());
659 FormDataMgr::GetInstance().AcquireFormStateBack(state, provider, wantArg);
660 return ERR_OK;
661 }
662
AcquireFormDataBack(const AAFwk::WantParams & wantParams,int64_t requestCode)663 ErrCode FormProviderMgr::AcquireFormDataBack(const AAFwk::WantParams &wantParams,
664 int64_t requestCode)
665 {
666 HILOG_DEBUG("start");
667 FormDataMgr::GetInstance().AcquireFormDataBack(wantParams, requestCode);
668 return ERR_OK;
669 }
670
IsNeedToFresh(FormRecord & record,int64_t formId,bool isVisibleToFresh)671 bool FormProviderMgr::IsNeedToFresh(FormRecord &record, int64_t formId, bool isVisibleToFresh)
672 {
673 bool isEnableRefresh = FormDataMgr::GetInstance().IsEnableRefresh(formId);
674 HILOG_DEBUG("isEnableRefresh is %{public}d", isEnableRefresh);
675 if (isEnableRefresh) {
676 return true;
677 }
678
679 HILOG_DEBUG("isVisibleToFresh is %{public}d, record.isVisible is %{public}d", isVisibleToFresh, record.isVisible);
680 if (isVisibleToFresh) {
681 if (!record.isVisible) {
682 FormRecordReport::GetInstance().IncreaseUpdateTimes(formId, HiSysEventPointType::TYPE_INVISIBLE_INTERCEPT);
683 }
684 return record.isVisible;
685 }
686
687 bool isEnableUpdate = FormDataMgr::GetInstance().IsEnableUpdate(formId);
688 HILOG_DEBUG("isEnableUpdate is %{public}d", isEnableUpdate);
689 return isEnableUpdate;
690 }
691
IsFormCached(const FormRecord & record)692 bool FormProviderMgr::IsFormCached(const FormRecord &record)
693 {
694 if (record.versionUpgrade) {
695 return false;
696 }
697 return FormCacheMgr::GetInstance().NeedAcquireProviderData(record.formId);
698 }
699
RebindByFreeInstall(const FormRecord & record,Want & want,const sptr<AAFwk::IAbilityConnection> formRefreshConnection)700 ErrCode FormProviderMgr::RebindByFreeInstall(const FormRecord &record, Want &want,
701 const sptr<AAFwk::IAbilityConnection> formRefreshConnection)
702 {
703 HILOG_INFO("start");
704 want.AddFlags(Want::FLAG_INSTALL_ON_DEMAND | Want::FLAG_INSTALL_WITH_BACKGROUND_MODE);
705 want.SetModuleName(record.moduleName);
706 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(want, formRefreshConnection);
707 if (errorCode != ERR_OK) {
708 HILOG_ERROR("ConnectServiceAbility failed, err:%{public}d", errorCode);
709 return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
710 }
711 return ERR_OK;
712 }
713
714 /**
715 * @brief Connect provider for update form size.
716 * @param newDimension The dimension value to be updated.
717 * @param newRect The rect value to be updated.
718 * @param formRecord The record of the form.
719 * @return Returns ERR_OK on success, others on failure.
720 */
ConnectAmsUpdateSize(const int32_t newDimension,const Rect & newRect,const FormRecord & record)721 ErrCode FormProviderMgr::ConnectAmsUpdateSize(const int32_t newDimension,
722 const Rect &newRect, const FormRecord &record)
723 {
724 HILOG_INFO("formId:%{public} " PRId64, record.formId);
725 sptr<IAbilityConnection> formUpdateSizeConnection = new (std::nothrow) FormUpdateSizeConnection(
726 record.formId, record.bundleName, record.abilityName, newDimension, newRect);
727 if (formUpdateSizeConnection == nullptr) {
728 HILOG_ERROR("create FormUpdateSizeConnection failed");
729 return ERR_APPEXECFWK_FORM_COMMON_CODE;
730 }
731 Want connectWant;
732 connectWant.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
733 connectWant.SetElementName(record.bundleName, record.abilityName);
734 ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(connectWant, formUpdateSizeConnection);
735 if (errorCode != ERR_OK) {
736 HILOG_ERROR("ConnectServiceAbility failed");
737 if (errorCode == ERR_ECOLOGICAL_CONTROL_STATUS) {
738 return ERR_APPEXECFWK_FORM_GET_AMSCONNECT_FAILED;
739 }
740 return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
741 }
742 return ERR_OK;
743 }
744 } // namespace AppExecFwk
745 } // namespace OHOS
746