1 /*
2  * Copyright (c) 2022-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_event_util.h"
17 
18 #include <regex>
19 
20 #include "fms_log_wrapper.h"
21 #include "form_bms_helper.h"
22 #include "form_cache_mgr.h"
23 #include "form_data_mgr.h"
24 #include "form_data_proxy_mgr.h"
25 #include "form_db_cache.h"
26 #include "form_info_mgr.h"
27 #include "form_mgr_adapter.h"
28 #include "form_render_mgr.h"
29 #include "form_timer_mgr.h"
30 #include "form_trust_mgr.h"
31 #include "form_util.h"
32 #include "form_provider_mgr.h"
33 #include "want.h"
34 
35 namespace OHOS {
36 namespace AppExecFwk {
37 namespace {
UpdateRecordByBundleInfo(const BundleInfo &bundleInfo, FormRecord &formRecord)38 void UpdateRecordByBundleInfo(const BundleInfo &bundleInfo, FormRecord &formRecord)
39 {
40     formRecord.modulePkgNameMap.clear();
41     if (!bundleInfo.hapModuleInfos.empty()) {
42         for (auto hapModuleInfo : bundleInfo.hapModuleInfos) {
43             auto hapPath = hapModuleInfo.hapPath;
44             auto moduleName = hapModuleInfo.moduleName;
45             HILOG_DEBUG("update record %{public}" PRId64 ". packageName is %{public}s, hap path is %{public}s",
46                 formRecord.formId, hapModuleInfo.packageName.c_str(), hapPath.c_str());
47             if (hapPath.find(Constants::ABS_CODE_PATH) != std::string::npos) {
48                 hapPath = std::regex_replace(hapPath, std::regex(Constants::ABS_CODE_PATH), Constants::LOCAL_BUNDLES);
49             }
50             nlohmann::json moduleInfos = {
51                 {Constants::MODULE_PKG_NAME_KEY, hapModuleInfo.packageName},
52                 {Constants::MODULE_HAP_PATH_KEY, hapPath}
53             };
54             formRecord.modulePkgNameMap.emplace(std::make_pair(moduleName, moduleInfos.dump()));
55             if (moduleName == formRecord.moduleName) {
56                 formRecord.jsFormCodePath = hapPath;
57             }
58         }
59     }
60 
61     formRecord.hapSourceDirs.clear();
62     for (const auto &item : bundleInfo.applicationInfo.moduleInfos) {
63         if (formRecord.moduleName == item.moduleName) {
64             formRecord.hapSourceDirs.emplace_back(item.moduleSourceDir);
65         }
66     }
67 }
68 }
HandleBundleFormInfoChanged(const std::string &bundleName, int32_t userId)69 void FormEventUtil::HandleBundleFormInfoChanged(const std::string &bundleName, int32_t userId)
70 {
71     FormTrustMgr::GetInstance().MarkTrustFlag(bundleName, true);
72     FormInfoMgr::GetInstance().UpdateStaticFormInfos(bundleName, userId);
73 }
74 
HandleUpdateFormCloud(const std::string &bundleName)75 void FormEventUtil::HandleUpdateFormCloud(const std::string &bundleName)
76 {
77     FormMgrAdapter::GetInstance().UpdateFormCloudUpdateDuration(bundleName);
78 }
79 
HandleProviderUpdated(const std::string &bundleName, const int userId)80 void FormEventUtil::HandleProviderUpdated(const std::string &bundleName, const int userId)
81 {
82     HILOG_INFO("bundleName:%{public}s, userId:%{public}d", bundleName.c_str(), userId);
83     std::vector<FormRecord> formInfos;
84     if (!FormDataMgr::GetInstance().GetFormRecord(bundleName, formInfos)) {
85         return;
86     }
87 
88     std::vector<FormInfo> targetForms;
89     if (FormInfoMgr::GetInstance().GetFormsInfoByBundle(bundleName, targetForms, userId) != ERR_OK) {
90         return;
91     }
92 
93     BundlePackInfo bundlePackInfo;
94     bool hasPackInfo = FormBmsHelper::GetInstance().GetBundlePackInfo(bundleName, userId, bundlePackInfo);
95     BundleInfo bundleInfo;
96     if (FormBmsHelper::GetInstance().GetBundleInfoV9(bundleName, userId, bundleInfo) != ERR_OK) {
97         HILOG_ERROR("get bundleInfo failed");
98         return;
99     }
100     std::vector<int64_t> removedForms;
101     std::vector<FormRecord> updatedForms;
102     for (FormRecord& formRecord : formInfos) {
103         HILOG_INFO("bundle update, formName:%{public}s", formRecord.formName.c_str());
104         int64_t formId = formRecord.formId;
105         if (ProviderFormUpdated(formId, formRecord, targetForms, bundleInfo)) {
106             updatedForms.emplace_back(formRecord);
107             continue;
108         }
109         if (hasPackInfo && ProviderFormUpdated(formId, formRecord, bundlePackInfo, bundleInfo)) {
110             updatedForms.emplace_back(formRecord);
111             continue;
112         }
113 
114         if (formRecord.formTempFlag) {
115             FormDataMgr::GetInstance().DeleteTempForm(formId);
116         } else {
117             FormDbCache::GetInstance().DeleteFormInfo(formId);
118         }
119         HILOG_INFO("form %{public}s deleted", formRecord.formName.c_str());
120         removedForms.emplace_back(formId);
121         FormDataMgr::GetInstance().DeleteFormRecord(formId);
122         FormRenderMgr::GetInstance().StopRenderingForm(formId, formRecord);
123         FormDataProxyMgr::GetInstance().UnsubscribeFormData(formId);
124     }
125 
126     if (!removedForms.empty()) {
127         HILOG_INFO("clean removed forms and timer");
128         FormDataMgr::GetInstance().CleanHostRemovedForms(removedForms);
129         for (const int64_t id : removedForms) {
130             FormTimerMgr::GetInstance().RemoveFormTimer(id);
131         }
132     }
133 
134     Want want;
135     want.SetParam(Constants::PARAM_FORM_USER_ID, userId);
136     for (const auto &updatedForm : updatedForms) {
137         FormProviderMgr::GetInstance().RefreshForm(updatedForm.formId, want, true);
138     }
139     FormRenderMgr::GetInstance().ReloadForm(std::move(updatedForms), bundleName, userId);
140 }
141 
HandleOnUnlock()142 void FormEventUtil::HandleOnUnlock()
143 {
144     FormRenderMgr::GetInstance().OnUnlock();
145 }
146 
HandleBundleFormInfoRemoved(const std::string &bundleName, int32_t userId)147 void FormEventUtil::HandleBundleFormInfoRemoved(const std::string &bundleName, int32_t userId)
148 {
149     FormTrustMgr::GetInstance().MarkTrustFlag(bundleName, true);
150     FormInfoMgr::GetInstance().Remove(bundleName, userId);
151     FormDataMgr::GetInstance().RemoveFormCloudUpdateDuration(bundleName);
152 }
153 
HandleProviderRemoved(const std::string &bundleName, const int32_t userId)154 void FormEventUtil::HandleProviderRemoved(const std::string &bundleName, const int32_t userId)
155 {
156     HILOG_INFO("bundleName:%{public}s, userId:%{public}d",
157         bundleName.c_str(), userId);
158     // clean removed form in DB
159     std::set<int64_t> removedForms;
160     std::vector<FormDBInfo> removedDBForm;
161     FormDbCache::GetInstance().DeleteFormInfoByBundleName(bundleName, userId, removedDBForm);
162     for (const auto &dbForm : removedDBForm) {
163         removedForms.emplace(dbForm.formId);
164         int32_t matchCount = FormDbCache::GetInstance().GetMatchCount(dbForm.bundleName, dbForm.moduleName);
165         if (matchCount == 0) {
166             FormBmsHelper::GetInstance().NotifyModuleRemovable(dbForm.bundleName, dbForm.moduleName);
167         }
168     }
169     // clean removed form in FormRecords
170     FormDataMgr::GetInstance().CleanRemovedFormRecords(bundleName, removedForms);
171     // clean removed temp form in FormRecords
172     FormDataMgr::GetInstance().CleanRemovedTempFormRecords(bundleName, userId, removedForms);
173     // clean removed forms in FormHostRecords
174     std::vector<int64_t> vRemovedForms;
175     vRemovedForms.assign(removedForms.begin(), removedForms.end());
176     FormDataMgr::GetInstance().CleanHostRemovedForms(vRemovedForms);
177     // clean removed form timers
178     for (auto &formId : removedForms) {
179         FormTimerMgr::GetInstance().RemoveFormTimer(formId);
180         FormDataProxyMgr::GetInstance().UnsubscribeFormData(formId);
181     }
182 }
183 
HandleBundleDataCleared(const std::string &bundleName, int32_t userId)184 void FormEventUtil::HandleBundleDataCleared(const std::string &bundleName, int32_t userId)
185 {
186     HILOG_DEBUG("bundleName:%{public}s, userId:%{public}d", bundleName.c_str(), userId);
187     // clear dynamic form info
188     FormInfoMgr::GetInstance().RemoveAllDynamicFormsInfo(bundleName, userId);
189 
190     // as provider data is cleared
191     std::set<int64_t> reCreateForms;
192     FormDataMgr::GetInstance().GetReCreateFormRecordsByBundleName(bundleName, reCreateForms);
193     if (!reCreateForms.empty()) {
194         for (int64_t formId : reCreateForms) {
195             ReCreateForm(formId);
196         }
197     }
198 
199     int32_t uid = FormBmsHelper::GetInstance().GetUidByBundleName(bundleName, userId);
200     if (uid == FormBmsHelper::INVALID_UID) {
201         HILOG_ERROR("invalid uid");
202         return;
203     }
204     // as form host data is cleared
205     HandleFormHostDataCleared(uid);
206 }
207 
HandleFormHostDataCleared(const int uid)208 void FormEventUtil::HandleFormHostDataCleared(const int uid)
209 {
210     HILOG_DEBUG("uid:%{public}d", uid);
211     std::map<int64_t, bool> removedFormsMap;
212     // clear formDBRecord
213     ClearFormDBRecordData(uid, removedFormsMap);
214 
215     // clear temp form
216     ClearTempFormRecordData(uid, removedFormsMap);
217 
218     // clear host data
219     FormDataMgr::GetInstance().ClearHostDataByUId(uid);
220 
221     // delete forms timer
222     for (const auto &removedForm : removedFormsMap) {
223         if (removedForm.second) {
224             FormTimerMgr::GetInstance().RemoveFormTimer(removedForm.first);
225         }
226     }
227 }
228 
ProviderFormUpdated(const int64_t formId, FormRecord &formRecord, const std::vector<FormInfo> &targetForms, const BundleInfo &bundleInfo)229 bool FormEventUtil::ProviderFormUpdated(const int64_t formId, FormRecord &formRecord,
230     const std::vector<FormInfo> &targetForms, const BundleInfo &bundleInfo)
231 {
232     HILOG_INFO("start");
233     if (targetForms.empty()) {
234         HILOG_ERROR("empty targetForms");
235         return false;
236     }
237 
238     FormInfo updatedForm;
239     bool bGetForm = FormDataMgr::GetInstance().GetUpdatedForm(formRecord, targetForms, updatedForm);
240     if (!bGetForm) {
241         HILOG_INFO("no updated form");
242         return false;
243     }
244     HILOG_INFO("form is still exist, form:%{public}s", formRecord.formName.c_str());
245 
246     // update resource
247     FormDataMgr::GetInstance().SetNeedRefresh(formId, true);
248     FormCacheMgr::GetInstance().DeleteData(formId);
249     FormBmsHelper::GetInstance().NotifyModuleNotRemovable(formRecord.bundleName, formRecord.moduleName);
250     FormTimerCfg timerCfg;
251     GetTimerCfg(updatedForm.updateEnabled, updatedForm.updateDuration, updatedForm.scheduledUpdateTime, timerCfg);
252     HandleTimerUpdate(formId, formRecord, timerCfg);
253     UpdateRecordByBundleInfo(bundleInfo, formRecord);
254     UpdateFormRecord(updatedForm, formRecord);
255     FormDataMgr::GetInstance().SetVersionUpgrade(formId, true);
256     return true;
257 }
258 
ProviderFormUpdated(const int64_t formId, FormRecord &formRecord, const BundlePackInfo &bundlePackInfo, const BundleInfo &bundleInfo)259 bool FormEventUtil::ProviderFormUpdated(const int64_t formId, FormRecord &formRecord,
260     const BundlePackInfo &bundlePackInfo, const BundleInfo &bundleInfo)
261 {
262     HILOG_INFO("start");
263     AbilityFormInfo packForm;
264     if (!FormDataMgr::GetInstance().GetPackageForm(formRecord, bundlePackInfo, packForm)) {
265         HILOG_INFO("no updated form");
266         return false;
267     }
268 
269     HILOG_INFO("form is still in package info, form:%{public}s", formRecord.formName.c_str());
270     FormDataMgr::GetInstance().SetRecordNeedFreeInstall(formId, true);
271     FormTimerCfg timerCfg;
272     GetTimerCfg(packForm.updateEnabled, packForm.updateDuration, packForm.scheduledUpdateTime, timerCfg);
273     HandleTimerUpdate(formId, formRecord, timerCfg);
274     UpdateRecordByBundleInfo(bundleInfo, formRecord);
275     UpdateFormRecord(packForm, formRecord);
276     FormDataMgr::GetInstance().SetVersionUpgrade(formId, true);
277     return true;
278 }
279 
ClearFormDBRecordData(const int uid, std::map<int64_t, bool> &removedFormsMap)280 void FormEventUtil::ClearFormDBRecordData(const int uid, std::map<int64_t, bool> &removedFormsMap)
281 {
282     std::map<int64_t, bool> foundFormsMap;
283     std::map<FormIdKey, std::set<int64_t>> noHostFormDbMap;
284     FormDbCache::GetInstance().GetNoHostDBForms(uid, noHostFormDbMap, foundFormsMap);
285     if (!foundFormsMap.empty()) {
286         for (const auto &element : foundFormsMap) {
287             FormDataMgr::GetInstance().DeleteFormUserUid(element.first, uid);
288         }
289     }
290 
291     HILOG_DEBUG("noHostFormDbMap size:%{public}zu", noHostFormDbMap.size());
292     if (!noHostFormDbMap.empty()) {
293         BatchDeleteNoHostDBForms(uid, noHostFormDbMap, foundFormsMap);
294     }
295 
296     if (!foundFormsMap.empty()) {
297         removedFormsMap.insert(foundFormsMap.begin(), foundFormsMap.end());
298     }
299 }
300 
ClearTempFormRecordData(const int uid, std::map<int64_t, bool> &removedFormsMap)301 void FormEventUtil::ClearTempFormRecordData(const int uid, std::map<int64_t, bool> &removedFormsMap)
302 {
303     std::map<int64_t, bool> foundFormsMap;
304     std::map<FormIdKey, std::set<int64_t>> noHostTempFormsMap;
305     FormDataMgr::GetInstance().GetNoHostTempForms(uid, noHostTempFormsMap, foundFormsMap);
306     HILOG_DEBUG("noHostTempFormsMap size:%{public}zu", noHostTempFormsMap.size());
307     if (!noHostTempFormsMap.empty()) {
308         BatchDeleteNoHostTempForms(uid, noHostTempFormsMap, foundFormsMap);
309     }
310     if (!foundFormsMap.empty()) {
311         removedFormsMap.insert(foundFormsMap.begin(), foundFormsMap.end());
312     }
313 }
314 
BatchDeleteNoHostTempForms(const int uid, std::map<FormIdKey, std::set<int64_t>> &noHostTempFormsMap, std::map<int64_t, bool> &foundFormsMap)315 void FormEventUtil::BatchDeleteNoHostTempForms(const int uid, std::map<FormIdKey,
316     std::set<int64_t>> &noHostTempFormsMap, std::map<int64_t, bool> &foundFormsMap)
317 {
318     for (const auto &element : noHostTempFormsMap) {
319         std::set<int64_t> formIds = element.second;
320         FormIdKey formIdKey = element.first;
321         std::string bundleName = formIdKey.bundleName;
322         std::string abilityName = formIdKey.abilityName;
323         int result = FormProviderMgr::GetInstance().NotifyProviderFormsBatchDelete(bundleName, abilityName, formIds);
324         if (result != ERR_OK) {
325             HILOG_ERROR("NotifyProviderFormsBatchDelete fail bundle:%{public}s ability:%{public}s",
326                 bundleName.c_str(), abilityName.c_str());
327             for (int64_t formId : formIds) {
328                 FormDataMgr::GetInstance().AddFormUserUid(formId, uid);
329             }
330         } else {
331             for (int64_t formId : formIds) {
332                 foundFormsMap.emplace(formId, true);
333                 FormDataMgr::GetInstance().DeleteFormRecord(formId);
334                 FormDataMgr::GetInstance().DeleteTempForm(formId);
335             }
336         }
337     }
338 }
339 
GetTimerCfg(const bool updateEnabled, const int updateDuration, const std::string &configUpdateAt, FormTimerCfg& cfg)340 void FormEventUtil::GetTimerCfg(const bool updateEnabled,
341     const int updateDuration, const std::string &configUpdateAt, FormTimerCfg& cfg)
342 {
343     HILOG_INFO("start");
344     if (!updateEnabled) {
345         HILOG_INFO("update disable");
346         return;
347     }
348 
349     if (updateDuration > 0) {
350         // interval timer
351         HILOG_INFO("interval timer updateDuration:%{public}d", updateDuration);
352         if (updateDuration <= Constants::MIN_CONFIG_DURATION) {
353             cfg.updateDuration = Constants::MIN_PERIOD;
354         } else if (updateDuration >= Constants::MAX_CONFIG_DURATION) {
355             cfg.updateDuration = Constants::MAX_PERIOD;
356         } else {
357             cfg.updateDuration = updateDuration * Constants::TIME_CONVERSION;
358         }
359         cfg.enableUpdate = true;
360         return;
361     } else {
362         // updateAtTimer
363         if (configUpdateAt.empty()) {
364             HILOG_INFO("empty configUpdateAt");
365             return;
366         }
367         HILOG_INFO("update at timer:%{public}s", configUpdateAt.c_str());
368         std::vector<std::string> temp = FormUtil::StringSplit(configUpdateAt, Constants::TIME_DELIMETER);
369         if (temp.size() != Constants::UPDATE_AT_CONFIG_COUNT) {
370             HILOG_ERROR("invalid config");
371             return;
372         }
373         int hour = std::stoi(temp[0]);
374         int min = std::stoi(temp[1]);
375         if (hour < Constants::MIN_TIME || hour > Constants::MAX_HOUR || min < Constants::MIN_TIME || min >
376             Constants::MAX_MINUTE) {
377             HILOG_ERROR("invalid time");
378             return;
379         }
380 
381         cfg.updateAtHour = hour;
382         cfg.updateAtMin = min;
383         cfg.enableUpdate = true;
384         return;
385     }
386 }
387 
HandleTimerUpdate(const int64_t formId, const FormRecord &record, const FormTimerCfg &timerCfg)388 void FormEventUtil::HandleTimerUpdate(const int64_t formId,
389     const FormRecord &record, const FormTimerCfg &timerCfg)
390 {
391     // both disable
392     if (!record.isEnableUpdate && !timerCfg.enableUpdate) {
393         return;
394     }
395 
396     // enable to disable
397     if (record.isEnableUpdate && !timerCfg.enableUpdate) {
398         FormDataMgr::GetInstance().SetEnableUpdate(formId, false);
399         FormTimerMgr::GetInstance().RemoveFormTimer(formId);
400         return;
401     }
402 
403     // disable to enable
404     if (!record.isEnableUpdate && timerCfg.enableUpdate) {
405         FormDataMgr::GetInstance().SetUpdateInfo(formId, true,
406             timerCfg.updateDuration, timerCfg.updateAtHour, timerCfg.updateAtMin);
407         if (timerCfg.updateDuration > 0) {
408             HILOG_INFO("add interval timer:%{public}" PRId64, timerCfg.updateDuration);
409             int64_t updateDuration = timerCfg.updateDuration;
410             if (!FormMgrAdapter::GetInstance().GetValidFormUpdateDuration(formId, updateDuration)) {
411                 HILOG_WARN("Get updateDuration failed, uses local configuration");
412             }
413             FormTimerMgr::GetInstance().AddFormTimer(formId, updateDuration, record.providerUserId);
414         } else {
415             HILOG_INFO("add at timer:%{public}d,%{public}d", timerCfg.updateAtHour, timerCfg.updateAtMin);
416             FormTimerMgr::GetInstance().AddFormTimer(formId, timerCfg.updateAtHour,
417                 timerCfg.updateAtMin, record.providerUserId);
418         }
419         return;
420     }
421 
422     // both enable
423     UpdateType type = GetUpdateType(record, timerCfg);
424     if (type == TYPE_NO_CHANGE) {
425         return;
426     }
427 
428     FormDataMgr::GetInstance().SetUpdateInfo(formId, true,
429         timerCfg.updateDuration, timerCfg.updateAtHour, timerCfg.updateAtMin);
430     auto newTimerCfg = timerCfg;
431     if (type == TYPE_INTERVAL_CHANGE || type == TYPE_ATTIME_TO_INTERVAL) {
432         int64_t updateDuration = timerCfg.updateDuration;
433         if (!FormMgrAdapter::GetInstance().GetValidFormUpdateDuration(formId, updateDuration)) {
434             HILOG_WARN("Get updateDuration failed, uses local configuration");
435         }
436         newTimerCfg.updateDuration = updateDuration;
437     }
438     FormTimerMgr::GetInstance().UpdateFormTimer(formId, type, newTimerCfg);
439 }
440 
GetUpdateType(const FormRecord &record, const FormTimerCfg &timerCfg)441 UpdateType FormEventUtil::GetUpdateType(const FormRecord &record, const FormTimerCfg &timerCfg)
442 {
443     HILOG_DEBUG("call");
444     if (record.updateDuration > 0) {
445         if (timerCfg.updateDuration > 0) {
446             // no change
447             if (record.updateDuration == timerCfg.updateDuration) {
448                 return TYPE_NO_CHANGE;
449             }
450             // interval change
451             return TYPE_INTERVAL_CHANGE;
452         } else {
453             // interval to update at time
454             return TYPE_INTERVAL_TO_ATTIME;
455         }
456     } else {
457         if (timerCfg.updateDuration > 0) {
458             // update at time to interval
459             return TYPE_ATTIME_TO_INTERVAL;
460         } else {
461             if (record.updateAtHour == timerCfg.updateAtHour && record.updateAtMin == timerCfg.updateAtMin) {
462                 return TYPE_NO_CHANGE;
463             }
464             // update at time change
465             return TYPE_ATTIME_CHANGE;
466         }
467     }
468 }
469 
ReCreateForm(const int64_t formId)470 void FormEventUtil::ReCreateForm(const int64_t formId)
471 {
472     HILOG_INFO("formId:%{public}" PRId64, formId);
473     FormRecord record;
474     bool isGetForm = FormDataMgr::GetInstance().GetFormRecord(formId, record);
475     if (!isGetForm) {
476         HILOG_ERROR("not exist such form:%{public}" PRId64 "", formId);
477         return;
478     }
479     FormCacheMgr::GetInstance().DeleteData(formId);
480     FormRecord reCreateRecord;
481     reCreateRecord.bundleName = record.bundleName;
482     reCreateRecord.abilityName = record.abilityName;
483     reCreateRecord.formName = record.formName;
484     reCreateRecord.specification = record.specification;
485     reCreateRecord.formTempFlag = record.formTempFlag;
486     reCreateRecord.isInited = record.isInited;
487     reCreateRecord.versionUpgrade = record.versionUpgrade;
488 
489     Want want;
490     want.SetParam(Constants::PARAM_FORM_NAME_KEY, reCreateRecord.formName);
491     want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, reCreateRecord.specification);
492     want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, reCreateRecord.formTempFlag);
493     want.SetParam(Constants::RECREATE_FORM_KEY, true);
494     want.SetParam(Constants::PARAM_FORM_RENDERINGMODE_KEY, (int)record.renderingMode);
495 
496     FormProviderMgr::GetInstance().ConnectAmsForRefresh(formId, reCreateRecord, want, false);
497 }
498 
BatchDeleteNoHostDBForms(const int uid, std::map<FormIdKey, std::set<int64_t>> &noHostFormDbMap, std::map<int64_t, bool> &removedFormsMap)499 void FormEventUtil::BatchDeleteNoHostDBForms(const int uid, std::map<FormIdKey, std::set<int64_t>> &noHostFormDbMap,
500     std::map<int64_t, bool> &removedFormsMap)
501 {
502     std::set<FormIdKey> removableModuleSet;
503     for (const auto &element: noHostFormDbMap) {
504         std::set<int64_t> formIds = element.second;
505         FormIdKey formIdKey = element.first;
506         std::string bundleName = formIdKey.bundleName;
507         std::string abilityName = formIdKey.abilityName;
508         int result = FormProviderMgr::GetInstance().NotifyProviderFormsBatchDelete(bundleName, abilityName, formIds);
509         if (result != ERR_OK) {
510             HILOG_ERROR("NotifyProviderFormsBatchDelete fail bundle:%{public}s ability:%{public}s",
511                 bundleName.c_str(), abilityName.c_str());
512             for (int64_t formId : formIds) {
513                 FormDBInfo dbInfo;
514                 int errCode = FormDbCache::GetInstance().GetDBRecord(formId, dbInfo);
515                 if (errCode == ERR_OK) {
516                     dbInfo.formUserUids.emplace_back(uid);
517                     FormDbCache::GetInstance().SaveFormInfo(dbInfo);
518                 }
519             }
520         } else {
521             for (const int64_t formId : formIds) {
522                 removedFormsMap.emplace(formId, true);
523                 FormDBInfo dbInfo;
524                 int errCode = FormDbCache::GetInstance().GetDBRecord(formId, dbInfo);
525                 if (errCode == ERR_OK) {
526                     FormIdKey removableModuleFormIdKey(dbInfo.bundleName, dbInfo.moduleName);
527                     removableModuleSet.emplace(removableModuleFormIdKey);
528                     FormDbCache::GetInstance().DeleteFormInfo(formId);
529                 }
530                 FormDataMgr::GetInstance().DeleteFormRecord(formId);
531             }
532         }
533     }
534 
535     for (const FormIdKey &item : removableModuleSet) {
536         int32_t matchCount = FormDbCache::GetInstance().GetMatchCount(item.bundleName, item.moduleName);
537         if (matchCount == 0) {
538             FormBmsHelper::GetInstance().NotifyModuleRemovable(item.bundleName, item.moduleName);
539         }
540     }
541 }
542 
HandleAdditionalInfoChanged(const std::string &bundleName)543 bool FormEventUtil::HandleAdditionalInfoChanged(const std::string &bundleName)
544 {
545     HILOG_DEBUG("Call, bundleName:%{public}s", bundleName.c_str());
546     FormMgrAdapter::GetInstance().UpdateFormCloudUpdateDuration(bundleName);
547     std::vector<FormRecord> formInfos;
548     if (!FormDataMgr::GetInstance().GetFormRecord(bundleName, formInfos)) {
549         HILOG_DEBUG("No form info");
550         return false;
551     }
552 
553     for (const auto& formRecord : formInfos) {
554         if (!formRecord.isEnableUpdate || (formRecord.updateDuration <= 0)) {
555             continue;
556         }
557         int64_t updateDuration = formRecord.updateDuration;
558         if (!FormMgrAdapter::GetInstance().GetValidFormUpdateDuration(formRecord.formId, updateDuration)) {
559             HILOG_WARN("Get updateDuration failed, uses local configuration");
560         }
561 
562         FormTimerCfg timerCfg;
563         timerCfg.enableUpdate = true;
564         timerCfg.updateDuration = updateDuration;
565         FormTimerMgr::GetInstance().UpdateFormTimer(formRecord.formId, UpdateType::TYPE_INTERVAL_CHANGE, timerCfg);
566     }
567     return true;
568 }
569 
UpdateFormRecord(const FormInfo &formInfo, FormRecord &formRecord)570 void FormEventUtil::UpdateFormRecord(const FormInfo &formInfo, FormRecord &formRecord)
571 {
572     formRecord.formSrc = formInfo.src;
573     formRecord.uiSyntax = formInfo.uiSyntax;
574     formRecord.isDynamic = formInfo.isDynamic;
575     formRecord.transparencyEnabled = formInfo.transparencyEnabled;
576     formRecord.privacyLevel = formInfo.privacyLevel;
577     formRecord.isEnableUpdate = formInfo.updateEnabled;
578     formRecord.updateDuration = formInfo.updateDuration * Constants::TIME_CONVERSION;
579     std::vector<std::string> time = FormUtil::StringSplit(formInfo.scheduledUpdateTime, Constants::TIME_DELIMETER);
580     if (time.size() == Constants::UPDATE_AT_CONFIG_COUNT) {
581         formRecord.updateAtHour = std::stoi(time[0]);
582         formRecord.updateAtMin = std::stoi(time[1]);
583     }
584     HILOG_DEBUG("formId:%{public}" PRId64 "", formRecord.formId);
585     FormDataMgr::GetInstance().UpdateFormRecord(formRecord.formId, formRecord);
586 }
587 
UpdateFormRecord(const AbilityFormInfo &formInfo, FormRecord &formRecord)588 void FormEventUtil::UpdateFormRecord(const AbilityFormInfo &formInfo, FormRecord &formRecord)
589 {
590     formRecord.uiSyntax = (formInfo.type.compare("arkts") == 0 ? FormType::ETS : FormType::JS);
591     formRecord.isEnableUpdate = formInfo.updateEnabled;
592     formRecord.updateDuration = formInfo.updateDuration * Constants::TIME_CONVERSION;
593     std::vector<std::string> time = FormUtil::StringSplit(formInfo.scheduledUpdateTime, Constants::TIME_DELIMETER);
594     if (time.size() == Constants::UPDATE_AT_CONFIG_COUNT) {
595         formRecord.updateAtHour = std::stoi(time[0]);
596         formRecord.updateAtMin = std::stoi(time[1]);
597     }
598     HILOG_DEBUG("formId:%{public}" PRId64 "", formRecord.formId);
599     FormDataMgr::GetInstance().UpdateFormRecord(formRecord.formId, formRecord);
600 }
601 } // namespace AppExecFwk
602 } // namespace OHOS
603