@sapui5/sap.ushell 1.133.0 → 1.134.1

package/src/main/js/sap/ushell/components/applicationIntegration/AppLifeCycle.js

@@ -1,20 +1,31 @@
-// Copyright (c) 2009-2024 SAP SE, All Rights Reserved
+// Copyright (c) 2009-2025 SAP SE, All Rights Reserved
 
 /**
  * @fileOverview handle all the resources for the different applications.
- * @version 1.133.0
+ * @version 1.134.1
  */
 sap.ui.define([
+    "sap/base/util/deepEqual",
+    "sap/base/util/ObjectPath",
     "sap/ui/Device",
     "sap/ui/core/Element",
     "sap/ui/core/EventBus",
-    "sap/ushell/components/applicationIntegration/Storage",
-    "sap/ushell/components/applicationIntegration/application/BlueBoxHandler",
-    "sap/ushell/components/applicationIntegration/application/Application",
-    "sap/ushell/components/applicationIntegration/application/PostMessageUtils",
-    "sap/ushell/components/applicationIntegration/application/WebGUIStatefulHandler",
-    "sap/ushell/components/applicationIntegration/relatedServices/RelatedServices",
+    "sap/ushell/components/applicationIntegration/KeepAliveApps",
+    "sap/ushell/state/BackNavigation",
     "sap/ushell/components/applicationIntegration/configuration/AppMeta",
+    "sap/ushell/components/applicationIntegration/contracts/EmbeddedUI5Handler",
+    "sap/ushell/components/applicationIntegration/contracts/StatefulContainerV1Handler",
+    "sap/ushell/components/applicationIntegration/contracts/StatefulContainerV2Handler",
+    "sap/ushell/components/applicationIntegration/ApplicationContainerCache",
+    "sap/ushell/components/applicationIntegration/PostMessageManager/AppruntimeHandler",
+    "sap/ushell/components/applicationIntegration/PostMessageManager/NWBCHandler",
+    "sap/ushell/components/applicationIntegration/PostMessageManager/LifecycleHandler",
+    "sap/ushell/components/applicationIntegration/PostMessageManager/ServiceHandler",
+    "sap/ushell/components/applicationIntegration/PostMessageManager/MessageBrokerHandler",
+    "sap/ushell/components/applicationIntegration/PostMessageManager",
+    "sap/ushell/components/applicationIntegration/PostMessagePluginInterface",
+    "sap/ushell/components/applicationIntegration/IframeApplicationContainer",
+    "sap/ushell/components/applicationIntegration/UI5ApplicationContainer",
     "sap/ushell/services/AppConfiguration",
     "sap/ushell/utils",
     "sap/ushell/Config",
@@ -36,18 +47,30 @@ sap.ui.define([
     "sap/ushell/state/KeepAlive",
     "sap/ushell/ui5service/ShellUIServiceFactory",
     "sap/ui/core/service/ServiceFactoryRegistry",
-    "sap/base/util/ObjectPath"
+    "sap/ushell/library",
+    "sap/ushell/components/applicationIntegrationOld/AppLifeCycle"
 ], (
+    deepEqual,
+    ObjectPath,
     Device,
     Element,
     EventBus,
-    Storage,
-    BlueBoxHandler,
-    Application,
-    PostMessageUtils,
-    WebGUIStatefulHandler,
-    RelatedServices,
+    KeepAliveApps,
+    BackNavigation,
     AppMeta,
+    EmbeddedUI5Handler,
+    StatefulContainerV1Handler,
+    StatefulContainerV2Handler,
+    ApplicationContainerCache,
+    AppRuntimeHandler,
+    NWBCHandler,
+    LifecycleHandler,
+    ServiceHandler,
+    MessageBrokerHandler,
+    PostMessageManager,
+    PostMessagePluginInterface,
+    IframeApplicationContainer,
+    UI5ApplicationContainer,
     AppConfiguration,
     ushellUtils,
     Config,
@@ -69,10 +92,19 @@ sap.ui.define([
     KeepAlive,
     ShellUIServiceFactory,
     ServiceFactoryRegistry,
-    ObjectPath
+    ushellLibrary,
+    AppLifeCycleFallback
 ) => {
     "use strict";
 
+    if (Config.last("/core/navigation/enableAppLifeCycleFallback")) {
+        ObjectPath.set("sap.ushell.components.applicationIntegration.AppLifeCycle", AppLifeCycleFallback);
+        return AppLifeCycleFallback;
+    }
+
+    // shortcut for sap.ushell.components.applicationIntegration.contracts.StatefulType
+    const StatefulType = ushellLibrary.components.applicationIntegration.contracts.StatefulType;
+
     // shortcut for sap.ushell.state.StateManager.ShellMode
     const ShellMode = StateManager.ShellMode;
 
@@ -89,11 +121,13 @@ sap.ui.define([
     // const CACHED_APP_TYPES = ["URL"];
 
     const KEEP_ALIVE_MODES = {
-        FULL: "true",
-        RESTRICTED: "restricted",
-        FALSE: "false"
+        True: "true",
+        Restricted: "restricted",
+        False: ""
     };
 
+    const iValidIframeTimeout = 3500;
+
     function AppLifeCycle () {
         //Dangling controls is a queue of requests to change shell elements attributes, requested by the application in the process of createContent before the actual application state was apply.
         let bDisableHomeAppCache = false;
@@ -109,13 +143,6 @@ sap.ui.define([
             MessageBrokerEngine.connect("FLP");
         }
 
-        /**
-         * @returns {object} Returns the RelatedServices API.
-         */
-        this.service = function () {
-            return RelatedServices;
-        };
-
         /**
          * Sets the componentCreated promise for a given appId if it does not exist yet.
          * Returns the promise along with the resolve and reject functions.
@@ -156,12 +183,14 @@ sap.ui.define([
         /**
          * Returns the componentCreated promise for the given appId. If the promise does not yet exist, it is created.
          * @param {string} sStorageAppId The id of the created application.
-         * @returns {Promise | undefined} The componentCreated promise for the given appId or undefined if no appId is given.
+         * @returns {Promise} The componentCreated promise for the given appId.
          * @private
          * @since 1.125.0
          */
-        this._getComponentCreatedPromise = function (sStorageAppId) {
-            if (!sStorageAppId) { return; }
+        this._getComponentCreatedPromise = async function (sStorageAppId) {
+            if (!sStorageAppId) {
+                return;
+            }
             return this._setComponentCreatedPromise(sStorageAppId).promise;
         };
 
@@ -185,20 +214,18 @@ sap.ui.define([
          * @param {object} oData
          */
         this._onComponentCreated = function (oEvent, sChannel, oData) {
-            const oApp = oData.component;
-            const sStorageAppId = this._normalizeAppId(oApp.getId());
-            const oStorageEntry = Storage.get(sStorageAppId);
+            const oAppComponent = oData.component;
+            const sStorageAppId = this._normalizeAppId(oAppComponent.getId());
+            const oStorageEntry = KeepAliveApps.get(sStorageAppId);
 
             if (oStorageEntry) {
-                oStorageEntry.app = oApp;
-                Application.active(oStorageEntry.app);
-
+                oStorageEntry.app = oAppComponent;
             } else {
-                oCurrentApplication.app = oApp;
+                oCurrentApplication.app = oAppComponent;
+            }
 
-                if (oApp.active) {
-                    oApp.active();
-                }
+            if (oAppComponent.active) {
+                oAppComponent.active();
             }
 
             this._resolveComponentCreatedPromise(sStorageAppId);
@@ -216,56 +243,108 @@ sap.ui.define([
         /**
          * @param {string} sStorageAppId
          */
-        this._store = function (sStorageAppId) {
-            const oStorageEntry = Storage.get(sStorageAppId);
+        this._storeApplication = async function (sStorageAppId) {
+            const oStorageEntry = KeepAliveApps.get(sStorageAppId);
 
             if (oStorageEntry) {
-                Application.store(oStorageEntry);
+                const oApplicationContainer = oStorageEntry.container;
+                const bShouldBeKeptAlive = oApplicationContainer.getIsKeepAlive();
+                if (!bShouldBeKeptAlive) {
+                    Log.error("Application should be kept alive but the flag is not set", null, "sap.ushell.components.applicationIntegration.AppLifeCycle");
+                    return;
+                }
+
+                if (oApplicationContainer.isA("sap.ushell.components.applicationIntegration.IframeApplicationContainer")) {
+                    if (oApplicationContainer.getStatefulType() === StatefulType.ContractV2) {
+                        const bSupportsKeepAliveWithinSameFrame = StatefulContainerV2Handler.isStatefulContainerSupportingKeepAlive(oApplicationContainer);
+
+                        if (bSupportsKeepAliveWithinSameFrame) {
+                            const sActualAppFromId = oApplicationContainer.getCurrentAppId();
+                            if (!sActualAppFromId) {
+                                return; // stateful container is already stored
+                            }
+
+                            // return the container to the pool
+                            this._setContainerReadyForReuse(oApplicationContainer);
+
+                            await StatefulContainerV2Handler.storeAppWithinSameFrame(oApplicationContainer, sActualAppFromId);
+                        }
+                    }
+
+                    await oApplicationContainer.sendRequest("sap.ushell.appRuntime.keepAliveAppHide", {}, false);
+
+                } else if (oApplicationContainer.isA("sap.ushell.components.applicationIntegration.UI5ApplicationContainer")) {
+                    await EmbeddedUI5Handler.storeApp(oApplicationContainer, oStorageEntry);
+                }
+
+                // close storage entry
                 oStorageEntry.stateStored = true;
+
+                // todo: [FLPCOREANDUX-10024] clarify how to handle appClosed events
+                EventBus.getInstance().publish("sap.ushell", "appClosed", oApplicationContainer);
             }
         };
 
         /**
+         * Should remove their foot print and prepare for possible reuse.
          * @param {string} sStorageAppId
          * @param {object} oApplicationContainer
-         * @param {boolean} bHardDestroy
+         * @param {boolean} [bIgnoreReuse=false]
          * @returns {Promise} Resolves when the app is destroyed.
          */
-        this._destroyApplication = async function (sStorageAppId, oApplicationContainer, bHardDestroy) {
-            const oStorageEntry = Storage.get(sStorageAppId);
+        this._destroyApplication = async function (sStorageAppId, oApplicationContainer, bIgnoreReuse) {
+            if (typeof sStorageAppId !== "string" || !oApplicationContainer) {
+                return;
+            }
 
-            if (!sStorageAppId || !oApplicationContainer) {
+            if (!oApplicationContainer.getCurrentAppId() && !bIgnoreReuse) {
+                // no active app in the container, only destroy this app if it shall not be reused.
                 return;
             }
 
-            // todo: [FLPCOREANDUX-10024] instead we should check for keepAlive property
-            // ignore stateful destroy when hard destroy is requested
-            if (oStorageEntry && !bHardDestroy) { // keep alive
-                Storage.removeById(sStorageAppId);
+            const oStorageEntry = KeepAliveApps.get(sStorageAppId);
 
-                // Stateful - appruntime (v1, v2 keepAlive is not stateful)
-                if (BlueBoxHandler.isStatefulContainer(oStorageEntry.container)) {
-                    await BlueBoxHandler.statefulDestroyApp(oStorageEntry.container, sStorageAppId);
+            KeepAliveApps.removeById(sStorageAppId);
+            KeepAlive.destroy(oStorageEntry);
 
-                    // Return v1, v2 keepAlive to pool
-                } else if (oStorageEntry.container.getIsKeepAlive() && BlueBoxHandler.isReusableContainer(oStorageEntry.container)) {
-                    BlueBoxHandler.returnUnusedKeepAliveContainer(oStorageEntry.container);
-                    await this._handleExitStateful(oStorageEntry.container, false);
+            // ===============================================================================
+            // try to reuse the iframe
 
-                    // embedded keep alive
-                } else {
-                    this._removeApplicationContainerFromViewPort(sStorageAppId);
-                    BlueBoxHandler.deleteBlueBoxByContainer(oStorageEntry.container);
-                    oStorageEntry.container.destroy();
+            const bIsReusableContainer = oApplicationContainer.getStatefulType() !== StatefulType.NotSupported;
+            if (!bIgnoreReuse && bIsReusableContainer) {
+                // First return the container to the pool in case it was keep alive.
+                // the "return to pool" step requires the current metadata and has to be done before the actual close
+                this._setContainerReadyForReuse(oApplicationContainer);
+
+                // Second close the app
+                if (oApplicationContainer.getStatefulType() === StatefulType.ContractV2) {
+                    await StatefulContainerV2Handler.destroyApp(oApplicationContainer, sStorageAppId);
+
+                } else if (oApplicationContainer.getStatefulType() === StatefulType.ContractV1) {
+                    await StatefulContainerV1Handler.destroyApp(oApplicationContainer, sStorageAppId);
                 }
+
+                // todo: [FLPCOREANDUX-10024] clarify how to handle appClosed events
+                EventBus.getInstance().publish("sap.ushell", "appClosed", oApplicationContainer);
                 return;
             }
 
-            if (bHardDestroy) {
-                Storage.removeByContainer(oApplicationContainer);
+            // ===============================================================================
+            // the app or iframe cannot be reused (or should not be reused) so we destroy it
+
+            // try to close the iframe gracefully
+            if (oApplicationContainer.getStatefulType() === StatefulType.ContractV2) {
+                await StatefulContainerV2Handler.destroyApp(oApplicationContainer, sStorageAppId);
+
+            } else if (oApplicationContainer.getStatefulType() === StatefulType.ContractV1) {
+                await StatefulContainerV1Handler.destroyApp(oApplicationContainer, sStorageAppId);
             }
 
-            this._removeApplicationContainerFromViewPort(sStorageAppId);
+            // remove all other related apps from the storage
+            KeepAliveApps.removeByContainer(oApplicationContainer, (oStorageEntry) => {
+                KeepAlive.destroy(oStorageEntry);
+            });
+
             /**
              * If the application running in an iframe registered for "before close" event,
              * we first post it a message to prepare for closing (usually, the app will close
@@ -290,158 +369,105 @@ sap.ui.define([
                 );
             }
 
-            if (oStorageEntry) {
-                KeepAlive.destroy(oStorageEntry);
-            }
+            ApplicationContainerCache.removeByContainer(oApplicationContainer);
+            this._removeApplicationContainerFromViewPort(oApplicationContainer);
 
-            BlueBoxHandler.deleteBlueBoxByContainer(oApplicationContainer);
-            Application.destroy(oApplicationContainer);
+            try {
+                oApplicationContainer.destroy();
+            } catch (oError) {
+                Log.error(
+                    `Exception when trying to close application with id '${oApplicationContainer.getId()}'. This error must be fixed in order for FLP to operate properly.`,
+                    oError,
+                    "sap.ushell.components.applicationIntegration.AppLifeCycle"
+                );
+            }
         };
 
         /**
          * @param {string} sStorageAppId
          */
-        this._restore = function (sStorageAppId) {
-            const oStorageEntry = Storage.get(sStorageAppId);
+        this._restoreApplication = async function (sStorageAppId) {
+            const oStorageEntry = KeepAliveApps.get(sStorageAppId);
 
             if (oStorageEntry?.stateStored) {
                 // 1) Extensions
-                RelatedServices.restore(oStorageEntry.service);
+                BackNavigation.restore(oStorageEntry.service);
                 AppMeta.restore(oStorageEntry.meta);
+
                 // 2) Extension API
                 ShellUIServiceFactory.restore(oStorageEntry);
+
                 // 3) Application
-                Application.restore(oStorageEntry);
-            }
-        };
+                const oApplicationContainer = oStorageEntry.container;
+                if (oApplicationContainer.isA("sap.ushell.components.applicationIntegration.IframeApplicationContainer")) {
+                    await oApplicationContainer.sendRequest("sap.ushell.appRuntime.keepAliveAppShow", {}, false);
 
-        /**
-         * @param {object} oApplicationContainer
-         * @param {boolean} bNavigationToFlpComponent
-         * @param {boolean} [bForceCloseApp]
-         * @returns {Promise} Resolves when the app is closed.
-         */
-        this._handleExitStateful = function (oApplicationContainer, bNavigationToFlpComponent, bForceCloseApp) {
-            const sActualAppFromId = oApplicationContainer.getCurrentAppId();
-
-            if (Storage.get(sActualAppFromId)) {
-                const bDestroyApp = bForceCloseApp || (RelatedServices.isBackNavigation() && !bNavigationToFlpComponent);
-                if (bDestroyApp) {
-                    EventBus.getInstance().publish("sap.ushell", "appClosed", oApplicationContainer);
-                    Storage.removeById(sActualAppFromId);
-                    return BlueBoxHandler.statefulDestroyApp(oApplicationContainer);
+                } else if (oApplicationContainer.isA("sap.ushell.components.applicationIntegration.UI5ApplicationContainer")) {
+                    await EmbeddedUI5Handler.restoreAppAfterNavigate(oApplicationContainer, oStorageEntry);
                 }
-                // in this case the store of the currently running application, so we do not need to pass the sCacheId
-                EventBus.getInstance().publish("sap.ushell", "appClosed", oApplicationContainer);
-                return BlueBoxHandler.statefulStoreKeepAliveApp(oApplicationContainer, sActualAppFromId);
             }
-            // in this case the destroy of the currently running application, so we do not need to pass the sCacheId
-            return BlueBoxHandler.statefulDestroyApp(oApplicationContainer);
         };
 
         /**
          * @param {object} oOldApplicationContainer
          * @param {boolean} bNavigationToFlpComponent
-         * @param {boolean} bFromAfterNavigate
          * @returns {Promise} Resolves when the app is closed.
          */
-        this._handleExitApplication = async function (oOldApplicationContainer, bNavigationToFlpComponent, bFromAfterNavigate) {
+        this._handleExitApplication = async function (oOldApplicationContainer, bNavigationToFlpComponent) {
             if (!oOldApplicationContainer) {
                 return;
             }
 
             const sOldStorageAppId = oOldApplicationContainer.getCurrentAppId();
-
             if (!sOldStorageAppId) {
+                // no active app in the container
                 return;
             }
 
-            // todo: [FLPCOREANDUX-10024] should not be necessary; the destroy should be callable multiple times w/o issues
-            // if called from onAfterNavigate, do nothing if oOldApplicationContainer is stateful container, because
-            // application was already closed at the beginning of 'handleCreateApplicationContainer'
-            if (!bNavigationToFlpComponent
-                && bFromAfterNavigate
-                && (
-                    BlueBoxHandler.isStatefulContainer(oOldApplicationContainer)
-                    || BlueBoxHandler.isStatefulContainerInKeepAlivePool(oOldApplicationContainer)
-                )
-            ) {
-                return;
-            }
-
-            const oOldStorageEntry = Storage.get(sOldStorageAppId);
-            // STATEFUL
-            if (BlueBoxHandler.isStatefulContainer(oOldApplicationContainer)) {
-                await this._handleExitStateful(oOldApplicationContainer, bNavigationToFlpComponent);
+            const bNavigationBackToApp = BackNavigation.isBackNavigation() && !bNavigationToFlpComponent;
 
-                //STATELESS
-            } else if (oOldStorageEntry) {
-                // Back Navigation Case
-                if (RelatedServices.isBackNavigation() && !bNavigationToFlpComponent) {
-                    //check if the Iframe needs to be cached instead of destroy
-                    if (oOldApplicationContainer.getIsKeepAlive() && BlueBoxHandler.isReusableContainer(oOldApplicationContainer)) {
-                        BlueBoxHandler.returnUnusedKeepAliveContainer(oOldApplicationContainer);
-                        await this._handleExitStateful(oOldApplicationContainer, bNavigationToFlpComponent);
+            // Back Navigation Case
+            if (bNavigationBackToApp) {
+                await this._destroyApplication(sOldStorageAppId, oOldApplicationContainer); // todo: [FLPCOREANDUX-10024] new marker
 
-                    } else {
-                        await this._destroyApplication(sOldStorageAppId, oOldApplicationContainer);
-                    }
-
-                    // Forward Navigation Cases
-                } else if (oOldApplicationContainer.getApplicationType() === "UI5") {
+            // Forward Navigation Case
+            //      (and back navigation to FLP component)
+            } else {
+                // todo: [FLPCOREANDUX-10024] this should probably moved to a UI5 ApplicationContainer implementation
+                if (oOldApplicationContainer.isA("sap.ushell.components.applicationIntegration.UI5ApplicationContainer")) {
                     // Wait until navigation's source app has been started completely, so that a later back navigation finds a proper app that
                     // can be re-enabled (keep-alive scenario)
                     await this._getComponentCreatedPromise(sOldStorageAppId);
-                    this._store(sOldStorageAppId);
-                } else {
-                    this._store(sOldStorageAppId);
                 }
-                EventBus.getInstance().publish("sap.ushell", "appClosed", oOldApplicationContainer);
 
-                // LEGACY STATEFUL (WebGUI)
-            } else if (oOldApplicationContainer.getStatefulType() === BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
-                if (bNavigationToFlpComponent) {
-                    await PostMessageUtils.postMessageToIframeApp(oOldApplicationContainer, "sap.gui", "triggerCloseSessionImmediately");
+                if (oOldApplicationContainer.getIsKeepAlive()) {
+                    return this._storeApplication(sOldStorageAppId);
                 }
-
-                // THE REST...
-            } else {
-                //destroy the application and its resources
-                await this._destroyApplication(sOldStorageAppId, oOldApplicationContainer);
+                return this._destroyApplication(sOldStorageAppId, oOldApplicationContainer);
             }
         };
 
         /**
          * @param {function(): boolean} fnFilterApps The filter function
+         * @param {boolean} [bIgnoreReuse=false]
          * @returns {Promise} Resolves when all keep alive apps are closed.
          */
-        this._closeKeepAliveApps = function (fnFilterApps) {
+        this._destroyKeepAliveApps = async function (fnFilterApps, bIgnoreReuse) {
             try {
-                const aKeepAliveRestrictedApps = [];
+                const aFilteredApps = [];
 
-                Storage.forEach((oStorageEntry) => {
+                KeepAliveApps.forEach((oStorageEntry) => {
                     if (fnFilterApps(oStorageEntry)) {
-                        aKeepAliveRestrictedApps.push(oStorageEntry);
+                        aFilteredApps.push(oStorageEntry);
                     }
                 });
-                const aClosePromises = aKeepAliveRestrictedApps.map((oRestrictedApp) => {
-                    //check if it needs to be cached instead of destroy
-                    const bCanHandleKeepAlive = BlueBoxHandler.isStatefulContainerSupportingKeepAlive(oRestrictedApp.container);
-                    const bIsKeepAlive = oRestrictedApp.container.getIsKeepAlive();
-                    const bIsReusable = BlueBoxHandler.isReusableContainer(oRestrictedApp.container);
-
-                    if (!bCanHandleKeepAlive && bIsKeepAlive && bIsReusable) {
-                        BlueBoxHandler.returnUnusedKeepAliveContainer(oRestrictedApp.container);
-                        // todo: [FLPCOREANDUX-10024] what is the actual difference between destroyApplication and handleExitStateful?
-                        return this._handleExitStateful(oRestrictedApp.container, true, true);
-                    }
-
-                    return this._destroyApplication(oRestrictedApp.appId, oRestrictedApp.container);
+                const aClosePromises = aFilteredApps.map((oFilteredApp) => {
+                    return this._destroyApplication(oFilteredApp.appId, oFilteredApp.container, bIgnoreReuse);
                 });
 
-                return Promise.all(aClosePromises);
+                await Promise.allSettled(aClosePromises);
             } catch (e) {
-                Log.error("closeKeepAliveApps call failed", e);
+                Log.error("_destroyKeepAliveApps call failed", e);
             }
         };
 
@@ -450,18 +476,18 @@ sap.ui.define([
          * @param {object} oFrom
          */
         this.onBeforeNavigate = function (sFromId, oFrom) {
-            if (sFromId && oFrom && oFrom.isA("sap.ushell.components.container.ApplicationContainer")) {
+            if (sFromId && oFrom && oFrom.isA("sap.ushell.components.applicationIntegration.ApplicationContainer")) {
                 const sStorageAppId = sFromId;
                 const oApplicationContainer = oFrom;
 
-                const bHasIframe = !!oApplicationContainer._getIFrame(); // todo: [FLPCOREANDUX-10024] is this really required?
-                const bIsSupportedType = oApplicationContainer.getStatefulType() > BlueBoxHandler.STATEFUL_TYPES.NOT_SUPPORTED;
+                const bHasIframe = !!oApplicationContainer.isA("sap.ushell.components.applicationIntegration.IframeApplicationContainer"); // todo: [FLPCOREANDUX-10024] is this really required?
+                const bIsSupportedType = oApplicationContainer.getStatefulType() > StatefulType.NotSupported;
 
-                const bCached = !!Storage.get(sStorageAppId);
+                const bCached = !!KeepAliveApps.get(sStorageAppId);
                 const bSessionHandlingSupported = bHasIframe && bIsSupportedType;
 
-                if (bCached || bSessionHandlingSupported) {
-                    PostMessageUtils.postMessageToIframeApp(oApplicationContainer, "sap.ushell.sessionHandler", "beforeApplicationHide", {}, false);
+                if (bHasIframe && (bCached || bSessionHandlingSupported)) {
+                    oApplicationContainer.sendRequest("sap.ushell.sessionHandler.beforeApplicationHide", {}, false);
                 }
             }
 
@@ -480,7 +506,7 @@ sap.ui.define([
             if (!sFromId) {
                 sFromId = "";
             }
-            //destroy the application if not cached or marked for reuse.
+
             const aFlpComponentIds = [
                 "Shell-appfinder-component",
                 "Shell-home-component",
@@ -491,71 +517,63 @@ sap.ui.define([
             ];
 
             const bNavigationToFlpComponent = aFlpComponentIds.some((sFlpComponentId) => sToId.includes(sFlpComponentId));
-            const bNavigationFromFlpComponent = aFlpComponentIds.some((sFlpComponentId) => sFromId.includes(sFlpComponentId));
 
-            if (bNavigationToFlpComponent) {
-                await this._closeKeepAliveApps((oStorageEntry) => oStorageEntry.keepAliveMode === KEEP_ALIVE_MODES.RESTRICTED);
+            if (sToId && oTo) {
+                // ==== Navigation from [any] to app ====
+                if (oTo.isA("sap.ushell.components.applicationIntegration.ApplicationContainer")) {
+                    const sStorageAppId = sToId;
+                    const oApplicationContainer = oTo;
+
+                    // this code must be at the beginning of the function to allow it to be processed once in
+                    // a cycle of opening an app
+                    if (oApplicationContainer.getIframeReusedForApp()) {
+                        oApplicationContainer.setProperty("iframeReusedForApp", false, true);
+                        if (oApplicationContainer.isA("sap.ushell.components.applicationIntegration.IframeApplicationContainer")) {
+                            oApplicationContainer.sendRequest("sap.ushell.sessionHandler.afterApplicationShow", {}, false);
+                        }
+                    }
 
-                Application.setActiveAppContainer(undefined);
+                    if (KeepAliveApps.get(sStorageAppId)) {
+                        await this._restoreApplication(sStorageAppId);
+                    }
 
-                // Clear custom About Dialog parameters
-                AppInfoParameters.flush();
-            } else if (sToId && oTo) {
-                const sStorageAppId = sToId;
-                const oApplicationContainer = oTo;
-
-                // this code must be at the beginning of the function to allow it to be processed once in
-                // a cycle of opening an app
-                if (oApplicationContainer.getIframeReusedForApp()) {
-                    oApplicationContainer.setProperty("iframeReusedForApp", false, true);
-                    PostMessageUtils.postMessageToIframeApp(oApplicationContainer, "sap.ushell.sessionHandler", "afterApplicationShow", {}, false);
-                }
+                // ==== Navigation from [any] to renderer managed component ====
+                } else {
+                    // navigation to home
+                    if (bNavigationToFlpComponent) {
+                        await this._destroyKeepAliveApps((oStorageEntry) => oStorageEntry.keepAliveMode === KEEP_ALIVE_MODES.Restricted);
+                    }
 
-                if (Storage.get(sStorageAppId)) {
-                    this._restore(sStorageAppId);
+                    // Clear custom About Dialog parameters
+                    AppInfoParameters.flush();
                 }
             }
 
-            if (bNavigationFromFlpComponent) {
-                //handle the case of appFinder
-                if (sToId.indexOf("Shell-appfinder-component") > 0) {
-                    EventBus.getInstance().publish("sap.ushell", "appFinderAfterNavigate");
-                }
+            if (sFromId && oFrom) {
+                // ==== Navigation from app to [any] ====
+                if (oFrom.isA("sap.ushell.components.applicationIntegration.ApplicationContainer")) {
+                    const oApplicationContainer = oFrom;
 
-                if (bDisableHomeAppCache) {
-                    try {
-                        this._removeApplicationContainerFromViewPort(sFromId);
-                        oFrom.destroy();
-                    } catch (oError) {
-                        Log.error(`Error when trying to destroy the home component: '${sToId}'`, oError);
-                    }
-                }
-            } else if (sFromId && oFrom) {
-                const oApplicationContainer = oFrom;
-
-                await this._handleExitApplication(oApplicationContainer, bNavigationToFlpComponent, true);
-            }
-        };
+                    await this._handleExitApplication(oApplicationContainer, bNavigationToFlpComponent);
 
-        /**
-         * @param {object} oOldResolvedHashFragment
-         * @param {object} oResolvedHashFragment
-         * @returns {Promise} Resolves when the after navigation was handled.
-         */
-        // todo: [FLPCOREANDUX-10024] should be moved to onAfterNavigate
-        this.handleAfterNavigate = async function (oResolvedHashFragment, oOldResolvedHashFragment) {
-            if (!oOldResolvedHashFragment) {
-                return;
-            }
+                // ==== Navigation from renderer managed component to [any] ====
+                } else {
+                    const sFromControlId = sFromId;
+                    const oFromControl = oFrom;
 
-            const sAppFrameworkId = ObjectPath.get("appCapabilities.appFrameworkId", oOldResolvedHashFragment);
-            const bFromApplicationIsTR = ushellUtils.isTRApplicationType(oOldResolvedHashFragment.applicationType, sAppFrameworkId);
-            const bToApplicationIsTR = ushellUtils.isTRApplicationType(oResolvedHashFragment.applicationType);
+                    // handle the case of appFinder
+                    if (sToId.indexOf("Shell-appfinder-component") > 0) {
+                        EventBus.getInstance().publish("sap.ushell", "appFinderAfterNavigate");
+                    }
 
-            if (bFromApplicationIsTR && !bToApplicationIsTR) {
-                const oPreviousStatefulContainer = BlueBoxHandler.getBlueBoxByUrl(oOldResolvedHashFragment.url);
-                if (oPreviousStatefulContainer && oPreviousStatefulContainer.getStatefulType() === BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
-                    return WebGUIStatefulHandler.guiStatefulCloseCurrentApp(oPreviousStatefulContainer);
+                    if (bDisableHomeAppCache) {
+                        try {
+                            this._removeApplicationContainerFromViewPort(oFromControl);
+                            oFromControl.destroy();
+                        } catch (oError) {
+                            Log.error(`Error when trying to destroy the home component: '${sFromControlId}'`, oError);
+                        }
+                    }
                 }
             }
         };
@@ -566,16 +584,15 @@ sap.ui.define([
          * @param {object} oResolvedHashFragment
          * @param {string} oParsedShellHash
          * @param {string} sKeepAliveMode
-         * @returns {boolean} Returns true if the app was stored
+         * @returns {object} Returns the storage entry.
          */
-        this._storeApp = function (sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode) {
-            if (Storage.get(sStorageAppId)) {
-                return false;
+        this._addStorageEntry = function (sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode) {
+            const oOldStorageEntry = KeepAliveApps.get(sStorageAppId);
+            if (oOldStorageEntry) {
+                return oOldStorageEntry;
             }
 
-            oApplicationContainer.setProperty("isKeepAlive", true, true);
-
-            Storage.set(sStorageAppId, {
+            const oNewStorageEntry = {
                 service: {},
                 shellHash: `#${UrlParsing.constructShellHash(oParsedShellHash)}`,
                 appId: sStorageAppId,
@@ -583,16 +600,18 @@ sap.ui.define([
                 currentState: null, // current state is stored before close see: sap/ushell/state/CurrentState
                 controlManager: null, // control manager state is stored before close see: sap/ushell/state/ControlManager
                 container: oApplicationContainer,
-                meta: AppConfiguration.getMetadata(oResolvedHashFragment),
+                meta: undefined, // is set after application start
                 app: undefined,
                 keepAliveMode: sKeepAliveMode,
                 appTarget: oResolvedHashFragment,
                 ui5ComponentName: oResolvedHashFragment.ui5ComponentName,
                 enableRouterRetrigger: bEnableRouterRetrigger,
                 stateStored: false
-            });
+            };
+
+            KeepAliveApps.set(sStorageAppId, oNewStorageEntry);
 
-            return true;
+            return oNewStorageEntry;
         };
 
         /**
@@ -611,19 +630,19 @@ sap.ui.define([
                 return;
             }
             const sStorageAppId = oCurrentApp.appId;
-            const oStorageEntry = Storage.get(sStorageAppId);
+            const oStorageEntry = KeepAliveApps.get(sStorageAppId);
 
             if (!oStorageEntry) {
                 // do not store for non-keep-alive apps
                 return;
             }
 
-            if (oStorageEntry.container.getApplicationType() === "UI5") {
+            if (oStorageEntry.container.isA("sap.ushell.components.applicationIntegration.UI5ApplicationContainer")) {
                 await this._getComponentCreatedPromise(sStorageAppId);
             }
 
             // back navigation
-            RelatedServices.store(oStorageEntry.service);
+            BackNavigation.store(oStorageEntry.service);
             // currentState, controlManager
             KeepAlive.store(oStorageEntry);
             // About Dialog
@@ -637,34 +656,30 @@ sap.ui.define([
          * @returns {string} Returns the keep alive mode.
          */
         this._calculateKeepAliveMode = function (sStorageAppId, oResolvedHashFragment, oParsedShellHash) {
+            const aKeepAliveModes = Object.values(KEEP_ALIVE_MODES);
+
             //generic intent currently can never be keep alive
             if (sStorageAppId === "application-Shell-startIntent") {
-                return;
+                return KEEP_ALIVE_MODES.False;
             }
 
             // Global override in query parameters
             let sKeepAlive = new URLSearchParams(window.location.search).get("sap-keep-alive");
-            if (sKeepAlive === KEEP_ALIVE_MODES.FULL || sKeepAlive === KEEP_ALIVE_MODES.RESTRICTED) {
+            if (aKeepAliveModes.includes(sKeepAlive)) {
                 return sKeepAlive;
-            } else if (sKeepAlive === KEEP_ALIVE_MODES.FALSE) {
-                return;
             }
 
             // App override in intent parameters
             sKeepAlive = oParsedShellHash.params?.["sap-keep-alive"];
-            if (sKeepAlive === KEEP_ALIVE_MODES.FULL || sKeepAlive === KEEP_ALIVE_MODES.RESTRICTED) {
+            if (aKeepAliveModes.includes(sKeepAlive)) {
                 return sKeepAlive;
-            } else if (sKeepAlive === KEEP_ALIVE_MODES.FALSE) {
-                return;
             }
 
             // Magic override in resolved hash fragment
             if (oResolvedHashFragment.url) {
                 sKeepAlive = UriParameters.fromURL(oResolvedHashFragment.url).get("sap-keep-alive");
-                if (sKeepAlive === KEEP_ALIVE_MODES.FULL || sKeepAlive === KEEP_ALIVE_MODES.RESTRICTED) {
+                if (aKeepAliveModes.includes(sKeepAlive)) {
                     return sKeepAlive;
-                } else if (sKeepAlive === KEEP_ALIVE_MODES.FALSE) {
-                    return;
                 }
             }
 
@@ -672,8 +687,10 @@ sap.ui.define([
             // can be overridden by the above checks
             const sShellHash = UrlParsing.constructShellHash(oParsedShellHash);
             if (sShellHash && ushellUtils.isRootIntent(sShellHash)) {
-                return KEEP_ALIVE_MODES.FULL;
+                return KEEP_ALIVE_MODES.True;
             }
+
+            return KEEP_ALIVE_MODES.False;
         };
 
         /**
@@ -692,14 +709,9 @@ sap.ui.define([
          * @returns {Promise} Resolves when the app is reloaded.
          */
         this._reloadCurrentApp = async function (oData) {
-            const oTmpAppContainer = BlueBoxHandler.getBlueBoxById(oData.sAppContainerId);
-            if (oTmpAppContainer) {
-                // todo: [FLPCOREANDUX-10024] this destroy/remove can be simplified
-                const sTmpUrl = oTmpAppContainer.getUrl();
-                BlueBoxHandler.removeCapabilities(oTmpAppContainer);
-                Storage.removeByContainer(oTmpAppContainer);
-                await this._destroyApplication(oData.sAppContainerId, oTmpAppContainer);
-                BlueBoxHandler.deleteBlueBoxByUrl(sTmpUrl);
+            const oTargetApplicationContainer = ApplicationContainerCache.getById(oData.sAppContainerId);
+            if (oTargetApplicationContainer) {
+                await this._destroyApplication(oTargetApplicationContainer.getCurrentAppId(), oTargetApplicationContainer);
             }
 
             const ShellNavigationInternal = await Container.getServiceAsync("ShellNavigationInternal");
@@ -713,151 +725,72 @@ sap.ui.define([
         /**
          * Opens an application in an application container and sets it as the current application.
          *
-         * @param {string} sAppId the id of the application.
+         * @param {string} sStorageAppId the id of the application.
          * @param {object} oResolvedHashFragment the resolved hash fragment.
-         * @param {object} oParsedShellHash the parsed shell hash.
+         * @param {object} bShouldBeCached Wether it should be cached.
          */
-        this._openApp = async function (sAppId, oResolvedHashFragment, oParsedShellHash) {
-            // format appId, the is the storage identifier
-            const sStorageAppId = `application-${sAppId}`;
+        this._createOrReuseApplicationContainer = function (sStorageAppId, oResolvedHashFragment, bShouldBeCached) {
+            let oApplicationContainer;
 
-            // this case will handle the stateful containers flow.
-            let oApplicationContainer = BlueBoxHandler.getBlueBoxByUrl(oResolvedHashFragment.url);
-
-            const sKeepAliveMode = this._calculateKeepAliveMode(sStorageAppId, oResolvedHashFragment, oParsedShellHash);
-            const bShouldBeCached = !!sKeepAliveMode;
-
-            if (BlueBoxHandler.isStatefulContainer(oApplicationContainer)) {
-                this._openAppInStatefulContainer(sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode, bShouldBeCached);
-                return;
+            const oStorageEntry = KeepAliveApps.get(sStorageAppId);
+            // app was kept alive
+            if (oStorageEntry && oStorageEntry.container) {
+                oApplicationContainer = oStorageEntry.container;
             }
 
-            if (bShouldBeCached) {
-                await this._openAppAndCacheIt(sStorageAppId, sAppId, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode);
-                return;
-            }
-
-            if (oResolvedHashFragment.applicationType === "TR" || oResolvedHashFragment.appCapabilities?.appFrameworkId === "GUI") {
-                await this._deleteSameIdAppContainer(sStorageAppId, sAppId);
-
-                if (!oApplicationContainer || oApplicationContainer.getStatefulType() !== BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
-                    oApplicationContainer = Application.createApplicationContainer(sStorageAppId, oResolvedHashFragment);
-                }
-
-            } else {
-                const aSpecialApplicationTypes = [
-                    "URL",
-                    "TR",
-                    "NWBC",
-                    "WDA"
-                ];
-
-                if (!oApplicationContainer || aSpecialApplicationTypes.includes(oResolvedHashFragment.applicationType)) {
-                    await this._deleteSameIdAppContainer(sStorageAppId, sAppId);
-                }
-
-                if (oApplicationContainer) {
-                    const oApplicationContainerFromViewPort = this._getApplicationContainerFromViewPort(sAppId);
+            // try to find a reusable container
+            if (!oApplicationContainer) {
+                const oStatefulApplicationContainer = ApplicationContainerCache.findFreeContainerByUrl(oResolvedHashFragment.url);
 
-                    if (oApplicationContainerFromViewPort) {
-                        this._removeApplicationContainerFromViewPort(oApplicationContainerFromViewPort.getId());
-                        oApplicationContainerFromViewPort.destroy();
-                    }
+                const bIsReusableContainer = oStatefulApplicationContainer?.getStatefulType() !== StatefulType.NotSupported;
+                if (bIsReusableContainer) {
+                    oApplicationContainer = oStatefulApplicationContainer;
                 }
-
-                oApplicationContainer = Application.createApplicationContainer(sStorageAppId, oResolvedHashFragment);
             }
 
-            // create application that is not persisted and not cashed
-            oCurrentApplication = {
-                appId: sStorageAppId,
-                stt: "loading",
-                container: oApplicationContainer,
-                meta: AppConfiguration.getMetadata(oResolvedHashFragment),
-                app: undefined
-            };
-        };
-
-        /**
-         * Open an application in a stateful container that already exists.
-         *
-         * @param {string} sStorageAppId the storage id of the application.
-         * @param {sap.ushell.components.container.ApplicationContainer} oApplicationContainer the stateful application container.
-         * @param {object} oResolvedHashFragment the resolved hash fragment.
-         * @param {object} oParsedShellHash the parsed shell hash.
-         * @param {string} sKeepAliveMode the keep alive mode.
-         * @param {boolean} bShouldBeCached whether the application container should be cached in the storage.
-         */
-        this._openAppInStatefulContainer = function (sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode, bShouldBeCached) {
-            if (bShouldBeCached) {
-                //this is the case where we have a stateful container and keep alive
-                //is cached application
-                let oStorageEntry = Storage.get(sStorageAppId);
-                if (!oStorageEntry) {
-                    this._storeApp(sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode);
-                    oStorageEntry = Storage.get(sStorageAppId);
-                }
-
-                oCurrentApplication = oStorageEntry;
-            } else {
-                // create application that is not persisted and not cashed
-                oCurrentApplication = {
-                    appId: sStorageAppId,
-                    stt: "loading",
-                    container: oApplicationContainer,
-                    meta: AppConfiguration.getMetadata(oResolvedHashFragment),
-                    app: undefined
+            // create a new container if no reusable container was found
+            if (!oApplicationContainer) {
+                // Add new ShellUIService instance of the interface to the application container
+                // this will only be used by iframe applications
+                oResolvedHashFragment.shellUIService = oGlobalShellUIService.getInterface();
+                const sTargetUi5ComponentName = oResolvedHashFragment?.ui5ComponentName;
+                const bIsUI5App = !!sTargetUi5ComponentName;
+
+                const oCommonProperties = {
+                    id: sStorageAppId,
+                    currentAppId: sStorageAppId,
+                    currentAppUrl: oResolvedHashFragment.url,
+                    shellUIService: oResolvedHashFragment.shellUIService,
+                    currentAppTargetResolution: oResolvedHashFragment,
+                    applicationType: oResolvedHashFragment.applicationType,
+                    openWithPostByAppParam: oResolvedHashFragment.openWithPostByAppParam,
+                    reservedParameters: oResolvedHashFragment.reservedParameters,
+                    systemAlias: oResolvedHashFragment.systemAlias,
+                    targetNavigationMode: oResolvedHashFragment.targetNavigationMode,
+                    url: oResolvedHashFragment.url,
+                    frameworkId: oResolvedHashFragment.appCapabilities?.appFrameworkId
                 };
-            }
-        };
-
-        /**
-         * Fetches an existing application container from storage or creates this application container and sets it in to the storage.
-         *
-         * @param {string} sStorageAppId the storage id of the application.
-         * @param {string} sAppId the id of the application.
-         * @param {object} oResolvedHashFragment the resolved hash fragment.
-         * @param {object} oParsedShellHash the parsed shell hash.
-         * @param {string} sKeepAliveMode the keep alive mode.
-         */
-        this._openAppAndCacheIt = async function (sStorageAppId, sAppId, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode) {
-            // is cached application
-            let oStorageEntry = Storage.get(sStorageAppId);
-            if (!oStorageEntry) {
-                let oApplicationContainer = BlueBoxHandler.findFreeContainerForNewKeepAliveApp(oResolvedHashFragment);
 
-                if (!oApplicationContainer) {
-                    await this._deleteSameIdAppContainer(sStorageAppId, sAppId);
-                    oApplicationContainer = Application.createApplicationContainer(sStorageAppId, oResolvedHashFragment);
+                if (bIsUI5App) {
+                    oApplicationContainer = new UI5ApplicationContainer({
+                        ...oCommonProperties,
+                        ui5ComponentName: oResolvedHashFragment.ui5ComponentName
+                    });
+                } else {
+                    oApplicationContainer = new IframeApplicationContainer({
+                        ...oCommonProperties
+                    });
                 }
 
-                this._storeApp(sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode);
-                oStorageEntry = Storage.get(sStorageAppId);
+                this._initializeApplicationContainer(oApplicationContainer, oResolvedHashFragment);
+            } else {
+                oApplicationContainer.setProperty("isFetchedFromCache", true, true);
             }
 
-            oCurrentApplication = oStorageEntry;
-        };
+            ApplicationContainerCache.setContainerActive(oApplicationContainer);
+            oApplicationContainer.setProperty("isKeepAlive", bShouldBeCached, true);
 
-        /**
-         * There might be two apps with the same Semantic object + Action, from two different servers,
-         * so we will need to destroy the first application to avoid duplicate id.
-         *
-         * The current stateful container mechanism does not support it.
-         * Until it is supported, we delete here the blue box and then create the new one.
-         * In future BLI, we plan to change the id of the container to be more unique.
-         *
-         * @param {string} sStorageAppId the storage app id.
-         * @param {string} sAppId the app id.
-         */
-        this._deleteSameIdAppContainer = async function (sStorageAppId, sAppId) {
-            const oTmpAppContainer = BlueBoxHandler.getBlueBoxById(sStorageAppId) || this._getApplicationContainerFromViewPort(sAppId);
-            if (oTmpAppContainer) {
-                // todo: [FLPCOREANDUX-10024] this destroy/remove can be simplified
-                const sTmpUrl = oTmpAppContainer.getUrl();
-                BlueBoxHandler.removeCapabilities(oTmpAppContainer);
-                await this._destroyApplication(sStorageAppId, oTmpAppContainer, true);
-                BlueBoxHandler.deleteBlueBoxByUrl(sTmpUrl);
-            }
+            return oApplicationContainer;
         };
 
         /**
@@ -877,8 +810,9 @@ sap.ui.define([
 
                         bEnableRouterRetrigger = oData.disable;
 
-                        if (Storage.get(sStorageAppId)) {
-                            Storage.get(sStorageAppId).enableRouterRetrigger = oData.disable;
+                        const oStorageEntry = KeepAliveApps.get(sStorageAppId);
+                        if (oStorageEntry) {
+                            oStorageEntry.enableRouterRetrigger = oData.disable;
                         }
                     });
                     EventHub.on("setApplicationFullWidth").do((oData) => {
@@ -917,6 +851,8 @@ sap.ui.define([
                 });
             }
 
+            this._startPostMessageHandling();
+
             ShellUIServiceFactory.init().then(() => {
                 ServiceFactoryRegistry.register(
                     "sap.ushell.ui5service.ShellUIService",
@@ -928,116 +864,87 @@ sap.ui.define([
             oViewPortContainer = oInViewPortContainer;
             bDisableHomeAppCache = bInDisableHomeAppCache;
 
-            BlueBoxHandler.init();
-            Application.init(BlueBoxHandler, PostMessageUtils);
-            PostMessageUtils.init(Application, BlueBoxHandler);
-
-            //setup & register communication
-            this.registerShellCommunicationHandler({
-                "sap.ushell.services.AppLifeCycle": {
-                    oRequestCalls: {
-                        create: {
-                            isActiveOnly: true,
-                            distributionType: ["URL"]
-                        },
-                        destroy: {
-                            isActiveOnly: true,
-                            distributionType: ["URL"]
-                        },
-                        store: {
-                            isActiveOnly: true,
-                            distributionType: ["URL"]
-                        },
-                        restore: {
-                            isActiveOnly: true,
-                            distributionType: ["URL"]
-                        }
-                    },
-                    oServiceCalls: {
-                        subscribe: {
-                            executeServiceCallFn: async function (oServiceParams) {
-                                const { oContainer: oApplicationContainer } = oServiceParams;
-                                const aNewCapabilities = oServiceParams.oMessageData.body;
-                                if (!Array.isArray(aNewCapabilities)) {
-                                    Log.error("subscribe service call failed: capabilities must be an array");
-                                    return {};
-                                }
-                                oApplicationContainer.addBlueBoxCapabilities(aNewCapabilities);
-                                return {};
-                            }
-                        },
-                        setup: {
-                            executeServiceCallFn: async function (oServiceParams) {
-                                const oSetup = oServiceParams?.oMessageData?.body;
-                                const { oContainer: oApplicationContainer } = oServiceParams;
-
-                                const aNewCapabilities = [];
-                                if (oSetup) {
-                                    const bIsSAPLegacyApplicationType = ushellUtils.isSAPLegacyApplicationType(oApplicationContainer.getApplicationType(), oApplicationContainer.getFrameworkId());
-                                    // appruntime supports statefulContainer + keepAlive
-                                    const bIgnoreStateful = oApplicationContainer.getIsKeepAlive() && bIsSAPLegacyApplicationType;
-
-                                    if (oSetup.isStateful) {
-                                        if (bIgnoreStateful) {
-                                            // todo: [FLPCOREANDUX-10024] why not NOT_SUPPORTED instead?
-                                            oApplicationContainer.setProperty("statefulType", BlueBoxHandler.STATEFUL_TYPES.FLP_V2_KEEP_ALIVE, true);
-                                        } else {
-                                            aNewCapabilities.push({ service: "sap.ushell.services.AppLifeCycle", action: "create" });
-                                            aNewCapabilities.push({ service: "sap.ushell.services.AppLifeCycle", action: "destroy" });
-                                            oApplicationContainer.setProperty("statefulType", BlueBoxHandler.STATEFUL_TYPES.FLP_V2, true);
+            //TODO add unsubscribe
+            EventBus.getInstance().subscribe("sap.ushell", "appComponentLoaded", this._onComponentCreated, this);
+            EventBus.getInstance().subscribe("sap.ushell", "getAppLifeCycle", this._onGetMe, this);
+
+            this._addEvents();
+        };
+
+        this._startPostMessageHandling = function () {
+            PostMessageManager.init({
+                getCurrentApplication: () => {
+                    return this.getCurrentApplication().container;
+                },
+                getAllApplications: () => {
+                    return ApplicationContainerCache.getAll();
+                }
+            });
+            AppRuntimeHandler.register();
+            NWBCHandler.register();
+            LifecycleHandler.register();
+            ServiceHandler.register();
+            MessageBrokerHandler.register();
+            this._waitForPluginsAndReplayPostMessages();
+
+            // todo: [FLPCOREANDUX-10024] harmonize with Appruntime
+            PostMessagePluginInterface.init(
+                true, // bRunsInOuterShell
+                (oCommObj) => { // fnAddCommunicationObject
+                    Object.keys(oCommObj).forEach((sService) => {
+                        const oServiceDef = oCommObj[sService];
+
+                        if (oServiceDef.oServiceCalls) {
+                            Object.keys(oServiceDef.oServiceCalls).forEach((sInterface) => {
+                                const oInterface = oServiceDef.oServiceCalls[sInterface];
+                                const sServiceRequest = `${sService}.${sInterface}`;
+
+                                if (oInterface.executeServiceCallFn) {
+                                    PostMessageManager.setRequestHandler(
+                                        sServiceRequest,
+                                        async (oMessageBody, oEvent) => {
+                                            const oServiceParams = {
+                                                oMessageData: JSON.parse(oEvent.data),
+                                                oMessage: oEvent
+                                            };
+                                            return ushellUtils.promisify(oInterface.executeServiceCallFn(oServiceParams));
                                         }
-                                    }
-                                    if (oSetup.isIframeValid) {
-                                        aNewCapabilities.push({ action: "iframeIsValid", service: "sap.ushell.appRuntime" });
-                                    }
-                                    if (oSetup.session?.bLogoutSupport) {
-                                        aNewCapabilities.push({ action: "logout", service: "sap.ushell.sessionHandler" });
-                                    }
-
-                                    // todo: [FLPCOREANDUX-10024] this is a workaround
-                                    const bIsAppruntime = ushellUtils.isSAPLegacyApplicationType(oApplicationContainer.getApplicationType(), oApplicationContainer.getFrameworkId());
-                                    if (bIsAppruntime) {
-                                        aNewCapabilities.push({ service: "sap.ushell.services.AppLifeCycle", action: "store" });
-                                        aNewCapabilities.push({ service: "sap.ushell.services.AppLifeCycle", action: "restore" });
-                                    }
-
-                                    oApplicationContainer.addBlueBoxCapabilities(aNewCapabilities);
+                                    );
                                 }
-                            }
+                            });
                         }
-                    }
-                },
-                "sap.gui": {
-                    oServiceCalls: {
-                        loadFinished: {
-                            executeServiceCallFn: async function (oServiceParams) {
-                                const { oContainer: oApplicationContainer } = oServiceParams;
-
-                                if (!oApplicationContainer.getIsKeepAlive()) {
-                                    oApplicationContainer.setProperty("statefulType", BlueBoxHandler.STATEFUL_TYPES.GUI_V1, true);
-                                    oCurrentApplication = {
-                                        appId: oApplicationContainer.getId(),
-                                        stt: "loading",
-                                        container: oApplicationContainer,
-                                        meta: undefined,
-                                        app: undefined
-                                    };
-                                } else {
-                                    oApplicationContainer.setProperty("statefulType", BlueBoxHandler.STATEFUL_TYPES.GUI_V1_KEEP_ALIVE, true);
+
+                        if (oServiceDef.oRequestCalls) {
+                            Object.keys(oServiceDef.oRequestCalls).forEach((sInterface) => {
+                                const oInterface = oServiceDef.oRequestCalls[sInterface];
+                                const sServiceRequest = `${sService}.${sInterface}`;
+                                const oTarget = {};
+
+                                if (deepEqual(oInterface.distributionType, ["all"])) {
+                                    oTarget.ignoreCapabilities = true;
+                                } else if (oInterface.distributionType) {
+                                    Log.error("Unsupported distribution type", oInterface.distributionType, "sap.ushell.components.applicationIntegration.AppLifeCycle");
                                 }
-                                return {};
-                            }
+
+                                if (oInterface.isActiveOnly) {
+                                    oTarget.activeOnly = true;
+                                }
+
+                                PostMessageManager.setDistributionPolicy(sServiceRequest, oTarget);
+                            });
                         }
-                    }
+                    });
                 }
+            );
+        };
 
-            });
+        this._waitForPluginsAndReplayPostMessages = async function () {
+            const PluginManager = await Container.getServiceAsync("PluginManager");
+            const oPluginDeferred = PluginManager.getPluginLoadingPromise("RendererExtensions");
 
-            //TODO add unsubscribe
-            EventBus.getInstance().subscribe("sap.ushell", "appComponentLoaded", this._onComponentCreated, this);
-            EventBus.getInstance().subscribe("sap.ushell", "getAppLifeCycle", this._onGetMe, this);
+            await ushellUtils.promisify(oPluginDeferred);
 
-            this._addEvents();
+            PostMessageManager.replayStoredMessages();
         };
 
         /**
@@ -1054,14 +961,14 @@ sap.ui.define([
                     return;
                 }
                 if (oHashChange.mParameters && oShellNavigationInternal.hashChanger.isInnerAppNavigation(oHashChange.mParameters.newHash, oHashChange.mParameters.oldHash)) {
-                    PostMessageUtils.postMessageToMultipleIframes("sap.ushell.appRuntime", "innerAppRouteChange", {
+                    PostMessageManager.sendRequestToAllApplications("sap.ushell.appRuntime.innerAppRouteChange", {
                         oHash: oHashChange.mParameters
-                    });
+                    }, false);
                 }
 
-                PostMessageUtils.postMessageToMultipleIframes("sap.ushell.appRuntime", "hashChange", {
+                PostMessageManager.sendRequestToAllApplications("sap.ushell.appRuntime.hashChange", {
                     sHash: oHashChange.mParameters.fullHash
-                });
+                }, false);
             });
         };
 
@@ -1075,13 +982,8 @@ sap.ui.define([
         /**
          * @param {string} sId
          */
-        this._removeApplicationContainerFromViewPort = function (sId) {
-            const oBlueBox = BlueBoxHandler.getBlueBoxById(sId);
-            const bIsStateful = BlueBoxHandler.isStatefulContainer(oBlueBox);
-
-            if (!bIsStateful) {
-                oViewPortContainer.removeCenterViewPort(sId, true);
-            }
+        this._removeApplicationContainerFromViewPort = function (oApplicationContainer) {
+            oViewPortContainer.removeCenterViewPort(oApplicationContainer.getId(), true);
         };
 
         /**
@@ -1117,12 +1019,6 @@ sap.ui.define([
             return oCurrentApplication;
         };
 
-        /**
-         */
-        this.unsetCurrentApplication = function () {
-            oCurrentApplication = {};
-        };
-
         /**
          * @param {boolean} bIsFull
          */
@@ -1183,8 +1079,8 @@ sap.ui.define([
          *
          * @private
          */
-        this._activeContainer = function (oTargetApplicationContainer) {
-            BlueBoxHandler.forEach((oApplicationContainer) => {
+        this._setApplicationContainerActive = function (oTargetApplicationContainer) {
+            ApplicationContainerCache.forEach((oApplicationContainer) => {
                 if (oApplicationContainer && oApplicationContainer !== oTargetApplicationContainer) {
                     try {
                         Log.info(`Deactivating container ${oApplicationContainer.getId()}`);
@@ -1201,19 +1097,107 @@ sap.ui.define([
             }
         };
 
+        /**
+         * @param {*} sStorageAppId
+         * @param {*} oApplicationContainer
+         * @param {*} oResolvedHashFragment
+         * @param {*} oParsedShellHash
+         * @param {*} bWasKeptAlive
+         * @returns
+         */
+        this._openApp = async function (sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, bWasKeptAlive) {
+            const bWasFetchedFromCache = oApplicationContainer.getIsFetchedFromCache();
+            if (bWasKeptAlive && bWasFetchedFromCache && StatefulContainerV2Handler.isStatefulContainerSupportingKeepAlive(oApplicationContainer)) {
+                return StatefulContainerV2Handler.restoreAppWithinSameFrame(
+                    oApplicationContainer,
+                    oResolvedHashFragment.url,
+                    sStorageAppId,
+                    oResolvedHashFragment
+                );
+            }
+
+            if (oApplicationContainer.getStatefulType() === StatefulType.ContractV2) {
+                if (bWasFetchedFromCache && oApplicationContainer.getCurrentAppId() === sStorageAppId) {
+                    // application is already running within container
+                    return;
+                }
+                const oResult = await StatefulContainerV2Handler.createApp(
+                    oApplicationContainer,
+                    oResolvedHashFragment.url,
+                    sStorageAppId,
+                    oResolvedHashFragment
+                );
+                if (oResult?.deletedKeepAliveId) {
+                    await this._destroyApplication(oResult.deletedKeepAliveId, oApplicationContainer);
+                }
+                return;
+            }
+
+            if (oApplicationContainer.getStatefulType() === StatefulType.ContractV1) {
+                if (bWasFetchedFromCache && oApplicationContainer.getCurrentAppId() === sStorageAppId) {
+                    // application is already running within container
+                    return;
+                }
+                await StatefulContainerV1Handler.createApp(
+                    oApplicationContainer,
+                    sStorageAppId,
+                    oResolvedHashFragment
+                );
+                return;
+            }
+
+            // for SAPUI5 apps, the application type is still "URL" due to backwards compatibility, but the
+            // NavTargetResolutionInternal service already extracts the component name, so this can directly be used as indicator
+            const sTargetUi5ComponentName = oResolvedHashFragment?.ui5ComponentName;
+            const bIsUI5App = !!sTargetUi5ComponentName;
+
+            if (bIsUI5App && !bWasKeptAlive) { // UI5 Application
+                // happens for direct app start scenario on the abap platform (sap/ushell_abap/bootstrap/evo/boottask)
+                    const bComponentLoadedInDirectAppStart = !!oResolvedHashFragment?.componentHandle;
+                if (!bComponentLoadedInDirectAppStart) {
+                    AppConfiguration.setApplicationInInitMode();
+
+                    await EmbeddedUI5Handler.createApp(oApplicationContainer, oResolvedHashFragment, oParsedShellHash);
+
+                    // todo: [FLPCOREANDUX-10024] check whether the issue still persists
+                    // the activation of user activity logging must be done after the app component is fully loaded
+                    // otherwise the module loading sequence causes race conditions on firefox
+                    const bContactSupportEnabled = Config.last("/core/extension/SupportTicket");
+                    if (bContactSupportEnabled) {
+                        ushellUtils.awaitTimeout(0)
+                            .then(() => {
+                                return ushellUtils.requireAsync(["sap/ushell/UserActivityLog"]);
+                            })
+                            .then(([UserActivityLog]) => {
+                                UserActivityLog.activate();
+                            });
+                    }
+                } else {
+                    oApplicationContainer.setProperty("componentHandle", oResolvedHashFragment.componentHandle, true);
+                }
+
+                // The trampoline application subsequently gets destroyed after it's used to enable the redirection.
+                const sNavigationRedirectHash = await EmbeddedUI5Handler.getNavigationRedirectHash(oApplicationContainer);
+                if (typeof sNavigationRedirectHash === "string") {
+                    await this._destroyApplication(sStorageAppId, oApplicationContainer);
+                    return sNavigationRedirectHash;
+                }
+            }
+        };
+
         /**
          * @param {object} oApplicationContainer
-         * @param {object} oApplication
+         * @param {object} oResolvedHashFragment
          * @param {function} fnOnAfterRendering
          */
-        this._publishNavigationStateEvents = function (oApplicationContainer, oApplication, fnOnAfterRendering) {
+        this._publishNavigationStateEvents = function (oApplicationContainer, oResolvedHashFragment, oMetadata) {
             //after the app container is rendered, publish an event to notify
             //that an app was opened
             const sId = oApplicationContainer.getId ? oApplicationContainer.getId() : "";
-            const appMetaData = AppConfiguration.getMetadata();
-            const sIcon = appMetaData.icon;
-            const sTitle = appMetaData.title;
+            const sIcon = oMetadata.icon;
+            const sTitle = oMetadata.title;
 
+            const fnOnAfterRendering = this._onAppAfterRendering.bind(this, oResolvedHashFragment);
             //Attach an event handler which will be called onAfterRendering
             oApplicationContainer.addEventDelegate({ onAfterRendering: fnOnAfterRendering });
 
@@ -1232,7 +1216,7 @@ sap.ui.define([
                 setTimeout(() => {
                     // TODO: do not mutate an internal structure (in a Timeout!),
                     // create a new object
-                    const oEventData = deepExtend({}, oApplication);
+                    const oEventData = deepExtend({}, oResolvedHashFragment);
                     delete oEventData.componentHandle;
                     oEventData.appId = sId;
                     oEventData.usageIcon = sIcon;
@@ -1244,7 +1228,7 @@ sap.ui.define([
                 // the former code leaked an *internal* data structure, making it part of a public API
                 // restrict hte public api to the minimal set of precise documented properties which can be retained under
                 // under future evolutions
-                const oPublicEventData = that._publicEventDataFromResolutionResult(oApplication);
+                const oPublicEventData = that._publicEventDataFromResolutionResult(oResolvedHashFragment);
                 //publish the event externally
                 RendererUtils.publishExternalEvent("appClosed", oPublicEventData);
             };
@@ -1269,91 +1253,15 @@ sap.ui.define([
         };
 
         /**
-         * @param {string} sAppId
-         * @param {string} sShellHash
-         * @param {boolean} bNavigationFromHome
-         * @param {boolean} bNavigationWithInnerAppRoute
-         * @returns {object}
+         * @param {*} oResolvedHashFragment
+         * @returns
          */
-        this._getInMemoryInstance = function (sAppId, sShellHash, bNavigationFromHome, bNavigationWithInnerAppRoute) {
-            const sStorageAppId = `application-${sAppId}`;
-            const oAppEntry = Storage.get(sStorageAppId);
-
-            //remove application from cache if has different parameters
-            if (oAppEntry) {
-                //Special case - when we're navigating from homepage to an application with state, when keep-alive
-                //is active. In this case, although keep alive is active we need to destroy the application
-                //ans re-open it.
-                const bNavigatingFromHomeWithInnerAppRoute = bNavigationFromHome && bNavigationWithInnerAppRoute;
-                // todo: [FLPCOREANDUX-10024] Add logging
-
-                const bSameParameters = oAppEntry.shellHash === sShellHash;
-                if (bSameParameters && !bNavigatingFromHomeWithInnerAppRoute) {
-                    return {
-                        destroyApplication: false,
-                        appId: oAppEntry.appId,
-                        container: oAppEntry.container
-                    };
-                }
-                return {
-                    destroyApplication: true,
-                    appId: oAppEntry.appId,
-                    container: oAppEntry.container
-                };
-            }
-
-            return {
-                destroyApplication: true,
-                appId: undefined,
-                container: undefined
-            };
-        };
-
-        /**
-         * @param {boolean} bNewlyCreatedApplicationContainer
-         * @param {boolean} bShouldBeCached
-         * @param {string} sStorageAppId
-         * @param {object} oApplicationContainer
-         * @param {object} oResolvedHashFragment
-         * @param {string} oParsedShellHash
-         * @param {string} sKeepAliveMode
-         * @param {boolean} bNavigationInSameStatefulContainer
-         * @param {boolean} bReturnedFromKeepAlivePoolFLPV2
-         * @returns {Promise} Resolves when the stateful app was opened.
-         */ // eslint-disable-next-line max-len
-        this._handleOpenStateful = async function (bNewlyCreatedApplicationContainer, bShouldBeCached, sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode, bNavigationInSameStatefulContainer, bReturnedFromKeepAlivePoolFLPV2) {
-            oApplicationContainer.setProperty("iframeReusedForApp", true, true);
-            try {
-                if (Storage.get(sStorageAppId) && !bNewlyCreatedApplicationContainer && !bReturnedFromKeepAlivePoolFLPV2) {
-                    await BlueBoxHandler.statefulRestoreKeepAliveApp(oApplicationContainer, oResolvedHashFragment.url, sStorageAppId, oResolvedHashFragment, bNavigationInSameStatefulContainer);
-                } else {
-                    const oResult = await BlueBoxHandler.statefulCreateApp(oApplicationContainer, oResolvedHashFragment.url, sStorageAppId, oResolvedHashFragment, bNavigationInSameStatefulContainer);
-                    if (oResult?.deletedKeepAliveId) {
-                        Storage.removeById(oResult.deletedKeepAliveId);
-                    }
-
-                    //creating a new application check if needs to be keep (for the keep alive), and if so store the application
-                    if (bShouldBeCached && !Storage.get(sStorageAppId)) {
-                        this._storeApp(sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode);
-                    }
-                }
-
-                Application.setActiveAppContainer(oApplicationContainer);
-
-                Log.info("New application context opened successfully in an existing transaction UI session.");
-            } catch (vError) {
-                Log.error(vError?.message || vError);
-                // do not bubble up the error
-            }
-        };
-
-        this._isFullWidth = function (oResolvedHashFragment) {
+        this._isFullWidth = function (oResolvedHashFragment, oMetadata) {
             let bFullWidth;
             const sAppType = this._calculateAppType(oResolvedHashFragment);
             const bDefaultFullWidth = ApplicationType.getDefaultFullWidthSetting(sAppType);
 
             const bFullWidthCapability = oResolvedHashFragment.appCapabilities?.fullWidth;
-            const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment);
             //Here there's a double check for the fullwidth - once as a type of boolean and one as a string.
             //This is because we found that developers configured this variable in the manifest also as a string,
             //so the checks of the oMetadata and the oResolvedHashFragment are to avoid regression with the use of this field.
@@ -1374,213 +1282,94 @@ sap.ui.define([
         };
 
         /**
-         * formerly known as "handleControl"
-         * @param {string} sAppId
-         * @param {object} oParsedShellHash
-         * @param {object} oResolvedHashFragment
-         * @param {string} sOldShellHash
-         * @param {boolean} bNavigationFromHome
-         * @returns {Promise} Resolves when the control is handled
+         * @param {*} sAppId
+         * @param {*} oParsedShellHash
+         * @param {*} oResolvedHashFragment
+         * @param {*} bNavigationFromHome
+         * @param {*} bNavigationWithInnerAppRoute
+         * @returns
          */
-        this.handleCreateApplicationContainer = async function (sAppId, oParsedShellHash, oResolvedHashFragment, sOldShellHash, bNavigationFromHome) {
-            let bReturnedFromKeepAlivePoolFLPV2 = false;
-            let bReturnedFromKeepAlivePoolGuiV1 = false;
+        this.createApplication = async function (sAppId, oParsedShellHash, oResolvedHashFragment, bNavigationFromHome, bNavigationWithInnerAppRoute) {
             const sStorageAppId = `application-${sAppId}`;
-            let bNewlyCreatedApplicationContainer = false;
-            let bNavigationInSameStatefulContainer = false;
-            let oApplicationContainer,
-                bReuseStatefulContainer,
-                oTargetAppContainer,
-                iLastValidTimeDelta,
-                bKeptAliveApp,
-                oCachedEntry;
-
-            //get the potential target stateful container and check if it's valid. if not, destroy it
-            //before we try to create the new application
-            oTargetAppContainer = BlueBoxHandler.getBlueBoxByUrl(oResolvedHashFragment.url);
-            // todo: [FLPCOREANDUX-10024] DELETES iframe
-            if (BlueBoxHandler.isStatefulContainer(oTargetAppContainer)) {
-                iLastValidTimeDelta = new Date().getTime() - oTargetAppContainer.getIsIframeValidTime().time;
-                if ((BlueBoxHandler.isIframeIsValidSupported(oTargetAppContainer) && iLastValidTimeDelta >= 3500) ||
-                    oTargetAppContainer.getIsInvalidIframe()) {
-                    const sReason = oTargetAppContainer.getIsInvalidIframe() ? `iframe did not ping in the last '${iLastValidTimeDelta}' ms` : "iframe is in invalid state";
-                    Log.warning(
-                        `Destroying stateful container iframe due to unresponsiveness (${oTargetAppContainer.getId()})`,
-                        `reason: ${sReason}`,
-                        "sap.ushell.components.applicationIntegration.AppLifeCycle"
-                    );
 
-                    // todo: [FLPCOREANDUX-10024] this destroy/remove can be simplified
-                    BlueBoxHandler.removeCapabilities(oTargetAppContainer);
-                    await this._destroyApplication(sStorageAppId, oTargetAppContainer);
-                    BlueBoxHandler.deleteBlueBoxByUrl(oResolvedHashFragment.url);
-                    oTargetAppContainer = undefined;
-                    //in this case we do not care about the old application intent as it is currently relevant only when
-                    //trying to open app in the same current stateful container
-                    sOldShellHash = undefined;
-                }
-            }
+            await this._cleanupBeforeNewApp(
+                sAppId,
+                oParsedShellHash,
+                oResolvedHashFragment,
+                bNavigationFromHome,
+                bNavigationWithInnerAppRoute
+            );
 
-            //we will close the application we are leaving when:
-            // 1. the application is running in a stateful container
-            // 2. this is a legacy keep alive app, and we navigate back (this in order to return the container to the pool
-            //    of containers to it can be used again for the upcoming opened app)
-            // todo: [FLPCOREANDUX-10024] DELETES more iframe
-            if (!bNavigationFromHome) {
-                const oCurrentAppContainer = this.getCurrentApplication()?.container;
-                bReuseStatefulContainer = BlueBoxHandler.isStatefulContainer(oCurrentAppContainer);
-                // todo [FLPCOREANDUX-10024] why is id required here?
-                const bSourceIsKeepAliveFromPool = oCurrentAppContainer && !!oCurrentAppContainer.getCurrentAppId() && BlueBoxHandler.isStatefulContainerInKeepAlivePool(oCurrentAppContainer);
-                if (bReuseStatefulContainer || bSourceIsKeepAliveFromPool) {
-                    await this._handleExitApplication(oCurrentAppContainer, false, false);
-                    if (oCurrentAppContainer === oTargetAppContainer) {
-                        bNavigationInSameStatefulContainer = true;
-                    }
-                }
-            }
+            this._sendFocusBackToShell();
+            this._announceAppOpening(oResolvedHashFragment);
 
-            //now, we can open the new application
             const sKeepAliveMode = this._calculateKeepAliveMode(sStorageAppId, oResolvedHashFragment, oParsedShellHash);
-            const bShouldBeCached = !!sKeepAliveMode;
-
-            oApplicationContainer = BlueBoxHandler.getBlueBoxByUrl(oResolvedHashFragment.url);
-            bReuseStatefulContainer = BlueBoxHandler.isStatefulContainer(oApplicationContainer);
-            // todo: [FLPCOREANDUX-10024] GETTER of innerControl for keep alive / stateful
-            if (!bReuseStatefulContainer) {
-                // only clear oApplicationContainer in case it is not a navigation from an application to the same application
-                if (oCurrentApplication && sStorageAppId !== oCurrentApplication.appId) {
-                    oApplicationContainer = undefined;
-                }
+            const bShouldBeCached = sKeepAliveMode !== KEEP_ALIVE_MODES.False;
 
-                oCachedEntry = Storage.get(sStorageAppId);
-                oApplicationContainer = oCachedEntry?.container;
+            const oApplicationContainer = this._createOrReuseApplicationContainer(sStorageAppId, oResolvedHashFragment, bShouldBeCached);
 
-                if (oApplicationContainer && bShouldBeCached) {
-                    bKeptAliveApp = true;
-                }
-            }
-
-            // todo: [FLPCOREANDUX-10024] CREATE / SETTER of currentApplication
-            if (bReuseStatefulContainer) {
-                if (!oApplicationContainer) {
-                    oApplicationContainer = await this._createApplicationContainer(sAppId, oParsedShellHash, oResolvedHashFragment);
+            // check after cleanup, but before creating the storage entry
+            const bWasKeptAlive = !!KeepAliveApps.get(sStorageAppId);
 
-                    // todo: [FLPCOREANDUX-10024] the following should be obsolete
-                    const oStorageEntry = Storage.get(oApplicationContainer.getId());
-                    if (oStorageEntry) {
-                        oCurrentApplication = oStorageEntry;
-                    }
-
-                    bNewlyCreatedApplicationContainer = true;
-                }
-            } else if (oApplicationContainer && !bShouldBeCached && BlueBoxHandler.getStatefulContainerType(oResolvedHashFragment.url, true) !== BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
-                //this case this controller can't be reused and we need it to be embed, so delete it.
-                await this._destroyApplication(oApplicationContainer.getId(), oApplicationContainer);
-
-                // The immediately following method call internally calls
-                // `this.oViewPortContainer.addCenterViewPort(oApplicationContainer)`
-                // when Gui V1 Stateful Container is true, and in that case
-                // `oApplicationContainer` will be the component control of an existing session.
-                oApplicationContainer = await this._createApplicationContainer(sAppId, oParsedShellHash, oResolvedHashFragment);
-            } else if (!oApplicationContainer) {
-                // The immediately following method call internally calls
-                // `this.oViewPortContainer.addCenterViewPort(oApplicationContainer)`
-                // when Gui V1 Stateful Container is true, and in that case
-                // `oApplicationContainer` will be the component control of an existing session.
-                oApplicationContainer = await this._createApplicationContainer(sAppId, oParsedShellHash, oResolvedHashFragment);
-
-                //if we got an iframe from cache, simulate stateful container
-                //open that should happen later here
-                if (oApplicationContainer.getIsFetchedFromCache()) {
-                    if (oApplicationContainer.getStatefulType() === BlueBoxHandler.STATEFUL_TYPES.GUI_V1_KEEP_ALIVE) {
-                        bReturnedFromKeepAlivePoolGuiV1 = true;
-                    } else {
-                        bReuseStatefulContainer = true;
-                        bReturnedFromKeepAlivePoolFLPV2 = true;
-                    }
-                }
-            }
-
-            // todo: [FLPCOREANDUX-10024] rework empty applicationContainer case
-            // fallback?
-
-            await ushellUtils.promisify(oApplicationContainer.getDeffedControlCreation());
-
-            //here, we simply show (turning to visible) the container of the new opened application in case it is not stateful container
-            //and not old gui v1 stateful
-            if (oApplicationContainer.getStatefulType() !== BlueBoxHandler.STATEFUL_TYPES.GUI_V1 && !bReuseStatefulContainer) {
-                if (bKeptAliveApp) {
-                    EventBus.getInstance().publish("launchpad", "appOpening", oResolvedHashFragment);
-                }
-                const oStorageEntry = Storage.get(oApplicationContainer.getId());
-                if (oStorageEntry) {
-                    oCurrentApplication = oStorageEntry;
-                }
-
-                if (bKeptAliveApp) {
-                    EventBus.getInstance().publish("sap.ushell", "appOpened", oResolvedHashFragment);
-                }
+            // Set current application
+            if (bShouldBeCached) {
+                oCurrentApplication = this._addStorageEntry(
+                    sStorageAppId,
+                    oApplicationContainer,
+                    oResolvedHashFragment,
+                    oParsedShellHash,
+                    sKeepAliveMode
+                );
+            } else {
+                // create application that is not persisted and not cached
+                oCurrentApplication = {
+                    appId: sStorageAppId,
+                    stt: "loading",
+                    container: oApplicationContainer,
+                    meta: undefined, // is set after application start
+                    app: undefined
+                };
             }
 
-            // Assuming a previously existing TR container existed and is now
-            // going to be reused, we prompt the container to load the new application context.
-
-            //  SAP GUI is sending post messages for back navigation as soon the create application event is sent to the iframe,
-            // so this makes sure the container is active before sending the event.
-            // For WD applications, the application is active only after the application is created.
-            // So it is not navigated twice.
-            if (oApplicationContainer.getApplicationType() === ApplicationType.TR.type) {
-                this._activeContainer(oApplicationContainer);
-            }
+            ushellUtils.setPerformanceMark("FLP - addAppContainer");
 
-            const oStorageEntry = Storage.get(sStorageAppId);
+            // restore the app info parameters before activating the application container
+            const oStorageEntry = KeepAliveApps.get(sStorageAppId);
             if (oStorageEntry) {
                 AppInfoParameters.restore(oStorageEntry);
             } else {
                 AppInfoParameters.flush();
             }
 
+            // enable the PostMessageAPI for the application
+            this._setApplicationContainerActive(oApplicationContainer);
 
-            //here, we create the application in case this is a stateful container (meaning, using the existing iframe)
-            if (bReuseStatefulContainer) {
-                //for scube - make sure the container is active before we open the app
-                //to allow post messages form the iframe to flp that are sent
-                //as part of the target resolution process
-                if (oResolvedHashFragment.appCapabilities?.appFrameworkId === "UI5") {
-                    oApplicationContainer.setProperty("active", true, true);
-                }
-                // eslint-disable-next-line max-len
-                await this._handleOpenStateful(bNewlyCreatedApplicationContainer, bShouldBeCached, sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode, bNavigationInSameStatefulContainer, bReturnedFromKeepAlivePoolFLPV2);
+            const sNavigationRedirectHash = await this._openApp(
+                sStorageAppId,
+                oApplicationContainer,
+                oResolvedHashFragment,
+                oParsedShellHash,
+                bWasKeptAlive
+            );
 
-            } else if (oApplicationContainer.getStatefulType() === BlueBoxHandler.STATEFUL_TYPES.GUI_V1 || bReturnedFromKeepAlivePoolGuiV1) {
-                //here, we create the application in case this is old gui v1 stateful
-                await WebGUIStatefulHandler.guiStatefulCreateApp(this, oApplicationContainer, oResolvedHashFragment);
+            if (typeof sNavigationRedirectHash === "string") {
+                // do not add the deleted application to the view port
+                return sNavigationRedirectHash;
             }
 
-            //for case of stateful container or gui v1 stateful, show the application view (make it visible)
+            // todo: [FLPCOREANDUX-10024] fix this
+            // initialize now because the app is required for additional information
+            this._initializeAppWithMetadata(oApplicationContainer, oResolvedHashFragment);
+
+            // todo: [FLPCOREANDUX-10024] fix this
+            // finally add the application container to the view port (triggers render call)
+            // do not add it earlier to prevent the application container
+            // from creating the component before this process is done
+            this._addApplicationContainerToViewPort(oApplicationContainer);
             ushellUtils.setPerformanceMark("FLP -- centerViewPort");
-            if (oApplicationContainer.getApplicationType() !== ApplicationType.TR.type) {
-                // Activate container before showing it (start reacting to postMessage calls)
-                this._activeContainer(oApplicationContainer);
-            }
 
-            /*
-             * Workaround:
-             * The oCurrentApplication object does not reflect the currently opened application.
-             * This leads to store/restore calls on the wrong application.
-             * Create application that is not persisted and not cashed as a fallback.
-             *
-             * This issue occurs for iframe applications reusing the iframe.
-             */
-            if (oCurrentApplication.appId !== sStorageAppId) {
-                oCurrentApplication = {
-                    appId: sStorageAppId,
-                    stt: "loading",
-                    container: oApplicationContainer,
-                    meta: AppConfiguration.getMetadata(oResolvedHashFragment),
-                    app: undefined
-                };
-            }
+            EventBus.getInstance().publish("sap.ushell", "appOpened", oResolvedHashFragment);
+            Log.info("app was opened");
         };
 
         /**
@@ -1611,7 +1400,7 @@ sap.ui.define([
          */
         this.switchViewState = function (sLaunchpadState, sAppId, sAppType, bIsExplaceNavigation) {
             // Store state before creating a new one
-            const oFromStorageEntry = Storage.get(oCurrentApplication.appId);
+            const oFromStorageEntry = KeepAliveApps.get(oCurrentApplication.appId);
             if (!oFromStorageEntry) {
                 // We have to destroy managed queue BEFORE we're applying the pending changes
                 StateManager.destroyManagedControls();
@@ -1633,7 +1422,7 @@ sap.ui.define([
 
             // Restore state if it already exists
             const sToStorageAppId = `application-${sAppId}`;
-            const oToStorageEntry = Storage.get(sToStorageAppId);
+            const oToStorageEntry = KeepAliveApps.get(sToStorageAppId);
             if (oToStorageEntry) {
                 KeepAlive.restore(oToStorageEntry);
             } else {
@@ -1644,13 +1433,6 @@ sap.ui.define([
             StateManager.applyStalledChanges();
         };
 
-        /**
-         * @param {object} oCommunicationHandler
-         */
-        this.registerShellCommunicationHandler = function (oCommunicationHandler) {
-            Application.registerShellCommunicationHandler(oCommunicationHandler);
-        };
-
         /**
          * @returns {boolean} Whether the floating container is docked.
          */
@@ -1705,48 +1487,24 @@ sap.ui.define([
             }, 0);
         };
 
-        /**
-         * @param {string} sAppId
-         * @param {object} oParsedShellHash
-         * @param {object} oResolvedHashFragment
-         * @param {string} sShellHash
-         * @returns {object} The app container.
-         */
-        this._createApplicationContainer = async function (sAppId, oParsedShellHash, oResolvedHashFragment) {
-            const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment, oResolvedHashFragment?.sFixedShellHash);
-            const bFullWidth = this._isFullWidth(oResolvedHashFragment);
-
-            /*
-             * The external navigation mode in the resolution result is calculated
-             * statically, and indicates a future state. It currently answers the
-             * question: "is the application going to be opened explace?".
-             *
-             * The target navigation mode, instead, answers the question: "was
-             * the application opened explace?".
-             *
-             * We need to have this logic, because embedded applications do not
-             * check the coldstart condition.
-             */
-            oResolvedHashFragment.targetNavigationMode = ushellUtils.isColdStart() ? "explace" : "inplace";
-            oResolvedHashFragment.shellUIService = oGlobalShellUIService.getInterface();
-
-            // send focus back to shell for new ApplicationContainers
-            this._sendFocusBackToShell();
-
-            this._announceAppOpening(oResolvedHashFragment);
+        this._initializeApplicationContainer = function (oApplicationContainer, oResolvedHashFragment) {
+            if (ushellUtils.isSAPLegacyApplicationType(oApplicationContainer.getApplicationType(), oApplicationContainer.getFrameworkId())) {
+                oApplicationContainer.addStyleClass("sapUShellApplicationContainerShiftedIframe");
+            }
+        };
 
-            await this._openApp(sAppId, oResolvedHashFragment, oParsedShellHash);
-            const oApplicationContainer = oCurrentApplication.container;
+        this._initializeAppWithMetadata = function (oApplicationContainer, oResolvedHashFragment) {
+            const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment, oResolvedHashFragment?.sFixedShellHash);
 
-            const bContainerFromCachePool = oApplicationContainer.getIsFetchedFromCache();
+            oCurrentApplication.meta = oMetadata;
 
-            if (!bContainerFromCachePool) {
-                this._publishNavigationStateEvents(oApplicationContainer, oResolvedHashFragment, this.onAppAfterRendering.bind(this, oResolvedHashFragment));
+            // ApplicationContainer is newly created
+            if (!oApplicationContainer.getIsFetchedFromCache()) {
+                this._publishNavigationStateEvents(oApplicationContainer, oResolvedHashFragment, oMetadata);
 
-                if (ushellUtils.isSAPLegacyApplicationType(oApplicationContainer.getApplicationType(), oApplicationContainer.getFrameworkId())) {
-                    oApplicationContainer.addStyleClass("sapUShellApplicationContainerShiftedIframe");
-                }
+                oApplicationContainer.toggleStyleClass("sapUshellDefaultBackground", !oMetadata.hideLightBackground);
 
+                const bFullWidth = this._isFullWidth(oResolvedHashFragment, oMetadata);
                 if (!bFullWidth) {
                     oApplicationContainer.addStyleClass("sapUShellApplicationContainerLimitedWidth");
                 }
@@ -1760,115 +1518,124 @@ sap.ui.define([
                     oApplicationContainer.removeStyleClass("sapUShellApplicationContainerLimitedWidth");
                 }
 
-                oApplicationContainer.toggleStyleClass("sapUshellDefaultBackground", !oMetadata.hideLightBackground);
-
                 AppMeta._applyContentDensityByPriority();
-
-                // Add inner control for next request
-                this._addApplicationContainerToViewPort(oApplicationContainer);
             }
-
-            ushellUtils.setPerformanceMark("FLP - addAppContainer");
-
-            return oApplicationContainer;
         };
 
         /**
-         * @param {string} sShellHash
+         *  - prevent duplicated ids in the viewport container.
+         *  - prevent reuse of stateful containers for different servers.
+         *  - destroy the keep alive app for certain navigation cases.
+         *  - destroy the app if the iframe is invalid/unresponsive.
+         *  - exit the current application if it is a stateful container.
+         *
+         * @param {string} sAppId
+         * @param {string} oParsedShellHash
          * @param {object} oResolvedHashFragment
          * @param {boolean} bNavigationFromHome
          * @param {boolean} bNavigationWithInnerAppRoute
          */
-        this.handleBeforeCreateApp = async function (sShellHash, oResolvedHashFragment, bNavigationFromHome, bNavigationWithInnerAppRoute) {
-            const sIntent = UrlParsing.getBasicHash(sShellHash);
-            const bComponentLoaded = !!oResolvedHashFragment?.componentHandle;
-            // for SAPUI5 apps, the application type is still "URL" due to backwards compatibility, but the
-            // NavTargetResolutionInternal service already extracts the component name, so this can directly be used as indicator
-            const sTargetUi5ComponentName = oResolvedHashFragment?.ui5ComponentName;
-
-            // handle special case when navigating from home to an application with state, when keep-alive is active
-            const oInMemoryApplicationInstance = this._getInMemoryInstance(sIntent, sShellHash, bNavigationFromHome, bNavigationWithInnerAppRoute);
-
-            if (!oInMemoryApplicationInstance.destroyApplication) {
-                // no destroy required
-
-            } else if (bComponentLoaded || !sTargetUi5ComponentName) { // non UI5 Application
-                if ((
-                    oResolvedHashFragment.applicationType === "URL"
-                    || ushellUtils.isSAPLegacyApplicationType(oResolvedHashFragment.applicationType)
-                )
-                    && oInMemoryApplicationInstance.destroyApplication
-                    && oInMemoryApplicationInstance.appId
-                ) {
-                    await this._destroyApplication(oInMemoryApplicationInstance.appId, oInMemoryApplicationInstance.container);
-                }
+        this._cleanupBeforeNewApp = async function (sAppId, oParsedShellHash, oResolvedHashFragment, bNavigationFromHome, bNavigationWithInnerAppRoute) {
+            // todo: [FLPCOREANDUX-10024] add staged logging for createApplication including the cleanup similar to CSTR
+            // ====== Exit current iframe app ======
+            /*
+             * for stateful containers, we need to exit/close the current application BEFORE any
+             * navigation in the viewportContainer
+             */
+            const oCurrentApplicationContainer = this.getCurrentApplication()?.container;
+            const bIsReusableContainer = oCurrentApplicationContainer && oCurrentApplicationContainer.getStatefulType() !== StatefulType.NotSupported;
+            if (bIsReusableContainer) {
+                await this._handleExitApplication(oCurrentApplicationContainer, false);
+            }
 
-            } else { // UI5 Application
-                await this._destroyApplication(oInMemoryApplicationInstance.appId, oInMemoryApplicationInstance.container);
-                const oApplicationContainer = this._getApplicationContainerFromViewPort(sIntent);
+            const sStorageAppId = `application-${sAppId}`;
+            const oStorageEntry = KeepAliveApps.get(sStorageAppId);
+            const bTargetAppWasKeptAlive = !!oStorageEntry;
+            // the appId on the storage entry and the appId on the application container might be different.
+            const oStoredApplicationContainer = oStorageEntry?.container;
 
-                if (oApplicationContainer) {
-                    this._removeApplicationContainerFromViewPort(oApplicationContainer.getId());
-                    oApplicationContainer.destroy();
+            // For SAPUI5 apps, the application type is still "URL" due to backwards compatibility, but the
+            // NavTargetResolutionInternal service already extracts the component name, so this can directly be used as indicator
+            const bIsUI5AppWithoutIframe = !!oResolvedHashFragment?.ui5ComponentName;
+
+            // ====== Handle special navigation scenarios for keep alive apps ======
+            if (bTargetAppWasKeptAlive) {
+                const sNewShellHash = `#${UrlParsing.constructShellHash(oParsedShellHash)}`;
+                const oComparison = UrlParsing.compareHashes(sNewShellHash, oStorageEntry.shellHash);
+                const bSameTarget = oComparison.sameIntent && oComparison.sameParameters;
+
+                // Case: different app
+                if (!bSameTarget) {
+                    Log.warning(`The keepAlive app '${sStorageAppId}' has to be destroyed because of id clashes.`);
+                    await this._destroyApplication(sStorageAppId, oStoredApplicationContainer);
+
+                // Case: Navigating from homepage to a keepAlive application via deep link (bookmark).
+                // In this case, although keepAlive is active we need to destroy the application and re-open it.
+                } else if (bNavigationFromHome && bNavigationWithInnerAppRoute) {
+                    Log.warning(`The keepAlive app '${sStorageAppId}' has to be destroyed because of a bookmark start.`);
+                    await this._destroyApplication(sStorageAppId, oStoredApplicationContainer);
                 }
 
-                // close all keep alive apps with the same component name
-                await this._closeKeepAliveApps((oStorageEntry) => oStorageEntry.ui5ComponentName === oResolvedHashFragment.ui5ComponentName);
+                // => we are navigating to the right keep alive app, so we keep it alive
             }
-        };
 
-        /**
-         * @param {string} sShellHash
-         * @param {object} oParsedShellHash
-         * @param {object} oResolvedHashFragment
-         * @param {boolean} bNavigationFromHome
-         * @param {boolean} bNavigationWithInnerAppRoute
-         */
-        this.handleCreateApp = async function (sShellHash, oParsedShellHash, oResolvedHashFragment, bNavigationFromHome, bNavigationWithInnerAppRoute) {
-            const sIntent = UrlParsing.getBasicHash(sShellHash);
-            const bComponentLoaded = !!oResolvedHashFragment?.componentHandle;
-            // for SAPUI5 apps, the application type is still "URL" due to backwards compatibility, but the
-            // NavTargetResolutionInternal service already extracts the component name, so this can directly be used as indicator
-            const sTargetUi5ComponentName = oResolvedHashFragment?.ui5ComponentName;
-            const bIsUI5App = !!sTargetUi5ComponentName;
-            const oInMemoryApplicationInstance = this._getInMemoryInstance(sIntent, sShellHash, bNavigationFromHome, bNavigationWithInnerAppRoute);
-
-            // todo: [FLPCOREANDUX-10024] checking on the destroyApplication flag is odd at this point
-            if (bIsUI5App && !bComponentLoaded && oInMemoryApplicationInstance.destroyApplication) { // UI5 Application
-                AppConfiguration.setApplicationInInitMode();
-
-                /*
-                * normal application:
-                * fire the _prior.newUI5ComponentInstantion event before creating the new component instance, so that
-                * the ApplicationContainer can stop the router of the current app (avoid inner-app hash change notifications)
-                * NOTE: this dependency to the ApplicationContainer is not nice, but we need a fast fix now; we should refactor
-                * the ApplicationContainer code, because most of the logic has to be done by the shell controller;
-                * maybe rather introduce a utility module
-                */
-                EventBus.getInstance().publish("ApplicationContainer", "_prior.newUI5ComponentInstantion",
-                    { name: sTargetUi5ComponentName }
-                );
+            // ====== Ensure that no id clashes occur ======
+            // Get the application container by its control id
+            // This might be different from the appId
+            const oApplicationContainer = this._getApplicationContainerFromViewPort(sAppId);
+            const bMatchesTheKeepAliveApp = oApplicationContainer === oStoredApplicationContainer;
+
+            if (oApplicationContainer && !bMatchesTheKeepAliveApp) { // non kept alive app
+                // Collision with a stateful container
+                if (bIsUI5AppWithoutIframe) {
+                    Log.warning(`The app '${oApplicationContainer.getCurrentAppId()}' has to be destroyed because of id clashes.`);
+                    await this._destroyApplication(oApplicationContainer.getCurrentAppId(), oApplicationContainer, true); // force destroy
 
-                // load ui5 component via shell service; core-ext-light will be loaded as part of the asyncHints
-                await Container.getServiceAsync("Ui5ComponentLoader");
-
-                /*
-                 * FIXME: It would be better to call a function that simply
-                 * and intentionally loads the dependencies of the UI5
-                 * application, rather than creating a component and expecting
-                 * the dependencies to be loaded as a side effect.
-                 * Moreover, the comment reads "load ui5 component via shell service"
-                 * however that is 'not needed' since the loaded component
-                 * is not used. We should evaluate the possible performance
-                 * hit taken due to this implicit means to an end.
-                 */
-
-                /*
-                 * return value is unused.
-                 * This is because oResolvedHashFragment contains the component handle already.
-                 * See the preceding note in AppLifeCycle.createComponent.
-                 */
-                await Application.createComponent(oResolvedHashFragment, oParsedShellHash);
+                } else if (!ApplicationContainerCache.canBeReused(oApplicationContainer, oResolvedHashFragment.url)) {
+
+                    // the application container found via id is from a different server
+                    Log.warning(`The app '${oApplicationContainer.getCurrentAppId()}' has to be destroyed because of id clashes.`);
+                    await this._destroyApplication(oApplicationContainer.getCurrentAppId(), oApplicationContainer, true); // force destroy
+                }
+            } // else means either no app container found or there is a stateful container with a matching url
+
+            // ====== Ensure that component name clashes are prevented ======
+            if (bIsUI5AppWithoutIframe) {
+                // close all keep alive apps with the same component name (except the current one)
+                // otherwise we have clashes on the component name
+                await this._destroyKeepAliveApps((oStorageEntry) => {
+                    return oStorageEntry.appId !== sStorageAppId
+                        && oStorageEntry.ui5ComponentName === oResolvedHashFragment.ui5ComponentName;
+                }, true); // force destroy
+            }
+
+            // ====== Handle invalid iframes ======
+            // get the potential target stateful container and check if it's valid. if not, destroy it
+            // before we try to create the new application within the same stateful container
+            const oPotentialApplicationContainer = ApplicationContainerCache.findFreeContainerByUrl(oResolvedHashFragment.url);
+            if (oPotentialApplicationContainer && oPotentialApplicationContainer.getStatefulType() === StatefulType.ContractV2) {
+                let bIframeInvalid = false;
+                let sReason;
+                if (oPotentialApplicationContainer.getIsInvalidIframe()) {
+                    bIframeInvalid = true;
+                    sReason = "iframe is in invalid state";
+
+                } else if (StatefulContainerV2Handler.isIframeIsValidSupported(oPotentialApplicationContainer)) {
+                    const iLastValidTimeDelta = new Date().getTime() - oPotentialApplicationContainer.getIsIframeValidTime().time;
+                    bIframeInvalid = iLastValidTimeDelta >= iValidIframeTimeout;
+                    sReason = `iframe did not ping in the last '${iLastValidTimeDelta}' ms`;
+                }
+
+                if (bIframeInvalid) {
+                    Log.warning(
+                        `Destroying stateful container iframe due to unresponsiveness (${oPotentialApplicationContainer.getId()})`,
+                        `reason: ${sReason}`,
+                        "sap.ushell.components.applicationIntegration.AppLifeCycle"
+                    );
+
+                    // not able to exit gracefully, destroy the container directly forcefully
+                    return this._destroyApplication(sStorageAppId, oPotentialApplicationContainer, true); // force destroy
+                }
             }
         };
 
@@ -1876,7 +1643,7 @@ sap.ui.define([
          *
          * @param {sap.ui.core.Component} oApplication
          */
-        this.onAppAfterRendering = function (oApplication) {
+        this._onAppAfterRendering = function (oApplication) {
             // wrapped in setTimeout since "publish" is not async
             window.setTimeout(() => {
                 EventBus.getInstance().publish("sap.ushell", "appOpened", oApplication);
@@ -1905,7 +1672,31 @@ sap.ui.define([
         this.setViewPortContainer = function (oNewViewPortContainer) {
             oViewPortContainer = oNewViewPortContainer;
         };
+
+        /**
+         * Only for testing
+         */
+        this.reset = function () {
+            oCurrentApplication = {};
+            KeepAliveApps._clean();
+            ApplicationContainerCache.destroyAllContainers();
+            PostMessageManager.reset();
+        };
+
+        this._setContainerReadyForReuse = function (oApplicationContainer) {
+            if (!oApplicationContainer) {
+                return;
+            }
+
+            ApplicationContainerCache.setContainerReadyForReuse(oApplicationContainer, oApplicationContainer.getCurrentAppUrl());
+
+            oApplicationContainer.setProperty("isKeepAlive", false, true);
+            oApplicationContainer.setProperty("currentAppUrl", "", true);
+            oApplicationContainer.setProperty("isFetchedFromCache", false, true);
+        };
     }
 
+    AppLifeCycle.prototype.KeepAliveMode = KEEP_ALIVE_MODES;
+
     return new AppLifeCycle();
-}, /* bExport= */ true);
+});