add actslifecyclesinglehaptest and actslifecyclemultihaptest

Signed-off-by: Ndy <dingyao5@huawei.com>

aafwk/aafwk_standard/BUILD.gn

@@ -23,15 +23,16 @@ group("aafwk_standard") {
       "actsabilitylifecyclestatenew:ActsAbilityLifecycleStateNewTest",
       "actsabilitymanageretstest:ActsAbilityManagerEtsTest",
       "actsdataabilityjs:ActsDataAbilityJsTest",
-      "actsfwkdataaccessortest:dataability",
-      "actsserviceabilityclienttest:serviceability",
       "actsstserviceabilityclientcase:ActsStServiceAbilityClientCaseTest",
-      "amsabilitymanager:amsabilitymanager",
+      "amsabilitymanager/amsMissionSnapshotTest:ActsAmsMissionSnapshotTest",
+      "amsabilitymanager/amsMissionSnapshotTestSingleton:ActsAmsMissionSnapshotTestSingleton",
+      "amsabilitymanager/amsMissionSnapshotTestSingletonS:ActsAmsMissionSnapshotTestSingletonS",
       "amsdatauriutils:ActsAmsDataUriUtilsTest",
       "amsgetabilityprocessinfo:amsgetabilityprocessinfo",
       "context:context",
       "featureability:featureability",
       "formmanager:formmanager",
+      "stage:stage",
       "want:want",
     ]
   }

aafwk/aafwk_standard/stage/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//test/xts/tools/build/suite.gni")
+
+group("stage") {
+  testonly = true
+  if (is_standard_system) {
+    deps = [
+      "actslifecyclemultihap2test:ActsLifecycleMultiHap2Test",
+      "actslifecyclemultihap3test:ActsLifecycleMultiHap3Test",
+      "actslifecyclemultihaptest:ActsLifecycleMultiHapTest",
+      "actslifecyclesinglehaptest:ActsLifecycleSingleHapTest",
+    ]
+  }
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/AppScope/app.json

+{
+    "app": {
+        "bundleName": "com.example.lifecycletest",
+        "vendor": "huawei",
+        "versionCode": 1000000,
+        "versionName": "1.0.0",
+        "debug": false,
+        "icon": "$media:icon",
+        "label": "$string:app_name",
+        "description": "$string:description_application",
+        "distributedNotificationEnabled": true,
+        "keepAlive": true,
+        "singleUser": true,
+        "minAPIVersion": 9,
+        "targetAPIVersion": 9,
+        "car": {
+            "apiCompatibleVersion": 9,
+            "singleUser": false
+        }
+    }
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/AppScope/resources/base/element/string.json

+{
+ "string":[
+    {
+      "name":"app_name",
+      "value":"LifecycleHap2Test"
+    }
+  ]
+}      
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//test/xts/tools/build/suite.gni")
+
+ohos_js_hap_suite("ActsLifecycleMultiHap2Test") {
+  hap_profile = "entry/src/main/module.json"
+  deps = [
+    ":actslifecyclemultihap2test_js_assets",
+    ":actslifecyclemultihap2test_resources",
+  ]
+  ets2abc = true
+  certificate_profile = "signature/openharmony_sx.p7b"
+  hap_name = "ActsLifecycleMultiHap2Test"
+}
+
+ohos_app_scope("actslifecyclemultihap2test_app_profile") {
+  app_profile = "AppScope/app.json"
+  sources = [ "AppScope/resources" ]
+}
+
+ohos_js_assets("actslifecyclemultihap2test_js_assets") {
+  source_dir = "entry/src/main/ets"
+}
+
+ohos_resources("actslifecyclemultihap2test_resources") {
+  sources = [ "entry/src/main/resources" ]
+  deps = [ ":actslifecyclemultihap2test_app_profile" ]
+  hap_profile = "entry/src/main/module.json"
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/Test.json

+{
+    "description": "Configuration for hjunit demo Tests",
+    "driver": {
+        "type": "JSUnitTest",
+        "test-timeout": "180000",
+        "package": "com.example.lifecycletest",
+        "shell-timeout": "600000"
+    },
+    "kits": [
+        {
+            "test-file-name": [
+                "ActsLifecycleMultiHap2Test.hap"
+            ],
+            "type": "AppInstallKit",
+            "cleanup-apps": true
+        }
+    ] 
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Application/AbilityStage.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import AbilityStage from "@ohos.application.AbilityStage"
+
+export default class MyAbilityStage extends AbilityStage {
+    onCreate() {
+        console.log("[Demo] MyAbilityStage onCreate")
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility1/Hap2MainAbility1.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility1 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility1 onCreate")
+        globalThis.abilityWant = want;
+
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility1 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility1 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility1_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility1 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility1 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility1 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility10/Hap2MainAbility10.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility10 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility10 onCreate")
+        globalThis.abilityWant = want;
+
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility10 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility10 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility10_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility10 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility10 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility10 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility2/Hap2MainAbility2.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility2 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility2 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility2 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility2 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility2_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility2 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility2 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility2 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility3/Hap2MainAbility3.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility3 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility3 onCreate")
+        globalThis.abilityWant = want;
+
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap2MainAbility3 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap2MainAbility3 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 2000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility3 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility3 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility3_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility3 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility3 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility3 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility4/Hap2MainAbility4.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility4 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility4 onCreate")
+        globalThis.abilityWant = want;
+
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap2MainAbility4 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap2MainAbility4 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 2000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility4 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility4 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility4_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility4 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility4 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility4 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility5/Hap2MainAbility5.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility5 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility5 onCreate")
+        globalThis.abilityWant = want;
+
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap2MainAbility5 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap2MainAbility5 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 2000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility5 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility5 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility5_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility5 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility5 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility5 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility6/Hap2MainAbility6.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility6 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility6 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility6 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility6 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility6_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility6 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility6 onForeground")
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap2MainAbility6 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap2MainAbility6 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 2000)
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility6 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility7/Hap2MainAbility7.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility7 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility7 onCreate")
+        globalThis.abilityWant = want;
+
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap2MainAbility7 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap2MainAbility7 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 2000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility7 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility7 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility7_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility7 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility7 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility7 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility8/Hap2MainAbility8.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility8 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility8 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility8 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility8 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility8_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resourcesl
+        console.log("[Demo] Hap2MainAbility8 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility8 onForeground")
+
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap2MainAbility8 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap2MainAbility8 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 500)
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility8 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/Hap2MainAbility9/Hap2MainAbility9.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Ability from '@ohos.application.Ability'
+
+export default class Hap2MainAbility9 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap2MainAbility9 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap2MainAbility9 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap2MainAbility9 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap2MainAbility9_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap2MainAbility9 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap2MainAbility9 onForeground")
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap2MainAbility9 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap2MainAbility9 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 500)
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap2MainAbility9 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility10_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility10_pages {
+  @State message: string = 'Hap2MainAbility10'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility1_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility1_pages {
+  @State message: string = 'Hap2MainAbility1'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility2_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility2_pages {
+  @State message: string = 'Hap2MainAbility2'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility3_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility3_pages {
+  @State message: string = 'Hap2MainAbility3'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility4_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility4_pages {
+  @State message: string = 'Hap2MainAbility4'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility5_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility5_pages {
+  @State message: string = 'Hap2MainAbility5'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility6_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility6_pages {
+  @State message: string = 'Hap2MainAbility6'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility7_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility7_pages {
+  @State message: string = 'Hap2MainAbility7'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility8_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility8_pages {
+  @State message: string = 'Hap2MainAbility8'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/ets/pages/Hap2MainAbility9_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap2MainAbility9_pages {
+  @State message: string = 'Hap2MainAbility9'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/module.json

+{
+    "module": {
+        "name": "hap2",
+        "type": "feature",
+        "srcEntrance": "./ets/Application/AbilityStage.ts",
+        "description": "$string:hap2_desc",
+        "mainElement": "MainAbility",
+        "deviceTypes": [
+            "phone"
+        ],
+        "deliveryWithInstall": true,
+        "installationFree": false,
+        "uiSyntax": "ets",
+        "pages": "$profile:main_pages",
+        "abilities": [{
+            "name": "com.example.lifecycletest.Hap2MainAbility1",
+            "srcEntrance": "./ets/Hap2MainAbility1/Hap2MainAbility1.ts",
+            "description": "$string:Hap2MainAbility1_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility1_label",
+            "visible": true,
+            "orientation": "portrait",
+            "skills": [{
+                "actions": [
+                    "action.system.home"
+                ],
+                "entities": [
+                    "entity.system.home"
+                ]
+            }]
+        },
+        {
+            "name": "Hap2MainAbility2",
+            "srcEntrance": "./ets/Hap2MainAbility2/Hap2MainAbility2.ts",
+            "description": "$string:Hap2MainAbility2_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility2_label"
+          },
+          {
+            "name": "Hap2MainAbility3",
+            "srcEntrance": "./ets/Hap2MainAbility3/Hap2MainAbility3.ts",
+            "description": "$string:Hap2MainAbility3_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility3_label"
+          },
+          {
+            "name": "Hap2MainAbility4",
+            "srcEntrance": "./ets/Hap2MainAbility4/Hap2MainAbility4.ts",
+            "description": "$string:Hap2MainAbility4_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility4_label",
+            "launchType": "singleton"
+          },
+          {
+            "name": "Hap2MainAbility5",
+            "srcEntrance": "./ets/Hap2MainAbility5/Hap2MainAbility5.ts",
+            "description": "$string:Hap2MainAbility5_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility5_label",
+            "launchType": "standard"
+          },
+          {
+            "name": "Hap2MainAbility6",
+            "srcEntrance": "./ets/Hap2MainAbility6/Hap2MainAbility6.ts",
+            "description": "$string:Hap2MainAbility6_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility6_label"
+          },
+          {
+            "name": "Hap2MainAbility7",
+            "srcEntrance": "./ets/Hap2MainAbility7/Hap2MainAbility7.ts",
+            "description": "$string:Hap2MainAbility7_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility7_label"
+          },
+          {
+            "name": "Hap2MainAbility8",
+            "srcEntrance": "./ets/Hap2MainAbility8/Hap2MainAbility8.ts",
+            "description": "$string:Hap2MainAbility8_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility8_label"
+          },
+          {
+            "name": "Hap2MainAbility9",
+            "srcEntrance": "./ets/Hap2MainAbility9/Hap2MainAbility9.ts",
+            "description": "$string:Hap2MainAbility9_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility9_label"
+          },
+          {
+            "name": "Hap2MainAbility10",
+            "srcEntrance": "./ets/Hap2MainAbility10/Hap2MainAbility10.ts",
+            "description": "$string:Hap2MainAbility10_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap2MainAbility10_label"
+          }],
+          "requestPermissions": [
+            {
+            "name": "ohos.permission.GET_BUNDLE_INFO"
+            },
+            {
+            "name": "ohos.permission.MANAGE_MISSIONS"
+            },
+            {
+            "name": "ohos.permission.INSTALL_BUNDLE"
+            },
+            {
+            "name": "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED"
+            },
+            {
+            "name": "ohos.permission.CHANGE_ABILITY_ENABLED_STATE"
+            },
+            {
+            "name": "ohos.permission.REMOVE_CACHE_FILES"
+            },
+            {
+            "name": "ohos.permission.LISTEN_BUNDLE_CHANGE"
+            }
+          ] 
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/resources/base/element/string.json

+{
+  "string":  [
+      {
+          "name": "phone_entry_dsc",
+          "value": "i am an entry for phone"
+      },
+      {
+          "name": "phone_entry_main",
+          "value": "the phone entry ability"
+      },
+      {
+          "name": "entry_label",
+          "value": "ActsLifecycleMultihapTest"
+      },
+      {
+          "name": "form_description",
+          "value": "my form"
+      },
+      {
+        "name": "description_application",
+        "value": "demo for test"
+      },
+      {
+        "name": "entry_desc",
+        "value": "description"
+      },
+      {
+        "name": "hap2_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility1_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility1_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility2_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility2_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility3_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility3_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility4_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility4_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility5_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility5_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility6_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility6_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility7_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility7_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility8_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility8_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility9_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility9_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap2MainAbility10_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap2MainAbility10_label",
+        "value": "label"
+      }
+  ]
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap2test/entry/src/main/resources/base/profile/main_pages.json

+{
+  "src": [
+    "pages/Hap2MainAbility1_pages",
+    "pages/Hap2MainAbility2_pages",
+    "pages/Hap2MainAbility3_pages",
+    "pages/Hap2MainAbility4_pages",
+    "pages/Hap2MainAbility5_pages",
+    "pages/Hap2MainAbility6_pages",
+    "pages/Hap2MainAbility7_pages",
+    "pages/Hap2MainAbility8_pages",
+    "pages/Hap2MainAbility9_pages",
+    "pages/Hap2MainAbility10_pages"
+  ]
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/AppScope/app.json

+{
+    "app": {
+        "bundleName": "com.example.lifecycletest",
+        "vendor": "huawei",
+        "versionCode": 1000000,
+        "versionName": "1.0.0",
+        "debug": false,
+        "icon": "$media:icon",
+        "label": "$string:app_name",
+        "description": "$string:description_application",
+        "distributedNotificationEnabled": true,
+        "keepAlive": true,
+        "singleUser": true,
+        "minAPIVersion": 9,
+        "targetAPIVersion": 9,
+        "car": {
+            "apiCompatibleVersion": 9,
+            "singleUser": false
+        }
+    }
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/AppScope/resources/base/element/string.json

+{
+ "string":[
+    {
+      "name":"app_name",
+      "value":"LifecycleHap3Test"
+    }
+  ]
+}      
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//test/xts/tools/build/suite.gni")
+
+ohos_js_hap_suite("ActsLifecycleMultiHap3Test") {
+  hap_profile = "entry/src/main/module.json"
+  deps = [
+    ":actslifecyclemultihap3test_js_assets",
+    ":actslifecyclemultihap3test_resources",
+  ]
+  ets2abc = true
+  certificate_profile = "signature/openharmony_sx.p7b"
+  hap_name = "ActsLifecycleMultiHap3Test"
+}
+
+ohos_app_scope("actslifecyclemultihap3test_app_profile") {
+  app_profile = "AppScope/app.json"
+  sources = [ "AppScope/resources" ]
+}
+
+ohos_js_assets("actslifecyclemultihap3test_js_assets") {
+  source_dir = "entry/src/main/ets"
+}
+
+ohos_resources("actslifecyclemultihap3test_resources") {
+  sources = [ "entry/src/main/resources" ]
+  deps = [ ":actslifecyclemultihap3test_app_profile" ]
+  hap_profile = "entry/src/main/module.json"
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/Test.json

+{
+    "description": "Configuration for hjunit demo Tests",
+    "driver": {
+        "type": "JSUnitTest",
+        "test-timeout": "180000",
+        "package": "com.example.lifecycletest",
+        "shell-timeout": "600000"
+    },
+    "kits": [
+        {
+            "test-file-name": [
+                "ActsLifecycleMultiHap3Test.hap"
+            ],
+            "type": "AppInstallKit",
+            "cleanup-apps": true
+        }
+    ] 
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/ets/Application/AbilityStage.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import AbilityStage from "@ohos.application.AbilityStage"
+
+export default class MyAbilityStage extends AbilityStage {
+    onCreate() {
+        console.log("[Demo] MyAbilityStage onCreate")
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/ets/Hap3MainAbility1/Hap3MainAbility1.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import commonEvent from '@ohos.commonEvent';
+import Ability from '@ohos.application.Ability'
+
+export default class Hap3MainAbility1 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap3MainAbility1 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap3MainAbility1 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap3MainAbility1 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap3MainAbility1_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap3MainAbility1 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap3MainAbility1 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap3MainAbility1 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/ets/Hap3MainAbility2/Hap3MainAbility2.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap3MainAbility2 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap3MainAbility2 onCreate")
+        globalThis.abilityWant = want;
+
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap3MainAbility2 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap3MainAbility2 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 2000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap3MainAbility2 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap3MainAbility2 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap3MainAbility2_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap3MainAbility2 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap3MainAbility2 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap3MainAbility2 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/ets/Hap3MainAbility3/Hap3MainAbility3.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import commonEvent from '@ohos.commonEvent';
+import Ability from '@ohos.application.Ability'
+
+export default class Hap3MainAbility3 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap3MainAbility3 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap3MainAbility3 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap3MainAbility3 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap3MainAbility3_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap3MainAbility3 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap3MainAbility3 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap3MainAbility3 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/ets/pages/Hap3MainAbility1_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap3MainAbility1_pages {
+  @State message: string = 'Hap3MainAbility1'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/ets/pages/Hap3MainAbility2_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap3MainAbility2_pages {
+  @State message: string = 'Hap3MainAbility2'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/ets/pages/Hap3MainAbility3_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Hap3MainAbility3_pages {
+  @State message: string = 'Hap3MainAbility3'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/module.json

+{
+    "module": {
+        "name": "hap3",
+        "type": "feature",
+        "srcEntrance": "./ets/Application/AbilityStage.ts",
+        "description": "$string:hap3_desc",
+        "mainElement": "MainAbility",
+        "deviceTypes": [
+            "phone"
+        ],
+        "deliveryWithInstall": true,
+        "installationFree": false,
+        "uiSyntax": "ets",
+        "pages": "$profile:main_pages",
+        "abilities": [{
+            "name": "com.example.lifecycletest.Hap3MainAbility1",
+            "srcEntrance": "./ets/Hap3MainAbility1/Hap3MainAbility1.ts",
+            "description": "$string:Hap3MainAbility1_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap3MainAbility1_label",
+            "visible": true,
+            "orientation": "portrait",
+            "skills": [{
+                "actions": [
+                    "action.system.home"
+                ],
+                "entities": [
+                    "entity.system.home"
+                ]
+            }]
+        },
+        {
+            "name": "Hap3MainAbility2",
+            "srcEntrance": "./ets/Hap3MainAbility2/Hap3MainAbility2.ts",
+            "description": "$string:Hap3MainAbility2_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap3MainAbility2_label"
+          },
+          {
+            "name": "Hap3MainAbility3",
+            "srcEntrance": "./ets/Hap3MainAbility3/Hap3MainAbility3.ts",
+            "description": "$string:Hap3MainAbility3_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap3MainAbility3_label"
+          }],
+          "requestPermissions": [
+            {
+            "name": "ohos.permission.GET_BUNDLE_INFO"
+            },
+            {
+            "name": "ohos.permission.MANAGE_MISSIONS"
+            },
+            {
+            "name": "ohos.permission.INSTALL_BUNDLE"
+            },
+            {
+            "name": "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED"
+            },
+            {
+            "name": "ohos.permission.CHANGE_ABILITY_ENABLED_STATE"
+            },
+            {
+            "name": "ohos.permission.REMOVE_CACHE_FILES"
+            },
+            {
+            "name": "ohos.permission.LISTEN_BUNDLE_CHANGE"
+            }
+          ] 
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/resources/base/element/string.json

+{
+  "string":  [
+      {
+          "name": "phone_entry_dsc",
+          "value": "i am an entry for phone"
+      },
+      {
+          "name": "phone_entry_main",
+          "value": "the phone entry ability"
+      },
+      {
+          "name": "entry_label",
+          "value": "ActsLifecycleMultihapTest"
+      },
+      {
+          "name": "form_description",
+          "value": "my form"
+      },
+      {
+        "name": "description_application",
+        "value": "demo for test"
+      },
+      {
+        "name": "entry_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_label",
+        "value": "label"
+      },
+      {
+        "name": "hap3_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap3MainAbility1_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap3MainAbility1_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap3MainAbility2_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap3MainAbility2_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap3MainAbility3_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap3MainAbility3_label",
+        "value": "label"
+      }
+  ]
+}

aafwk/aafwk_standard/stage/actslifecyclemultihap3test/entry/src/main/resources/base/profile/main_pages.json

+{
+  "src": [
+    "pages/Hap3MainAbility1_pages",
+    "pages/Hap3MainAbility2_pages",
+    "pages/Hap3MainAbility3_pages"
+  ]
+}

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/AppScope/app.json

+{
+    "app": {
+        "bundleName": "com.example.lifecycletest",
+        "vendor": "huawei",
+        "versionCode": 1000000,
+        "versionName": "1.0.0",
+        "debug": false,
+        "icon": "$media:icon",
+        "label": "$string:app_name",
+        "description": "$string:description_application",
+        "distributedNotificationEnabled": true,
+        "keepAlive": true,
+        "singleUser": true,
+        "minAPIVersion": 9,
+        "targetAPIVersion": 9,
+        "car": {
+            "apiCompatibleVersion": 9,
+            "singleUser": false
+        }
+    }
+}

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/AppScope/resources/base/element/string.json

+{
+ "string":[
+    {
+      "name":"app_name",
+      "value":"LifecycleTest"
+    }
+  ]
+}      
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//test/xts/tools/build/suite.gni")
+
+ohos_js_hap_suite("ActsLifecycleMultiHapTest") {
+  hap_profile = "entry/src/main/module.json"
+  deps = [
+    ":actslifecyclemultihaptest_js_assets",
+    ":actslifecyclemultihaptest_resources",
+  ]
+  ets2abc = true
+  certificate_profile = "signature/openharmony_sx.p7b"
+  hap_name = "ActsLifecycleMultiHapTest"
+}
+
+ohos_app_scope("actslifecyclemultihaptest_app_profile") {
+  app_profile = "AppScope/app.json"
+  sources = [ "AppScope/resources" ]
+}
+
+ohos_js_assets("actslifecyclemultihaptest_js_assets") {
+  source_dir = "entry/src/main/ets"
+}
+
+ohos_resources("actslifecyclemultihaptest_resources") {
+  sources = [ "entry/src/main/resources" ]
+  deps = [ ":actslifecyclemultihaptest_app_profile" ]
+  hap_profile = "entry/src/main/module.json"
+}

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/Test.json

+{
+    "description": "Configuration for hjunit demo Tests",
+    "driver": {
+        "type": "JSUnitTest",
+        "test-timeout": "180000",
+        "package": "com.example.lifecycletest",
+        "shell-timeout": "600000"
+    },
+    "kits": [
+        {
+            "test-file-name": [
+                "ActsLifecycleMultiHapTest.hap",
+                "ActsLifecycleMultiHap2Test.hap",
+                "ActsLifecycleMultiHap3Test.hap"
+            ],
+            "type": "AppInstallKit",
+            "cleanup-apps": true
+        }
+    ] 
+}

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/Application/AbilityStage.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import AbilityStage from "@ohos.application.AbilityStage"
+
+export default class MyAbilityStage extends AbilityStage {
+    onCreate() {
+        console.log("[Demo] MyAbilityStage onCreate")
+        globalThis.stageOnCreateRun = 1;
+        globalThis.stageContext = this.context;
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/MainAbility/MainAbility.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility extends Ability {
+
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility onWindowStageCreate")
+        globalThis.abilityContext = this.context;
+        windowStage.setUIContent(this.context, "pages/MainAbility_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/MainAbility1/MainAbility1.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility1 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility1 onCreate")
+        globalThis.abilityWant = want;
+
+        var listKey = [];
+        var abilityName = "";
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityCreate")
+                listKey.push(abilityName +" onAbilityCreate");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityWindowStageCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityWindowStageCreate")
+                listKey.push(abilityName +" onAbilityWindowStageCreate");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityForeground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityForeground")
+                listKey.push(abilityName +" onAbilityForeground");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityBackground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityBackground")
+                listKey.push(abilityName +" onAbilityBackground");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityWindowStageDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityWindowStageDestroy")
+                listKey.push(abilityName +" onAbilityWindowStageDestroy");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityDestroy")
+                listKey.push(abilityName +" onAbilityDestroy");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityContinue(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityContinue")
+                listKey.push(abilityName +" onAbilityContinue");
+                console.log("listKey is :" + listKey);
+            }
+        }
+
+        globalThis.mainAbility1ListKey = listKey
+        var callBackId = this.context.getApplicationContext().registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        globalThis.mainAbility1CallBackId = callBackId
+        setTimeout(() => {
+            console.log("listKey is :" + listKey);
+            console.log("callBackId is :" + callBackId);
+            this.context.getApplicationContext().unregisterAbilityLifecycleCallback  (callBackId, (error, data)=> {
+                console.log("unRegisterAbilityLifecycleCallback err is :" +
+                JSON.stringify(error) + ",data is : " + JSON.stringify(data))
+            });
+        }, 4000)
+
+
+        setTimeout(()=>{
+            this.context.terminateSelf().then((data) => {
+                console.log("[Demo] MainAbility1 terminateSelf windowStage data: " + JSON.stringify(data))
+            }).catch((error) => {
+                console.log("[Demo] MainAbility1 terminateSelf windowStage error: " + JSON.stringify(error))
+            })
+        }, 3000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility1 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility1 onWindowStageCreate")
+        globalThis.ability2Context = this.context;
+        windowStage.setUIContent(this.context, "pages/MainAbility1_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility1 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility1 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility1 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/MainAbility2/MainAbility2.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility2 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility2 onCreate")
+        globalThis.abilityWant = want;
+
+        var listKey = [];
+        var abilityName = "";
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityCreate")
+                listKey.push(abilityName +" onAbilityCreate");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityWindowStageCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityWindowStageCreate")
+                listKey.push(abilityName +" onAbilityWindowStageCreate");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityForeground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityForeground")
+                listKey.push(abilityName +" onAbilityForeground");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityBackground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityBackground")
+                listKey.push(abilityName +" onAbilityBackground");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityWindowStageDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityWindowStageDestroy")
+                listKey.push(abilityName +" onAbilityWindowStageDestroy");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityDestroy")
+                listKey.push(abilityName +" onAbilityDestroy");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityContinue(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityContinue")
+                listKey.push(abilityName +" onAbilityContinue");
+                console.log("listKey is :" + listKey);
+            }
+        }
+
+        var callBackId = this.context.getApplicationContext().registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+
+        setTimeout(() => {
+            globalThis.mainAbility2ListKey = listKey
+            globalThis.mainAbility2CallBackId = callBackId
+            console.log("listKey is :" + listKey);
+            console.log("callBackId is :" + callBackId);
+        }, 3000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility2 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility2 onWindowStageCreate")
+        globalThis.ability3Context = this.context;
+        windowStage.setUIContent(this.context, "pages/MainAbility2_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility2 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility2 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/MainAbility3/MainAbility3.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import commonEvent from '@ohos.commonEvent';
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility3 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility3 onCreate")
+        globalThis.abilityWant = want;
+
+        var getauxMainAbilityContext = {
+            events: ["auxMainAbilityContext"]
+        }
+
+
+        var a;
+        function SubscribeCallBackContext(err, data) {
+            console.log(" Subscribe CallBack data:" + JSON.stringify(data));
+            a = data.parameters;
+            if(data.event != ""){
+                for (var key in data.parameters){
+                    console.log("data.parameters[key] is :" + data.parameters[key])
+                }
+            }
+        }
+
+        commonEvent.createSubscriber(getauxMainAbilityContext).then(async (data) => {
+            console.debug("====>Create Subscriber====>");
+            var Subscriber = data;
+            await commonEvent.subscribe(Subscriber, SubscribeCallBackContext);
+        });
+
+        var listKey = [];
+        var abilityName = "";
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityCreate")
+                listKey.push(abilityName +" onAbilityCreate");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityWindowStageCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityWindowStageCreate")
+                listKey.push(abilityName +" onAbilityWindowStageCreate");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityForeground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityForeground")
+                listKey.push(abilityName +" onAbilityForeground");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityBackground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityBackground")
+                listKey.push(abilityName +" onAbilityBackground");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityWindowStageDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityWindowStageDestroy")
+                listKey.push(abilityName +" onAbilityWindowStageDestroy");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityDestroy")
+                listKey.push(abilityName +" onAbilityDestroy");
+                console.log("listKey is :" + listKey);
+            },
+            onAbilityContinue(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName +" onAbilityContinue")
+                listKey.push(abilityName +" onAbilityContinue");
+                console.log("listKey is :" + listKey);
+            }
+        }
+
+        setTimeout(() => {
+            console.log("mainAbility3ListKey a is : " + JSON.stringify(a))
+            //TODO:
+            var callBackId = a.auxMainAbilityContext.getApplicationContext().
+            registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+            console.log("mainAbility3ListKey callBackId is : " + callBackId)
+            globalThis.mainAbility3ListKey = listKey
+            console.log("mainAbility3ListKey mainAbility3ListKey is : " + globalThis.mainAbility3ListKey)
+            globalThis.mainAbility3CallBackId = callBackId
+            console.log("mainAbility3ListKey listKey is :" + listKey);
+            console.log("mainAbility3ListKey globalThis.callBackId is :" + globalThis.callBackId);
+        }, 3000)
+
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility3 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility3 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/MainAbility3_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility3 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility3 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility3 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/MainAbility4/MainAbility4.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility4 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility4 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility4 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility4 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/MainAbility4_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility4 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility4 onForeground")
+
+        var listKey = [];
+        var abilityName = "";
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityCreate")
+                listKey.push(abilityName+" onAbilityCreate");
+            },
+            onAbilityWindowStageCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityWindowStageCreate")
+                listKey.push(abilityName+" onAbilityWindowStageCreate");
+            },
+            onAbilityForeground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityForeground")
+                listKey.push(abilityName+" onAbilityForeground");
+            },
+            onAbilityBackground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityBackground")
+                listKey.push(abilityName+" onAbilityBackground");
+            },
+            onAbilityWindowStageDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityWindowStageDestroy")
+                listKey.push(abilityName+" onAbilityWindowStageDestroy");
+            },
+            onAbilityDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityDestroy")
+                listKey.push(abilityName+" onAbilityDestroy");
+            },
+            onAbilityContinue(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityContinue")
+                listKey.push(abilityName+" onAbilityContinue");
+            }
+        }
+        var callBackId = this.context.getApplicationContext().registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        globalThis.abilityContext111 = this.context;
+        console.log("callBackId is aaa :" + callBackId);
+        setTimeout(() => {
+            globalThis.mainAbility4ListKey = listKey
+            globalThis.mainAbility4CallBackId = callBackId
+            console.log("listKey is :" + listKey);
+            console.log("callBackId is :" + callBackId);
+        }, 3000)
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility4 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/MainAbility5/MainAbility5.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility5 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility5 onCreate")
+        globalThis.abilityWant = want;
+
+        var listKey = [];
+        var abilityName = "";
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityCreate")
+                listKey.push(abilityName+" onAbilityCreate");
+            },
+            onAbilityWindowStageCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityWindowStageCreate")
+                listKey.push(abilityName+" onAbilityWindowStageCreate");
+            },
+            onAbilityForeground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityForeground")
+                listKey.push(abilityName+" onAbilityForeground");
+            },
+            onAbilityBackground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityBackground")
+                listKey.push(abilityName+" onAbilityBackground");
+            },
+            onAbilityWindowStageDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityWindowStageDestroy")
+                listKey.push(abilityName+" onAbilityWindowStageDestroy");
+            },
+            onAbilityDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityDestroy")
+                listKey.push(abilityName+" onAbilityDestroy");
+            },
+            onAbilityContinue(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityContinue")
+                listKey.push(abilityName+" onAbilityContinue");
+            }
+        }
+        var callBackId = this.context.getApplicationContext().registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("callBackId is aaa :" + callBackId);
+
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap2MainAbility6 EventTest terminateSelf data: " + JSON.stringify(data));
+                globalThis.mainAbility5ListKey = listKey
+                globalThis.mainAbility5CallBackId = callBackId
+                console.log("listKey is :" + listKey);
+                console.log("callBackId is :" + callBackId);
+            }).catch((error) => {
+                console.log("Hap2MainAbility6 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 1000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility5 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility5 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/MainAbility5_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility5 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility5 onForeground")
+
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility5 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/MainAbility6/MainAbility6.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility6 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility6 onCreate")
+        globalThis.abilityWant = want;
+
+        var listKey = [];
+        var abilityName = "";
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityCreate")
+                listKey.push(abilityName+" onAbilityCreate");
+            },
+            onAbilityWindowStageCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityWindowStageCreate")
+                listKey.push(abilityName+" onAbilityWindowStageCreate");
+            },
+            onAbilityForeground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityForeground")
+                listKey.push(abilityName+" onAbilityForeground");
+            },
+            onAbilityBackground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityBackground")
+                listKey.push(abilityName+" onAbilityBackground");
+            },
+            onAbilityWindowStageDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityWindowStageDestroy")
+                listKey.push(abilityName+" onAbilityWindowStageDestroy");
+            },
+            onAbilityDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityDestroy")
+                listKey.push(abilityName+" onAbilityDestroy");
+            },
+            onAbilityContinue(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName+" onAbilityContinue")
+                listKey.push(abilityName+" onAbilityContinue");
+            }
+        }
+        var callBackId = this.context.getApplicationContext().registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("callBackId is aaa :" + callBackId);
+        setTimeout(() => {
+            globalThis.mainAbility6ListKey = listKey
+            globalThis.mainAbility6CallBackId = callBackId
+            console.log("listKey is :" + listKey);
+            console.log("callBackId is :" + callBackId);
+        }, 3000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility6 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility6 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/MainAbility6_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility6 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility6 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility6 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/pages/MainAbility1_pages.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct MainAbility1_pages {
+  @State message: string = 'MainAbility1'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/pages/MainAbility2_pages.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct MainAbility2_pages {
+  @State message: string = 'MainAbility2'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/pages/MainAbility3_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct MainAbility3_pages {
+  @State message: string = 'MainAbility3_pages'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/pages/MainAbility4_pages.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct MainAbility4_pages {
+  @State message: string = 'MainAbility4'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/pages/MainAbility5_pages.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct MainAbility5_pages {
+  @State message: string = 'MainAbility5'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/pages/MainAbility6_pages.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct MainAbility6_pages {
+  @State message: string = 'MainAbility6'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/pages/MainAbility_pages.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import file from '@system.file';
+import {Core, ExpectExtend, InstrumentLog, ReportExtend} from "deccjsunit/index.ets"
+import list from '../test/ListTest'
+
+@Entry
+@Component
+struct Index {
+  @State message: string = 'MainAbility'
+
+  aboutToAppear() {
+    console.info("start run testcase!!!!")
+    const core = Core.getInstance()
+    const expectExtend = new ExpectExtend({
+      'id': 'extend'
+    })
+    core.addService('expect', expectExtend)
+    const reportExtend = new ReportExtend(file)
+
+    core.addService('report', reportExtend)
+    core.init()
+    globalThis.abilityWant.parameters.timeout = 20000;
+
+    core.subscribeEvent('task', reportExtend)
+    const configService = core.getDefaultService('config')
+    configService.setConfig(globalThis.abilityWant.parameters)
+    console.info('parameters---->' + JSON.stringify(globalThis.abilityWant.parameters))
+    list(globalThis.abilityContext)
+    core.execute()
+  }
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/test/LifecycleTest.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from "deccjsunit/index"
+
+export default function abilityTest(abilityContext){
+
+  describe('AbilityTest', function() {
+
+    console.info("-----------------LifecycleTest is start----------------")
+
+    var TAG;
+    var listKeyTemp = [];
+    var listKeyTemp1 = [];
+
+
+    function sleep(time) {
+      return new Promise((resolve) => setTimeout(resolve, time))
+    }
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_001
+     * @tc.name    The ability of HAP A listens to the ability lifecycle callback of HAP B
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Multihap_LifecycleTest_001", 0, async function (done) {
+      console.info("---------------Multihap_LifecycleTest_001 is start---------------")
+      TAG = "Multihap_LifecycleTest_001";
+      listKeyTemp = [];
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility3"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": Hap2MainAbility3 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          for (var i = 0;i < globalThis.mainAbility4ListKey.length; i++) {
+            if (globalThis.mainAbility4ListKey[i].substring(0, 16) == "Hap2MainAbility3") {
+              listKeyTemp.push(globalThis.mainAbility4ListKey[i]);
+            }
+          }
+          console.log(TAG +  "listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + "globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+          expect(listKeyTemp[0]).assertEqual("Hap2MainAbility3 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap2MainAbility3 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap2MainAbility3 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap2MainAbility3 onAbilityBackground");
+          expect(listKeyTemp[4]).assertEqual("Hap2MainAbility3 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[5]).assertEqual("Hap2MainAbility3 onAbilityDestroy");
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              expect(error.code == 0).assertTrue()
+              done();
+            });
+        }, 4000)
+      });
+      console.info("---------------Multihap_LifecycleTest_001 is end---------------")
+    });
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_002
+     * @tc.name    The ability of HAP A listens to the ability lifecycle callback of HAP B (single instance)
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Multihap_LifecycleTest_002", 0, async function (done) {
+      console.log("------------Multihap_LifecycleTest_002 start-------------");
+      TAG = "Multihap_LifecycleTest_002";
+      listKeyTemp = [];
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ":first Hap2MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility4"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": second Hap2MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          for(var i = 0; i<globalThis.mainAbility4ListKey.length;i++){
+            if(globalThis.mainAbility4ListKey[i].substring(0,16)=="Hap2MainAbility4"){
+              listKeyTemp.push(globalThis.mainAbility4ListKey[i]);
+            }
+          }
+          console.log(TAG + "listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + "globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+          expect(listKeyTemp[0]).assertEqual("Hap2MainAbility4 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap2MainAbility4 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap2MainAbility4 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap2MainAbility4 onAbilityBackground");
+          expect(listKeyTemp[4]).assertEqual("Hap2MainAbility4 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[5]).assertEqual("Hap2MainAbility4 onAbilityDestroy");
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              expect(error.code == 0).assertTrue()
+              done();
+            });
+        }, 3000)
+      });
+      console.log("------------Multihap_LifecycleTest_002 end-------------");
+    });
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_003
+     * @tc.name    The ability of HAP A listens to the ability lifecycle callback of HAP B (multiple cases)
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Multihap_LifecycleTest_003", 0, async function (done) {
+      console.log("------------Multihap_LifecycleTest_003 start-------------");
+      TAG = "Multihap_LifecycleTest_003";
+      listKeyTemp = [];
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility5"
+      }, (error, data) => {
+        console.log(TAG + ":first Hap2MainAbility5 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility5"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": second Hap2MainAbility5 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          for(var i = 0;i<globalThis.mainAbility4ListKey.length;i++){
+            if(globalThis.mainAbility4ListKey[i].substring(0,16)=="Hap2MainAbility5"){
+              listKeyTemp.push(globalThis.mainAbility4ListKey[i]);
+            }
+          }
+          console.log(TAG + "listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + "globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+          expect(listKeyTemp[0]).assertEqual("Hap2MainAbility5 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap2MainAbility5 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap2MainAbility5 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap2MainAbility5 onAbilityCreate");
+          expect(listKeyTemp[4]).assertEqual("Hap2MainAbility5 onAbilityWindowStageCreate");
+          expect(listKeyTemp[5]).assertEqual("Hap2MainAbility5 onAbilityForeground");
+          expect(listKeyTemp[6]).assertEqual("Hap2MainAbility5 onAbilityBackground");
+          expect(listKeyTemp[7]).assertEqual("Hap2MainAbility5 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[8]).assertEqual("Hap2MainAbility5 onAbilityDestroy");
+          expect(listKeyTemp[9]).assertEqual("Hap2MainAbility5 onAbilityBackground");
+          expect(listKeyTemp[10]).assertEqual("Hap2MainAbility5 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[11]).assertEqual("Hap2MainAbility5 onAbilityDestroy");
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              expect(error.code == 0).assertTrue()
+              done();
+            });
+        }, 3000)
+      });
+      console.log("------------Multihap_LifecycleTest_003 end-------------");
+    });
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_004
+     * @tc.name    The ability of HAP A monitors the ability life cycle callback of HAP B and HAP C
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Multihap_LifecycleTest_004", 0, async function (done) {
+      console.log("------------Multihap_LifecycleTest_004 start-------------");
+      TAG = "Multihap_LifecycleTest_004";
+      listKeyTemp = [];
+      listKeyTemp1 = [];
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility6"
+      }, (error, data) => {
+        console.log(TAG + ":first Hap2MainAbility6 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap3MainAbility2"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": second Hap3MainAbility2 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          for(var i = 0;i<globalThis.mainAbility4ListKey.length;i++){
+            if(globalThis.mainAbility4ListKey[i].substring(0,16)=="Hap2MainAbility6"){
+              listKeyTemp.push(globalThis.mainAbility4ListKey[i]);
+            }else if(globalThis.mainAbility4ListKey[i].substring(0,16)=="Hap3MainAbility2"){
+              listKeyTemp1.push(globalThis.mainAbility4ListKey[i]);
+            }
+          }
+          console.log(TAG + "listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + "listKeyTemp1 is :" + listKeyTemp1);
+          console.log(TAG + "globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+          expect(listKeyTemp[0]).assertEqual("Hap2MainAbility6 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap2MainAbility6 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap2MainAbility6 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap2MainAbility6 onAbilityBackground");
+          expect(listKeyTemp[4]).assertEqual("Hap2MainAbility6 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[5]).assertEqual("Hap2MainAbility6 onAbilityDestroy");
+
+          expect(listKeyTemp1[0]).assertEqual("Hap3MainAbility2 onAbilityCreate");
+          expect(listKeyTemp1[1]).assertEqual("Hap3MainAbility2 onAbilityWindowStageCreate");
+          expect(listKeyTemp1[2]).assertEqual("Hap3MainAbility2 onAbilityForeground");
+          expect(listKeyTemp1[3]).assertEqual("Hap3MainAbility2 onAbilityBackground");
+          expect(listKeyTemp1[4]).assertEqual("Hap3MainAbility2 onAbilityWindowStageDestroy");
+          expect(listKeyTemp1[5]).assertEqual("Hap3MainAbility2 onAbilityDestroy");
+
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              expect(error.code == 0).assertTrue()
+              done();
+            });
+        }, 3000)
+      });
+      console.log("------------Multihap_LifecycleTest_004 end-------------");
+    });
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_005
+     * @tc.name    The ability of HAP A listens to two ability life cycle callbacks in HAP B
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Multihap_LifecycleTest_005", 0, async function (done) {
+      console.log("------------Multihap_LifecycleTest_005 start-------------");
+      TAG = "Multihap_LifecycleTest_005";
+      listKeyTemp = [];
+      listKeyTemp1 = [];
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility6"
+      }, (error, data) => {
+        console.log(TAG + ":first Hap2MainAbility6 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility7"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": second Hap2MainAbility7 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          for(var i = 0;i<globalThis.mainAbility4ListKey.length;i++){
+            if(globalThis.mainAbility4ListKey[i].substring(0,16)=="Hap2MainAbility6"){
+              listKeyTemp.push(globalThis.mainAbility4ListKey[i]);
+            }else if(globalThis.mainAbility4ListKey[i].substring(0,16)=="Hap2MainAbility7"){
+              listKeyTemp1.push(globalThis.mainAbility4ListKey[i]);
+            }
+          }
+          console.log(TAG + "listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + "listKeyTemp1 is :" + listKeyTemp1);
+          console.log(TAG + "globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+          expect(listKeyTemp[0]).assertEqual("Hap2MainAbility6 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap2MainAbility6 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap2MainAbility6 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap2MainAbility6 onAbilityBackground");
+          expect(listKeyTemp[4]).assertEqual("Hap2MainAbility6 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[5]).assertEqual("Hap2MainAbility6 onAbilityDestroy");
+
+          expect(listKeyTemp1[0]).assertEqual("Hap2MainAbility7 onAbilityCreate");
+          expect(listKeyTemp1[1]).assertEqual("Hap2MainAbility7 onAbilityWindowStageCreate");
+          expect(listKeyTemp1[2]).assertEqual("Hap2MainAbility7 onAbilityForeground");
+          expect(listKeyTemp1[3]).assertEqual("Hap2MainAbility7 onAbilityBackground");
+          expect(listKeyTemp1[4]).assertEqual("Hap2MainAbility7 onAbilityWindowStageDestroy");
+          expect(listKeyTemp1[5]).assertEqual("Hap2MainAbility7 onAbilityDestroy");
+
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              expect(error.code == 0).assertTrue()
+              done();
+            });
+        }, 3000)
+      });
+      console.log("------------end Multihap_LifecycleTest_005-------------");
+    });
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_006
+     * @tc.name    Repeat the registration. The ability of HAP A listens to the life
+                    cycle callback of the ability of HAP B
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Multihap_LifecycleTest_006", 0, async function (done) {
+      console.log("------------Multihap_LifecycleTest_006 start-------------");
+      TAG = "Multihap_LifecycleTest_006";
+      listKeyTemp = [];
+      listKeyTemp1 = [];
+      var firstCallbackId;
+      var secondCallbackId;
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ": first MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility8"
+      }, (error, data) => {
+        setTimeout(function(){
+          console.log(TAG + ": first Hap2MainAbility8 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          console.log(TAG + "first globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+          firstCallbackId = globalThis.mainAbility4CallBackId;
+          console.log(TAG + "firstCallbackId is : " + firstCallbackId);
+        }, 3000)
+      });
+
+      await sleep(1000);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ": second MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility8"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": second Hap2MainAbility8 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          for(var i = 0;i<globalThis.mainAbility4ListKey.length;i++){
+            if(globalThis.mainAbility4ListKey[i].substring(0,16)=="Hap2MainAbility8"){
+              listKeyTemp1.push(globalThis.mainAbility4ListKey[i]);
+            }
+          }
+          console.log(TAG + "second globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+          secondCallbackId = globalThis.mainAbility4CallBackId;
+          console.log(TAG + "secondCallbackId is : " + secondCallbackId);
+          expect(secondCallbackId).assertEqual(firstCallbackId+1)
+
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              expect(error.code == 0).assertTrue()
+              done();
+            });
+        }, 3000)
+      });
+
+      console.log("------------Multihap_LifecycleTest_006 end-------------");
+    });
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_007
+     * @tc.name    Repeat registration and deregistration. The ability of HAP A listens to the life
+                    cycle callback of the ability of HAP B
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Multihap_LifecycleTest_007", 0, async function (done) {
+      console.log("------------Multihap_LifecycleTest_007 start-------------");
+      TAG = "Multihap_LifecycleTest_007";
+      listKeyTemp = [];
+      listKeyTemp1 = [];
+      var callBackId1;
+      var callBackId2;
+      var flag;
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility6"
+      }, (error, data) => {
+        console.log(TAG + ": first MainAbility6 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      setTimeout(function(){
+        abilityContext.startAbility({
+          bundleName: "com.example.lifecycletest",
+          abilityName: "Hap2MainAbility9"
+        }, (error, data) => {
+          setTimeout(() => {
+            console.log(TAG + ":first Hap2MainAbility9 startAbility success, err: " +
+            JSON.stringify(error) + ",data: " + JSON.stringify(data));
+
+            for(var i = 0;i<globalThis.mainAbility6ListKey.length;i++){
+              if(globalThis.mainAbility6ListKey[i].substring(0,16)=="Hap2MainAbility9"){
+                listKeyTemp.push(globalThis.mainAbility6ListKey[i]);
+              }
+            }
+            console.log(TAG + "listKeyTemp is :" + listKeyTemp);
+            console.log(TAG + "first globalThis.mainAbility6CallBackId is :" + globalThis.mainAbility6CallBackId);
+            callBackId1 = globalThis.mainAbility6CallBackId
+            console.log(TAG + "callBackId1 is :" + callBackId1);
+            expect(listKeyTemp[0]).assertEqual("Hap2MainAbility9 onAbilityCreate");
+            expect(listKeyTemp[1]).assertEqual("Hap2MainAbility9 onAbilityWindowStageCreate");
+            expect(listKeyTemp[2]).assertEqual("Hap2MainAbility9 onAbilityForeground");
+            expect(listKeyTemp[3]).assertEqual("Hap2MainAbility9 onAbilityBackground");
+            expect(listKeyTemp[4]).assertEqual("Hap2MainAbility9 onAbilityWindowStageDestroy");
+            expect(listKeyTemp[5]).assertEqual("Hap2MainAbility9 onAbilityDestroy");
+
+            abilityContext.getApplicationContext()
+              .unregisterAbilityLifecycleCallback(globalThis.mainAbility6CallBackId, (error, data) => {
+                console.log(TAG + ": first unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+                ",data: " + JSON.stringify(data));
+                expect(error.code == 0).assertTrue()
+                flag = error.code;
+                console.log(TAG + "flag is:" + flag);
+              });
+          }, 3000)
+        });
+      }, 1000)
+
+
+      setTimeout(function(){
+        if(flag == 0){
+
+          abilityContext.startAbility({
+            bundleName: "com.example.lifecycletest",
+            abilityName: "MainAbility6"
+          }, (error, data) => {
+            console.log(TAG + ": first MainAbility6 startAbility success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+          });
+
+          setTimeout(function(){
+            abilityContext.startAbility({
+              bundleName: "com.example.lifecycletest",
+              abilityName: "Hap2MainAbility9"
+            }, (error, data) => {
+
+              setTimeout(() => {
+                console.log(TAG + ":second Hap2MainAbility9 startAbility success, err: " +
+                JSON.stringify(error) + ",data: " + JSON.stringify(data));
+
+                for(var i = 0;i<globalThis.mainAbility6ListKey.length;i++){
+                  if(globalThis.mainAbility6ListKey[i].substring(0,16)=="Hap2MainAbility9"){
+                    listKeyTemp1.push(globalThis.mainAbility6ListKey[i]);
+                  }
+                }
+                console.log(TAG + "listKeyTemp1 is :" + listKeyTemp1);
+                console.log(TAG + "second globalThis.mainAbility6CallBackId is :" + globalThis.mainAbility6CallBackId);
+                callBackId2 = globalThis.mainAbility6CallBackId
+                console.log(TAG + "callBackId2 is :" + callBackId2);
+                expect(callBackId2).assertEqual(callBackId1 + 1)
+                expect(listKeyTemp1[0]).assertEqual("Hap2MainAbility9 onAbilityCreate");
+                expect(listKeyTemp1[1]).assertEqual("Hap2MainAbility9 onAbilityWindowStageCreate");
+                expect(listKeyTemp1[2]).assertEqual("Hap2MainAbility9 onAbilityForeground");
+                expect(listKeyTemp1[3]).assertEqual("Hap2MainAbility9 onAbilityBackground");
+                expect(listKeyTemp1[4]).assertEqual("Hap2MainAbility9 onAbilityWindowStageDestroy");
+                expect(listKeyTemp1[5]).assertEqual("Hap2MainAbility9 onAbilityDestroy");
+
+                abilityContext.getApplicationContext()
+                  .unregisterAbilityLifecycleCallback(globalThis.mainAbility6CallBackId, (error, data) => {
+                    console.log(TAG + ": second unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+                    ",data: " + JSON.stringify(data));
+                    expect(error.code == 0).assertTrue()
+                    done();
+                  });
+                }, 3000)
+              })
+            }, 2000)
+        }
+      }, 10000)
+
+      console.log("------------Multihap_LifecycleTest_007 end-------------");
+    });
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_008
+     * @tc.name    Repeat deregistration. The ability of HAP A listens to the life
+                    cycle callback of the ability of HAP B
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Multihap_LifecycleTest_008", 0, async function (done) {
+      console.log("------------Multihap_LifecycleTest_008 start-------------");
+      TAG = "Multihap_LifecycleTest_008";
+      listKeyTemp = [];
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4"
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility4 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility6"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": Hap2MainAbility6 startAbility success, err: " +
+          JSON.stringify(error) + ",data: " + JSON.stringify(data));
+
+          for(var i = 0;i<globalThis.mainAbility4ListKey.length;i++){
+            if(globalThis.mainAbility4ListKey[i].substring(0,16)=="Hap2MainAbility6"){
+              listKeyTemp.push(globalThis.mainAbility4ListKey[i]);
+            }
+          }
+          console.log(TAG + "listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + "globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+          expect(listKeyTemp[0]).assertEqual("Hap2MainAbility6 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap2MainAbility6 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap2MainAbility6 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap2MainAbility6 onAbilityBackground");
+          expect(listKeyTemp[4]).assertEqual("Hap2MainAbility6 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[5]).assertEqual("Hap2MainAbility6 onAbilityDestroy");
+
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+              console.log(TAG + ": first unregisterAbilityLifecycleCallback, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              expect(error.code == 0).assertTrue;
+              abilityContext.getApplicationContext()
+                .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+                  console.log(TAG + ": second unregisterAbilityLifecycleCallback, err: " + JSON.stringify(error) +
+                  ",data: " + JSON.stringify(data));
+                  expect(error.code == 0).assertTrue;
+                  done()
+                });
+            });
+        }, 4000)
+      });
+      console.log("------------Multihap_LifecycleTest_008 end-------------");
+    });
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_010
+     * @tc.name    Switch the front and background for many times to monitor the life cycle
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it('Multihap_LifecycleTest_010', 0, async function (done) {
+      console.info("---------------Multihap_LifecycleTest_010 is start---------------")
+      TAG = "Multihap_LifecycleTest_010";
+      listKeyTemp = [];
+      listKeyTemp1 = [];
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility4",
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility4 startAbility success, err: " +
+        JSON.stringify(error) + ",data: " + JSON.stringify(data));
+      })
+
+      await sleep(1000)
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility10",
+      }, (error, data) => {
+        console.log(TAG + ": first Hap2MainAbility10 startAbility success, err: " +
+        JSON.stringify(error) + ",data: " + JSON.stringify(data));
+      })
+
+      await sleep(1000)
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap3MainAbility3",
+      }, (error, data) => {
+        console.log(TAG + ": first Hap3MainAbility3 startAbility success, err: " +
+        JSON.stringify(error) + ",data: " + JSON.stringify(data));
+      })
+
+      await sleep(1000)
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility10",
+      }, (error, data) => {
+        console.log(TAG + ": second Hap2MainAbility10 startAbility success, err: " +
+        JSON.stringify(error) + ",data: " + JSON.stringify(data));
+      })
+
+      await sleep(1000)
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap3MainAbility3",
+      }, (error, data) => {
+        console.log(TAG + ": second Hap3MainAbility3 startAbility success, err: " +
+        JSON.stringify(error) + ",data: " + JSON.stringify(data));
+      })
+
+
+      await sleep(1000)
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap2MainAbility10",
+      }, (error, data) => {
+        console.log(TAG + ": third Hap2MainAbility10 startAbility success, err: " +
+        JSON.stringify(error) + ",data: " + JSON.stringify(data));
+      })
+
+      await sleep(1000)
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap3MainAbility3",
+      }, (error, data) => {
+
+        setTimeout(() => {
+          console.log(TAG + ": third Hap3MainAbility3 startAbility success, err: " +
+          JSON.stringify(error) + ",data: " + JSON.stringify(data));
+
+          for (var i = 0;i < globalThis.mainAbility4ListKey.length; i++) {
+            if (globalThis.mainAbility4ListKey[i].substring(0, 17) == "Hap2MainAbility10") {
+              listKeyTemp.push(globalThis.mainAbility4ListKey[i]);
+            }else if (globalThis.mainAbility4ListKey[i].substring(0, 16) == "Hap3MainAbility3") {
+              listKeyTemp1.push(globalThis.mainAbility4ListKey[i]);
+            }
+          }
+          console.log(TAG + " listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + " listKeyTemp1 is :" + listKeyTemp1);
+          console.log(TAG + " globalThis.mainAbility4CallBackId is :" + globalThis.mainAbility4CallBackId);
+
+          expect(listKeyTemp[0]).assertEqual("Hap2MainAbility10 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap2MainAbility10 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap2MainAbility10 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap2MainAbility10 onAbilityBackground");
+          expect(listKeyTemp[4]).assertEqual("Hap2MainAbility10 onAbilityForeground");
+          expect(listKeyTemp[5]).assertEqual("Hap2MainAbility10 onAbilityBackground");
+          expect(listKeyTemp[6]).assertEqual("Hap2MainAbility10 onAbilityForeground");
+          expect(listKeyTemp[7]).assertEqual("Hap2MainAbility10 onAbilityBackground");
+
+          expect(listKeyTemp1[0]).assertEqual("Hap3MainAbility3 onAbilityCreate");
+          expect(listKeyTemp1[1]).assertEqual("Hap3MainAbility3 onAbilityWindowStageCreate");
+          expect(listKeyTemp1[2]).assertEqual("Hap3MainAbility3 onAbilityForeground");
+          expect(listKeyTemp1[3]).assertEqual("Hap3MainAbility3 onAbilityBackground");
+          expect(listKeyTemp1[4]).assertEqual("Hap3MainAbility3 onAbilityForeground");
+          expect(listKeyTemp1[5]).assertEqual("Hap3MainAbility3 onAbilityBackground");
+          expect(listKeyTemp1[6]).assertEqual("Hap3MainAbility3 onAbilityForeground");
+
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility4CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              expect(error.code == 0).assertTrue()
+              done();
+            });
+        }, 4000)
+      })
+      console.info("---------------Multihap_LifecycleTest_010 is end---------------")
+    })
+
+    /*
+     * @tc.number  Multihap_LifecycleTest_011
+     * @tc.name    The ability of HAP A listens to the life cycle callback
+                    of the ability of HAP B in different processes
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it('Multihap_LifecycleTest_011', 0, async function (done) {
+      console.info("---------------Multihap_LifecycleTest_011 is start---------------")
+      TAG = "Multihap_LifecycleTest_011";
+      listKeyTemp = [];
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "MainAbility2",
+      }, (error, data) => {
+        console.log(TAG + ": Hap1MainAbility2 startAbility success, err: " +
+        JSON.stringify(error) + ",data: " + JSON.stringify(data));
+      })
+
+      await sleep(500);
+
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycletest",
+        abilityName: "Hap4MainAbility1",
+      }, (error, data) => {
+      setTimeout(() => {
+        console.log(TAG + ": Hap4MainAbility1 startAbility success, err: " +
+        JSON.stringify(error) + ",data: " + JSON.stringify(data));
+
+        for (var i = 0; i < globalThis.mainAbility2ListKey.length; i++) {
+          if (globalThis.mainAbility2ListKey[i].substring(0, 16) == "Hap4MainAbility1") {
+            listKeyTemp.push(globalThis.mainAbility2ListKey[i]);
+          }
+        }
+        console.log(TAG + " listKeyTemp is :" + listKeyTemp);
+        console.log(TAG + " globalThis.mainAbility2CallBackId is :" + globalThis.mainAbility2CallBackId);
+        expect(listKeyTemp.length == 0).assertTrue();
+
+        abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.mainAbility2CallBackId, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            expect(error.code == 0).assertTrue()
+            done();
+          });
+        }, 4000)
+      });
+      console.info("---------------Multihap_LifecycleTest_011 is end---------------")
+    })
+  })
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/ets/test/ListTest.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import lifecycleTest from './LifecycleTest'
+
+export default function List(context) {
+
+  lifecycleTest(context)
+
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/module.json

+{
+    "module": {
+        "name": "phone",
+        "type": "entry",
+        "srcEntrance": "./ets/Application/AbilityStage.ts",
+        "description": "$string:phone_entry_dsc",
+        "mainElement": "MainAbility",
+        "deviceTypes": [
+            "phone"
+        ],
+        "deliveryWithInstall": true,
+        "installationFree": false,
+        "uiSyntax": "ets",
+        "pages": "$profile:main_pages",
+        "abilities": [{
+            "name": "com.example.lifecycletest.MainAbility",
+            "srcEntrance": "./ets/MainAbility/MainAbility.ts",
+            "description": "$string:phone_entry_main",
+            "icon": "$media:icon",
+            "label": "$string:entry_label",
+            "visible": true,
+            "orientation": "portrait",
+            "skills": [{
+                "actions": [
+                    "action.system.home"
+                ],
+                "entities": [
+                    "entity.system.home"
+                ]
+            }]
+        },
+        {
+          "name": "MainAbility1",
+          "srcEntrance": "./ets/MainAbility1/MainAbility1.ts",
+          "description": "$string:MainAbility1_desc",
+          "icon": "$media:icon",
+          "label": "$string:MainAbility1_label"
+          },
+          {
+          "name": "MainAbility2",
+          "srcEntrance": "./ets/MainAbility2/MainAbility2.ts",
+          "description": "$string:MainAbility2_desc",
+          "icon": "$media:icon",
+          "label": "$string:MainAbility2_label"
+          },
+          {
+          "name": "MainAbility3",
+          "srcEntrance": "./ets/MainAbility3/MainAbility3.ts",
+          "description": "$string:MainAbility3_desc",
+          "icon": "$media:icon",
+          "label": "$string:MainAbility3_label"
+          },
+          {
+          "name": "MainAbility4",
+          "srcEntrance": "./ets/MainAbility4/MainAbility4.ts",
+          "description": "$string:MainAbility4_desc",
+          "icon": "$media:icon",
+          "label": "$string:MainAbility4_label"
+          },
+          {
+          "name": "MainAbility5",
+          "srcEntrance": "./ets/MainAbility5/MainAbility5.ts",
+          "description": "$string:MainAbility5_desc",
+          "icon": "$media:icon",
+          "label": "$string:MainAbility5_label"
+          },
+          {
+          "name": "MainAbility6",
+          "srcEntrance": "./ets/MainAbility6/MainAbility6.ts",
+          "description": "$string:MainAbility6_desc",
+          "icon": "$media:icon",
+          "label": "$string:MainAbility6_label",
+          "launchType": "standard"
+          }],
+          "requestPermissions": [
+            {
+            "name": "ohos.permission.GET_BUNDLE_INFO"
+            },
+            {
+            "name": "ohos.permission.MANAGE_MISSIONS"
+            },
+            {
+            "name": "ohos.permission.INSTALL_BUNDLE"
+            },
+            {
+            "name": "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED"
+            },
+            {
+            "name": "ohos.permission.CHANGE_ABILITY_ENABLED_STATE"
+            },
+            {
+            "name": "ohos.permission.REMOVE_CACHE_FILES"
+            },
+            {
+            "name": "ohos.permission.LISTEN_BUNDLE_CHANGE"
+            }
+          ] 
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/resources/base/element/string.json

+{
+  "string":  [
+      {
+          "name": "phone_entry_dsc",
+          "value": "i am an entry for phone"
+      },
+      {
+          "name": "phone_entry_main",
+          "value": "the phone entry ability"
+      },
+      {
+          "name": "entry_label",
+          "value": "ActsLifecycleMultihapTest"
+      },
+      {
+          "name": "form_description",
+          "value": "my form"
+      },
+      {
+        "name": "description_application",
+        "value": "demo for test"
+      },
+      {
+        "name": "entry_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility1_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility1_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility2_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility2_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility3_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility3_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility4_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility4_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility5_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility5_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility6_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility6_label",
+        "value": "label"
+      }
+  ]
+}

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/entry/src/main/resources/base/profile/main_pages.json

+{
+  "src": [
+    "pages/MainAbility_pages",
+    "pages/MainAbility1_pages",
+    "pages/MainAbility2_pages",
+    "pages/MainAbility3_pages",
+    "pages/MainAbility4_pages",
+    "pages/MainAbility5_pages",
+    "pages/MainAbility6_pages"
+  ]
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/hap4/src/main/ets/Application/AbilityStage.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import AbilityStage from "@ohos.application.AbilityStage"
+
+export default class MyAbilityStage extends AbilityStage {
+    onCreate() {
+        console.log("[Demo] MyAbilityStage onCreate")
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/hap4/src/main/ets/Hap4MainAbility1/Hap4MainAbility1.ts

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Ability from '@ohos.application.Ability'
+
+export default class Hap4MainAbility1 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap4MainAbility1 onCreate")
+        globalThis.abilityWant = want;
+
+        setTimeout(()=>{
+            this.context.terminateSelf().then((data) => {
+                console.log("[Demo] Hap4MainAbility1 terminateSelf windowStage data: " + JSON.stringify(data))
+            }).catch((error) => {
+                console.log("[Demo] Hap4MainAbility1 terminateSelf windowStage error: " + JSON.stringify(error))
+            })
+        }, 2000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap4MainAbility1 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap4MainAbility1 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/Hap4MainAbility1_pages", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap4MainAbility1 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap4MainAbility1 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap4MainAbility1 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/hap4/src/main/ets/pages/Hap4MainAbility1_pages.ets

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@Entry
+@Component
+struct Index {
+  @State message: string = 'Hap4MainAbility1'
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/hap4/src/main/module.json

+{
+    "module": {
+        "name": "hap4",
+        "type": "feature",
+        "srcEntrance": "./ets/Application/AbilityStage.ts",
+        "description": "$string:hap4_desc",
+        "mainElement": "Hap4MainAbility1",
+        "deviceTypes": [
+            "phone"
+        ],
+        "deliveryWithInstall": true,
+        "installationFree": false,
+        "uiSyntax": "ets",
+        "process": "hap4mainability",
+        "pages": "$profile:main_pages",
+        "abilities": [{
+            "name": "com.example.lifecycletest.hap4mainability",
+            "srcEntrance": "./ets/hap4mainability/hap4mainability.ts",
+            "description": "$string:Hap4MainAbility1_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap4MainAbility1_label",
+            "visible": true,
+            "orientation": "portrait",
+            "skills": [{
+                "actions": [
+                    "action.system.home"
+                ],
+                "entities": [
+                    "entity.system.home"
+                ]
+            }]
+        }],
+          "requestPermissions": [
+            {
+            "name": "ohos.permission.GET_BUNDLE_INFO"
+            },
+            {
+            "name": "ohos.permission.MANAGE_MISSIONS"
+            },
+            {
+            "name": "ohos.permission.INSTALL_BUNDLE"
+            },
+            {
+            "name": "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED"
+            },
+            {
+            "name": "ohos.permission.CHANGE_ABILITY_ENABLED_STATE"
+            },
+            {
+            "name": "ohos.permission.REMOVE_CACHE_FILES"
+            },
+            {
+            "name": "ohos.permission.LISTEN_BUNDLE_CHANGE"
+            }
+          ] 
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/hap4/src/main/resources/base/element/string.json

+{
+  "string":  [
+      {
+          "name": "phone_entry_dsc",
+          "value": "i am an entry for phone"
+      },
+      {
+          "name": "phone_entry_main",
+          "value": "the phone entry ability"
+      },
+      {
+          "name": "entry_label",
+          "value": "ActsLifecycleMultihapTest"
+      },
+      {
+          "name": "form_description",
+          "value": "my form"
+      },
+      {
+        "name": "description_application",
+        "value": "demo for test"
+      },
+      {
+        "name": "entry_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_label",
+        "value": "label"
+      },
+      {
+        "name": "hap4_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap4MainAbility1_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap4MainAbility1_label",
+        "value": "label"
+      }
+  ]
+}

aafwk/aafwk_standard/stage/actslifecyclemultihaptest/hap4/src/main/resources/base/profile/main_pages.json

+{
+  "src": [
+    "pages/Hap4MainAbility1_pages"
+  ]
+}

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/AppScope/app.json

+{
+    "app": {
+        "bundleName": "com.example.lifecycle_xts",
+        "vendor": "huawei",
+        "versionCode": 1000000,
+        "versionName": "1.0.0",
+        "debug": false,
+        "icon": "$media:icon",
+        "label": "$string:app_name",
+        "description": "$string:description_application",
+        "distributedNotificationEnabled": true,
+        "keepAlive": true,
+        "singleUser": true,
+        "minAPIVersion": 9,
+        "targetAPIVersion": 9,
+        "car": {
+            "apiCompatibleVersion": 9,
+            "singleUser": false
+        }
+    }
+}

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/AppScope/resources/base/element/string.json

+{
+ "string":[
+    {
+      "name":"app_name",
+      "value":"LifeCycle_XTS"
+    }
+  ]
+}      
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//test/xts/tools/build/suite.gni")
+
+ohos_js_hap_suite("ActsLifecycleSingleHapTest") {
+  hap_profile = "entry/src/main/module.json"
+  deps = [
+    ":actslifecyclesinglehaptest_js_assets",
+    ":actslifecyclesinglehaptest_resources",
+  ]
+  ets2abc = true
+  certificate_profile = "signature/openharmony_sx.p7b"
+  hap_name = "ActsLifecycleSingleHapTest"
+}
+
+ohos_app_scope("actslifecyclesinglehaptest_app_profile") {
+  app_profile = "AppScope/app.json"
+  sources = [ "AppScope/resources" ]
+}
+
+ohos_js_assets("actslifecyclesinglehaptest_js_assets") {
+  source_dir = "entry/src/main/ets"
+}
+
+ohos_resources("actslifecyclesinglehaptest_resources") {
+  sources = [ "entry/src/main/resources" ]
+  deps = [ ":actslifecyclesinglehaptest_app_profile" ]
+  hap_profile = "entry/src/main/module.json"
+}

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/Test.json

+{
+    "description": "Configuration for hjunit demo Tests",
+    "driver": {
+        "type": "JSUnitTest",
+        "test-timeout": "180000",
+        "package": "com.example.lifecycle_xts",
+        "shell-timeout": "600000"
+    },
+    "kits": [
+        {
+            "test-file-name": [
+                "ActsLifecycleSingleHapTest.hap"
+            ],
+            "type": "AppInstallKit",
+            "cleanup-apps": true
+        }
+    ] 
+}

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/Application/AbilityStage.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import AbilityStage from "@ohos.application.AbilityStage";
+
+export default class MyAbilityStage extends AbilityStage {
+    onCreate() {
+        console.log("[Demo] MyAbilityStage onCreate")
+        console.log("[Demo] MyAbilityStage stagecontext: " + JSON.stringify(this.context));
+        var listKey = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback onAbilityCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey.push(abilityname + " onAbilityCreate");
+                console.log("[Demo] 1listKey:" + JSON.stringify(listKey));
+            },
+            onAbilityWindowStageCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback onAbilityWindowStageCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey.push(abilityname + " onAbilityWindowStageCreate");
+                console.log("[Demo] 2listKey:" + JSON.stringify(listKey));
+            },
+            onAbilityWindowStageDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback onAbilityWindowStageDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey.push(abilityname + " onAbilityWindowStageDestroy");
+                console.log("[Demo] 3listKey:" + JSON.stringify(listKey));
+            },
+            onAbilityDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback onAbilityDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey.push(abilityname + " onAbilityDestroy");
+                console.log("[Demo] 4listKey:" + JSON.stringify(listKey));
+            },
+            onAbilityForeground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback onAbilityForeground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey.push(abilityname + " onAbilityForeground");
+                console.log("[Demo] 5listKey:" + JSON.stringify(listKey));
+            },
+            onAbilityBackground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback onAbilityBackground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey.push(abilityname + " onAbilityBackground");
+                console.log("[Demo] 6listKey:" + JSON.stringify(listKey));
+            },
+            onAbilityContinue(ability) {
+                console.log("[Demo] AbilityLifecycleCallback onAbilityContinue ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey.push(abilityname + " onAbilityContinue");
+                console.log("[Demo] 7listKey:" + JSON.stringify(listKey));
+            }
+        }
+        let applicationContext = this.context.getApplicationContext();
+        console.log("[Demo] stage applicationContext: " + JSON.stringify(applicationContext));
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] registerAbilityLifecycleCallback number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] AbilityLifecycleCallback listKey : " + JSON.stringify(listKey));
+            globalThis.list = listKey;
+            globalThis.callbackid = lifecycleid;
+        }, 2000);
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/Hap1MainAbility1/Hap1MainAbility1.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap1MainAbility1 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap1MainAbility1 onCreate")
+        globalThis.abilityWant = want;
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap1MainAbility1 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap1MainAbility1 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 2000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap1MainAbility1 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap1MainAbility1 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/indexh1a1", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap1MainAbility1 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap1MainAbility1 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap1MainAbility1 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/Hap1MainAbility2/Hap1MainAbility2.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class Hap1MainAbility2 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] Hap1MainAbility2 onCreate")
+        globalThis.abilityWant = want;
+
+        setTimeout(() => {
+            this.context.terminateSelf().then((data) => {
+                console.log("Hap1MainAbility2 EventTest terminateSelf data: " + JSON.stringify(data));
+            }).catch((error) => {
+                console.log("Hap1MainAbility2 EventTest terminateSelf error: " + JSON.stringify(error));
+            })
+        }, 2000)
+    }
+
+    onDestroy() {
+        console.log("[Demo] Hap1MainAbility2 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] Hap1MainAbility2 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/indexh1a2", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] Hap1MainAbility2 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] Hap1MainAbility2 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] Hap1MainAbility2 onBackground")
+    }
+};
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility/MainAbility.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability';
+
+export default class MainAbility extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility onWindowStageCreate")
+        globalThis.abilityContext = this.context;
+        windowStage.setUIContent(this.context, "pages/index", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility1/MainAbility1.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility1 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility1 onCreate")
+        globalThis.abilityWant = want;
+        console.log("[Demo] MainAbility1 context: " + JSON.stringify(this.context));
+        var listKey1 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey1.push(abilityname + " onAbilityCreate");
+                console.log("[Demo] 1listKey1:" + JSON.stringify(listKey1));
+            },
+            onAbilityWindowStageCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityWindowStageCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey1.push(abilityname + " onAbilityWindowStageCreate");
+                console.log("[Demo] 2listKey1:" + JSON.stringify(listKey1));
+            },
+            onAbilityWindowStageDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityWindowStageDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey1.push(abilityname + " onAbilityWindowStageDestroy");
+                console.log("[Demo] 3listKey1:" + JSON.stringify(listKey1));
+            },
+            onAbilityDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey1.push(abilityname + " onAbilityDestroy");
+                console.log("[Demo] 4listKey1:" + JSON.stringify(listKey1));
+            },
+            onAbilityForeground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityForeground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey1.push(abilityname + " onAbilityForeground");
+                console.log("[Demo] 5listKey1:" + JSON.stringify(listKey1));
+            },
+            onAbilityBackground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityBackground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey1.push(abilityname + " onAbilityBackground");
+                console.log("[Demo] 6listKey1:" + JSON.stringify(listKey1));
+            },
+            onAbilityContinue(ability) {
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityContinue ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback1 onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey1.push(abilityname + " onAbilityContinue");
+                console.log("[Demo] 7listKey1:" + JSON.stringify(listKey1));
+            }
+        }
+        let applicationContext = this.context.getApplicationContext();
+        console.log("[Demo] MainAbility1 applicationContext: " + JSON.stringify(applicationContext));
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] registerAbilityLifecycleCallback1 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] registerAbilityLifecycleCallback1 listKey: " + JSON.stringify(listKey1));
+            globalThis.list1 = listKey1;
+            globalThis.callbackid1 = lifecycleid;
+        }, 2500);
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility1 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility1 onWindowStageCreate")
+        globalThis.ability1context = this.context;
+        windowStage.setUIContent(this.context, "pages/index1", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility1 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility1 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility1 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility10/MainAbility10.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility10 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility10 onCreate")
+        globalThis.abilityWant = want;
+        var listKey10 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback10 onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey10.push(abilityname + " onAbilityCreate");
+                console.log("[Demo] 1listKey10:" + JSON.stringify(listKey10));
+            },
+            onAbilityWindowStageCreate(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback10 onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey10.push(abilityname + " onAbilityWindowStageCreate");
+                console.log("[Demo] 2listKey10:" + JSON.stringify(listKey10));
+            },
+            onAbilityWindowStageDestroy(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback10 onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey10.push(abilityname + " onAbilityWindowStageDestroy");
+                console.log("[Demo] 3listKey10:" + JSON.stringify(listKey10));
+            },
+            onAbilityDestroy(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback10 onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey10.push(abilityname + " onAbilityDestroy");
+                console.log("[Demo] 4listKey10:" + JSON.stringify(listKey10));
+            },
+            onAbilityForeground(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback10 onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey10.push(abilityname + " onAbilityForeground");
+                console.log("[Demo] 5listKey10:" + JSON.stringify(listKey10));
+            },
+            onAbilityBackground(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback10 onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey10.push(abilityname + " onAbilityBackground");
+                console.log("[Demo] 6listKey10:" + JSON.stringify(listKey10));
+            },
+            onAbilityContinue(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback10 onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey10.push(abilityname + " onAbilityContinue");
+                console.log("[Demo] 7listKey10:" + JSON.stringify(listKey10));
+            }
+        }
+        let applicationContext = this.context.getApplicationContext();
+        console.log("[Demo] MainAbility10 applicationContext: " + JSON.stringify(applicationContext));
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] registerAbilityLifecycleCallback10 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] registerAbilityLifecycleCallback10 listKey: " + JSON.stringify(listKey10));
+            globalThis.list10 = listKey10;
+            globalThis.callbackid10 = lifecycleid;
+        }, 1500);
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility10 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility10 onWindowStageCreate")
+        globalThis.ability10 = this.context;
+        windowStage.setUIContent(this.context, "pages/index10", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility10 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility10 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility10 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility11/MainAbility11.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility11 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility11 onCreate")
+        globalThis.abilityWant = want;
+        globalThis.ability11 = this.context;
+        var listKey11 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback11 onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey11.push(abilityname + " onAbilityCreate");
+            },
+            onAbilityWindowStageCreate(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback11 onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey11.push(abilityname + " onAbilityWindowStageCreate");
+            },
+            onAbilityWindowStageDestroy(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback11 onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey11.push(abilityname + " onAbilityWindowStageDestroy");
+            },
+            onAbilityDestroy(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback11 onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey11.push(abilityname + " onAbilityDestroy");
+            },
+            onAbilityForeground(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback11 onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey11.push(abilityname + " onAbilityForeground");
+            },
+            onAbilityBackground(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback11 onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey11.push(abilityname + " onAbilityBackground");
+            },
+            onAbilityContinue(ability) {
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback11 onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey11.push(abilityname + " onAbilityContinue");
+            }
+        }
+        let applicationContext = globalThis.ability11.getApplicationContext();
+        console.log("[Demo] MainAbility11 applicationContext: " + JSON.stringify(applicationContext));
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] registerAbilityLifecycleCallback11 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] registerAbilityLifecycleCallback11 listKey: " + JSON.stringify(listKey11));
+            globalThis.list11 = listKey11;
+            globalThis.callbackid11 = lifecycleid;
+        }, 2000);
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility11 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility11 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/index11", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility11 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility11 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility12/MainAbility12.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility12 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility12 onCreate")
+        globalThis.abilityWant = want;
+        var listKey12 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback12 onAbilityCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey12.push(abilityname + " onAbilityCreate");
+            },
+            onAbilityWindowStageCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback12 onAbilityWindowStageCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey12.push(abilityname + " onAbilityWindowStageCreate");
+            },
+            onAbilityWindowStageDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback12 onAbilityWindowStageDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey12.push(abilityname + " onAbilityWindowStageDestroy");
+            },
+            onAbilityDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback12 onAbilityDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey12.push(abilityname + " onAbilityDestroy");
+            },
+            onAbilityForeground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback12 onAbilityForeground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey12.push(abilityname + " onAbilityForeground");
+            },
+            onAbilityBackground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback12 onAbilityBackground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey12.push(abilityname + " onAbilityBackground");
+            },
+            onAbilityContinue(ability) {
+                console.log("[Demo] AbilityLifecycleCallback12 onAbilityContinue ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey12.push(abilityname + " onAbilityContinue");
+            }
+        }
+        let applicationContext = this.context.getApplicationContext();
+        console.log("[Demo] MainAbility12 applicationContext: " + JSON.stringify(applicationContext));
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] registerAbilityLifecycleCallback12 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] registerAbilityLifecycleCallback12 listKey: " + JSON.stringify(listKey12));
+            globalThis.list12 = listKey12;
+            globalThis.callbackid12 = lifecycleid;
+        }, 1700);
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility12 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility12 onWindowStageCreate")
+        globalThis.ability12 = this.context;
+        windowStage.setUIContent(this.context, "pages/index12", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility12 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility12 onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility12 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility2/MainAbility2.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility2 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility2 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility2 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility2 onWindowStageCreate")
+        globalThis.ability2 = this.context;
+        windowStage.setUIContent(this.context, "pages/index2", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility2 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility2 onForeground")
+        setTimeout(function () {
+            globalThis.ability2.terminateSelf()
+                .then((data) => {
+                    console.info('[Demo] MainAbility2 terminateself succeeded: ' + data);
+                }).catch((error) => {
+                console.error('[Demo] MainAbility2 terminateself failed. Cause: ' + error);
+            })
+        }, 500);
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility2 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility3/MainAbility3.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility3 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility3 onCreate")
+        globalThis.abilityWant = want;
+
+        console.log("[Demo] MainAbility3 context: " + JSON.stringify(this.context));
+        var listKey3 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey3.push(abilityname + " onAbilityCreate");
+                console.log("[Demo] 1listKey3:" + JSON.stringify(listKey3));
+            },
+            onAbilityWindowStageCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityWindowStageCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey3.push(abilityname + " onAbilityWindowStageCreate");
+                console.log("[Demo] 2listKey3:" + JSON.stringify(listKey3));
+            },
+            onAbilityWindowStageDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityWindowStageDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey3.push(abilityname + " onAbilityWindowStageDestroy");
+                console.log("[Demo] 3listKey3:" + JSON.stringify(listKey3));
+            },
+            onAbilityDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey3.push(abilityname + " onAbilityDestroy");
+                console.log("[Demo] 4listKey3:" + JSON.stringify(listKey3));
+            },
+            onAbilityForeground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityForeground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey3.push(abilityname + " onAbilityForeground");
+                console.log("[Demo] 5listKey3:" + JSON.stringify(listKey3));
+            },
+            onAbilityBackground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityBackground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey3.push(abilityname + " onAbilityBackground");
+                console.log("[Demo] 6listKey3:" + JSON.stringify(listKey3));
+            },
+            onAbilityContinue(ability) {
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityContinue ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback3 onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey3.push(abilityname + " onAbilityContinue");
+                console.log("[Demo] 7listKey3:" + JSON.stringify(listKey3));
+            }
+        }
+        let applicationContext = this.context.getApplicationContext();
+        console.log("[Demo] MainAbility3 applicationContext: " + JSON.stringify(applicationContext));
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] registerAbilityLifecycleCallback3 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] registerAbilityLifecycleCallback3 listKey : " + JSON.stringify(listKey3));
+            globalThis.list3 = listKey3;
+            globalThis.callbackid3 = lifecycleid;
+        }, 2000);
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility3 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility3 onWindowStageCreate")
+        globalThis.ability3 = this.context
+        windowStage.setUIContent(this.context, "pages/index3", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility3 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility onForeground")
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility4/MainAbility4.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility4 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility4 onCreate")
+        globalThis.abilityWant = want;
+
+        console.log("[Demo] MainAbility4 context: " + JSON.stringify(this.context));
+        var listKey4 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey4.push(abilityname + " onAbilityCreate");
+                console.log("[Demo] 1listKey4:" + JSON.stringify(listKey4));
+            },
+            onAbilityWindowStageCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityWindowStageCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey4.push(abilityname + " onAbilityWindowStageCreate");
+                console.log("[Demo] 2listKey4:" + JSON.stringify(listKey4));
+            },
+            onAbilityWindowStageDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityWindowStageDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey4.push(abilityname + " onAbilityWindowStageDestroy");
+                console.log("[Demo] 3listKey4:" + JSON.stringify(listKey4));
+            },
+            onAbilityDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey4.push(abilityname + " onAbilityDestroy");
+                console.log("[Demo] 4listKey4:" + JSON.stringify(listKey4));
+            },
+            onAbilityForeground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityForeground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey4.push(abilityname + " onAbilityForeground");
+                console.log("[Demo] 5listKey4:" + JSON.stringify(listKey4));
+            },
+            onAbilityBackground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityBackground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey4.push(abilityname + " onAbilityBackground");
+                console.log("[Demo] 6listKey4:" + JSON.stringify(listKey4));
+            },
+            onAbilityContinue(ability) {
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityContinue ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback4 onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey4.push(abilityname + " onAbilityContinue");
+                console.log("[Demo] 7listKey4:" + JSON.stringify(listKey4));
+            }
+        }
+        let applicationContext = this.context.getApplicationContext();
+        console.log("[Demo] MainAbility4 applicationContext: " + JSON.stringify(applicationContext));
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] registerAbilityLifecycleCallback4 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] registerAbilityLifecycleCallback4 listKey : " + JSON.stringify(listKey4));
+            globalThis.list4 = listKey4;
+            globalThis.callbackid4 = lifecycleid;
+        }, 1500);
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility4 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility4 onWindowStageCreate")
+        globalThis.ability4 = this.context;
+        windowStage.setUIContent(this.context, "pages/index4", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility4 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility4 onForeground")
+        setTimeout(function () {
+            globalThis.ability4.terminateSelf()
+                .then((data) => {
+                    console.info('[Demo] MainAbility4 terminateself succeeded: ' + data);
+                }).catch((error) => {
+                console.error('[Demo] MainAbility4 terminateself failed. Cause: ' + error);
+            })
+        }, 5000);
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility4 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility5/MainAbility5.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility5 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility5 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility5 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility5 onWindowStageCreate")
+        globalThis.ability5 = this.context;
+        windowStage.setUIContent(this.context, "pages/index5", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility5 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility5 onForeground")
+        setTimeout(function () {
+            globalThis.ability5.terminateSelf()
+                .then((data) => {
+                    console.info('[Demo] MainAbility5 terminateself succeeded: ' + data);
+                }).catch((error) => {
+                console.error('[Demo] MainAbility5 terminateself failed. Cause: ' + error);
+            })
+        }, 500);
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility5 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility6/MainAbility6.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility6 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility6 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility6 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility6 onWindowStageCreate")
+        globalThis.ability6 = this.context;
+        windowStage.setUIContent(this.context, "pages/index6", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility6 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility6 onForeground")
+
+        var listKey6 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey6.push(abilityname + " onAbilityCreate");
+                console.log("[Demo] 1listKey6:" + JSON.stringify(listKey6));
+            },
+            onAbilityWindowStageCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityWindowStageCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey6.push(abilityname + " onAbilityWindowStageCreate");
+                console.log("[Demo] 2listKey6:" + JSON.stringify(listKey6));
+            },
+            onAbilityWindowStageDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityWindowStageDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey6.push(abilityname + " onAbilityWindowStageDestroy");
+                console.log("[Demo] 3listKey6:" + JSON.stringify(listKey6));
+            },
+            onAbilityDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey6.push(abilityname + " onAbilityDestroy");
+                console.log("[Demo] 4listKey6:" + JSON.stringify(listKey6));
+            },
+            onAbilityForeground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityForeground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey6.push(abilityname + " onAbilityForeground");
+                console.log("[Demo] 5listKey6:" + JSON.stringify(listKey6));
+            },
+            onAbilityBackground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityBackground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey6.push(abilityname + " onAbilityBackground");
+                console.log("[Demo] 6listKey6:" + JSON.stringify(listKey6));
+            },
+            onAbilityContinue(ability) {
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityContinue ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback6 onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey6.push(abilityname + " onAbilityContinue");
+                console.log("[Demo] 7listKey6:" + JSON.stringify(listKey6));
+            }
+        }
+        let applicationContext = globalThis.ability6.getApplicationContext();
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] registerAbilityLifecycleCallback6 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] registerAbilityLifecycleCallback6 listKey: " + JSON.stringify(listKey6));
+            globalThis.list6 = listKey6;
+            globalThis.callbackid6 = lifecycleid;
+        }, 1500);
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility6 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility7/MainAbility7.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility7 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility7 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility7 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility7 onWindowStageCreate")
+        globalThis.ability7 = this.context;
+        windowStage.setUIContent(this.context, "pages/index7", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility7 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility7 onForeground")
+
+        var listKey7 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey7.push(abilityname + " onAbilityCreate");
+                console.log("[Demo] 1listKey7:" + JSON.stringify(listKey7));
+            },
+            onAbilityWindowStageCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityWindowStageCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey7.push(abilityname + " onAbilityWindowStageCreate");
+                console.log("[Demo] 2listKey7:" + JSON.stringify(listKey7));
+            },
+            onAbilityWindowStageDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityWindowStageDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey7.push(abilityname + " onAbilityWindowStageDestroy");
+                console.log("[Demo] 3listKey7:" + JSON.stringify(listKey7));
+            },
+            onAbilityDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey7.push(abilityname + " onAbilityDestroy");
+                console.log("[Demo] 4listKey7:" + JSON.stringify(listKey7));
+            },
+            onAbilityForeground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityForeground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey7.push(abilityname + " onAbilityForeground");
+                console.log("[Demo] 5listKey7:" + JSON.stringify(listKey7));
+            },
+            onAbilityBackground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityBackground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey7.push(abilityname + " onAbilityBackground");
+                console.log("[Demo] 6listKey7:" + JSON.stringify(listKey7));
+            },
+            onAbilityContinue(ability) {
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityContinue ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback7 onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey7.push(abilityname + " onAbilityContinue");
+                console.log("[Demo] 7listKey7:" + JSON.stringify(listKey7));
+            }
+        }
+        let applicationContext = this.context.getApplicationContext();
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] AbilityLifecycleCallback7 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] AbilityLifecycleCallback7 listKey: " + JSON.stringify(listKey7));
+            globalThis.list7 = listKey7;
+            globalThis.callbackid7 = lifecycleid;
+        }, 1500);
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility7 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility8/MainAbility8.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility8 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility8 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility8 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility8 onWindowStageCreate")
+        globalThis.ability8 = this.context;
+        windowStage.setUIContent(this.context, "pages/index8", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility8 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility8 onForeground")
+        var listKey8 = [];
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityCreate");
+                listKey8.push(abilityname + " onAbilityCreate");
+                console.log("[Demo] 1listKey8:" + JSON.stringify(listKey8));
+            },
+            onAbilityWindowStageCreate(ability) {
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityWindowStageCreate ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityWindowStageCreate abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageCreate");
+                listKey8.push(abilityname + " onAbilityWindowStageCreate");
+                console.log("[Demo] 2listKey8:" + JSON.stringify(listKey8));
+            },
+            onAbilityWindowStageDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityWindowStageDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityWindowStageDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityWindowStageDestroy");
+                listKey8.push(abilityname + " onAbilityWindowStageDestroy");
+                console.log("[Demo] 3listKey8:" + JSON.stringify(listKey8));
+            },
+            onAbilityDestroy(ability) {
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityDestroy ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityDestroy abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityDestroy");
+                listKey8.push(abilityname + " onAbilityDestroy");
+                console.log("[Demo] 4listKey8:" + JSON.stringify(listKey8));
+            },
+            onAbilityForeground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityForeground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityForeground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityForeground");
+                listKey8.push(abilityname + " onAbilityForeground");
+                console.log("[Demo] 5listKey8:" + JSON.stringify(listKey8));
+            },
+            onAbilityBackground(ability) {
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityBackground ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityBackground abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityBackground");
+                listKey8.push(abilityname + " onAbilityBackground");
+                console.log("[Demo] 6listKey8:" + JSON.stringify(listKey8));
+            },
+            onAbilityContinue(ability) {
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityContinue ability:"
+                + JSON.stringify(ability));
+                let abilityname = ability.context.abilityInfo.name;
+                console.log("[Demo] AbilityLifecycleCallback8 onAbilityContinue abilityname:"
+                + JSON.stringify(abilityname));
+                console.log("[Demo] " + abilityname + " onAbilityContinue");
+                listKey8.push(abilityname + " onAbilityContinue");
+                console.log("[Demo] 7listKey8:" + JSON.stringify(listKey8));
+            }
+        }
+        let applicationContext = this.context.getApplicationContext();
+        let lifecycleid = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log("[Demo] AbilityLifecycleCallback8 number: " + JSON.stringify(lifecycleid));
+        setTimeout(function () {
+            console.log("[Demo] AbilityLifecycleCallback8 listKey: " + JSON.stringify(listKey8));
+            globalThis.list8 = listKey8;
+            globalThis.callbackid8 = lifecycleid;
+        }, 1500);
+
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility8 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/MainAbility9/MainAbility9.ts

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Ability from '@ohos.application.Ability'
+
+export default class MainAbility9 extends Ability {
+    onCreate(want, launchParam) {
+        console.log("[Demo] MainAbility9 onCreate")
+        globalThis.abilityWant = want;
+    }
+
+    onDestroy() {
+        console.log("[Demo] MainAbility9 onDestroy")
+    }
+
+    onWindowStageCreate(windowStage) {
+        // Main window is created, set main page for this ability
+        console.log("[Demo] MainAbility9 onWindowStageCreate")
+
+        windowStage.setUIContent(this.context, "pages/index9", null)
+    }
+
+    onWindowStageDestroy() {
+        // Main window is destroyed, release UI related resources
+        console.log("[Demo] MainAbility9 onWindowStageDestroy")
+    }
+
+    onForeground() {
+        // Ability has brought to foreground
+        console.log("[Demo] MainAbility9 onForeground")
+
+        var listKey9 = [];
+        var abilityName = "";
+        let AbilityLifecycleCallback = {
+            onAbilityCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName + " onAbilityCreate")
+                listKey9.push(abilityName + " onAbilityCreate");
+            },
+            onAbilityWindowStageCreate(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName + " onAbilityWindowStageCreate")
+                listKey9.push(abilityName + " onAbilityWindowStageCreate");
+            },
+            onAbilityForeground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName + " onAbilityForeground")
+                listKey9.push(abilityName + " onAbilityForeground");
+            },
+            onAbilityBackground(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName + " onAbilityBackground")
+                listKey9.push(abilityName + " onAbilityBackground");
+            },
+            onAbilityWindowStageDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName + " onAbilityWindowStageDestroy")
+                listKey9.push(abilityName + " onAbilityWindowStageDestroy");
+            },
+            onAbilityDestroy(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName + " onAbilityDestroy")
+                listKey9.push(abilityName + " onAbilityDestroy");
+            },
+            onAbilityContinue(ability) {
+                abilityName = ability.context.abilityInfo.name;
+                console.log(abilityName + " onAbilityContinue")
+                listKey9.push(abilityName + " onAbilityContinue");
+            }
+        }
+        var callBackId = this.context.getApplicationContext()
+            .registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+
+        console.log("callBackId is aaa :" + callBackId);
+        setTimeout(() => {
+            globalThis.mainAbility9ListKey = listKey9
+            globalThis.mainAbility9CallBackId = callBackId
+            console.log("listKey is :" + listKey9);
+            console.log("callBackId is :" + callBackId);
+        }, 3000)
+    }
+
+    onBackground() {
+        // Ability has back to background
+        console.log("[Demo] MainAbility9 onBackground")
+    }
+};

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import file from '@system.file';
+import { Core, ExpectExtend, InstrumentLog, ReportExtend } from "deccjsunit/index"
+import List from '../test/ListTest'
+
+@Entry
+@Component
+struct Index {
+  aboutToAppear() {
+    console.info("start run testcase!!!!")
+    const core = Core.getInstance()
+    const expectExtend = new ExpectExtend({
+      'id': 'extend'
+    })
+    core.addService('expect', expectExtend)
+    const reportExtend = new ReportExtend(file)
+    core.addService('report', reportExtend)
+    core.init()
+    globalThis.abilityWant.parameters.timeout = 10000;
+    core.subscribeEvent('task', reportExtend)
+    const configService = core.getDefaultService('config')
+    configService.setConfig(globalThis.abilityWant.parameters);
+    List(globalThis.abilityContext)
+    core.execute()
+  }
+
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+      Button() {
+        Text('next page')
+          .fontSize(25)
+          .fontWeight(FontWeight.Bold)
+      }.type(ButtonType.Capsule)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index1.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index1 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability1')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index10.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index10 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability10')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index11.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index11 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability11')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index12.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index12 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability12')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index2.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index2 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability2')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index3.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index3 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability3')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index4.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index4 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability4')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index5.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index5 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability5')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index6.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index6 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability6')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index7.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index7 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability7')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index8.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index8 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability8')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/index9.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct Index9 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Mainability9')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/indexh1a1.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct indexh1a1 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Hap1MainAbility1')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/pages/indexh1a2.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@Entry
+@Component
+struct indexh1a2 {
+  build() {
+    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
+      Text('Hello World Hap1MainAbility2')
+        .fontSize(50)
+        .fontWeight(FontWeight.Bold)
+    }
+    .width('100%')
+    .height('100%')
+  }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/test/LifeCycleTest.ets

+// @ts-nocheck
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "deccjsunit/index"
+
+export default function lifecycleTest(abilityContext) {
+  describe('LifeCycleTest', function () {
+
+    beforeEach(async function (done) {
+      console.info('LifeCycleTest before each called');
+      await sleep(1000);
+      done()
+    });
+
+    afterEach(async function (done) {
+      console.info('LifeCycleTest after each called');
+      if ("Singlehap_LifeCycleTest_0200" === TAG || "Singlehap_LifeCycleTest_0300" === TAG
+      || "Singlehap_LifeCycleTest_0500" === TAG || "Singlehap_LifeCycleTest_0600" === TAG
+      || "Singlehap_LifeCycleTest_0800" === TAG || "Singlehap_LifeCycleTest_0900" === TAG) {
+        var para = {
+          resultCode: 2,
+          want: {
+            "abilityName": "MainAbility1",
+            "bundleName": "com.example.lifecycle_xts"
+          }
+        }
+        console.log("LifeCycleTest terminateSelfwithresult para: " + JSON.stringify(para));
+        await globalThis.ability1context.terminateSelfWithResult(para)
+          .then((data) => {
+            console.log("LifeCycleTest terminateSelfwithresult successful data: " + JSON.stringify(data));
+          }).catch((error) => {
+            console.log("LifeCycleTest terminateSelfwithresult error: " + JSON.stringify(error));
+          });
+      } else if ("Singlehap_LifeCycleTest_2000" === TAG) {
+        var para1 = {
+          resultCode: 2,
+          want: {
+            "abilityName": "MainAbility12",
+            "bundleName": "com.example.lifecycle_xts"
+          }
+        }
+        console.log("LifeCycleTest terminateSelfwithresult para: " + JSON.stringify(para1));
+        await globalThis.ability12.terminateSelfWithResult(para1)
+          .then((data) => {
+            console.log("LifeCycleTest terminateSelfwithresult successful data: " + JSON.stringify(data));
+          }).catch((error) => {
+            console.log("LifeCycleTest terminateSelfwithresult error: " + JSON.stringify(error));
+          });
+      }
+      done();
+    });
+
+    var TAG = "";
+    var listKeyTemp = ""
+    function sleep(time) {
+      return new Promise((resolve) => setTimeout(resolve, time))
+    }
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_0100
+     * @tc.name    Register in abilitystage,listen to the lifecycle of abilityA,deregister after listening
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_0100", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0100 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0100";
+      var code;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility2",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        console.log(TAG + " registerAbilityLifecycleCallback listKey : " + JSON.stringify(globalThis.list));
+        console.log(TAG + " registerAbilityLifecycleCallback callbackid : " + JSON.stringify(globalThis.callbackid));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list.length; i++) {
+          strtemp = globalThis.list[i].substring(0, 12);
+          if (strtemp === "MainAbility2") {
+            listtemp.push(globalThis.list[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + JSON.stringify(listtemp));
+        let exlist = listtemp;
+        globalThis.abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            code = error.code;
+          });
+        setTimeout(function () {
+          expect(exlist[0]).assertEqual("MainAbility2 onAbilityCreate");
+          expect(exlist[1]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+          expect(exlist[2]).assertEqual("MainAbility2 onAbilityForeground");
+          expect(exlist[3]).assertEqual("MainAbility2 onAbilityBackground");
+          expect(exlist[4]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+          expect(exlist[5]).assertEqual("MainAbility2 onAbilityDestroy");
+          expect(code).assertEqual(0);
+          console.log("------------Singlehap_LifeCycleTest_0100 END-------------");
+          done();
+        }, 1000);
+      }, 3000);
+    })
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_0200
+     * @tc.name    Register in abilityA,listen to the lifecycle of abilityB,deregister after listening
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_0200", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0200 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0200";
+      var code;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility1",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        console.log(TAG + " registerAbilityLifecycleCallback listKey : " + JSON.stringify(globalThis.list1));
+        var list = globalThis.list1
+        console.log(TAG + " registerAbilityLifecycleCallback callbackid : " + JSON.stringify(globalThis.callbackid1));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list1.length; i++) {
+          strtemp = globalThis.list1[i].substring(0, 12);
+          if (strtemp === "MainAbility1" || strtemp === "MainAbility2") {
+            listtemp.push(globalThis.list1[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + JSON.stringify(listtemp));
+        let exlist = listtemp;
+        globalThis.ability1context.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid1, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            code = error.code;
+          })
+        setTimeout(function () {
+          expect(exlist[0]).assertEqual("MainAbility1 onAbilityWindowStageCreate");
+          expect(exlist[1]).assertEqual("MainAbility1 onAbilityForeground");
+          expect(exlist[2]).assertEqual("MainAbility2 onAbilityCreate");
+          expect(exlist[3]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+          expect(exlist[4]).assertEqual("MainAbility2 onAbilityForeground");
+          expect(exlist[5]).assertEqual("MainAbility1 onAbilityBackground");
+          expect(exlist[6]).assertEqual("MainAbility1 onAbilityForeground");
+          expect(exlist[7]).assertEqual("MainAbility2 onAbilityBackground");
+          expect(exlist[8]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+          expect(exlist[9]).assertEqual("MainAbility2 onAbilityDestroy");
+          expect(code).assertEqual(0);
+          console.log("------------Singlehap_LifeCycleTest_0200 END-------------");
+          done();
+        }, 1000);
+      }, 3000);
+    });
+
+    /*
+    * @tc.number  Singlehap_LifeCycleTest_0300
+    * @tc.name    Register in abilityA,listening the lifecycle of abilityB,deregister,repeat the unregister
+    * @tc.desc    Function test
+    * @tc.level   0
+    */
+    it("Singlehap_LifeCycleTest_0300", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0300 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0300";
+      var code;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility1",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        console.log(TAG + " registerAbilityLifecycleCallback listKey : " + JSON.stringify(globalThis.list1));
+        console.log(TAG + " registerAbilityLifecycleCallback callbackid : " + JSON.stringify(globalThis.callbackid1));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list1.length; i++) {
+          strtemp = globalThis.list1[i].substring(0, 12);
+          if (strtemp === "MainAbility1" || strtemp === "MainAbility2") {
+            listtemp.push(globalThis.list1[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + JSON.stringify(listtemp));
+        let exlist = listtemp;
+        globalThis.ability1context.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid1)
+          .then((data) => {
+            console.info(TAG + ' unregisterAbilityLifecycleCallback successful. Data: ' + data);
+          })
+          .catch((error) => {
+            console.error(TAG + ' unregisterAbilityLifecycleCallback failed. Cause: ' + JSON.stringify(error));
+          })
+        setTimeout(function () {
+          console.log(TAG + " secondunregister callbackid : " + JSON.stringify(globalThis.callbackid1));
+          globalThis.ability1context.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.callbackid1, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback_1 success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              code = error.code;
+            })
+        }, 500);
+        setTimeout(function () {
+          expect(exlist[0]).assertEqual("MainAbility1 onAbilityWindowStageCreate");
+          expect(exlist[1]).assertEqual("MainAbility1 onAbilityForeground");
+          expect(exlist[2]).assertEqual("MainAbility2 onAbilityCreate");
+          expect(exlist[3]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+          expect(exlist[4]).assertEqual("MainAbility2 onAbilityForeground");
+          expect(exlist[5]).assertEqual("MainAbility1 onAbilityBackground");
+          expect(exlist[6]).assertEqual("MainAbility1 onAbilityForeground");
+          expect(exlist[7]).assertEqual("MainAbility2 onAbilityBackground");
+          expect(exlist[8]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+          expect(exlist[9]).assertEqual("MainAbility2 onAbilityDestroy");
+          expect(code).assertEqual(1);
+          console.log("------------Singlehap_LifeCycleTest_0300 END-------------");
+          done();
+        }, 2000);
+      }, 3000);
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_0400
+     * @tc.name    Register in abilityA,listening the lifecycle of abilityB,terminate abilityA,unregister
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_0400", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0400 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0400";
+      var code;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility3",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start3 successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start3 failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start2 successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start2 failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        console.log(TAG + " registerAbilityLifecycleCallback listKey : " + JSON.stringify(globalThis.list3));
+        console.log(TAG + " registerAbilityLifecycleCallback callbackid : " + JSON.stringify(globalThis.callbackid3));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list3.length; i++) {
+          strtemp = globalThis.list3[i].substring(0, 12);
+          if (strtemp === "MainAbility3" || strtemp === "MainAbility2") {
+            listtemp.push(globalThis.list3[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + JSON.stringify(listtemp));
+        let exlist = listtemp;
+        var para = {
+          resultCode: 1,
+          want: {
+            "abilityName": "MainAbility3",
+            "bundleName": "com.example.lifecycle_xts"
+          }
+        }
+        console.log(TAG + " terminateSelfwithresult para: " + JSON.stringify(para));
+        globalThis.ability3.terminateSelfWithResult(para)
+          .then((data) => {
+            console.log(TAG + " terminateSelfwithresult successful data: " + JSON.stringify(data));
+          }).catch((error) => {
+          console.log(TAG + " terminateSelfwithresult error: " + JSON.stringify(error));
+        });
+        setTimeout(function () {
+          globalThis.ability1context.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.callbackid3, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback3 success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              code = error.code;
+            })
+        }, 500);
+        setTimeout(function () {
+          expect(exlist[0]).assertEqual("MainAbility3 onAbilityWindowStageCreate");
+          expect(exlist[1]).assertEqual("MainAbility3 onAbilityForeground");
+          expect(exlist[2]).assertEqual("MainAbility2 onAbilityCreate");
+          expect(exlist[3]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+          expect(exlist[4]).assertEqual("MainAbility2 onAbilityForeground");
+          expect(exlist[5]).assertEqual("MainAbility3 onAbilityBackground");
+          expect(exlist[6]).assertEqual("MainAbility3 onAbilityForeground");
+          expect(exlist[7]).assertEqual("MainAbility2 onAbilityBackground");
+          expect(exlist[8]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+          expect(exlist[9]).assertEqual("MainAbility2 onAbilityDestroy");
+          expect(code).assertEqual(0);
+          console.log("------------Singlehap_LifeCycleTest_0400 END-------------");
+          done();
+        }, 1000);
+      }, 3000);
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_0500
+     * @tc.name    Register in abilityA and abilityB,unregister MainabilityB,then Register in ManinabilityC
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_0500", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0500 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0500";
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility1",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start1 successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start1 failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility3",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start3 successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start3 failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        console.log(TAG + " start after callbackid3 : " + JSON.stringify(globalThis.callbackid3));
+        globalThis.abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid3)
+          .then((data) => {
+            console.info(TAG + ' unregisterAbilityLifecycleCallback3 successful. Data: ' + data);
+          })
+          .catch((error) => {
+            console.error(TAG + ' unregisterAbilityLifecycleCallback3 failed. Cause: ' + JSON.stringify(error));
+          });
+        var str2 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility4",
+        }
+        globalThis.abilityContext.startAbility(str2)
+          .then((data) => {
+            console.info(TAG + ' start4 successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start4 failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 2800);
+      setTimeout(function () {
+        console.log(TAG + " listKey1 : " + JSON.stringify(globalThis.list1));
+        console.log(TAG + " callbackid1 : " + JSON.stringify(globalThis.callbackid1));
+        console.log(TAG + " listKey3 : " + JSON.stringify(globalThis.list3));
+        console.log(TAG + " callbackid3 : " + JSON.stringify(globalThis.callbackid3));
+        let id3 = globalThis.callbackid3;
+        console.log(TAG + " listKey4 : " + JSON.stringify(globalThis.list4));
+        console.log(TAG + " callbackid4 : " + JSON.stringify(globalThis.callbackid4));
+        let id4 = globalThis.callbackid4;
+        expect(id3 + 1).assertEqual(id4);
+        globalThis.ability1context.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid4, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback4 success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+          })
+        globalThis.ability1context.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid1, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback1 success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            console.log("------------Singlehap_LifeCycleTest_0500 END-------------");
+            done();
+          })
+      }, 4500);
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_0600
+     * @tc.name    Register in abilityA,start abilityB、abilityC,terminate abilityB 、abilityC
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_0600", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0600 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0600";
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility1",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start1 successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start1 failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility5",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start5 successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start5 failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        var str2 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str2)
+          .then((data) => {
+            console.info(TAG + ' start2 successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start2 failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 1100);
+      setTimeout(function () {
+        console.log(TAG + " listKey1 : " + JSON.stringify(globalThis.list1));
+        console.log(TAG + " callbackid1 : " + JSON.stringify(globalThis.callbackid1));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list1.length; i++) {
+          strtemp = globalThis.list1[i].substring(0, 12);
+          if (strtemp == "MainAbility5" || strtemp == "MainAbility2") {
+            listtemp.push(globalThis.list1[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + JSON.stringify(listtemp));
+        let exlist = listtemp;
+        expect(exlist[0]).assertEqual("MainAbility5 onAbilityCreate");
+        expect(exlist[1]).assertEqual("MainAbility5 onAbilityWindowStageCreate");
+        expect(exlist[2]).assertEqual("MainAbility5 onAbilityForeground");
+        expect(exlist[3]).assertEqual("MainAbility2 onAbilityCreate");
+        expect(exlist[4]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+        expect(exlist[5]).assertEqual("MainAbility2 onAbilityForeground");
+        expect(exlist[6]).assertEqual("MainAbility5 onAbilityBackground");
+        expect(exlist[7]).assertEqual("MainAbility5 onAbilityWindowStageDestroy");
+        expect(exlist[8]).assertEqual("MainAbility5 onAbilityDestroy");
+        expect(exlist[9]).assertEqual("MainAbility2 onAbilityBackground");
+        expect(exlist[10]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+        expect(exlist[11]).assertEqual("MainAbility2 onAbilityDestroy");
+        globalThis.ability1context.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid1, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            console.log("------------Singlehap_LifeCycleTest_0600 END-------------");
+            done();
+          })
+      }, 4200);
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_0700
+     * @tc.name    Multiple registration/unregistration
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_0700", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0700 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0700";
+      var code1;
+      var code2;
+      var code3;
+      var id1;
+      var id2;
+      var id3;
+      var listKey8 = [];
+      let AbilityLifecycleCallback = {
+        onAbilityCreate(ability) {
+          console.log(TAG + " onAbilityCreate ability:" + JSON.stringify(ability));
+          let abilityname = ability.context.abilityInfo.name;
+          console.log(TAG + " onAbilityCreate abilityname:" + JSON.stringify(abilityname));
+          console.log(TAG + " " + abilityname + " onAbilityCreate");
+          listKey8.push(abilityname + " onAbilityCreate");
+        },
+        onAbilityWindowStageCreate(ability) {
+          console.log(TAG + " onAbilityWindowStageCreate ability:" + JSON.stringify(ability));
+          let abilityname = ability.context.abilityInfo.name;
+          console.log(TAG + " onAbilityWindowStageCreate abilityname:" + JSON.stringify(abilityname));
+          console.log(TAG + " " + abilityname + " onAbilityWindowStageCreate");
+          listKey8.push(abilityname + " onAbilityWindowStageCreate");
+        },
+        onAbilityWindowStageDestroy(ability) {
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityWindowStageDestroy ability:"
+          + JSON.stringify(ability));
+          let abilityname = ability.context.abilityInfo.name;
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityWindowStageDestroy abilityname:"
+          + JSON.stringify(abilityname));
+          console.log(TAG + " " + abilityname + " onAbilityWindowStageDestroy");
+          listKey8.push(abilityname + " onAbilityWindowStageDestroy");
+        },
+        onAbilityDestroy(ability) {
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityDestroy ability:"
+          + JSON.stringify(ability));
+          let abilityname = ability.context.abilityInfo.name;
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityDestroy abilityname:"
+          + JSON.stringify(abilityname));
+          console.log(TAG + " " + abilityname + " onAbilityDestroy");
+          listKey8.push(abilityname + " onAbilityDestroy");
+        },
+        onAbilityForeground(ability) {
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityForeground ability:"
+          + JSON.stringify(ability));
+          let abilityname = ability.context.abilityInfo.name;
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityForeground abilityname:"
+          + JSON.stringify(abilityname));
+          console.log(TAG + " " + abilityname + " onAbilityForeground");
+          listKey8.push(abilityname + " onAbilityForeground");
+        },
+        onAbilityBackground(ability) {
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityBackground ability:"
+          + JSON.stringify(ability));
+          let abilityname = ability.context.abilityInfo.name;
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityBackground abilityname:"
+          + JSON.stringify(abilityname));
+          console.log(TAG + " " + abilityname + " onAbilityBackground");
+          listKey8.push(abilityname + " onAbilityBackground");
+        },
+        onAbilityContinue(ability) {
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityContinue ability:"
+          + JSON.stringify(ability));
+          let abilityname = ability.context.abilityInfo.name;
+          console.log(TAG + " AbilityLifecycleCallback1 onAbilityContinue abilityname:"
+          + JSON.stringify(abilityname));
+          console.log(TAG + " " + abilityname + " onAbilityContinue");
+          listKey8.push(abilityname + " onAbilityContinue");
+        }
+      }
+      let applicationContext = globalThis.abilityContext.getApplicationContext();
+      id1 = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+      console.log(TAG + " registerAbilityLifecycleCallback1 number: " + JSON.stringify(id1));
+      applicationContext.unregisterAbilityLifecycleCallback(id1, (error, data) => {
+        console.log(TAG + ": unregisterAbilityLifecycleCallback1 success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+        code1 = error.code;
+      })
+      setTimeout(function () {
+        id2 = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log(TAG + " registerAbilityLifecycleCallback2 number: " + JSON.stringify(id2));
+        applicationContext.unregisterAbilityLifecycleCallback(id2, (error, data) => {
+          console.log(TAG + ": unregisterAbilityLifecycleCallback2 success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          code2 = error.code;
+        })
+      }, 1000);
+      setTimeout(function () {
+        id3 = applicationContext.registerAbilityLifecycleCallback(AbilityLifecycleCallback);
+        console.log(TAG + " registerAbilityLifecycleCallback3 number: " + JSON.stringify(id3));
+        applicationContext.unregisterAbilityLifecycleCallback(id3, (error, data) => {
+          console.log(TAG + ": unregisterAbilityLifecycleCallback3 success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          code3 = error.code;
+          expect(id1 > 0).assertTrue();
+          expect(id2).assertEqual(id1 + 1);
+          expect(id3).assertEqual(id2 + 1);
+          expect(code1).assertEqual(0);
+          expect(code2).assertEqual(0);
+          expect(code3).assertEqual(0);
+          console.log("------------Singlehap_LifeCycleTest_0700 END-------------");
+          done();
+        })
+      }, 3000);
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_0800
+     * @tc.name    Maninability1 Register listening, Repeat starting and termination Ability2
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_0800", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0800 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0800";
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility1",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 3000);
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 4500);
+      setTimeout(function () {
+        console.log(TAG + " registerAbilityLifecycleCallback listKey : " + JSON.stringify(globalThis.list1));
+        console.log(TAG + " registerAbilityLifecycleCallback callbackid : " + JSON.stringify(globalThis.callbackid1));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list1.length; i++) {
+          strtemp = globalThis.list1[i].substring(0, 12);
+          if (strtemp === "MainAbility1" || strtemp === "MainAbility2") {
+            listtemp.push(globalThis.list1[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + listtemp);
+        let exlist = listtemp;
+        expect(exlist[0]).assertEqual("MainAbility1 onAbilityWindowStageCreate");
+        expect(exlist[1]).assertEqual("MainAbility1 onAbilityForeground");
+        expect(exlist[2]).assertEqual("MainAbility2 onAbilityCreate");
+        expect(exlist[3]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+        expect(exlist[4]).assertEqual("MainAbility2 onAbilityForeground");
+        expect(exlist[5]).assertEqual("MainAbility1 onAbilityBackground");
+        expect(exlist[6]).assertEqual("MainAbility1 onAbilityForeground");
+        expect(exlist[7]).assertEqual("MainAbility2 onAbilityBackground");
+        expect(exlist[8]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+        expect(exlist[9]).assertEqual("MainAbility2 onAbilityDestroy");
+        expect(exlist[10]).assertEqual("MainAbility2 onAbilityCreate");
+        expect(exlist[11]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+        expect(exlist[12]).assertEqual("MainAbility2 onAbilityForeground");
+        expect(exlist[13]).assertEqual("MainAbility1 onAbilityBackground");
+        expect(exlist[14]).assertEqual("MainAbility1 onAbilityForeground");
+        expect(exlist[15]).assertEqual("MainAbility2 onAbilityBackground");
+        expect(exlist[16]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+        expect(exlist[17]).assertEqual("MainAbility2 onAbilityDestroy");
+        expect(exlist[18]).assertEqual("MainAbility2 onAbilityCreate");
+        expect(exlist[19]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+        expect(exlist[20]).assertEqual("MainAbility2 onAbilityForeground");
+        expect(exlist[21]).assertEqual("MainAbility1 onAbilityBackground");
+        abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid1, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            console.log("------------Singlehap_LifeCycleTest_0800 END-------------");
+            done();
+          });
+      }, 4950);
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_0900
+     * @tc.name    Repeat switching Ability1 between front and back
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_0900", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_0900 START-------------");
+      TAG = "Singlehap_LifeCycleTest_0900";
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility1",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 2000);
+      setTimeout(function () {
+        console.log(TAG + " registerAbilityLifecycleCallback listKey : " + JSON.stringify(globalThis.list1));
+        console.log(TAG + " registerAbilityLifecycleCallback callbackid : " + JSON.stringify(globalThis.callbackid1));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list1.length; i++) {
+          strtemp = globalThis.list1[i].substring(0, 12);
+          if (strtemp === "MainAbility1" || strtemp === "MainAbility2") {
+            listtemp.push(globalThis.list1[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + listtemp);
+        let exlist = listtemp;
+        expect(exlist[0]).assertEqual("MainAbility1 onAbilityWindowStageCreate");
+        expect(exlist[1]).assertEqual("MainAbility1 onAbilityForeground");
+        expect(exlist[2]).assertEqual("MainAbility2 onAbilityCreate");
+        expect(exlist[3]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+        expect(exlist[4]).assertEqual("MainAbility2 onAbilityForeground");
+        expect(exlist[5]).assertEqual("MainAbility1 onAbilityBackground");
+        expect(exlist[6]).assertEqual("MainAbility1 onAbilityForeground");
+        expect(exlist[7]).assertEqual("MainAbility2 onAbilityBackground");
+        expect(exlist[8]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+        expect(exlist[9]).assertEqual("MainAbility2 onAbilityDestroy");
+        expect(exlist[10]).assertEqual("MainAbility2 onAbilityCreate");
+        expect(exlist[11]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+        expect(exlist[12]).assertEqual("MainAbility2 onAbilityForeground");
+        expect(exlist[13]).assertEqual("MainAbility1 onAbilityBackground");
+        expect(exlist[14]).assertEqual("MainAbility1 onAbilityForeground");
+        expect(exlist[15]).assertEqual("MainAbility2 onAbilityBackground");
+        expect(exlist[16]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+        expect(exlist[17]).assertEqual("MainAbility2 onAbilityDestroy");
+        abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid1, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            console.log("------------Singlehap_LifeCycleTest_0900 END-------------");
+            done();
+          });
+      }, 4000);
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1000
+     * @tc.name    Register listening in abilityA foreground,repeat the registration
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_1000", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1000 START-------------");
+      TAG = "Singlehap_LifeCycleTest_1000";
+      var id1;
+      var id2;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility6",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        console.log(TAG + " firstCallback listKey : " + JSON.stringify(globalThis.list6));
+        console.log(TAG + " firstCallback callbackid : " + JSON.stringify(globalThis.callbackid6));
+        id1 = globalThis.callbackid6;
+        console.log(TAG + " firstCallback id : " + JSON.stringify(id1));
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 2000);
+      setTimeout(function () {
+        console.log(TAG + " secondCallback listKey : " + JSON.stringify(globalThis.list6));
+        console.log(TAG + " secondCallback callbackid : " + JSON.stringify(globalThis.callbackid6));
+        id2 = globalThis.callbackid6;
+        console.log(TAG + " secondCallback id : " + JSON.stringify(id2));
+        expect(id1 + 1).assertEqual(id2);
+        abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid6, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            console.log("------------Singlehap_LifeCycleTest_1000 END-------------");
+            done();
+          });
+      }, 4500);
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1100
+     * @tc.name    Register listening in abilityA foreground,repeat the registration (singleton)
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_1100", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1100 START-------------");
+      TAG = "Singlehap_LifeCycleTest_1100";
+      var id1;
+      var id2;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility7",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        console.log(TAG + " firstCallback listKey : " + JSON.stringify(globalThis.list7));
+        console.log(TAG + " firstCallback callbackid : " + JSON.stringify(globalThis.callbackid7));
+        id1 = globalThis.callbackid7;
+        console.log(TAG + " firstCallback id : " + JSON.stringify(id1));
+        var str = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility7",
+        }
+        globalThis.abilityContext.startAbility(str)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 2000);
+      setTimeout(function () {
+        console.log(TAG + " secondCallback listKey : " + JSON.stringify(globalThis.list7));
+        console.log(TAG + " secondCallback callbackid : " + JSON.stringify(globalThis.callbackid7));
+        id2 = globalThis.callbackid7;
+        console.log(TAG + " secondCallback id : " + JSON.stringify(id2));
+        expect(id1).assertEqual(id2);
+        abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid7, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+          });
+        var para = {
+          resultCode: 1,
+          want: {
+            "abilityName": "MainAbility1",
+            "bundleName": "com.example.lifecycle_xts"
+          }
+        }
+        console.log(TAG + " terminateSelfwithresult para: " + JSON.stringify(para));
+        globalThis.ability7.terminateSelfWithResult(para, (error, data) => {
+          console.log(TAG + " terminateSelfwithresult success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          console.log("------------Singlehap_LifeCycleTest_1100 END-------------");
+          done();
+        });
+      }, 4000);
+    });
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1200
+     * @tc.name    Register listening in abilityA foreground,repeat the registration (standard)
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_1200", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1200 START-------------");
+      TAG = "Singlehap_LifeCycleTest_1200";
+      var id1;
+      var id2;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility8",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        console.log(TAG + " firstCallback listKey : " + JSON.stringify(globalThis.list8));
+        console.log(TAG + " firstCallback callbackid : " + JSON.stringify(globalThis.callbackid8));
+        id1 = globalThis.callbackid8;
+        console.log(TAG + " firstCallback id : " + JSON.stringify(id1));
+        var str = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility8",
+        }
+        globalThis.abilityContext.startAbility(str)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 2000);
+      setTimeout(function () {
+        console.log(TAG + " secondCallback listKey : " + JSON.stringify(globalThis.list8));
+        console.log(TAG + " secondCallback callbackid : " + JSON.stringify(globalThis.callbackid8));
+        id2 = globalThis.callbackid8;
+        console.log(TAG + " secondCallback id : " + JSON.stringify(id2));
+        expect(id1 + 1).assertEqual(id2);
+        abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid8, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+          });
+        var para = {
+          resultCode: 1,
+          want: {
+            "abilityName": "MainAbility8",
+            "bundleName": "com.example.lifecycle_xts"
+          }
+        }
+        console.log(TAG + " terminateSelfwithresult para: " + JSON.stringify(para));
+        globalThis.ability8.terminateSelfWithResult(para, (error, data) => {
+          console.log(TAG + " terminateSelfwithresult success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          console.log("------------Singlehap_LifeCycleTest_1200 END-------------");
+          done();
+        });
+      }, 4000);
+    });
+
+    /*
+    * @tc.number  Singlehap_LifeCycleTest_1300
+    * @tc.name    The ability of HAP A listens to the ability lifecycle callback of HAP B (singleton)
+    * @tc.desc    Function test
+    * @tc.level   0
+    */
+    it("Singlehap_LifeCycleTest_1300", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1300 start-------------");
+      TAG = "Singlehap_LifeCycleTest_1300";
+      listKeyTemp = [];
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycle_xts",
+        abilityName: "MainAbility9"
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility9 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+      await sleep(500);
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycle_xts",
+        abilityName: "Hap1MainAbility1"
+      }, (error, data) => {
+        console.log(TAG + ":first Hap1MainAbility1 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+      await sleep(500);
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycle_xts",
+        abilityName: "Hap1MainAbility1"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": second Hap1MainAbility1 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          for (var i = 0; i < globalThis.mainAbility9ListKey.length; i++) {
+            if (globalThis.mainAbility9ListKey[i].substring(0, 16) == "Hap1MainAbility1") {
+              listKeyTemp.push(globalThis.mainAbility9ListKey[i]);
+            }
+          }
+          console.log(TAG + "listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + "globalThis.mainAbility9CallBackId is :" + globalThis.mainAbility9CallBackId);
+          expect(listKeyTemp[0]).assertEqual("Hap1MainAbility1 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap1MainAbility1 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap1MainAbility1 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap1MainAbility1 onAbilityBackground");
+          expect(listKeyTemp[4]).assertEqual("Hap1MainAbility1 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[5]).assertEqual("Hap1MainAbility1 onAbilityDestroy");
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility9CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              done();
+            });
+        }, 3000)
+      });
+      console.log("------------Singlehap_LifeCycleTest_1300 end-------------");
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1400
+     * @tc.name    The ability of HAP A listens to the ability lifecycle callback of HAP B (standard)
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_1400", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1400 start-------------");
+      TAG = "Singlehap_LifeCycleTest_1400";
+      listKeyTemp = [];
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycle_xts",
+        abilityName: "MainAbility9"
+      }, (error, data) => {
+        console.log(TAG + ": MainAbility9 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+      await sleep(500);
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycle_xts",
+        abilityName: "Hap1MainAbility2"
+      }, (error, data) => {
+        console.log(TAG + ":first Hap1MainAbility2 startAbility success, err: " + JSON.stringify(error) +
+        ",data: " + JSON.stringify(data));
+      });
+      await sleep(500);
+      abilityContext.startAbility({
+        bundleName: "com.example.lifecycle_xts",
+        abilityName: "Hap1MainAbility2"
+      }, (error, data) => {
+        setTimeout(() => {
+          console.log(TAG + ": second Hap1MainAbility2 startAbility success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          for (var i = 0;i < globalThis.mainAbility9ListKey.length; i++) {
+            if (globalThis.mainAbility9ListKey[i].substring(0, 16) == "Hap1MainAbility2") {
+              listKeyTemp.push(globalThis.mainAbility9ListKey[i]);
+            }
+          }
+          console.log(TAG + "listKeyTemp is :" + listKeyTemp);
+          console.log(TAG + "globalThis.mainAbility9CallBackId is :" + globalThis.mainAbility9CallBackId);
+          expect(listKeyTemp[0]).assertEqual("Hap1MainAbility2 onAbilityCreate");
+          expect(listKeyTemp[1]).assertEqual("Hap1MainAbility2 onAbilityWindowStageCreate");
+          expect(listKeyTemp[2]).assertEqual("Hap1MainAbility2 onAbilityForeground");
+          expect(listKeyTemp[3]).assertEqual("Hap1MainAbility2 onAbilityCreate");
+          expect(listKeyTemp[4]).assertEqual("Hap1MainAbility2 onAbilityWindowStageCreate");
+          expect(listKeyTemp[5]).assertEqual("Hap1MainAbility2 onAbilityForeground");
+          expect(listKeyTemp[6]).assertEqual("Hap1MainAbility2 onAbilityBackground");
+          expect(listKeyTemp[7]).assertEqual("Hap1MainAbility2 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[8]).assertEqual("Hap1MainAbility2 onAbilityDestroy");
+          expect(listKeyTemp[9]).assertEqual("Hap1MainAbility2 onAbilityBackground");
+          expect(listKeyTemp[10]).assertEqual("Hap1MainAbility2 onAbilityWindowStageDestroy");
+          expect(listKeyTemp[11]).assertEqual("Hap1MainAbility2 onAbilityDestroy");
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.mainAbility9CallBackId, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              done();
+            });
+        }, 3000)
+      });
+      console.log("------------Singlehap_LifeCycleTest_1400 end-------------");
+    });
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1500
+     * @tc.name    Register in abilityA , starting and termination AbilityB,Repeat previous steps (standard)
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_1500", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1500 START-------------");
+      TAG = "Singlehap_LifeCycleTest_1500";
+      var id1;
+      var id2;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility11",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        console.log(TAG + " firstCallback listKey : " + JSON.stringify(globalThis.list11));
+        console.log(TAG + " firstCallback callbackid : " + JSON.stringify(globalThis.callbackid11));
+        id1 = globalThis.callbackid11;
+        console.log(TAG + " firstCallback id : " + JSON.stringify(id1));
+        var str = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility11",
+        }
+        globalThis.abilityContext.startAbility(str)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+        setTimeout(function () {
+          var str1 = {
+            "bundleName": "com.example.lifecycle_xts",
+            "abilityName": "MainAbility2",
+          }
+          globalThis.abilityContext.startAbility(str1)
+            .then((data) => {
+              console.info(TAG + ' start successful. Data: ' + data);
+            }).catch((error) => {
+            console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+          })
+        }, 1000);
+      }, 3000);
+      setTimeout(function () {
+        console.log(TAG + " secondCallback listKey : " + JSON.stringify(globalThis.list11));
+        console.log(TAG + " secondCallback callbackid : " + JSON.stringify(globalThis.callbackid11));
+        id2 = globalThis.callbackid11;
+        console.log(TAG + " secondCallback id : " + JSON.stringify(id2));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list11.length; i++) {
+          strtemp = globalThis.list11[i].substring(0, 12);
+          if (strtemp == "MainAbility2") {
+            listtemp.push(globalThis.list11[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + JSON.stringify(listtemp));
+        let exlist = listtemp;
+        expect(exlist[0]).assertEqual("MainAbility2 onAbilityCreate");
+        expect(exlist[1]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+        expect(exlist[2]).assertEqual("MainAbility2 onAbilityForeground");
+        expect(exlist[3]).assertEqual("MainAbility2 onAbilityBackground");
+        expect(exlist[4]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+        expect(exlist[5]).assertEqual("MainAbility2 onAbilityDestroy");
+        expect(id1 + 1).assertEqual(id2);
+        abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid11, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            console.log("------------Singlehap_LifeCycleTest_1500 END-------------");
+            done();
+          });
+      }, 6000);
+    });
+
+    var callbackid_NA = 100
+    var callbackid_errorNum = -1
+    var callbackid_errorType = "test"
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1600
+     * @tc.name    input Nonexistent callbackid for unregisterAbilityLifecycleCallback parameter
+     * @tc.desc    Function test
+     * @tc.level   1
+     */
+    it("Singlehap_LifeCycleTest_1600", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1600 START-------------");
+      TAG = "Singlehap_LifeCycleTest_1600";
+      let code;
+      abilityContext.getApplicationContext()
+        .unregisterAbilityLifecycleCallback(callbackid_NA, (error, data) => {
+          console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          code = error.code;
+          sleep(1000);
+          expect(code).assertEqual(1);
+          done();
+        });
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1700
+     * @tc.name    input error callbackid for unregisterAbilityLifecycleCallback parameter
+     * @tc.desc    Function test
+     * @tc.level   1
+     */
+    it("Singlehap_LifeCycleTest_1700", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1700 START-------------");
+      TAG = "Singlehap_LifeCycleTest_1700";
+      let code;
+      abilityContext.getApplicationContext()
+        .unregisterAbilityLifecycleCallback(callbackid_errorNum, (error, data) => {
+          console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          code = error.code;
+          sleep(1000);
+          expect(code).assertEqual(1);
+          done();
+        });
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1800
+     * @tc.name    input error type callbackid for unregisterAbilityLifecycleCallback parameter
+     * @tc.desc    Function test
+     * @tc.level   1
+     */
+    it("Singlehap_LifeCycleTest_1800", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1800 START-------------");
+      TAG = "Singlehap_LifeCycleTest_1800";
+      let code;
+      abilityContext.getApplicationContext()
+        .unregisterAbilityLifecycleCallback(callbackid_errorType, (error, data) => {
+          console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          code = error.code;
+          sleep(1000);
+          expect(code).assertEqual(1);
+          done();
+        });
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_1900
+     * @tc.name    input null callbackid for unregisterAbilityLifecycleCallback parameter
+     * @tc.desc    Function test
+     * @tc.level   1
+     */
+    it("Singlehap_LifeCycleTest_1900", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_1900 START-------------");
+      TAG = "Singlehap_LifeCycleTest_1900";
+      let code;
+      abilityContext.getApplicationContext()
+        .unregisterAbilityLifecycleCallback(null, (error, data) => {
+          console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+          ",data: " + JSON.stringify(data));
+          code = error.code;
+          sleep(1000);
+          expect(code).assertEqual(1);
+          done();
+        });
+    });
+
+    /*
+     * @tc.number  Singlehap_LifeCycleTest_2000
+     * @tc.name    Register in abilityA, starting and termination AbilityB, terminate abilityA, Re-register in abilityA
+     * @tc.desc    Function test
+     * @tc.level   0
+     */
+    it("Singlehap_LifeCycleTest_2000", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_2000 START-------------");
+      TAG = "Singlehap_LifeCycleTest_2000";
+      var id1;
+      var id2;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility12",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility2",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+      }, 500);
+      setTimeout(function () {
+        console.log(TAG + " firstCallback listKey : " + JSON.stringify(globalThis.list12));
+        console.log(TAG + " firstCallback callbackid : " + JSON.stringify(globalThis.callbackid12));
+        id1 = globalThis.callbackid12;
+        console.log(TAG + " firstCallback id : " + JSON.stringify(id1));
+        var para = {
+          resultCode: 2000,
+          want: {
+            "abilityName": "MainAbility12",
+            "bundleName": "com.example.lifecycle_xts"
+          }
+        }
+        console.log(TAG + " terminateSelfwithresult para: " + JSON.stringify(para));
+        globalThis.ability12.terminateSelfWithResult(para)
+          .then((data) => {
+            console.log(TAG + " terminateSelfwithresult successful data: " + JSON.stringify(data));
+          }).catch((error) => {
+          console.log(TAG + " terminateSelfwithresult error: " + JSON.stringify(error));
+        });
+      }, 2500);
+      setTimeout(function () {
+        var str = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility12",
+        }
+        globalThis.abilityContext.startAbility(str)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+        setTimeout(function () {
+          var str1 = {
+            "bundleName": "com.example.lifecycle_xts",
+            "abilityName": "MainAbility2",
+          }
+          globalThis.abilityContext.startAbility(str1)
+            .then((data) => {
+              console.info(TAG + ' start successful. Data: ' + data);
+            }).catch((error) => {
+            console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+          })
+        }, 500);
+      }, 4000);
+      setTimeout(function () {
+        console.log(TAG + " secondCallback listKey : " + JSON.stringify(globalThis.list12));
+        console.log(TAG + " secondCallback callbackid : " + JSON.stringify(globalThis.callbackid12));
+        id2 = globalThis.callbackid12;
+        console.log(TAG + " secondCallback id : " + JSON.stringify(id2));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < globalThis.list12.length; i++) {
+          strtemp = globalThis.list12[i].substring(0, 12);
+          if (strtemp == "MainAbility2") {
+            listtemp.push(globalThis.list12[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + JSON.stringify(listtemp));
+        let exlist = listtemp;
+        expect(exlist[0]).assertEqual("MainAbility2 onAbilityCreate");
+        expect(exlist[1]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+        expect(exlist[2]).assertEqual("MainAbility2 onAbilityForeground");
+        expect(exlist[3]).assertEqual("MainAbility2 onAbilityBackground");
+        expect(exlist[4]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+        expect(exlist[5]).assertEqual("MainAbility2 onAbilityDestroy");
+        expect(id1 + 1).assertEqual(id2);
+        abilityContext.getApplicationContext()
+          .unregisterAbilityLifecycleCallback(globalThis.callbackid6, (error, data) => {
+            console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+            ",data: " + JSON.stringify(data));
+            console.log("------------Singlehap_LifeCycleTest_2000 END-------------");
+            done();
+          });
+      }, 6200);
+    });
+
+    /*
+    * @tc.number  Singlehap_LifeCycleTest_2100
+    * @tc.name    Register in abilityA,register in abilityB, starting and termination abilityC,
+                  termination abilityB、abilityA, Re-register in abilityA、abilityB
+    * @tc.desc    Function test
+    * @tc.level   0
+    */
+    it("Singlehap_LifeCycleTest_2100", 0, async function (done) {
+      console.log("------------Singlehap_LifeCycleTest_2100 START-------------");
+      TAG = "Singlehap_LifeCycleTest_2100";
+      var id1;
+      var id2;
+      var id3;
+      var id4;
+      var str = {
+        "bundleName": "com.example.lifecycle_xts",
+        "abilityName": "MainAbility1",
+      }
+      globalThis.abilityContext.startAbility(str)
+        .then((data) => {
+          console.info(TAG + ' start successful. Data: ' + data);
+        }).catch((error) => {
+        console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+      })
+      setTimeout(function () {
+        var str1 = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility12",
+        }
+        globalThis.abilityContext.startAbility(str1)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+        setTimeout(function () {
+          var str2 = {
+            "bundleName": "com.example.lifecycle_xts",
+            "abilityName": "MainAbility2",
+          }
+          globalThis.abilityContext.startAbility(str2)
+            .then((data) => {
+              console.info(TAG + ' start successful. Data: ' + data);
+            }).catch((error) => {
+            console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+          })
+        }, 500);
+      }, 500);
+      setTimeout(function () {
+        console.log(TAG + " firstCallback listKey1 : " + JSON.stringify(globalThis.list1));
+        console.log(TAG + " firstCallback callbackid1 : " + JSON.stringify(globalThis.callbackid1));
+        console.log(TAG + " firstCallback listKey12 : " + JSON.stringify(globalThis.list12));
+        console.log(TAG + " firstCallback callbackid12 : " + JSON.stringify(globalThis.callbackid12));
+        id1 = globalThis.callbackid1;
+        console.log(TAG + " firstCallback id1 : " + JSON.stringify(id1));
+        id2 = globalThis.callbackid12;
+        console.log(TAG + " firstCallback id12 : " + JSON.stringify(id2));
+        var para = {
+          resultCode: 2100,
+          want: {
+            "abilityName": "MainAbility12",
+            "bundleName": "com.example.lifecycle_xts"
+          }
+        }
+        console.log(TAG + " terminateSelfwithresult para: " + JSON.stringify(para));
+        globalThis.ability12.terminateSelfWithResult(para)
+          .then((data) => {
+            console.log(TAG + " terminateSelfwithresult successful data: " + JSON.stringify(data));
+          }).catch((error) => {
+          console.log(TAG + " terminateSelfwithresult error: " + JSON.stringify(error));
+        });
+        setTimeout(function () {
+          var para = {
+            resultCode: 2100,
+            want: {
+              "abilityName": "MainAbility1",
+              "bundleName": "com.example.lifecycle_xts"
+            }
+          }
+          console.log(TAG + " terminateSelfwithresult para: " + JSON.stringify(para));
+          globalThis.ability1context.terminateSelfWithResult(para)
+            .then((data) => {
+              console.log(TAG + " terminateSelfwithresult successful data: " + JSON.stringify(data));
+            }).catch((error) => {
+            console.log(TAG + " terminateSelfwithresult error: " + JSON.stringify(error));
+          });
+        }, 500);
+      }, 3000);
+      setTimeout(function () {
+        var str = {
+          "bundleName": "com.example.lifecycle_xts",
+          "abilityName": "MainAbility1",
+        }
+        globalThis.abilityContext.startAbility(str)
+          .then((data) => {
+            console.info(TAG + ' start successful. Data: ' + data);
+          }).catch((error) => {
+          console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+        })
+        setTimeout(function () {
+          var str1 = {
+            "bundleName": "com.example.lifecycle_xts",
+            "abilityName": "MainAbility12",
+          }
+          globalThis.abilityContext.startAbility(str1)
+            .then((data) => {
+              console.info(TAG + ' start successful. Data: ' + data);
+            }).catch((error) => {
+            console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+          })
+          setTimeout(function () {
+            var str2 = {
+              "bundleName": "com.example.lifecycle_xts",
+              "abilityName": "MainAbility2",
+            }
+            globalThis.abilityContext.startAbility(str2)
+              .then((data) => {
+                console.info(TAG + ' start successful. Data: ' + data);
+              }).catch((error) => {
+              console.error(TAG + ' start failed. Cause: ' + JSON.stringify(error));
+            })
+          }, 500);
+        }, 500);
+      }, 4000);
+      setTimeout(function () {
+        console.log(TAG + " secondCallback listKey1 : " + JSON.stringify(globalThis.list1));
+        let templist1 = globalThis.list1;
+        console.log(TAG + " secondCallback templist1 : " + JSON.stringify(templist1));
+        console.log(TAG + " secondCallback callbackid1 : " + JSON.stringify(globalThis.callbackid1));
+        console.log(TAG + " secondCallback listKey12 : " + JSON.stringify(globalThis.list12));
+        let templist2 = globalThis.list12;
+        console.log(TAG + " secondCallback templist2 : " + JSON.stringify(templist2));
+        console.log(TAG + " secondCallback callbackid12 : " + JSON.stringify(globalThis.callbackid12));
+        id3 = globalThis.callbackid1;
+        console.log(TAG + " secondCallback id1 : " + JSON.stringify(id3));
+        id4 = globalThis.callbackid12;
+        console.log(TAG + " secondCallback id12 : " + JSON.stringify(id4));
+        var strtemp = "";
+        var listtemp = [];
+        for (var i = 0; i < templist1.length; i++) {
+          strtemp = templist1[i].substring(0, 13);
+          if (strtemp === "MainAbility2 " || strtemp === "MainAbility12") {
+            listtemp.push(templist1[i]);
+          }
+        }
+        console.log(TAG + " listtemp is :" + JSON.stringify(listtemp));
+        setTimeout(function () {
+          var strtemp1 = "";
+          var listtemp1 = [];
+          for (var j = 0; j < templist2.length; j++) {
+            strtemp1 = templist2[j].substring(0, 12);
+            if (strtemp1 === "MainAbility2") {
+              listtemp1.push(templist2[j]);
+            }
+          }
+          console.log(TAG + " listtemp1 is :" + JSON.stringify(listtemp1));
+          let exlist = listtemp;
+          let exlist1 = listtemp1;
+          expect(exlist[0]).assertEqual("MainAbility12 onAbilityCreate");
+          expect(exlist[1]).assertEqual("MainAbility12 onAbilityWindowStageCreate");
+          expect(exlist[2]).assertEqual("MainAbility12 onAbilityForeground");
+          expect(exlist[3]).assertEqual("MainAbility2 onAbilityCreate");
+          expect(exlist[4]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+          expect(exlist[5]).assertEqual("MainAbility2 onAbilityForeground");
+          expect(exlist[6]).assertEqual("MainAbility12 onAbilityBackground");
+          expect(exlist[7]).assertEqual("MainAbility12 onAbilityForeground");
+          expect(exlist[8]).assertEqual("MainAbility2 onAbilityBackground");
+          expect(exlist[9]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+          expect(exlist[10]).assertEqual("MainAbility2 onAbilityDestroy");
+          expect(exlist1[0]).assertEqual("MainAbility2 onAbilityCreate");
+          expect(exlist1[1]).assertEqual("MainAbility2 onAbilityWindowStageCreate");
+          expect(exlist1[2]).assertEqual("MainAbility2 onAbilityForeground");
+          expect(exlist1[3]).assertEqual("MainAbility2 onAbilityBackground");
+          expect(exlist1[4]).assertEqual("MainAbility2 onAbilityWindowStageDestroy");
+          expect(exlist1[5]).assertEqual("MainAbility2 onAbilityDestroy");
+          expect(id1 + 1).assertEqual(id2);
+          expect(id3 + 1).assertEqual(id4);
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.callbackid12, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+            });
+          abilityContext.getApplicationContext()
+            .unregisterAbilityLifecycleCallback(globalThis.callbackid1, (error, data) => {
+              console.log(TAG + ": unregisterAbilityLifecycleCallback success, err: " + JSON.stringify(error) +
+              ",data: " + JSON.stringify(data));
+              console.log("------------Singlehap_LifeCycleTest_2100 END-------------");
+              done();
+            });
+        }, 100);
+      }, 7000);
+    });
+  })
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/ets/test/ListTest.ets

+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import LifeCycleTest from './LifeCycleTest'
+
+export default function List(context) {
+  LifeCycleTest(context)
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/module.json

+{
+    "module": {
+        "name": "phone",
+        "type": "entry",
+        "srcEntrance": "./ets/Application/AbilityStage.ts",
+        "description": "$string:phone_entry_dsc",
+        "mainElement": "MainAbility",
+        "deviceTypes": [
+            "phone"
+        ],
+        "deliveryWithInstall": true,
+        "installationFree": false,
+        "uiSyntax": "ets",
+        "pages": "$profile:main_pages",
+        "abilities": [{
+            "name": "com.example.lifecycle_xts.MainAbility",
+            "srcEntrance": "./ets/MainAbility/MainAbility.ts",
+            "description": "$string:phone_entry_main",
+            "icon": "$media:icon",
+            "label": "$string:entry_label",
+            "visible": true,
+            "orientation": "portrait",
+            "skills": [{
+                "actions": [
+                    "action.system.home"
+                ],
+                "entities": [
+                    "entity.system.home"
+                ]
+            }]
+        },
+        {
+            "name": "MainAbility1",
+            "srcEntrance": "./ets/MainAbility1/MainAbility1.ts",
+            "description": "$string:MainAbility1_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility1_label"
+          },
+          {
+            "name": "MainAbility2",
+            "srcEntrance": "./ets/MainAbility2/MainAbility2.ts",
+            "description": "$string:MainAbility2_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility2_label"
+          },
+          {
+            "name": "MainAbility3",
+            "srcEntrance": "./ets/MainAbility3/MainAbility3.ts",
+            "description": "$string:MainAbility3_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility3_label"
+          },
+          {
+            "name": "MainAbility4",
+            "srcEntrance": "./ets/MainAbility4/MainAbility4.ts",
+            "description": "$string:MainAbility4_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility4_label"
+          },
+          {
+            "name": "MainAbility5",
+            "srcEntrance": "./ets/MainAbility5/MainAbility5.ts",
+            "description": "$string:MainAbility5_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility5_label"
+          },
+          {
+            "name": "MainAbility6",
+            "srcEntrance": "./ets/MainAbility6/MainAbility6.ts",
+            "description": "$string:MainAbility6_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility6_label"
+          },
+          {
+            "name": "MainAbility7",
+            "srcEntrance": "./ets/MainAbility7/MainAbility7.ts",
+            "description": "$string:MainAbility7_desc",
+            "launchType": "singleton",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility7_label"
+          },
+          {
+            "name": "MainAbility8",
+            "srcEntrance": "./ets/MainAbility8/MainAbility8.ts",
+            "description": "$string:MainAbility8_desc",
+            "launchType": "standard",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility8_label"
+          },
+          {
+            "name": "MainAbility9",
+            "srcEntrance": "./ets/MainAbility9/MainAbility9.ts",
+            "description": "$string:MainAbility9_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility9_label"
+          },
+          {
+            "name": "Hap1MainAbility1",
+            "srcEntrance": "./ets/Hap1MainAbility1/Hap1MainAbility1.ts",
+            "description": "$string:Hap1MainAbility1_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap1MainAbility1_label",
+            "launchType": "singleton"
+          },
+          {
+            "name": "Hap1MainAbility2",
+            "srcEntrance": "./ets/Hap1MainAbility2/Hap1MainAbility2.ts",
+            "description": "$string:Hap1MainAbility2_desc",
+            "icon": "$media:icon",
+            "label": "$string:Hap1MainAbility2_label",
+            "launchType": "standard"
+          },
+          {
+            "name": "MainAbility10",
+            "srcEntrance": "./ets/MainAbility10/MainAbility10.ts",
+            "description": "$string:MainAbility10_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility10_label"
+          },
+          {
+            "name": "MainAbility11",
+            "srcEntrance": "./ets/MainAbility11/MainAbility11.ts",
+            "description": "$string:MainAbility11_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility11_label",
+            "launchType": "standard"
+          },
+          {
+            "name": "MainAbility12",
+            "srcEntrance": "./ets/MainAbility12/MainAbility12.ts",
+            "description": "$string:MainAbility12_desc",
+            "icon": "$media:icon",
+            "label": "$string:MainAbility12_label"
+          }]
+    }
+}
\ No newline at end of file

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/resources/base/element/string.json

+{
+  "string":  [
+      {
+          "name": "phone_entry_dsc",
+          "value": "i am an entry for phone"
+      },
+      {
+          "name": "phone_entry_main",
+          "value": "the phone entry ability"
+      },
+      {
+          "name": "entry_label",
+          "value": "ActsContextTest"
+      },
+      {
+          "name": "form_description",
+          "value": "my form"
+      },
+      {
+          "name": "serviceability_description",
+          "value": "my whether"
+      },
+      {
+          "name": "description_application",
+          "value": "demo for test"
+      },
+      {
+        "name": "entry_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility1_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility1_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility2_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility2_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility3_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility3_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility4_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility4_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility5_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility5_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility6_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility6_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility7_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility7_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility8_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility8_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility9_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility9_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap1MainAbility1_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap1MainAbility1_label",
+        "value": "label"
+      },
+      {
+        "name": "Hap1MainAbility2_desc",
+        "value": "description"
+      },
+      {
+        "name": "Hap1MainAbility2_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility10_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility10_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility11_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility11_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility12_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility12_label",
+        "value": "label"
+      },
+      {
+        "name": "MainAbility13_desc",
+        "value": "description"
+      },
+      {
+        "name": "MainAbility13_label",
+        "value": "label"
+      }
+  ]
+}

aafwk/aafwk_standard/stage/actslifecyclesinglehaptest/entry/src/main/resources/base/profile/main_pages.json

+{
+  "src": [
+    "pages/index",
+    "pages/index1",
+    "pages/index2",
+    "pages/index3",
+    "pages/index4",
+    "pages/index5",
+    "pages/index6",
+    "pages/index7",
+    "pages/index8",
+    "pages/index9",
+    "pages/index10",
+    "pages/index11",
+    "pages/index12",
+    "pages/indexh1a1",
+    "pages/indexh1a2"
+  ]
+}