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