1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "form_render_impl.h"
17 
18 #include <cstddef>
19 #include <memory>
20 
21 #include "event_handler.h"
22 #include "fms_log_wrapper.h"
23 #include "form_constants.h"
24 #include "form_render_event_report.h"
25 #include "form_render_service_extension.h"
26 #include "js_runtime.h"
27 #include "service_extension.h"
28 #include "form_memmgr_client.h"
29 #ifdef SUPPORT_POWER
30 #include "power_mgr_client.h"
31 #endif
32 
33 namespace OHOS {
34 namespace AppExecFwk {
35 namespace FormRender {
36 namespace {
37 constexpr int32_t RENDER_FORM_FAILED = -1;
38 constexpr int32_t RELOAD_FORM_FAILED = -1;
39 constexpr int32_t RECYCLE_FORM_FAILED = -1;
40 constexpr int32_t SET_VISIBLE_CHANGE_FAILED = -1;
41 constexpr int32_t FORM_RENDER_TASK_DELAY_TIME = 20; // ms
42 constexpr int32_t ENABLE_FORM_FAILED = -1;
43 constexpr int32_t UPDATE_FORM_SIZE_FAILED = -1;
44 }
45 using namespace AbilityRuntime;
46 using namespace OHOS::AAFwk::GlobalConfigurationKey;
47 
FormRenderServiceCreator(const std::unique_ptr<Runtime> & runtime)48 static OHOS::AbilityRuntime::ServiceExtension *FormRenderServiceCreator(const std::unique_ptr<Runtime> &runtime)
49 {
50     HILOG_DEBUG("Create FormRenderServiceExtension");
51     return FormRenderServiceExtension::Create(runtime);
52 }
53 
RegisterServiceExtensionCreator()54 __attribute__((constructor)) void RegisterServiceExtensionCreator()
55 {
56     HILOG_DEBUG("Set FormRenderServiceExtension creator");
57     OHOS::AbilityRuntime::ServiceExtension::SetCreator(FormRenderServiceCreator);
58 }
59 
FormRenderImpl()60 FormRenderImpl::FormRenderImpl()
61 {
62     const std::string queueName = "FormRenderSerialQueue";
63     serialQueue_ = std::make_shared<FormRenderSerialQueue>(queueName);
64     if (serialQueue_ == nullptr) {
65         HILOG_ERROR("null serialQueue_");
66     }
67 }
68 
69 FormRenderImpl::~FormRenderImpl() = default;
70 
RenderForm(const FormJsInfo & formJsInfo,const Want & want,sptr<IRemoteObject> callerToken)71 int32_t FormRenderImpl::RenderForm(const FormJsInfo &formJsInfo, const Want &want,
72     sptr<IRemoteObject> callerToken)
73 {
74     HILOG_INFO("Render form,bundleName=%{public}s,abilityName=%{public}s,formName=%{public}s,"
75         "moduleName=%{public}s,jsFormCodePath=%{public}s,formSrc=%{public}s,formId=%{public}" PRId64,
76         formJsInfo.bundleName.c_str(), formJsInfo.abilityName.c_str(), formJsInfo.formName.c_str(),
77         formJsInfo.moduleName.c_str(), formJsInfo.jsFormCodePath.c_str(), formJsInfo.formSrc.c_str(),
78         formJsInfo.formId);
79 
80     sptr<IFormSupply> formSupplyClient = iface_cast<IFormSupply>(callerToken);
81     if (formSupplyClient == nullptr) {
82         HILOG_ERROR("null IFormSupply");
83         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
84     }
85     {
86         std::lock_guard<std::mutex> lock(formSupplyMutex_);
87         formSupplyClient_ = formSupplyClient;
88     }
89     HILOG_DEBUG("connectId:%{public}d",
90         want.GetIntParam(Constants::FORM_CONNECT_ID, 0L));
91 
92     std::string uid = want.GetStringParam(Constants::FORM_SUPPLY_UID);
93     if (uid.empty()) {
94         HILOG_ERROR("GetUid failed");
95         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
96     }
97     int32_t result = ERR_OK;
98     Want formRenderWant(want);
99     sptr<IRemoteObject> hostToken = formRenderWant.GetRemoteObject(Constants::PARAM_FORM_HOST_TOKEN);
100     {
101         std::lock_guard<std::mutex> lock(renderRecordMutex_);
102         ConfirmUnlockState(formRenderWant);
103         if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
104             result = search->second->UpdateRenderRecord(formJsInfo, formRenderWant, hostToken);
105         } else {
106             auto record = FormRenderRecord::Create(formJsInfo.bundleName, uid, formJsInfo.isDynamic, formSupplyClient);
107             if (record == nullptr) {
108                 HILOG_ERROR("null record");
109                 return RENDER_FORM_FAILED;
110             }
111 
112             record->SetConfiguration(configuration_);
113             result = record->UpdateRenderRecord(formJsInfo, formRenderWant, hostToken);
114             if (renderRecordMap_.empty()) {
115                 FormMemmgrClient::GetInstance().SetCritical(true);
116             }
117             renderRecordMap_.emplace(uid, record);
118             FormRenderGCTask(uid);
119         }
120     }
121     formSupplyClient->OnRenderTaskDone(formJsInfo.formId, formRenderWant);
122     return result;
123 }
124 
StopRenderingForm(const FormJsInfo & formJsInfo,const Want & want,const sptr<IRemoteObject> & callerToken)125 int32_t FormRenderImpl::StopRenderingForm(const FormJsInfo &formJsInfo, const Want &want,
126     const sptr<IRemoteObject> &callerToken)
127 {
128     HILOG_INFO("call");
129     sptr<IFormSupply> formSupplyClient = iface_cast<IFormSupply>(callerToken);
130     if (formSupplyClient == nullptr) {
131         HILOG_ERROR("null IFormSupply");
132         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
133     }
134 
135     std::string uid = want.GetStringParam(Constants::FORM_SUPPLY_UID);
136     if (uid.empty()) {
137         HILOG_ERROR("GetUid failed");
138         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
139     }
140 
141     bool isRenderGroupEmpty = false;
142     sptr<IRemoteObject> hostToken = want.GetRemoteObject(Constants::PARAM_FORM_HOST_TOKEN);
143     {
144         std::shared_ptr<FormRenderRecord> search = nullptr;
145         {
146             std::lock_guard<std::mutex> lock(renderRecordMutex_);
147             auto iterator = renderRecordMap_.find(uid);
148             if (iterator == renderRecordMap_.end() || !(iterator->second)) {
149                 HILOG_ERROR("fail");
150                 return RENDER_FORM_FAILED;
151             }
152             search = iterator->second;
153         }
154 
155         std::string compId = want.GetStringParam(Constants::FORM_RENDER_COMP_ID);
156         search->DeleteRenderRecord(formJsInfo.formId, compId, hostToken, isRenderGroupEmpty);
157         {
158             std::lock_guard<std::mutex> lock(renderRecordMutex_);
159             if (search->IsEmpty()) {
160                 auto iterator = renderRecordMap_.find(uid);
161                 if (iterator == renderRecordMap_.end()) {
162                     HILOG_ERROR("fail.");
163                     return RENDER_FORM_FAILED;
164                 }
165                 renderRecordMap_.erase(iterator);
166                 HILOG_INFO("DeleteRenderRecord success,uid:%{public}s", uid.c_str());
167                 if (renderRecordMap_.empty()) {
168                     FormMemmgrClient::GetInstance().SetCritical(false);
169                 }
170             }
171         }
172     }
173 
174     HILOG_INFO("connectId:%{public}d",
175         want.GetIntParam(Constants::FORM_CONNECT_ID, 0L));
176     if (isRenderGroupEmpty) {
177         formSupplyClient->OnStopRenderingTaskDone(formJsInfo.formId, want);
178     }
179 
180     return ERR_OK;
181 }
182 
ReleaseRenderer(int64_t formId,const std::string & compId,const std::string & uid)183 int32_t FormRenderImpl::ReleaseRenderer(int64_t formId, const std::string &compId, const std::string &uid)
184 {
185     HILOG_INFO("formId:%{public}" PRId64 ",compId:%{public}s,uid:%{public}s", formId, compId.c_str(), uid.c_str());
186     if (formId <= 0 || compId.empty() || uid.empty()) {
187         HILOG_ERROR("param invalid");
188         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
189     }
190 
191     std::lock_guard<std::mutex> lock(renderRecordMutex_);
192     bool isRenderGroupEmpty = false;
193     auto search = renderRecordMap_.find(uid);
194     if (search == renderRecordMap_.end()) {
195         HILOG_ERROR("invalid record,formId:%{public}" PRId64, formId);
196         return RENDER_FORM_FAILED;
197     }
198 
199     if (!search->second) {
200         HILOG_ERROR("record invalid,formId:%{public}" PRId64, formId);
201         return RENDER_FORM_FAILED;
202     }
203 
204     search->second->ReleaseRenderer(formId, compId, isRenderGroupEmpty);
205     HILOG_INFO("end,isRenderGroupEmpty:%{public}d", isRenderGroupEmpty);
206     if (isRenderGroupEmpty) {
207         search->second->Release();
208     }
209 
210     return ERR_OK;
211 }
212 
CleanFormHost(const sptr<IRemoteObject> & hostToken)213 int32_t FormRenderImpl::CleanFormHost(const sptr<IRemoteObject> &hostToken)
214 {
215     HILOG_INFO("Form host is died,clean renderRecord");
216     std::lock_guard<std::mutex> lock(renderRecordMutex_);
217     for (auto iter = renderRecordMap_.begin(); iter != renderRecordMap_.end();) {
218         auto renderRecord = iter->second;
219         if (renderRecord && renderRecord->HandleHostDied(hostToken)) {
220             HILOG_DEBUG("empty renderRecord,remove");
221             iter = renderRecordMap_.erase(iter);
222         } else {
223             ++iter;
224         }
225     }
226     if (renderRecordMap_.empty()) {
227         HILOG_INFO("empty renderRecordMap_,FormRenderService will exit later");
228         FormMemmgrClient::GetInstance().SetCritical(false);
229     }
230     return ERR_OK;
231 }
232 
ReloadForm(const std::vector<FormJsInfo> && formJsInfos,const Want & want)233 int32_t FormRenderImpl::ReloadForm(const std::vector<FormJsInfo> &&formJsInfos, const Want &want)
234 {
235     HILOG_INFO("ReloadForm start");
236     std::string uid = want.GetStringParam(Constants::FORM_SUPPLY_UID);
237     if (uid.empty()) {
238         HILOG_ERROR("Get uid failed");
239         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
240     }
241     std::shared_ptr<FormRenderRecord> search = nullptr;
242     {
243         std::lock_guard<std::mutex> lock(renderRecordMutex_);
244         auto iterator = renderRecordMap_.find(uid);
245         if (iterator == renderRecordMap_.end()) {
246             HILOG_ERROR("RenderRecord not find");
247             return RELOAD_FORM_FAILED;
248         }
249         search = iterator->second;
250     }
251     if (search != nullptr) {
252         search->ReloadFormRecord(std::forward<decltype(formJsInfos)>(formJsInfos), want);
253     }
254     return ERR_OK;
255 }
256 
OnUnlock()257 int32_t FormRenderImpl::OnUnlock()
258 {
259     HILOG_INFO("OnUnlock start");
260     std::lock_guard<std::mutex> lock(renderRecordMutex_);
261     if (isVerified_) {
262         HILOG_WARN("Has been unlocked in render form, maybe miss or delay unlock event");
263         return ERR_OK;
264     }
265 
266     isVerified_ = true;
267     for (const auto& iter : renderRecordMap_) {
268         if (iter.second) {
269             iter.second->OnUnlock();
270         }
271     }
272     return ERR_OK;
273 }
274 
SetVisibleChange(const int64_t & formId,bool isVisible,const Want & want)275 int32_t FormRenderImpl::SetVisibleChange(const int64_t &formId, bool isVisible, const Want &want)
276 {
277     HILOG_INFO("SetVisibleChange start");
278     if (formId <= 0) {
279         HILOG_ERROR("formId is negative");
280         return ERR_APPEXECFWK_FORM_INVALID_FORM_ID;
281     }
282 
283     std::string uid = want.GetStringParam(Constants::FORM_SUPPLY_UID);
284     if (uid.empty()) {
285         HILOG_ERROR("empty uid,formId:%{public}" PRId64, formId);
286         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
287     }
288     HILOG_INFO("formId:%{public}" PRId64 ",uid:%{public}s", formId, uid.c_str());
289 
290     std::lock_guard<std::mutex> lock(renderRecordMutex_);
291     if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
292         if (search->second == nullptr) {
293             HILOG_ERROR("null renderRecord of %{public}s", std::to_string(formId).c_str());
294             return SET_VISIBLE_CHANGE_FAILED;
295         }
296         auto ret = search->second->SetVisibleChange(formId, isVisible);
297         if (ret != ERR_OK) {
298             return ret;
299         }
300     } else {
301         HILOG_ERROR("can't find render record of %{public}s", std::to_string(formId).c_str());
302         return SET_VISIBLE_CHANGE_FAILED;
303     }
304     return ERR_OK;
305 }
306 
OnConfigurationUpdated(const std::shared_ptr<OHOS::AppExecFwk::Configuration> & configuration)307 void FormRenderImpl::OnConfigurationUpdated(
308     const std::shared_ptr<OHOS::AppExecFwk::Configuration>& configuration)
309 {
310     HILOG_DEBUG("OnConfigurationUpdated start");
311     std::lock_guard<std::mutex> lock(renderRecordMutex_);
312     if (!configuration) {
313         HILOG_ERROR("null configuration");
314         return;
315     }
316 
317     SetConfiguration(configuration);
318 
319 #ifdef SUPPORT_POWER
320     bool screenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsScreenOn();
321     bool collaborationScreenOnFlag = PowerMgr::PowerMgrClient::GetInstance().IsCollaborationScreenOn();
322     if (!screenOnFlag && !collaborationScreenOnFlag) {
323         HILOG_WARN("screen off");
324         hasCachedConfig_ = true;
325         return;
326     }
327 #endif
328 
329     constexpr int64_t minDurationMs = 1500;
330     const std::string taskName = "FormRenderImpl::OnConfigurationUpdated";
331     serialQueue_->CancelDelayTask(taskName);
332     auto duration = std::chrono::steady_clock::now() - configUpdateTime_;
333     if (std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() < minDurationMs) {
334         HILOG_INFO("OnConfigurationUpdated ignored");
335         auto configUpdateFunc = [this]() {
336             HILOG_INFO("OnConfigurationUpdated task run");
337             this->OnConfigurationUpdatedInner();
338         };
339         constexpr int64_t taskDelayMs = 1000;
340         serialQueue_->ScheduleDelayTask(taskName, taskDelayMs, configUpdateFunc);
341         return;
342     }
343     OnConfigurationUpdatedInner();
344 }
345 
OnConfigurationUpdatedInner()346 void FormRenderImpl::OnConfigurationUpdatedInner()
347 {
348     sptr<IFormSupply> formSupplyClient = nullptr;
349     {
350         std::lock_guard<std::mutex> lock(formSupplyMutex_);
351         formSupplyClient = formSupplyClient_;
352     }
353     if (formSupplyClient == nullptr) {
354         HILOG_ERROR("null formSupplyClient");
355     }
356 
357     configUpdateTime_ = std::chrono::steady_clock::now();
358     size_t allFormCount = 0;
359     for (auto iter = renderRecordMap_.begin(); iter != renderRecordMap_.end(); ++iter) {
360         if (iter->second) {
361             iter->second->UpdateConfiguration(configuration_, formSupplyClient);
362             allFormCount += iter->second->FormCount();
363         }
364     }
365     HILOG_INFO("OnConfigurationUpdated %{public}zu forms updated.", allFormCount);
366     hasCachedConfig_ = false;
367     PerformanceEventInfo eventInfo;
368     eventInfo.timeStamp = FormRenderEventReport::GetNowMillisecond();
369     eventInfo.bundleName = Constants::FRS_BUNDLE_NAME;
370     eventInfo.sceneId = Constants::CPU_SCENE_ID_CONFIG_UPDATE;
371     FormRenderEventReport::SendPerformanceEvent(SceneType::CPU_SCENE_ENTRY, eventInfo);
372 }
373 
SetConfiguration(const std::shared_ptr<OHOS::AppExecFwk::Configuration> & config)374 void FormRenderImpl::SetConfiguration(const std::shared_ptr<OHOS::AppExecFwk::Configuration>& config)
375 {
376     if (config != nullptr && configuration_ != nullptr) {
377         std::string colorMode = config->GetItem(SYSTEM_COLORMODE);
378         std::string languageTag = config->GetItem(SYSTEM_LANGUAGE);
379         std::string colorModeOld = configuration_->GetItem(SYSTEM_COLORMODE);
380         std::string languageTagOld = configuration_->GetItem(SYSTEM_LANGUAGE);
381         configuration_ = config;
382         if (colorMode.empty()) {
383             configuration_->AddItem(SYSTEM_COLORMODE, colorModeOld);
384         }
385         if (languageTag.empty()) {
386             configuration_->AddItem(SYSTEM_LANGUAGE, languageTagOld);
387         }
388         return;
389     }
390 
391     configuration_ = config;
392 }
393 
RunCachedConfigurationUpdated()394 void FormRenderImpl::RunCachedConfigurationUpdated()
395 {
396     HILOG_INFO("RunCachedConfigUpdated");
397     std::lock_guard<std::mutex> lock(renderRecordMutex_);
398     if (hasCachedConfig_) {
399         OnConfigurationUpdatedInner();
400     }
401 }
402 
FormRenderGCTask(const std::string & uid)403 void FormRenderImpl::FormRenderGCTask(const std::string &uid)
404 {
405     auto mainHandler = std::make_shared<AppExecFwk::EventHandler>(AppExecFwk::EventRunner::GetMainEventRunner());
406     if (mainHandler == nullptr) {
407         HILOG_ERROR("null mainHandler");
408         return;
409     }
410     auto formRenderGCFunc = [uid]() {
411         auto formRenderImpl = OHOS::DelayedSingleton<FormRenderImpl>::GetInstance();
412         if (formRenderImpl == nullptr) {
413             HILOG_ERROR("null formRenderImpl");
414             return;
415         }
416         formRenderImpl->FormRenderGC(uid);
417     };
418     mainHandler->PostTask(formRenderGCFunc, "FormRenderGC", FORM_RENDER_TASK_DELAY_TIME);
419 }
420 
FormRenderGC(const std::string & uid)421 void FormRenderImpl::FormRenderGC(const std::string &uid)
422 {
423     HILOG_INFO("form gc, uid is %{s}public", uid.c_str());
424     std::lock_guard<std::mutex> lock(renderRecordMutex_);
425     if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
426         search->second->FormRenderGC();
427     }
428 }
429 
RecycleForm(const int64_t & formId,const Want & want)430 int32_t FormRenderImpl::RecycleForm(const int64_t &formId, const Want &want)
431 {
432     if (formId <= 0) {
433         HILOG_ERROR("formId is negative");
434         return ERR_APPEXECFWK_FORM_INVALID_FORM_ID;
435     }
436 
437     std::string uid = want.GetStringParam(Constants::FORM_SUPPLY_UID);
438     if (uid.empty()) {
439         HILOG_ERROR("empty uid,formId:%{public}" PRId64, formId);
440         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
441     }
442     HILOG_INFO("formId:%{public}" PRId64 ",uid:%{public}s", formId, uid.c_str());
443 
444     std::string statusData;
445     {
446         std::lock_guard<std::mutex> lock(renderRecordMutex_);
447         if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
448             if (search->second == nullptr) {
449                 HILOG_ERROR("null renderRecord of %{public}s", std::to_string(formId).c_str());
450                 return RECYCLE_FORM_FAILED;
451             }
452             auto ret = search->second->RecycleForm(formId, statusData);
453             if (ret != ERR_OK) {
454                 return ret;
455             }
456         } else {
457             HILOG_ERROR("can't find render record of %{public}s", std::to_string(formId).c_str());
458             return RECYCLE_FORM_FAILED;
459         }
460         if (statusData.empty()) {
461             HILOG_WARN("empty statusData of %{public}s", std::to_string(formId).c_str());
462         }
463     }
464 
465     sptr<IFormSupply> formSupplyClient = nullptr;
466     {
467         std::lock_guard<std::mutex> lock(formSupplyMutex_);
468         formSupplyClient = formSupplyClient_;
469     }
470     if (formSupplyClient == nullptr) {
471         HILOG_ERROR("null formSupplyClient, formId:%{public}" PRId64, formId);
472         return RECYCLE_FORM_FAILED;
473     }
474 
475     Want newWant = want;
476     newWant.SetParam(Constants::FORM_STATUS_DATA, statusData);
477     formSupplyClient->OnRecycleForm(formId, newWant);
478     return ERR_OK;
479 }
480 
RecoverForm(const FormJsInfo & formJsInfo,const Want & want)481 int32_t FormRenderImpl::RecoverForm(const FormJsInfo &formJsInfo, const Want &want)
482 {
483     auto formId = formJsInfo.formId;
484     if (formId <= 0) {
485         HILOG_ERROR("formId is negative");
486         return ERR_APPEXECFWK_FORM_INVALID_FORM_ID;
487     }
488 
489     std::string uid = want.GetStringParam(Constants::FORM_SUPPLY_UID);
490     if (uid.empty()) {
491         HILOG_ERROR("empty uid,formId:%{public}" PRId64, formId);
492         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
493     }
494     HILOG_INFO("formId:%{public}" PRId64 ", connectId:%{public}d, uid:%{public}s",
495         formId, want.GetIntParam(Constants::FORM_CONNECT_ID, 0L), uid.c_str());
496 
497     std::string statusData = want.GetStringParam(Constants::FORM_STATUS_DATA);
498     if (statusData.empty()) {
499         HILOG_WARN("empty statusData of %{public}s", std::to_string(formId).c_str());
500     }
501 
502     bool isRecoverFormToHandleClickEvent = want.GetBoolParam(
503         Constants::FORM_IS_RECOVER_FORM_TO_HANDLE_CLICK_EVENT, false);
504     std::lock_guard<std::mutex> lock(renderRecordMutex_);
505     if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
506         if (search->second == nullptr) {
507             HILOG_ERROR("null renderRecord of %{public}s", std::to_string(formId).c_str());
508             return RECYCLE_FORM_FAILED;
509         }
510         return search->second->RecoverForm(formJsInfo, statusData, isRecoverFormToHandleClickEvent);
511     }
512     HILOG_ERROR("can't find render record of %{public}s", std::to_string(formId).c_str());
513     return RENDER_FORM_FAILED;
514 }
515 
ConfirmUnlockState(Want & renderWant)516 void FormRenderImpl::ConfirmUnlockState(Want &renderWant)
517 {
518     // Ensure that there are no issues with adding form and unlocking drawing concurrency
519     if (isVerified_) {
520         renderWant.SetParam(Constants::FORM_RENDER_STATE, true);
521     } else if (renderWant.GetBoolParam(Constants::FORM_RENDER_STATE, false)) {
522         HILOG_WARN("Maybe unlock event is missed or delayed, all form record begin to render");
523         isVerified_ = true;
524         for (const auto& iter : renderRecordMap_) {
525             if (iter.second) {
526                 iter.second->OnUnlock();
527             }
528         }
529     }
530 }
531 
UpdateFormSize(const int64_t & formId,float width,float height,float borderWidth,const std::string & uid)532 int32_t FormRenderImpl::UpdateFormSize(
533     const int64_t &formId, float width, float height, float borderWidth, const std::string &uid)
534 {
535     std::lock_guard<std::mutex> lock(renderRecordMutex_);
536     if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
537         if (search->second == nullptr) {
538             HILOG_ERROR("UpdateFormSize null renderRecord of %{public}" PRId64, formId);
539             return UPDATE_FORM_SIZE_FAILED;
540         }
541         search->second->UpdateFormSizeOfGroups(formId, width, height, borderWidth);
542         return ERR_OK;
543     }
544     HILOG_ERROR("can't find render record of %{public}" PRId64, formId);
545     return UPDATE_FORM_SIZE_FAILED;
546 }
547 } // namespace FormRender
548 } // namespace AppExecFwk
549 } // namespace OHOS
550