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_mgr_inner.h"
17 
18 #include <mutex>
19 
20 #include "form_render_mgr.h"
21 #include "fms_log_wrapper.h"
22 #include "form_ams_helper.h"
23 #include "form_bms_helper.h"
24 #include "form_cache_mgr.h"
25 #include "form_constants.h"
26 #include "form_data_mgr.h"
27 #include "form_event_report.h"
28 #include "form_host_interface.h"
29 #include "form_mgr_errors.h"
30 #include "form_render_mgr.h"
31 #include "form_supply_callback.h"
32 #include "form_task_mgr.h"
33 #include "form_trust_mgr.h"
34 #include "form_util.h"
35 #include "ipc_skeleton.h"
36 #include "os_account_manager.h"
37 #include "want.h"
38 #include "form_info_rdb_storage_mgr.h"
39 
40 namespace OHOS {
41 namespace AppExecFwk {
42 namespace {
43 constexpr size_t LAST_CONNECTION = 1;
44 const std::string DLP_INDEX = "ohos.dlp.params.index";
45 const int FORM_DISCONNECT_FRS_DELAY_TIME = 5000; // ms
46 }
47 using Want = OHOS::AAFwk::Want;
FormRenderMgrInner()48 FormRenderMgrInner::FormRenderMgrInner()
49 {
50 }
~FormRenderMgrInner()51 FormRenderMgrInner::~FormRenderMgrInner()
52 {
53 }
54 
RenderForm( const FormRecord &formRecord, Want &want, const sptr<IRemoteObject> &hostToken)55 ErrCode FormRenderMgrInner::RenderForm(
56     const FormRecord &formRecord, Want &want, const sptr<IRemoteObject> &hostToken)
57 {
58     if (!isActiveUser_) {
59         HILOG_WARN("isActiveUser is false");
60         return ERR_APPEXECFWK_FORM_RENDER_SERVICE_DIED;
61     }
62     if (atomicRerenderCount_ > 0) {
63         --atomicRerenderCount_;
64     } else {
65         atomicRerenderCount_ = 0;
66     }
67     if (hostToken) {
68         HILOG_DEBUG("Add host token");
69         AddHostToken(hostToken, formRecord.formId);
70         want.SetParam(Constants::PARAM_FORM_HOST_TOKEN, hostToken);
71     }
72     FillBundleInfo(want, formRecord.bundleName);
73 
74     bool connectionExisted = false;
75     sptr<FormRenderConnection> connection = nullptr;
76     {
77         std::lock_guard<std::mutex> lock(resourceMutex_);
78         HILOG_DEBUG("renderFormConnections_ size:%{public}zu", renderFormConnections_.size());
79         auto conIterator = renderFormConnections_.find(formRecord.formId);
80         if (conIterator != renderFormConnections_.end()) {
81             connectionExisted = true;
82             connection = conIterator->second;
83         }
84     }
85     if (connectionExisted) {
86         if (connection == nullptr) {
87             HILOG_ERROR("null connection");
88             return ERR_APPEXECFWK_FORM_INVALID_PARAM;
89         }
90         std::shared_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
91         if (renderRemoteObj_ == nullptr) {
92             connection->UpdateFormRecord(formRecord);
93             connection->UpdateWantParams(want.GetParams());
94             ErrCode ret = ConnectRenderService(connection, formRecord.privacyLevel);
95             HILOG_INFO("ret:%{public}d", ret);
96             if (ret) {
97                 FormRenderMgr::GetInstance().HandleConnectFailed(formRecord.formId, ret);
98             }
99             return ret;
100         }
101         auto remoteObject = renderRemoteObj_->AsObject();
102         if (remoteObject == nullptr) {
103             HILOG_ERROR("null remoteObject");
104             return ERR_APPEXECFWK_FORM_INVALID_PARAM;
105         }
106         guard.unlock();
107         want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
108         FormTaskMgr::GetInstance().PostRenderForm(formRecord, want, remoteObject);
109         return ERR_OK;
110     }
111 
112     auto formRenderConnection = new (std::nothrow) FormRenderConnection(formRecord, want.GetParams());
113     if (formRenderConnection == nullptr) {
114         HILOG_ERROR("null formRenderConnection");
115         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
116     }
117     ErrCode errorCode = ConnectRenderService(formRenderConnection, formRecord.privacyLevel);
118     if (errorCode != ERR_OK) {
119         HILOG_ERROR("ConnectServiceAbility failed");
120         FormRenderMgr::GetInstance().HandleConnectFailed(formRecord.formId, errorCode);
121         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
122     }
123     return ERR_OK;
124 }
125 
CheckIfFormRecycled(FormRecord &formRecord, Want& want) const126 void FormRenderMgrInner::CheckIfFormRecycled(FormRecord &formRecord, Want& want) const
127 {
128     if (formRecord.recycleStatus == RecycleStatus::RECYCLED) {
129         formRecord.recycleStatus = RecycleStatus::NON_RECYCLABLE;
130         FormDataMgr::GetInstance().UpdateFormRecord(formRecord.formId, formRecord);
131         std::string statusData;
132         if (FormInfoRdbStorageMgr::GetInstance().LoadStatusData(
133             std::to_string(formRecord.formId), statusData) != ERR_OK) {
134             HILOG_ERROR("read status data of %{public}" PRId64 " failed.", formRecord.formId);
135         } else {
136             want.SetParam(Constants::FORM_STATUS_DATA, statusData);
137         }
138     }
139 }
140 
GetConnectionAndRenderForm(FormRecord &formRecord, Want &want)141 ErrCode FormRenderMgrInner::GetConnectionAndRenderForm(FormRecord &formRecord, Want &want)
142 {
143     std::lock_guard<std::mutex> lock(resourceMutex_);
144     auto conIterator = renderFormConnections_.find(formRecord.formId);
145     if (conIterator == renderFormConnections_.end()) {
146         HILOG_ERROR("Not find renderFormConnection");
147         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
148     }
149     auto connection = conIterator->second;
150     if (connection == nullptr) {
151         HILOG_ERROR("null connection");
152         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
153     }
154     sptr<IRemoteObject> remoteObject;
155     auto ret = GetRenderObject(remoteObject);
156     if (ret != ERR_OK) {
157         HILOG_ERROR("null remoteObjectGotten");
158         return ret;
159     }
160     CheckIfFormRecycled(formRecord, want);
161     want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
162     FormTaskMgr::GetInstance().PostRenderForm(formRecord, std::move(want), remoteObject);
163     return ERR_OK;
164 }
165 
UpdateRenderingForm(FormRecord &formRecord, const FormProviderData &formProviderData, const WantParams &wantParams, bool mergeData)166 ErrCode FormRenderMgrInner::UpdateRenderingForm(FormRecord &formRecord, const FormProviderData &formProviderData,
167     const WantParams &wantParams, bool mergeData)
168 {
169     if (mergeData) {
170         nlohmann::json jsonData = formProviderData.GetData();
171         formRecord.formProviderInfo.MergeData(jsonData);
172         auto providerData = formRecord.formProviderInfo.GetFormData();
173         providerData.SetImageDataState(formProviderData.GetImageDataState());
174         providerData.SetImageDataMap(formProviderData.GetImageDataMap());
175         formRecord.formProviderInfo.SetFormData(providerData);
176     } else {
177         formRecord.formProviderInfo.SetFormData(formProviderData);
178     }
179 
180     if (formRecord.formProviderInfo.NeedCache()) {
181         FormCacheMgr::GetInstance().AddData(formRecord.formId, formRecord.formProviderInfo.GetFormData());
182         if (formRecord.recycleStatus != RecycleStatus::NON_RECYCLABLE) {
183             std::string cacheData;
184             std::map<std::string, std::pair<sptr<FormAshmem>, int32_t>> imageDataMap;
185             if (FormCacheMgr::GetInstance().GetData(formRecord.formId, cacheData, imageDataMap)) {
186                 formRecord.formProviderInfo.SetImageDataMap(imageDataMap);
187             }
188         }
189     } else {
190         HILOG_DEBUG("need to delete data");
191         FormCacheMgr::GetInstance().DeleteData(formRecord.formId);
192     }
193     FormDataMgr::GetInstance().SetFormCacheInited(formRecord.formId, true);
194 
195     HILOG_INFO("enableForm:%{public}d", formRecord.enableForm);
196     if (!formRecord.enableForm) {
197         FormDataMgr::GetInstance().UpdateFormRecord(formRecord.formId, formRecord);
198         FormDataMgr::GetInstance().SetUpdateDuringDisableForm(formRecord.formId, true);
199         return ERR_APPEXECFWK_FORM_DISABLE_REFRESH;
200     }
201     Want want;
202     want.SetParams(wantParams);
203     FillBundleInfo(want, formRecord.bundleName);
204     want.SetParam(Constants::FORM_RENDER_TYPE_KEY, Constants::UPDATE_RENDERING_FORM);
205     std::string recordUid = std::to_string(formRecord.providerUserId) + formRecord.bundleName;
206     want.SetParam(Constants::FORM_SUPPLY_UID, recordUid);
207     return GetConnectionAndRenderForm(formRecord, want);
208 }
209 
ReloadForm( const std::vector<FormRecord> &&formRecords, const std::string &bundleName, int32_t userId)210 ErrCode FormRenderMgrInner::ReloadForm(
211     const std::vector<FormRecord> &&formRecords, const std::string &bundleName, int32_t userId)
212 {
213     sptr<IRemoteObject> remoteObject;
214     auto ret = GetRenderObject(remoteObject);
215     if (ret != ERR_OK) {
216         HILOG_ERROR("null remoteObjectGotten");
217         return ret;
218     }
219     Want want;
220     FillBundleInfo(want, bundleName);
221     want.SetParam(Constants::FORM_SUPPLY_UID, std::to_string(userId) + bundleName);
222     FormTaskMgr::GetInstance().PostReloadForm(std::forward<decltype(formRecords)>(formRecords), want, remoteObject);
223     return ERR_OK;
224 }
225 
FillBundleInfo(Want &want, const std::string &bundleName) const226 void FormRenderMgrInner::FillBundleInfo(Want &want, const std::string &bundleName) const
227 {
228     BundleInfo bundleInfo;
229     if (!FormBmsHelper::GetInstance().GetBundleInfoDefault(
230         bundleName, FormUtil::GetCurrentAccountId(), bundleInfo)) {
231         HILOG_ERROR("get bundle info failed. %{public}s", bundleName.c_str());
232         return;
233     }
234 
235     want.SetParam(Constants::FORM_COMPATIBLE_VERSION_KEY, static_cast<int32_t>(bundleInfo.compatibleVersion));
236     want.SetParam(Constants::FORM_TARGET_VERSION_KEY, static_cast<int32_t>(bundleInfo.targetVersion));
237 }
238 
PostOnUnlockTask()239 void FormRenderMgrInner::PostOnUnlockTask()
240 {
241     HILOG_DEBUG("call");
242     sptr<IRemoteObject> remoteObject;
243     auto ret = GetRenderObject(remoteObject);
244     if (ret != ERR_OK) {
245         HILOG_ERROR("null remoteObjectGotten");
246         return;
247     }
248     FormTaskMgr::GetInstance().PostOnUnlock(remoteObject);
249 }
250 
NotifyScreenOn()251 void FormRenderMgrInner::NotifyScreenOn()
252 {
253     HILOG_DEBUG("call");
254     sptr<IRemoteObject> remoteObject;
255     auto ret = GetRenderObject(remoteObject);
256     if (ret != ERR_OK) {
257         HILOG_ERROR("null remoteObjectGotten");
258         return;
259     }
260     sptr<IFormRender> remoteFormRenderer = iface_cast<IFormRender>(remoteObject);
261     if (remoteFormRenderer == nullptr) {
262         return;
263     }
264     remoteFormRenderer->RunCachedConfigurationUpdated();
265 }
266 
StopRenderingForm(int64_t formId, const FormRecord &formRecord, const std::string &compId, const sptr<IRemoteObject> &hostToken)267 ErrCode FormRenderMgrInner::StopRenderingForm(int64_t formId, const FormRecord &formRecord,
268     const std::string &compId, const sptr<IRemoteObject> &hostToken)
269 {
270     if (formRecord.uiSyntax != FormType::ETS) {
271         return ERR_OK;
272     }
273     if (formRecord.abilityName.empty()) {
274         HILOG_ERROR("empty formRecord.abilityName");
275         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
276     }
277     if (formRecord.bundleName.empty()) {
278         HILOG_ERROR("empty formRecord.bundleName");
279         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
280     }
281     Want want;
282     std::string recordUid = std::to_string(formRecord.providerUserId) + formRecord.bundleName;
283     want.SetParam(Constants::FORM_SUPPLY_UID, recordUid);
284     if (!compId.empty()) {
285         want.SetParam(Constants::FORM_RENDER_COMP_ID, compId);
286     }
287     if (hostToken) {
288         HILOG_DEBUG("StopRenderingForm Add host token");
289         want.SetParam(Constants::PARAM_FORM_HOST_TOKEN, hostToken);
290     }
291 
292     {
293         std::lock_guard<std::mutex> lock(resourceMutex_);
294         auto conIterator = renderFormConnections_.find(formRecord.formId);
295         if (conIterator != renderFormConnections_.end()) {
296             auto connection = conIterator->second;
297             if (connection == nullptr) {
298                 HILOG_ERROR("null connection");
299                 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
300             }
301             sptr<IRemoteObject> remoteObject;
302             auto ret = GetRenderObject(remoteObject);
303             if (ret != ERR_OK) {
304                 HILOG_ERROR("null remoteObjectGotten");
305                 return ret;
306             }
307             want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
308             FormTaskMgr::GetInstance().PostStopRenderingForm(formRecord, std::move(want), remoteObject);
309             return ERR_OK;
310         }
311     }
312     return ERR_APPEXECFWK_FORM_INVALID_PARAM;
313 }
314 
StopRenderingFormCallback(int64_t formId, const Want &want)315 ErrCode FormRenderMgrInner::StopRenderingFormCallback(int64_t formId, const Want &want)
316 {
317     size_t renderFormConnectionSize = 0;
318     sptr<FormRenderConnection> stopConnection = nullptr;
319     {
320         std::lock_guard<std::mutex> lock(resourceMutex_);
321         HILOG_DEBUG("renderFormConnections_ size:%{public}zu", renderFormConnections_.size());
322         auto conIterator = renderFormConnections_.find(formId);
323         if (conIterator == renderFormConnections_.end()) {
324             HILOG_ERROR("Can't find formId in map");
325             return ERR_APPEXECFWK_FORM_INVALID_PARAM;
326         }
327         stopConnection = conIterator->second;
328         renderFormConnectionSize = renderFormConnections_.size();
329         for (auto iter = etsHosts_.begin(); iter != etsHosts_.end();) {
330             iter->second.erase(formId);
331             if (iter->second.empty()) {
332                 HILOG_INFO("All forms of the host have been removed, remove the host");
333                 iter = etsHosts_.erase(iter);
334             } else {
335                 ++iter;
336             }
337         }
338         renderFormConnections_.erase(formId);
339     }
340     if (stopConnection == nullptr) {
341         HILOG_ERROR("Can't find stopConnection in map");
342         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
343     }
344     DisconnectRenderService(stopConnection, renderFormConnectionSize);
345     return ERR_OK;
346 }
347 
ReleaseRenderer(int64_t formId, const FormRecord &formRecord, const std::string &compId)348 ErrCode FormRenderMgrInner::ReleaseRenderer(int64_t formId, const FormRecord &formRecord, const std::string &compId)
349 {
350     if (formRecord.uiSyntax != FormType::ETS) {
351         return ERR_OK;
352     }
353     if (formRecord.abilityName.empty()) {
354         HILOG_ERROR("empty formRecord.abilityName");
355         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
356     }
357     if (formRecord.bundleName.empty()) {
358         HILOG_ERROR("empty formRecord.bundleName");
359         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
360     }
361 
362     std::string uid = std::to_string(formRecord.providerUserId) + formRecord.bundleName;
363     {
364         std::lock_guard<std::mutex> lock(resourceMutex_);
365         auto conIterator = renderFormConnections_.find(formRecord.formId);
366         if (conIterator != renderFormConnections_.end()) {
367             auto connection = conIterator->second;
368             if (connection == nullptr) {
369                 HILOG_ERROR("null connection");
370                 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
371             }
372             sptr<IRemoteObject> remoteObject;
373             auto ret = GetRenderObject(remoteObject);
374             if (ret != ERR_OK) {
375                 HILOG_ERROR("null remoteObjectGotten");
376                 return ret;
377             }
378             FormTaskMgr::GetInstance().PostReleaseRenderer(formId, compId, uid, remoteObject);
379             return ERR_OK;
380         }
381     }
382     return ERR_APPEXECFWK_FORM_INVALID_PARAM;
383 }
384 
AddConnection(int64_t formId, sptr<FormRenderConnection> connection)385 ErrCode FormRenderMgrInner::AddConnection(int64_t formId, sptr<FormRenderConnection> connection)
386 {
387     if (connection == nullptr) {
388         HILOG_ERROR("null FormRenderConnection");
389         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
390     }
391     size_t renderFormConnectionSize = 0;
392     sptr<FormRenderConnection> oldConnection = nullptr;
393     {
394         std::lock_guard<std::mutex> lock(resourceMutex_);
395         int32_t connectKey = static_cast<int32_t>(FormUtil::GetCurrentMillisecond());
396         auto conIterator = renderFormConnections_.find(formId);
397         if (conIterator == renderFormConnections_.end()) {
398             connection->SetConnectId(connectKey);
399             renderFormConnections_.emplace(formId, connection);
400         } else if (renderFormConnections_[formId]->GetConnectId() != connection->GetConnectId()) {
401             HILOG_WARN("Duplicate connection of formId:%{public}" PRId64 ", delete old connection", formId);
402             renderFormConnectionSize = renderFormConnections_.size();
403             oldConnection = renderFormConnections_[formId];
404             renderFormConnections_[formId] = connection;
405             connection->SetConnectId(connectKey);
406         }
407         HILOG_DEBUG("renderFormConnections size:%{public}zu", renderFormConnections_.size());
408     }
409     if (oldConnection) {
410         DisconnectRenderService(oldConnection, renderFormConnectionSize);
411     }
412     return ERR_OK;
413 }
414 
RemoveConnection(int64_t formId)415 void FormRenderMgrInner::RemoveConnection(int64_t formId)
416 {
417     std::lock_guard<std::mutex> lock(resourceMutex_);
418     if (renderFormConnections_.find(formId) != renderFormConnections_.end()) {
419         HILOG_DEBUG("Remove connection of formId:%{public}" PRId64 "", formId);
420         renderFormConnections_.erase(formId);
421     }
422 }
423 
RerenderAllForms()424 void FormRenderMgrInner::RerenderAllForms()
425 {
426     HILOG_INFO("FRS is died,notify host");
427     std::unique_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
428     renderRemoteObj_ = nullptr;
429     guard.unlock();
430     {
431         std::lock_guard<std::mutex> lock(resourceMutex_);
432         atomicRerenderCount_ = renderFormConnections_.size();
433         if (etsHosts_.empty() || renderFormConnections_.empty()) {
434             HILOG_INFO("All hosts died or all connections erased, no need to rerender");
435             return;
436         }
437         HILOG_INFO("The forms need to rerender count:%{public}zu", renderFormConnections_.size());
438         for (auto &item : renderFormConnections_) {
439             if (item.second == nullptr) {
440                 HILOG_ERROR("null Connection");
441                 continue;
442             }
443             item.second->SetStateDisconnected();
444         }
445     }
446 
447     NotifyHostRenderServiceIsDead();
448 }
449 
CleanFormHost(const sptr<IRemoteObject> &host)450 void FormRenderMgrInner::CleanFormHost(const sptr<IRemoteObject> &host)
451 {
452     HILOG_INFO("Host is died or been removed, notify FormRenderService and remove host");
453     RemoveHostToken(host);
454     std::unique_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
455     if (renderRemoteObj_ == nullptr) {
456         HILOG_WARN("renderRemoteObj is null,render service may exit already");
457         return;
458     }
459     renderRemoteObj_->CleanFormHost(host);
460 }
461 
AddRenderDeathRecipient(const sptr<IRemoteObject> &remoteObject)462 void FormRenderMgrInner::AddRenderDeathRecipient(const sptr<IRemoteObject> &remoteObject)
463 {
464     std::shared_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
465     if (renderRemoteObj_) {
466         HILOG_INFO("renderDeathRecipient is exist, no need to add again");
467         return;
468     }
469     guard.unlock();
470 
471     HILOG_INFO("Get renderRemoteObj,add death recipient");
472     auto renderRemoteObj = iface_cast<IFormRender>(remoteObject);
473     if (renderRemoteObj == nullptr) {
474         HILOG_ERROR("null renderRemoteObj");
475         return;
476     }
477 
478     if (renderDeathRecipient_ == nullptr) {
479         renderDeathRecipient_ = new (std::nothrow) FormRenderRecipient([this]() {
480             HILOG_WARN("FRS is Death, userId:%{public}d, isActiveUser:%{public}d", userId_, isActiveUser_);
481             if (isActiveUser_) {
482                 RerenderAllForms();
483             } else {
484                 std::unique_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
485                 renderRemoteObj_ = nullptr;
486                 guard.unlock();
487             }
488         });
489     }
490     if (!remoteObject->AddDeathRecipient(renderDeathRecipient_)) {
491         HILOG_ERROR("AddDeathRecipient failed");
492         return;
493     }
494     SetRenderRemoteObj(renderRemoteObj);
495 }
496 
ConnectRenderService( const sptr<FormRenderConnection> &connection, int32_t level) const497 inline ErrCode FormRenderMgrInner::ConnectRenderService(
498     const sptr<FormRenderConnection> &connection, int32_t level) const
499 {
500     if (connection == nullptr) {
501         HILOG_INFO("null connection");
502         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
503     }
504     Want want;
505     want.SetElementName(Constants::FRS_BUNDLE_NAME, "ServiceExtension");
506     want.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
507     if (level > 0) {
508         want.SetParam(DLP_INDEX, Constants::DEFAULT_SANDBOX_FRS_APP_INDEX);
509         want.SetParam(Constants::FRS_APP_INDEX, Constants::DEFAULT_SANDBOX_FRS_APP_INDEX);
510     }
511     connection->SetStateConnecting();
512     return FormAmsHelper::GetInstance().ConnectServiceAbility(want, connection);
513 }
514 
SetUserId(int32_t userId)515 void FormRenderMgrInner::SetUserId(int32_t userId)
516 {
517     userId_ = userId;
518 }
519 
GetUserId() const520 int32_t FormRenderMgrInner::GetUserId() const
521 {
522     return userId_;
523 }
524 
RerenderAllFormsImmediate()525 void FormRenderMgrInner::RerenderAllFormsImmediate()
526 {
527     HILOG_INFO("call");
528     isActiveUser_ = true;
529     if (etsHosts_.empty()) {
530         HILOG_WARN("All hosts died,no need to rerender");
531         return;
532     }
533     NotifyHostRenderServiceIsDead();
534 }
535 
DisconnectAllRenderConnections()536 void FormRenderMgrInner::DisconnectAllRenderConnections()
537 {
538     HILOG_INFO("renderFormConnections size:%{public}zu", renderFormConnections_.size());
539     std::lock_guard<std::mutex> lock(resourceMutex_);
540     size_t size = renderFormConnections_.size();
541     for (auto iter = renderFormConnections_.begin(); iter != renderFormConnections_.end();) {
542         DisconnectRenderService(iter->second, size);
543         iter = renderFormConnections_.erase(iter);
544         size--;
545     }
546     isActiveUser_ = false;
547 }
548 
DisconnectRenderService(const sptr<FormRenderConnection> connection, size_t size) const549 void FormRenderMgrInner::DisconnectRenderService(const sptr<FormRenderConnection> connection, size_t size) const
550 {
551     if (size == LAST_CONNECTION) {
552         HILOG_INFO("This is the last connection, disconnect render service delay");
553         FormAmsHelper::GetInstance().DisconnectServiceAbilityDelay(connection, FORM_DISCONNECT_FRS_DELAY_TIME);
554     } else {
555         HILOG_DEBUG("Disconnect render service ability");
556         FormAmsHelper::GetInstance().DisconnectServiceAbility(connection);
557     }
558 }
559 
OnRenderingBlock(const std::string &bundleName)560 void FormRenderMgrInner::OnRenderingBlock(const std::string &bundleName)
561 {
562     HILOG_INFO("bundleName:%{public}s", bundleName.c_str());
563     FormEventInfo eventInfo;
564     eventInfo.bundleName = bundleName;
565     FormEventReport::SendSecondFormEvent(
566         FormEventName::FORM_RENDER_BLOCK, HiSysEventType::FAULT, eventInfo);
567 
568     FormTrustMgr::GetInstance().MarkTrustFlag(bundleName, false);
569 
570     Want want;
571     want.SetElementName(Constants::FRS_BUNDLE_NAME, "ServiceExtension");
572     want.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
573     FormAmsHelper::GetInstance().StopExtensionAbility(want);
574 }
575 
AddHostToken(const sptr<IRemoteObject> &host, int64_t formId)576 inline void FormRenderMgrInner::AddHostToken(const sptr<IRemoteObject> &host, int64_t formId)
577 {
578     std::lock_guard<std::mutex> lock(resourceMutex_);
579     auto iter = etsHosts_.find(host);
580     if (iter == etsHosts_.end()) {
581         HILOG_DEBUG("Add host, current etsHosts.size:%{public}zu", etsHosts_.size());
582         std::unordered_set<int64_t> formIdSet;
583         formIdSet.emplace(formId);
584         etsHosts_.emplace(host, formIdSet);
585     } else {
586         HILOG_DEBUG("Add formId to host, current etsHosts.size:%{public}zu", etsHosts_.size());
587         iter->second.emplace(formId);
588     }
589 }
590 
RemoveHostToken(const sptr<IRemoteObject> &host)591 void FormRenderMgrInner::RemoveHostToken(const sptr<IRemoteObject> &host)
592 {
593     size_t left = 0;
594     std::unordered_map<int64_t, sptr<FormRenderConnection>> connections;
595     {
596         std::lock_guard<std::mutex> lock(resourceMutex_);
597         auto iter = etsHosts_.find(host);
598         if (iter == etsHosts_.end()) {
599             HILOG_ERROR("Can't find host in etsHosts");
600             return;
601         }
602         auto formIdSet = iter->second;
603         etsHosts_.erase(host);
604         if (etsHosts_.empty()) {
605             HILOG_DEBUG("etsHosts is empty, disconnect all connections size:%{public}zu",
606                 renderFormConnections_.size());
607             connections.swap(renderFormConnections_);
608         } else {
609             for (const int64_t formId : formIdSet) {
610                 FormRecord formRecord;
611                 if (!FormDataMgr::GetInstance().GetFormRecord(formId, formRecord)) {
612                     connections.emplace(formId, renderFormConnections_[formId]);
613                     renderFormConnections_.erase(formId);
614                 }
615             }
616         }
617         left = renderFormConnections_.size();
618     }
619     for (auto iter = connections.begin(); iter != connections.end();) {
620         DisconnectRenderService(iter->second, connections.size() > left ? connections.size() : left);
621         iter = connections.erase(iter);
622     }
623 }
624 
NotifyHostRenderServiceIsDead() const625 void FormRenderMgrInner::NotifyHostRenderServiceIsDead() const
626 {
627     std::unordered_map<sptr<IRemoteObject>, std::unordered_set<int64_t>, RemoteObjHash> hostsForNotify;
628     {
629         std::lock_guard<std::mutex> lock(resourceMutex_);
630         HILOG_INFO("Notify hosts the render is dead, hosts.size:%{public}zu", etsHosts_.size());
631         auto tmpMap(etsHosts_);
632         hostsForNotify.swap(tmpMap);
633     }
634     for (const auto &item : hostsForNotify) {
635         sptr<IRemoteObject> hostClient = item.first;
636         if (hostClient == nullptr) {
637             HILOG_ERROR("null hostClient");
638             continue;
639         }
640         FormTaskMgr::GetInstance().PostFrsDiedTaskToHost(hostClient);
641     }
642 }
643 
GetRenderRemoteObj() const644 sptr<IFormRender> FormRenderMgrInner::GetRenderRemoteObj() const
645 {
646     return renderRemoteObj_;
647 }
648 
SetRenderRemoteObj(sptr<IFormRender> remoteObject)649 void FormRenderMgrInner::SetRenderRemoteObj(sptr<IFormRender> remoteObject)
650 {
651     std::unique_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
652     renderRemoteObj_ = remoteObject;
653 }
654 
GetReRenderCount() const655 int32_t FormRenderMgrInner::GetReRenderCount() const
656 {
657     return atomicRerenderCount_;
658 }
659 
RecycleForms( const std::vector<int64_t> &formIds, const Want &want, const sptr<IRemoteObject> &remoteObjectOfHost)660 ErrCode FormRenderMgrInner::RecycleForms(
661     const std::vector<int64_t> &formIds, const Want &want, const sptr<IRemoteObject> &remoteObjectOfHost)
662 {
663     HILOG_DEBUG("call");
664     sptr<IRemoteObject> remoteObject;
665     auto ret = GetRenderObject(remoteObject);
666     if (ret != ERR_OK) {
667         HILOG_ERROR("null remoteObjectGotten");
668         return ret;
669     }
670 
671     std::lock_guard<std::mutex> lock(resourceMutex_);
672     std::vector<int64_t> connectedForms;
673     for (const int64_t &formId : formIds) {
674         auto conIterator = renderFormConnections_.find(formId);
675         if (conIterator != renderFormConnections_.end()) {
676             auto connection = conIterator->second;
677             if (connection == nullptr) {
678                 HILOG_ERROR("connection of %{public}" PRId64 " is null.", formId);
679                 continue;
680             }
681             connectedForms.emplace_back(formId);
682         }
683     }
684     FormTaskMgr::GetInstance().PostRecycleForms(connectedForms, want, remoteObjectOfHost, remoteObject);
685     return ERR_OK;
686 }
687 
RecoverForms(const std::vector<int64_t> &formIds, const WantParams &wantParams)688 ErrCode FormRenderMgrInner::RecoverForms(const std::vector<int64_t> &formIds, const WantParams &wantParams)
689 {
690     HILOG_DEBUG("call");
691     sptr<IRemoteObject> remoteObject;
692     auto ret = GetRenderObject(remoteObject);
693     if (ret != ERR_OK) {
694         HILOG_ERROR("null remoteObjectGotten");
695         return ret;
696     }
697 
698     for (const int64_t &formId : formIds) {
699         Want want;
700         want.SetParams(wantParams);
701 
702         FormRecord formRecord;
703         if (!FormDataMgr::GetInstance().GetFormRecord(formId, formRecord)) {
704             HILOG_ERROR("form record %{public}" PRId64 " not exist", formId);
705             continue;
706         }
707 
708         std::string cacheData;
709         std::map<std::string, std::pair<sptr<FormAshmem>, int32_t>> imageDataMap;
710         if (FormCacheMgr::GetInstance().GetData(formRecord.formId, cacheData, imageDataMap)) {
711             formRecord.formProviderInfo.SetImageDataMap(imageDataMap);
712         }
713 
714         std::string uid = std::to_string(formRecord.providerUserId) + formRecord.bundleName;
715         want.SetParam(Constants::FORM_SUPPLY_UID, uid);
716 
717         std::lock_guard<std::mutex> lock(resourceMutex_);
718         auto conIterator = renderFormConnections_.find(formId);
719         if (conIterator != renderFormConnections_.end()) {
720             auto connection = conIterator->second;
721             if (connection == nullptr) {
722                 HILOG_ERROR("connection of %{public}" PRId64 " is null.", formId);
723                 continue;
724             }
725             want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
726 
727             std::string statusData;
728             if (FormInfoRdbStorageMgr::GetInstance().LoadStatusData(std::to_string(formId), statusData) != ERR_OK) {
729                 HILOG_ERROR("read status data of %{public}" PRId64 " failed.", formId);
730             }
731             want.SetParam(Constants::FORM_STATUS_DATA, statusData);
732 
733             FormTaskMgr::GetInstance().PostRecoverForm(formRecord, want, remoteObject);
734         } else {
735             HILOG_ERROR("can't find connection of %{public}" PRId64, formId);
736         }
737     }
738     return ERR_OK;
739 }
740 
GetRenderObject(sptr<IRemoteObject> &renderObj)741 ErrCode FormRenderMgrInner::GetRenderObject(sptr<IRemoteObject> &renderObj)
742 {
743     std::shared_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
744     if (renderRemoteObj_ == nullptr) {
745         HILOG_ERROR("null renderRemoteObj");
746         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
747     }
748     renderObj = renderRemoteObj_->AsObject();
749     if (renderObj == nullptr) {
750         HILOG_ERROR("null remoteObj");
751         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
752     }
753     return ERR_OK;
754 }
755 
OnRemoteDied(const wptr<IRemoteObject> &remote)756 void FormRenderRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
757 {
758     HILOG_INFO("Recv FormRenderService death notice");
759     if (handler_) {
760         handler_();
761     }
762 }
763 
FormRenderRecipient(RemoteDiedHandler handler)764 FormRenderRecipient::FormRenderRecipient(RemoteDiedHandler handler) : handler_(handler) {}
765 
~FormRenderRecipient()766 FormRenderRecipient::~FormRenderRecipient() {}
767 } // namespace AppExecFwk
768 } // namespace OHOS
769