1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "form_share_mgr.h"
16 #include "form_ams_helper.h"
17 #include "form_bms_helper.h"
18 #include "form_constants.h"
19 #include "form_data_mgr.h"
20 #include "form_event_handler.h"
21 #include "form_mgr_errors.h"
22 #include "form_host_interface.h"
23 #include "form_provider_interface.h"
24 #include "form_serial_queue.h"
25 #include "form_share_connection.h"
26 #include "form_supply_callback.h"
27 #include "form_util.h"
28 #include "in_process_call_wrapper.h"
29 #include "nlohmann/json.hpp"
30 #include "string_wrapper.h"
31 
32 namespace OHOS {
33 namespace AppExecFwk {
34 namespace {
35 constexpr int64_t FORM_SHARE_INFO_DELAY_TIMER = 50000;
36 constexpr int64_t FORM_PACKAGE_FREE_INSTALL_TIMER = 40000;
37 constexpr int64_t FORM_SHARE_INFO_MAX_SIZE = 32;
38 constexpr const char* ACTION_SHARE_FORM = "action.form.share";
39 }
40 
FormShareMgr()41 FormShareMgr::FormShareMgr()
42 {
43     HILOG_DEBUG("FormShareMgr is created");
44 };
45 
~FormShareMgr()46 FormShareMgr::~FormShareMgr()
47 {
48     HILOG_DEBUG("FormShareMgr is destroyed");
49     if (eventHandler_ != nullptr) {
50         eventHandler_->UnregisterEventTimeoutObserver(shared_from_this());
51     }
52 };
53 
ShareForm(int64_t formId,const std::string & deviceId,const sptr<IRemoteObject> & callerToken,int64_t requestCode)54 int32_t FormShareMgr::ShareForm(int64_t formId, const std::string &deviceId, const sptr<IRemoteObject> &callerToken,
55     int64_t requestCode)
56 {
57     HILOG_DEBUG("call");
58     FormRecord formRecord;
59     bool isFormRecExist = FormDataMgr::GetInstance().GetFormRecord(formId, formRecord);
60     if (!isFormRecExist) {
61         HILOG_ERROR("form share info get formRecord failed");
62         return ERR_APPEXECFWK_FORM_GET_INFO_FAILED;
63     }
64 
65     {
66         std::unique_lock<std::shared_mutex> guard(requestMapMutex_);
67         requestMap_.emplace(requestCode, callerToken);
68     }
69 
70     sptr<FormShareConnection> formShareConnection = new (std::nothrow) FormShareConnection(
71         formId, formRecord.bundleName, formRecord.abilityName, deviceId, requestCode);
72     if (formShareConnection == nullptr) {
73         HILOG_ERROR("create formShareConnection failed");
74         return ERR_APPEXECFWK_FORM_COMMON_CODE;
75     }
76     Want want;
77     want.SetElementName(formRecord.bundleName, formRecord.abilityName);
78     want.AddFlags(Want::FLAG_ABILITY_FORM_ENABLED);
79     ErrCode errorCode = FormAmsHelper::GetInstance().ConnectServiceAbility(want, formShareConnection);
80     if (errorCode != ERR_OK) {
81         HILOG_ERROR("ConnectServiceAbility failed");
82         std::unique_lock<std::shared_mutex> guard(requestMapMutex_);
83         requestMap_.erase(requestCode);
84         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
85     }
86 
87     return ERR_OK;
88 }
89 
RecvFormShareInfoFromRemote(const FormShareInfo & info)90 int32_t FormShareMgr::RecvFormShareInfoFromRemote(const FormShareInfo &info)
91 {
92     HILOG_DEBUG("call");
93 
94     if (serialQueue_ == nullptr) {
95         HILOG_ERROR("null serialQueue_");
96         return ERR_APPEXECFWK_FORM_COMMON_CODE;
97     }
98 
99     auto task = [info]() {
100         DelayedSingleton<FormShareMgr>::GetInstance()->HandleRecvFormShareInfoFromRemoteTask(info);
101     };
102     serialQueue_->ScheduleTask(0, task);
103 
104     return ERR_OK;
105 }
106 
HandleRecvFormShareInfoFromRemoteTask(const FormShareInfo & info)107 int32_t FormShareMgr::HandleRecvFormShareInfoFromRemoteTask(const FormShareInfo &info)
108 {
109     HILOG_DEBUG("call");
110 
111     if (!CheckFormShareInfo(info)) {
112         HILOG_ERROR("form share info check failed");
113         return ERR_APPEXECFWK_FORM_SHARE_INFO_CHECK_FAILED;
114     }
115 
116     AbilityInfo abilityInfo;
117     ExtensionAbilityInfo extensionAbilityInfo;
118     int32_t userId = FormUtil::GetCurrentAccountId();
119     if (!FormBmsHelper::GetInstance().GetAbilityInfoByAction(
120         ACTION_SHARE_FORM, userId, abilityInfo, extensionAbilityInfo)) {
121         HILOG_ERROR("get ability info by action failed");
122         return ERR_APPEXECFWK_FORM_FORM_USER_NOT_EXIST;
123     }
124     if (abilityInfo.name.empty() && extensionAbilityInfo.name.empty()) {
125         HILOG_ERROR("formUser not exist");
126         return ERR_APPEXECFWK_FORM_FORM_USER_NOT_EXIST;
127     }
128 
129     auto formShareInfoKey = MakeFormShareInfoKey(info);
130     {
131         std::unique_lock<std::shared_mutex> guard(shareInfoMapMutex_);
132         if (shareInfo_.find(formShareInfoKey) != shareInfo_.end()) {
133             HILOG_ERROR("form is sharing");
134             return ERR_APPEXECFWK_FORM_SHARING;
135         }
136         if (shareInfo_.size() > FORM_SHARE_INFO_MAX_SIZE) {
137             HILOG_ERROR("The maximum number of shared cards has been reached");
138             return ERR_APPEXECFWK_FORM_SHARING_MAX_SIZE;
139         }
140 
141         shareInfo_.emplace(formShareInfoKey, info);
142     }
143     {
144         std::unique_lock<std::shared_mutex> guard(eventMapMutex_);
145         auto eventId = FormEventHandler::GetEventId();
146         eventMap_.emplace(eventId, formShareInfoKey);
147         if (eventHandler_ != nullptr) {
148             eventHandler_->ProcessEvent(MSG::FORM_SHARE_INFO_DELAY_MSG, eventId, FORM_SHARE_INFO_DELAY_TIMER);
149         }
150     }
151     auto ret = CheckFormPackage(info, formShareInfoKey);
152     if (ret == ERR_APPEXECFWK_FORM_FREE_INSTALLATION) {
153         return ERR_OK;
154     }
155     if (ret != ERR_OK) {
156         return ret;
157     }
158     StartFormUser(info);
159     return ERR_OK;
160 }
161 
CheckFormPackage(const FormShareInfo & info,const std::string & formShareInfoKey)162 int32_t FormShareMgr::CheckFormPackage(const FormShareInfo &info, const std::string &formShareInfoKey)
163 {
164     if (IsExistFormPackage(info.bundleName, info.moduleName)) {
165         return ERR_OK;
166     }
167 
168     if (serialQueue_ == nullptr) {
169         HILOG_ERROR("null serialQueue_");
170         return ERR_APPEXECFWK_FORM_COMMON_CODE;
171     }
172 
173     if (eventHandler_ == nullptr) {
174         HILOG_ERROR("null eventHandler_");
175         return ERR_APPEXECFWK_FORM_COMMON_CODE;
176     }
177 
178     std::shared_ptr<FormFreeInstallOperator> freeInstallOperator =
179         std::make_shared<FormFreeInstallOperator>(formShareInfoKey, serialQueue_);
180     auto eventId = FormEventHandler::GetEventId();
181     HILOG_DEBUG("free install operator send event, eventId:%{public}" PRId64 ", key:%{public}s",
182         eventId, formShareInfoKey.c_str());
183     eventHandler_->ProcessEvent(
184         MSG::FORM_PACKAGE_FREE_INSTALL_DELAY_MSG, eventId, FORM_PACKAGE_FREE_INSTALL_TIMER);
185 
186     {
187         std::unique_lock<std::shared_mutex> guard(freeInstallMapMutex_);
188         freeInstallOperatorMap_.emplace(eventId, freeInstallOperator);
189     }
190 
191     auto ret = freeInstallOperator->StartFreeInstall(info.bundleName, info.moduleName, info.abilityName);
192     if (ret != ERR_OK) {
193         HILOG_ERROR("free install failed");
194         RemoveFormShareInfo(formShareInfoKey);
195         FinishFreeInstallTask(freeInstallOperator);
196         return ERR_APPEXECFWK_FORM_FREE_INSTALL_FAILED;
197     }
198     return ERR_APPEXECFWK_FORM_FREE_INSTALLATION;
199 }
200 
CheckFormShareInfo(const FormShareInfo & info)201 bool FormShareMgr::CheckFormShareInfo(const FormShareInfo &info)
202 {
203     return !(info.bundleName.empty() ||
204             info.moduleName.empty() ||
205             info.abilityName.empty() ||
206             info.formName.empty() ||
207             info.deviceId.empty());
208 }
209 
MakeFormShareInfoKey(const FormShareInfo & info)210 std::string FormShareMgr::MakeFormShareInfoKey(const FormShareInfo &info)
211 {
212     return (info.bundleName + info.moduleName + info.abilityName + info.formName);
213 }
214 
MakeFormShareInfoKey(const Want & want)215 std::string FormShareMgr::MakeFormShareInfoKey(const Want &want)
216 {
217     std::string bundleName = want.GetElement().GetBundleName();
218     std::string abilityName = want.GetElement().GetAbilityName();
219     std::string moduleName = want.GetStringParam(Constants::PARAM_MODULE_NAME_KEY);
220     std::string formName = want.GetStringParam(Constants::PARAM_FORM_NAME_KEY);
221     return (bundleName + moduleName + abilityName + formName);
222 }
223 
StartFormUser(const FormShareInfo & info)224 void FormShareMgr::StartFormUser(const FormShareInfo &info)
225 {
226     HILOG_DEBUG("call");
227     AbilityInfo abilityInfo;
228     ExtensionAbilityInfo extensionAbilityInfo;
229     int32_t userId = FormUtil::GetCurrentAccountId();
230     if (!FormBmsHelper::GetInstance().GetAbilityInfoByAction(
231         ACTION_SHARE_FORM, userId, abilityInfo, extensionAbilityInfo)) {
232         HILOG_ERROR("get ability info by action failed");
233         return;
234     }
235 
236     Want want;
237     if (!abilityInfo.name.empty()) {
238         want.SetElementName(abilityInfo.bundleName, abilityInfo.name);
239     } else if (!extensionAbilityInfo.name.empty()) {
240         want.SetElementName(extensionAbilityInfo.bundleName, extensionAbilityInfo.name);
241     } else {
242         HILOG_ERROR("formUser not exist");
243         return;
244     }
245 
246     want.SetAction(ACTION_SHARE_FORM);
247     want.SetParam(Constants::PARAM_BUNDLE_NAME_KEY, info.bundleName);
248     want.SetParam(Constants::PARAM_MODULE_NAME_KEY, info.moduleName);
249     want.SetParam(Constants::PARAM_ABILITY_NAME_KEY, info.abilityName);
250     want.SetParam(Constants::PARAM_FORM_NAME_KEY, info.formName);
251     want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, info.formTempFlag);
252     want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, info.dimensionId);
253 
254     auto errorCode = FormAmsHelper::GetInstance().StartAbility(want, userId);
255     if (errorCode != ERR_OK) {
256         HILOG_ERROR("start ability failed");
257         RemoveFormShareInfo(MakeFormShareInfoKey(info));
258     }
259 }
260 
IsExistFormPackage(const std::string & bundleName,const std::string & moduleName)261 bool FormShareMgr::IsExistFormPackage(const std::string &bundleName, const std::string &moduleName)
262 {
263     HILOG_DEBUG("call");
264     BundleInfo bundleInfo;
265     auto userId = FormUtil::GetCurrentAccountId();
266     if (!FormBmsHelper::GetInstance().GetBundleInfo(bundleName, userId, bundleInfo)) {
267         HILOG_ERROR("get bundle info failed");
268         return false;
269     }
270 
271     for (const auto &moduleInfo : bundleInfo.moduleNames) {
272         if (moduleInfo.compare(moduleName) == 0) {
273             HILOG_DEBUG("module name is exist, moduleName:%{public}s", moduleInfo.c_str());
274             return true;
275         }
276     }
277 
278     HILOG_ERROR("moduleName:%{public}s not exist", moduleName.c_str());
279     return false;
280 }
281 
RemoveFormShareInfo(const std::string & formShareInfoKey)282 void FormShareMgr::RemoveFormShareInfo(const std::string &formShareInfoKey)
283 {
284     HILOG_DEBUG("call");
285     {
286         std::unique_lock<std::shared_mutex> guard(eventMapMutex_);
287         int64_t eventId = 0;
288         for (auto iter = eventMap_.begin(); iter != eventMap_.end(); iter++) {
289             if (iter->second == formShareInfoKey) {
290                 eventId = iter->first;
291                 break;
292             }
293         }
294 
295         if (eventId != 0) {
296             eventMap_.erase(eventId);
297             if (serialQueue_ != nullptr) {
298                 serialQueue_->CancelDelayTask(std::make_pair(MSG::FORM_SHARE_INFO_DELAY_MSG, eventId));
299             }
300         }
301     }
302 
303     {
304         std::unique_lock<std::shared_mutex> guard(shareInfoMapMutex_);
305         shareInfo_.erase(formShareInfoKey);
306     }
307 }
308 
FinishFreeInstallTask(const std::shared_ptr<FormFreeInstallOperator> & freeInstallOperator)309 void FormShareMgr::FinishFreeInstallTask(const std::shared_ptr<FormFreeInstallOperator> &freeInstallOperator)
310 {
311     HILOG_DEBUG("call");
312     std::unique_lock<std::shared_mutex> guard(freeInstallMapMutex_);
313 
314     int64_t eventId = 0;
315     for (auto iter = freeInstallOperatorMap_.begin(); iter != freeInstallOperatorMap_.end(); iter++) {
316         if (iter->second == freeInstallOperator) {
317             eventId = iter->first;
318             break;
319         }
320     }
321 
322     if (eventId != 0) {
323         freeInstallOperatorMap_.erase(eventId);
324         if (serialQueue_ != nullptr) {
325             serialQueue_->CancelDelayTask(std::make_pair(MSG::FORM_PACKAGE_FREE_INSTALL_DELAY_MSG, eventId));
326         }
327     }
328 }
329 
OnInstallFinished(const std::shared_ptr<FormFreeInstallOperator> & freeInstallOperator,int32_t resultCode,const std::string & formShareInfoKey)330 void FormShareMgr::OnInstallFinished(const std::shared_ptr<FormFreeInstallOperator> &freeInstallOperator,
331     int32_t resultCode, const std::string &formShareInfoKey)
332 {
333     HILOG_DEBUG("call");
334 
335     FinishFreeInstallTask(freeInstallOperator);
336 
337     if (resultCode != ERR_OK) {
338         HILOG_ERROR("free install failed");
339         RemoveFormShareInfo(formShareInfoKey);
340         return;
341     }
342 
343     FormShareInfo info;
344     {
345         std::shared_lock<std::shared_mutex> guard(shareInfoMapMutex_);
346         auto it = shareInfo_.find(formShareInfoKey);
347         if (it == shareInfo_.end()) {
348             HILOG_ERROR("invalid formShareInfo");
349             return;
350         }
351 
352         it->second.isFreeInstall = true;
353         info = it->second;
354     }
355 
356     StartFormUser(info);
357 }
358 
HandleFormShareInfoTimeout(int64_t eventId)359 void FormShareMgr::HandleFormShareInfoTimeout(int64_t eventId)
360 {
361     HILOG_DEBUG("eventId:%{public}" PRId64 "", eventId);
362 
363     std::string formShareInfoKey;
364     {
365         std::unique_lock<std::shared_mutex> guard(eventMapMutex_);
366         auto it = eventMap_.find(eventId);
367         if (it == eventMap_.end()) {
368             HILOG_ERROR("eventId not find");
369             return;
370         }
371         formShareInfoKey = it->second;
372         eventMap_.erase(eventId);
373     }
374     HILOG_DEBUG("form share info timeout, key:%{public}s", formShareInfoKey.c_str());
375 
376     RemoveFormShareInfo(formShareInfoKey);
377 }
378 
HandleFreeInstallTimeout(int64_t eventId)379 void FormShareMgr::HandleFreeInstallTimeout(int64_t eventId)
380 {
381     HILOG_DEBUG("eventId:%{public}" PRId64 "", eventId);
382     std::unique_lock<std::shared_mutex> guard(freeInstallMapMutex_);
383     freeInstallOperatorMap_.erase(eventId);
384 }
385 
AddProviderData(const Want & want,WantParams & wantParams)386 void FormShareMgr::AddProviderData(const Want &want, WantParams &wantParams)
387 {
388     HILOG_DEBUG("call");
389 
390     auto formShareInfoKey = MakeFormShareInfoKey(want);
391     std::string deviceId;
392     std::string bundleName;
393     std::string moduleName;
394     bool isFreeInstall = false;
395     std::map<std::string, sptr<IInterface>> providerWantParams;
396     {
397         std::shared_lock<std::shared_mutex> guard(shareInfoMapMutex_);
398         auto it = shareInfo_.find(formShareInfoKey);
399         if (it == shareInfo_.end()) {
400             HILOG_DEBUG("No sharedProviderData");
401             return;
402         }
403 
404         providerWantParams = it->second.providerShareData.GetParams();
405         deviceId = it->second.deviceId;
406         bundleName = it->second.bundleName;
407         moduleName = it->second.moduleName;
408         isFreeInstall = it->second.isFreeInstall;
409     }
410 
411     if (!wantParams.HasParam(Constants::PARAM_DEVICE_ID_KEY)) {
412         wantParams.SetParam(Constants::PARAM_DEVICE_ID_KEY, AAFwk::String::Box(deviceId));
413     }
414     for (auto iter = providerWantParams.begin(); iter != providerWantParams.end(); iter++) {
415         wantParams.SetParam(iter->first, iter->second);
416     }
417 
418     if (isFreeInstall) {
419         FormBmsHelper::GetInstance().NotifyModuleNotRemovable(bundleName, moduleName);
420         HILOG_INFO("notify module not removable, bundleName:%{public}s, moduleName:%{public}s",
421             bundleName.c_str(), moduleName.c_str());
422     }
423 
424     RemoveFormShareInfo(formShareInfoKey);
425 }
426 
AcquireShareFormData(int64_t formId,const std::string & remoteDeviceId,const Want & want,const sptr<IRemoteObject> & remoteObject)427 void FormShareMgr::AcquireShareFormData(int64_t formId, const std::string &remoteDeviceId,
428     const Want &want, const sptr<IRemoteObject> &remoteObject)
429 {
430     HILOG_DEBUG("call");
431     int64_t requestCode = static_cast<int64_t>(want.GetLongParam(Constants::FORM_SHARE_REQUEST_CODE, 0));
432     auto connectId = want.GetIntParam(Constants::FORM_CONNECT_ID, 0);
433     sptr<IFormProvider> formProviderProxy = iface_cast<IFormProvider>(remoteObject);
434 
435     if (formProviderProxy == nullptr) {
436         FormSupplyCallback::GetInstance()->RemoveConnection(connectId);
437         SendResponse(requestCode, ERR_APPEXECFWK_FORM_COMMON_CODE);
438         HILOG_ERROR("get formProviderProxy failed");
439         return;
440     }
441 
442     int32_t error = formProviderProxy->AcquireShareFormData(formId, remoteDeviceId,
443         FormSupplyCallback::GetInstance(), requestCode);
444     if (error != ERR_OK) {
445         SendResponse(requestCode, error);
446         HILOG_ERROR("acquire providerFormInfo failed");
447     }
448 
449     FormSupplyCallback::GetInstance()->RemoveConnection(connectId);
450 }
451 
HandleProviderShareData(int64_t formId,const std::string & remoteDeviceId,const AAFwk::WantParams & wantParams,int64_t requestCode,const bool & result)452 void FormShareMgr::HandleProviderShareData(int64_t formId, const std::string &remoteDeviceId,
453     const AAFwk::WantParams &wantParams, int64_t requestCode, const bool &result)
454 {
455     HILOG_DEBUG("call");
456 
457     FormRecord formRecord;
458     bool isFormRecExist = FormDataMgr::GetInstance().GetFormRecord(formId, formRecord);
459     if (!isFormRecExist) {
460         HILOG_ERROR("form share info get formRecord failed");
461         SendResponse(requestCode, ERR_APPEXECFWK_FORM_GET_INFO_FAILED);
462         return;
463     }
464 
465     if (!result) {
466         HILOG_ERROR("fail parse shared data");
467         SendResponse(requestCode, ERR_APPEXECFWK_FORM_COMMON_CODE);
468         return;
469     }
470 
471     FormShareInfo formShareInfo;
472     formShareInfo.formId = formRecord.formId;
473     formShareInfo.formName = formRecord.formName;
474     formShareInfo.bundleName = formRecord.bundleName;
475     formShareInfo.moduleName = formRecord.moduleName;
476     formShareInfo.abilityName = formRecord.abilityName;
477     formShareInfo.formTempFlag = formRecord.formTempFlag;
478     formShareInfo.dimensionId = formRecord.specification;
479     formShareInfo.providerShareData = wantParams;
480 
481     if (formDmsClient_ == nullptr) {
482         formDmsClient_ = std::make_shared<FormDistributedClient>();
483     }
484     int32_t retval = formDmsClient_->ShareForm(remoteDeviceId, formShareInfo);
485     if (retval != ERR_OK) {
486         HILOG_ERROR("fail share form from DMS retval = %{public}d", retval);
487         SendResponse(requestCode, ERR_APPEXECFWK_FORM_DISTRIBUTED_SCHEDULE_FAILED);
488         return;
489     }
490     SendResponse(requestCode, ERR_OK);
491 }
492 
SendResponse(int64_t requestCode,int32_t result)493 void FormShareMgr::SendResponse(int64_t requestCode, int32_t result)
494 {
495     HILOG_DEBUG("FormMgrService SendResponse call, requestCode:%{public}" PRId64 " result:%{public}d",
496         requestCode, result);
497     std::unique_lock<std::shared_mutex> guard(requestMapMutex_);
498     auto iter = requestMap_.find(requestCode);
499     if (iter == requestMap_.end()) {
500         HILOG_DEBUG("No form shared request");
501         return;
502     }
503 
504     sptr<IFormHost> remoteFormHost = iface_cast<IFormHost>(iter->second);
505     if (remoteFormHost == nullptr) {
506         HILOG_ERROR("get formHostProxy failed");
507         return;
508     }
509     remoteFormHost->OnShareFormResponse(requestCode, result);
510     requestMap_.erase(requestCode);
511 }
512 
IsShareForm(const Want & want)513 bool FormShareMgr::IsShareForm(const Want &want)
514 {
515     HILOG_DEBUG("call");
516     auto formShareInfoKey = MakeFormShareInfoKey(want);
517     HILOG_DEBUG("formShareInfoKey:%{public}s", formShareInfoKey.c_str());
518 
519     std::shared_lock<std::shared_mutex> guard(shareInfoMapMutex_);
520     auto it = shareInfo_.find(formShareInfoKey);
521     if (it == shareInfo_.end()) {
522         HILOG_DEBUG("The form not sharedForm");
523         return false;
524     }
525     return true;
526 }
527 
OnEventTimeoutResponse(int64_t msg,int64_t eventId)528 void FormShareMgr::OnEventTimeoutResponse(int64_t msg, int64_t eventId)
529 {
530     HILOG_DEBUG("call");
531     switch (msg) {
532         case MSG::FORM_SHARE_INFO_DELAY_MSG: {
533             HandleFormShareInfoTimeout(eventId);
534             break;
535         }
536         case MSG::FORM_PACKAGE_FREE_INSTALL_DELAY_MSG: {
537             HandleFreeInstallTimeout(eventId);
538             break;
539         }
540         default: {
541             break;
542         }
543     }
544 }
545 } // namespace AppExecFwk
546 } // namespace OHOS
547