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
16 #include <gtest/gtest.h>
17
18 #define private public
19 #include "ability_manager_service.h"
20 #include "task_handler_wrap.h"
21 #undef private
22
23 #include "ability_record.h"
24 #include "sa_mgr_client.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::AAFwk;
28
29 namespace OHOS {
30 namespace AppExecFwk {
31 namespace {
32 const int BUNDLE_MGR_SERVICE_SYS_ABILITY_ID = 401;
33 }
34 class FreeInstallTest : public testing::Test {
35 public:
FreeInstallTest()36 FreeInstallTest()
37 {}
~FreeInstallTest()38 ~FreeInstallTest()
39 {}
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 sptr<Token> MockToken();
45 std::shared_ptr<FreeInstallManager> freeInstallManager_ = nullptr;
46 };
47
SetUpTestCase(void)48 void FreeInstallTest::SetUpTestCase(void) {}
49
TearDownTestCase(void)50 void FreeInstallTest::TearDownTestCase(void) {}
51
SetUp(void)52 void FreeInstallTest::SetUp(void) {}
53
TearDown(void)54 void FreeInstallTest::TearDown(void)
55 {}
56
MockToken()57 sptr<Token> FreeInstallTest::MockToken()
58 {
59 sptr<Token> token = nullptr;
60 AbilityRequest abilityRequest;
61 abilityRequest.appInfo.bundleName = "com.test.demo";
62 abilityRequest.abilityInfo.name = "MainAbility";
63 abilityRequest.abilityInfo.type = AbilityType::PAGE;
64 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
65 if (!abilityRecord) {
66 return nullptr;
67 }
68 return abilityRecord->GetToken();
69 }
70
71 /**
72 * @tc.number: FreeInstall_StartFreeInstall_001
73 * @tc.name: StartFreeInstall
74 * @tc.desc: Test StartFreeInstall when callback is success.
75 */
76 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_001, TestSize.Level1)
77 {
78 auto abilityMs_ = std::make_shared<AbilityManagerService>();
79 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
80 Want want;
81 ElementName element("", "com.test.demo", "MainAbility");
82 want.SetElement(element);
83 const int32_t userId = 100;
84 const int requestCode = 0;
85 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
86 // mock callerToken
87 const sptr<IRemoteObject> callerToken = MockToken();
88 int res = 0;
89
90 usleep(100000); // 100000 means us.
91 // from freeInstallManager_->freeInstallList_ find startInstallTime
92 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
93 std::string bundleName = (*it).want.GetElement().GetBundleName();
94 std::string abilityName = (*it).want.GetElement().GetAbilityName();
95 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
96 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
97 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
98 break;
99 }
100 }
101 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
102
103 EXPECT_TRUE(freeInstallManager_ != nullptr);
104 }
105
106 /**
107 * @tc.number: FreeInstall_StartFreeInstall_002
108 * @tc.name: StartFreeInstall
109 * @tc.desc: Test StartFreeInstall when token is nullptr.
110 */
111 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_002, TestSize.Level1)
112 {
113 auto abilityMs_ = std::make_shared<AbilityManagerService>();
114 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
115 Want want;
116 ElementName element("", "com.test.demo", "MainAbility");
117 want.SetElement(element);
118 const int32_t userId = 100; // 100 means userId
119 const int requestCode = 0;
120 // token is nullptr, IsTopAbility failed
121 const sptr<IRemoteObject> callerToken = nullptr;
122 // NotTopAbility
123 freeInstallManager_->StartFreeInstall(want, userId, requestCode, callerToken);
124 EXPECT_TRUE(freeInstallManager_ != nullptr);
125 }
126
127 /**
128 * @tc.number: FreeInstall_StartFreeInstall_003
129 * @tc.name: StartFreeInstall
130 * @tc.desc: Test StartFreeInstall when callback is failed.
131 */
132 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_003, TestSize.Level1)
133 {
134 auto abilityMs_ = std::make_shared<AbilityManagerService>();
135 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
136 Want want;
137 ElementName element("", "com.test.demo", "MainAbility");
138 want.SetElement(element);
139 const int32_t userId = 1;
140 const int requestCode = 0;
141 // mock callerToken
142 const sptr<IRemoteObject> callerToken = MockToken();
143 int res = 0;
144
145 usleep(100000); // 100000 means us.
146 // from freeInstallManager_->freeInstallList_ find startInstallTime
147 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
148 std::string bundleName = (*it).want.GetElement().GetBundleName();
149 std::string abilityName = (*it).want.GetElement().GetAbilityName();
150 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
151 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
152 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
153 break;
154 }
155 }
156 freeInstallManager_->OnInstallFinished(-1, 1, want, userId, false);
157
158 EXPECT_TRUE(freeInstallManager_ != nullptr);
159 }
160
161 /**
162 * @tc.number: FreeInstall_OnInstallFinished_001
163 * @tc.name: OnInstallFinished
164 * @tc.desc: Test OnInstallFinished succeed.
165 */
166 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_001, TestSize.Level1)
167 {
168 auto abilityMs_ = std::make_shared<AbilityManagerService>();
169 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
170 Want want;
171 ElementName element("", "com.test.demo", "MainAbility");
172 want.SetElement(element);
173 const int32_t userId = 1;
174 const int requestCode = 0;
175 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
176
177 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
178 freeInstallManager_->freeInstallList_.resize(0);
179 freeInstallManager_->freeInstallList_.emplace_back(info);
180 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
181
182 for (auto it = freeInstallManager_->freeInstallList_.begin();
183 it != freeInstallManager_->freeInstallList_.end(); it++) {
184 std::string bundleName = (*it).want.GetElement().GetBundleName();
185 std::string abilityName = (*it).want.GetElement().GetAbilityName();
186 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
187 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
188 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
189 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
190 EXPECT_EQ((*it).promise->get_future().get(), 0);
191 }
192 }
193 }
194
195 /**
196 * @tc.number: FreeInstall_OnInstallFinished_002
197 * @tc.name: OnInstallFinished
198 * @tc.desc: Test OnInstallFinished failed.
199 */
200 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_002, TestSize.Level1)
201 {
202 auto abilityMs_ = std::make_shared<AbilityManagerService>();
203 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
204 Want want;
205 ElementName element("", "com.test.demo", "MainAbility");
206 want.SetElement(element);
207 const int32_t userId = 1;
208 const int requestCode = 0;
209 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
210
211 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
212 freeInstallManager_->freeInstallList_.resize(0);
213 freeInstallManager_->freeInstallList_.emplace_back(info);
214 freeInstallManager_->OnInstallFinished(-1, 1, want, userId, false);
215
216 for (auto it = freeInstallManager_->freeInstallList_.begin();
217 it != freeInstallManager_->freeInstallList_.end(); it++) {
218 std::string bundleName = (*it).want.GetElement().GetBundleName();
219 std::string abilityName = (*it).want.GetElement().GetAbilityName();
220 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
221 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
222 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
223 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
224 EXPECT_EQ((*it).promise->get_future().get(), 1);
225 }
226 }
227 }
228
229 /**
230 * @tc.number: FreeInstall_OnInstallFinished_003
231 * @tc.name: OnInstallFinished
232 * @tc.desc: Test OnInstallFinished failed.
233 */
234 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_003, TestSize.Level1)
235 {
236 auto abilityMs_ = std::make_shared<AbilityManagerService>();
237 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
238 Want want;
239 ElementName element("", "com.test.demo", "MainAbility");
240 want.SetElement(element);
241 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
242 const int32_t userId = 1;
243 const int requestCode = 0;
244
245 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
246 info.isInstalled = true;
247 freeInstallManager_->freeInstallList_.resize(0);
248 info.promise.reset();
249 freeInstallManager_->freeInstallList_.emplace_back(info);
250 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
251
252 int size = freeInstallManager_->freeInstallList_.size();
253 EXPECT_EQ(size, 1);
254 }
255
256 /**
257 * @tc.number: FreeInstall_FreeInstallAbilityFromRemote_001
258 * @tc.name: FreeInstallAbilityFromRemote
259 * @tc.desc: Test FreeInstallAbilityFromRemote.
260 */
261 HWTEST_F(FreeInstallTest, FreeInstall_FreeInstallAbilityFromRemote_001, TestSize.Level1)
262 {
263 auto abilityMs_ = std::make_shared<AbilityManagerService>();
264 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
265 Want want;
266 ElementName element("", "com.test.demo", "MainAbility");
267 want.SetElement(element);
268 const int32_t userId = 1;
269 const int requestCode = 0;
270
271 int res = freeInstallManager_->FreeInstallAbilityFromRemote(want, nullptr, userId, requestCode);
272 EXPECT_EQ(res, 22);
273 }
274
275 /**
276 * @tc.number: FreeInstall_OnRemoteInstallFinished_001
277 * @tc.name: OnRemoteInstallFinished
278 * @tc.desc: Test OnRemoteInstallFinished.
279 */
280 HWTEST_F(FreeInstallTest, FreeInstall_OnRemoteInstallFinished_001, TestSize.Level1)
281 {
282 auto abilityMs_ = std::make_shared<AbilityManagerService>();
283 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
284 Want want;
285 ElementName element("", "com.test.demo", "MainAbility");
286 want.SetElement(element);
287 const int32_t userId = 1;
288 const int requestCode = 0;
289 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
290
291 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
292 freeInstallManager_->freeInstallList_.resize(0);
293 freeInstallManager_->freeInstallList_.emplace_back(info);
294 freeInstallManager_->OnRemoteInstallFinished(-1, 0, want, userId);
295
296 for (auto it = freeInstallManager_->freeInstallList_.begin();
297 it != freeInstallManager_->freeInstallList_.end(); it++) {
298 std::string bundleName = (*it).want.GetElement().GetBundleName();
299 std::string abilityName = (*it).want.GetElement().GetAbilityName();
300 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
301 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
302 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
303 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
304 EXPECT_EQ((*it).promise->get_future().get(), 0);
305 }
306 }
307 }
308
309 /**
310 * @tc.number: FreeInstall_ConnectFreeInstall_001
311 * @tc.name: ConnectFreeInstall
312 * @tc.desc: Test ConnectFreeInstall.
313 */
314 HWTEST_F(FreeInstallTest, FreeInstall_ConnectFreeInstall_001, TestSize.Level1)
315 {
316 auto abilityMs_ = std::make_shared<AbilityManagerService>();
317 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
318 Want want;
319 ElementName element("", "com.test.demo", "MainAbility");
320 want.SetElement(element);
321 const int32_t userId = 1;
322
323 int res = freeInstallManager_->ConnectFreeInstall(want, userId, nullptr, "");
324 EXPECT_NE(res, 0);
325 }
326
327
328 /**
329 * @tc.number: FreeInstall_UpdateElementName_001
330 * @tc.name: UpdateElementName
331 * @tc.desc: Test UpdateElementName.
332 */
333 HWTEST_F(FreeInstallTest, FreeInstall_UpdateElementName_001, TestSize.Level1)
334 {
335 auto abilityMs_ = std::make_shared<AbilityManagerService>();
336 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
337 Want want;
338 const int32_t userId = 1;
339 freeInstallManager_->UpdateElementName(want, userId);
340 freeInstallManager_->GetTimeStamp();
341 EXPECT_TRUE(freeInstallManager_ != nullptr);
342 }
343
344 /**
345 * @tc.number: FreeInstall_AddFreeInstallObserver_001
346 * @tc.name: AddFreeInstallObserver
347 * @tc.desc: Test AddFreeInstallObserver.
348 */
349 HWTEST_F(FreeInstallTest, FreeInstall_AddFreeInstallObserver_001, TestSize.Level1)
350 {
351 auto abilityMs_ = std::make_shared<AbilityManagerService>();
352 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
353
354 auto ret = freeInstallManager_->AddFreeInstallObserver(nullptr, nullptr);
355 EXPECT_EQ(CHECK_PERMISSION_FAILED, ret);
356 }
357
358 /**
359 * @tc.number: FreeInstall_SetSCBCallStatus_001
360 * @tc.name: SetSCBCallStatus
361 * @tc.desc: Test SetSCBCallStatus.
362 */
363 HWTEST_F(FreeInstallTest, FreeInstall_SetSCBCallStatus_001, TestSize.Level1)
364 {
365 auto abilityMs_ = std::make_shared<AbilityManagerService>();
366 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
367
368 freeInstallManager_->SetSCBCallStatus("com.ix.hiservcie", "ServiceAbility", "2024-7-17 00:00:00", false);
369 FreeInstallInfo freeInstallInfo;
370 freeInstallManager_->GetFreeInstallTaskInfo("com.ix.hiservcie", "ServiceAbility",
371 "2024-7-17 00:00:00", freeInstallInfo);
372 EXPECT_EQ(freeInstallInfo.isStartUIAbilityBySCBCalled, false);
373 }
374
375 /**
376 * @tc.number: FreeInstall_SetPreStartMissionCallStatus_001
377 * @tc.name: SetPreStartMissionCallStatus
378 * @tc.desc: Test SetPreStartMissionCallStatus.
379 */
380 HWTEST_F(FreeInstallTest, FreeInstall_SetPreStartMissionCallStatus_001, TestSize.Level1)
381 {
382 auto abilityMs_ = std::make_shared<AbilityManagerService>();
383 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
384
385 freeInstallManager_->SetPreStartMissionCallStatus("com.ix.hiservcie", "ServiceAbility",
386 "2024-7-17 00:00:00", false);
387 FreeInstallInfo freeInstallInfo;
388 freeInstallManager_->GetFreeInstallTaskInfo("com.ix.hiservcie", "ServiceAbility",
389 "2024-7-17 00:00:00", freeInstallInfo);
390 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
391 }
392
393 /**
394 * @tc.number: FreeInstall_SetFreeInstallTaskSessionId_001
395 * @tc.name: SetFreeInstallTaskSessionId
396 * @tc.desc: Test SetFreeInstallTaskSessionId.
397 */
398 HWTEST_F(FreeInstallTest, FreeInstall_SetFreeInstallTaskSessionId_001, TestSize.Level1)
399 {
400 auto abilityMs_ = std::make_shared<AbilityManagerService>();
401 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
402
403 Want want;
404 ElementName element("", "com.ix.hiservcie", "ServiceAbility");
405 want.SetElement(element);
406
407 std::string startTime = "2024-7-17 00:00:00";
408 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
409 const int32_t userId = 1;
410 const int requestCode = 0;
411 // mock callerToken
412 const sptr<IRemoteObject> callerToken = MockToken();
413 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, callerToken);
414 {
415 std::lock_guard<ffrt::mutex> lock(freeInstallManager_->freeInstallListLock_);
416 freeInstallManager_->freeInstallList_.push_back(info);
417 }
418
419 freeInstallManager_->SetFreeInstallTaskSessionId("com.ix.hiservcie", "ServiceAbility",
420 "2024-7-17 00:00:00", "sessionId");
421 FreeInstallInfo freeInstallInfo;
422 bool ret = freeInstallManager_->GetFreeInstallTaskInfo("sessionId", freeInstallInfo);
423 EXPECT_EQ(true, ret);
424
425 freeInstallManager_->RemoveFreeInstallInfo("com.ix.hiservcie", "ServiceAbility", "2024-7-17 00:00:00");
426 ret = freeInstallManager_->GetFreeInstallTaskInfo("com.ix.hiservcie", "ServiceAbility",
427 "2024-7-17 00:00:00", freeInstallInfo);
428 EXPECT_EQ(false, ret);
429 freeInstallManager_->OnInstallFinished(-1, 1, want, userId, false);
430 }
431
432 /**
433 * @tc.number: FreeInstall_VerifyStartFreeInstallPermission_001
434 * @tc.name: VerifyStartFreeInstallPermission
435 * @tc.desc: Test VerifyStartFreeInstallPermission.
436 */
437 HWTEST_F(FreeInstallTest, FreeInstall_VerifyStartFreeInstallPermission_001, TestSize.Level1)
438 {
439 auto abilityMs_ = std::make_shared<AbilityManagerService>();
440 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
441
442 const sptr<IRemoteObject> callerToken = MockToken();
443 freeInstallManager_->VerifyStartFreeInstallPermission(callerToken);
444 freeInstallManager_->GetRecordIdByToken(callerToken);
445 EXPECT_TRUE(freeInstallManager_ != nullptr);
446 }
447
448 /**
449 * @tc.number: FreeInstall_SetAppRunningState_001
450 * @tc.name: SetAppRunningState
451 * @tc.desc: Test SetAppRunningState.
452 */
453 HWTEST_F(FreeInstallTest, FreeInstall_SetAppRunningState_001, TestSize.Level1)
454 {
455 auto abilityMs_ = std::make_shared<AbilityManagerService>();
456 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
457
458 Want want;
459 freeInstallManager_->SetAppRunningState(want);
460 EXPECT_TRUE(freeInstallManager_ != nullptr);
461 }
462
463 /**
464 * @tc.number: FreeInstall_PostUpgradeAtomicServiceTask_001
465 * @tc.name: PostUpgradeAtomicServiceTask
466 * @tc.desc: Test PostUpgradeAtomicServiceTask.
467 */
468 HWTEST_F(FreeInstallTest, FreeInstall_PostUpgradeAtomicServiceTask_001, TestSize.Level1)
469 {
470 auto abilityMs_ = std::make_shared<AbilityManagerService>();
471 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
472
473 Want want;
474 ElementName element("", "com.test.demo", "MainAbility");
475 want.SetElement(element);
476 const int32_t userId = 100;
477 int resultCode = 0;
478 freeInstallManager_->PostUpgradeAtomicServiceTask(resultCode, want, userId);
479 EXPECT_TRUE(freeInstallManager_ != nullptr);
480 }
481
482 /**
483 * @tc.number: FreeInstall_StartAbilityByOriginalWant_001
484 * @tc.name: StartAbilityByOriginalWant
485 * @tc.desc: Test StartAbilityByOriginalWant.
486 */
487 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByOriginalWant_001, TestSize.Level1)
488 {
489 auto abilityMs_ = std::make_shared<AbilityManagerService>();
490 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
491
492 FreeInstallInfo freeInstallInfo;
493 freeInstallManager_->StartAbilityByOriginalWant(freeInstallInfo, "2024-07-17 00:00:00");
494 EXPECT_TRUE(freeInstallManager_ != nullptr);
495 }
496
497 /**
498 * @tc.number: FreeInstall_StartAbilityByConvertedWant_001
499 * @tc.name: StartAbilityByConvertedWant
500 * @tc.desc: Test StartAbilityByConvertedWant.
501 */
502 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByConvertedWant_001, TestSize.Level1)
503 {
504 auto abilityMs_ = std::make_shared<AbilityManagerService>();
505 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
506
507 FreeInstallInfo freeInstallInfo;
508 freeInstallManager_->StartAbilityByConvertedWant(freeInstallInfo, "2024-07-17 00:00:00");
509 EXPECT_TRUE(freeInstallManager_ != nullptr);
510 }
511
512 } // namespace AppExecFwk
513 } // namespace OHOS