@sapui5/sap.ushell 1.129.1 → 1.130.1

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

@@ -2,9 +2,10 @@
 
 /**
  * @fileOverview handle all the resources for the different applications.
- * @version 1.129.1
+ * @version 1.130.1
  */
 sap.ui.define([
+    "sap/ui/Device",
     "sap/ui/core/Element",
     "sap/ui/core/EventBus",
     "sap/ushell/components/applicationIntegration/Storage",
@@ -27,12 +28,17 @@ sap.ui.define([
     "sap/ushell/services/MessageBroker/MessageBrokerEngine",
     "sap/ushell/renderer/utils",
     "sap/m/library",
+    "sap/ushell/AppInfoParameters",
     "sap/ushell/Container",
+    "sap/ushell/resources",
+    "sap/ushell/state/ShellModel",
     "sap/ushell/state/StateManager",
     "sap/ushell/state/KeepAlive",
     "sap/ushell/ui5service/ShellUIServiceFactory",
-    "sap/ui/core/service/ServiceFactoryRegistry"
+    "sap/ui/core/service/ServiceFactoryRegistry",
+    "sap/base/util/ObjectPath"
 ], (
+    Device,
     Element,
     EventBus,
     Storage,
@@ -50,30 +56,42 @@ sap.ui.define([
     UriParameters,
     Log,
     EventHub,
-    oUrlParsing,
+    UrlParsing,
     hasher,
     MessageBrokerEngine,
     RendererUtils,
     mobileLibrary,
+    AppInfoParameters,
     Container,
+    ushellResources,
+    ShellModel,
     StateManager,
     KeepAlive,
     ShellUIServiceFactory,
-    ServiceFactoryRegistry
+    ServiceFactoryRegistry,
+    ObjectPath
 ) => {
     "use strict";
 
     // shortcut for sap.ushell.state.StateManager.ShellMode
     const ShellMode = StateManager.ShellMode;
 
+    // shortcut for sap.ushell.state.StateManager.LaunchpadState
+    const LaunchpadState = StateManager.LaunchpadState;
+
+    // shortcut for sap.ushell.state.StateManager.Operation
+    const Operation = StateManager.Operation;
+
     // shortcut for sap.m.URLHelper
     const URLHelper = mobileLibrary.URLHelper;
 
-    const CACHED_APP_TYPES = ["URL"];
+    // todo: [FLPCOREANDUX-10024] cleanup
+    // const CACHED_APP_TYPES = ["URL"];
 
     const KEEP_ALIVE_MODES = {
         FULL: "true",
-        RESTRICTED: "restricted"
+        RESTRICTED: "restricted",
+        FALSE: "false"
     };
 
     function AppLifeCycle () {
@@ -81,12 +99,8 @@ sap.ui.define([
         let bDisableHomeAppCache = false;
         let bEnableRouterRetrigger = true;
         let oCurrentApplication = {};
-        const oGlobalShellCommunicationHandlers = [];
-        const oGlobalIframeCommunicationHandlers = {};
         const oComponentCreatedPromises = {};
-        let isBackNavigationChanged = false;
-        let sRootIntent,
-            oGlobalShellUIService,
+        let oGlobalShellUIService,
             fnOldTriggerEmail,
             oViewPortContainer;
 
@@ -102,112 +116,67 @@ sap.ui.define([
             return RelatedServices;
         };
 
-        ///////////////////APPLICATION INTEGRATION API///////////////////////////////
-        ///////////////////END APPLICATION INTEGRATION API///////////////////////////////
-
-        /**
-         * @param {string} sAppId
-         * @returns {boolean} Returns true if it is the current application
-         */
-        this.isCurrentApp = function (sAppId) {
-            return (oCurrentApplication.appId === sAppId);
-        };
-
         /**
          * Sets the componentCreated promise for a given appId if it does not exist yet.
          * Returns the promise along with the resolve and reject functions.
          * @private
          * @since 1.125.0
-         * @param {string} sAppId The id of the created application.
+         * @param {string} sStorageAppId The id of the created application.
          * @returns {{
          *     promise: Promise,
          *     resolve: function,
          *     reject: function
          * }} An object containing the promise and the resolve and reject functions.
          */
-        this.setComponentCreatedPromise = function (sAppId) {
-            if (!oComponentCreatedPromises[sAppId]) {
-                oComponentCreatedPromises[sAppId] = {};
-                oComponentCreatedPromises[sAppId].promise = new Promise((resolve, reject) => {
-                    oComponentCreatedPromises[sAppId].resolve = resolve;
-                    oComponentCreatedPromises[sAppId].reject = reject;
+        this._setComponentCreatedPromise = function (sStorageAppId) {
+            if (!oComponentCreatedPromises[sStorageAppId]) {
+                oComponentCreatedPromises[sStorageAppId] = {};
+                oComponentCreatedPromises[sStorageAppId].promise = new Promise((resolve, reject) => {
+                    oComponentCreatedPromises[sStorageAppId].resolve = resolve;
+                    oComponentCreatedPromises[sStorageAppId].reject = reject;
                 });
             }
 
-            return oComponentCreatedPromises[sAppId];
+            return oComponentCreatedPromises[sStorageAppId];
         };
 
         /**
          * Resolves the componentCreated promise for the given appId. If the promise does not yet exist, it is created.
-         * @param {string} sAppId The id of the created application.
-         * @private
-         * @since 1.125.0
-         */
-        this.resolveComponentCreatedPromise = function (sAppId) {
-            if (!sAppId) { return; }
-            this.setComponentCreatedPromise(sAppId).resolve();
-        };
-
-        /**
-         * Rejects the componentCreated promise for the given appId. If the promise does not yet exist, it is created.
-         * @param {string} sAppId The id of the created application.
+         * @param {string} sStorageAppId The id of the created application.
          * @private
          * @since 1.125.0
          */
-        this.rejectComponentCreatedPromise = function (sAppId) {
-            if (!sAppId) { return; }
-            this.setComponentCreatedPromise(sAppId).reject(`Component was not created for app "${sAppId}"`);
+        this._resolveComponentCreatedPromise = function (sStorageAppId) {
+            if (!sStorageAppId) {
+                return;
+            }
+            this._setComponentCreatedPromise(sStorageAppId).resolve();
         };
 
         /**
          * Returns the componentCreated promise for the given appId. If the promise does not yet exist, it is created.
-         * @param {string} sAppId The id of the created application.
+         * @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.
          * @private
          * @since 1.125.0
          */
-        this.getComponentCreatedPromise = function (sAppId) {
-            if (!sAppId) { return; }
-            return this.setComponentCreatedPromise(sAppId).promise;
-        };
-
-        /**
-         * @param {string} sAppId
-         * @param {string} sFixedShellHash
-         * @returns {boolean} Returns true if a similar app was found in the cache
-         */
-        this.isAppWithSimilarShellHashInCache = function (sAppId, sFixedShellHash) {
-            const oAppEntry = Storage.get(sAppId);
-
-            if (oAppEntry) {
-                if (oAppEntry.shellHash === sFixedShellHash) {
-                    return true;
-                }
-                return false;
-            }
-            return false;
-        };
-
-        /**
-         * @param {string} sAppId
-         * @returns {boolean} Returns true if the app is in the cache
-         */
-        this.isAppInCache = function (sAppId) {
-            return !!Storage.get(sAppId);
+        this._getComponentCreatedPromise = function (sStorageAppId) {
+            if (!sStorageAppId) { return; }
+            return this._setComponentCreatedPromise(sStorageAppId).promise;
         };
 
         /**
-         * @param {string} sAppId
+         * @param {string} sId Id of the control might end with "-component"
          * @returns {string} Returns the normalized appId
          */
-        this.normalizeAppId = function (sAppId) {
+        this._normalizeAppId = function (sId) {
             const sCmp = "-component";
-            const isCmp = sAppId.endsWith(sCmp);
+            const isCmp = sId.endsWith(sCmp);
 
             if (isCmp) {
-                return sAppId.substring(0, sAppId.length - sCmp.length);
+                return sId.substring(0, sId.length - sCmp.length);
             }
-            return sAppId;
+            return sId;
         };
 
         /**
@@ -215,13 +184,15 @@ sap.ui.define([
          * @param {string} sChannel
          * @param {object} oData
          */
-        this.onComponentCreated = function (oEvent, sChannel, oData) {
+        this._onComponentCreated = function (oEvent, sChannel, oData) {
             const oApp = oData.component;
-            const sAppId = this.normalizeAppId(oApp.getId());
+            const sStorageAppId = this._normalizeAppId(oApp.getId());
+            const oStorageEntry = Storage.get(sStorageAppId);
+
+            if (oStorageEntry) {
+                oStorageEntry.app = oApp;
+                Application.active(oStorageEntry.app);
 
-            if (this.isAppInCache(sAppId)) {
-                Storage.get(sAppId).app = oApp;
-                this.active(sAppId);
             } else {
                 oCurrentApplication.app = oApp;
 
@@ -230,7 +201,7 @@ sap.ui.define([
                 }
             }
 
-            this.resolveComponentCreatedPromise(sAppId);
+            this._resolveComponentCreatedPromise(sStorageAppId);
         };
 
         /**
@@ -238,15 +209,15 @@ sap.ui.define([
          * @param {string} sChannel
          * @param {object} oData
          */
-        this.onGetMe = function (oEvent, sChannel, oData) {
+        this._onGetMe = function (oEvent, sChannel, oData) {
             oData.AppLifeCycle = this;
         };
 
         /**
-         * @param {string} sAppId
+         * @param {string} sStorageAppId
          */
-        this.store = function (sAppId) {
-            const oStorageEntry = Storage.get(sAppId);
+        this._store = function (sStorageAppId) {
+            const oStorageEntry = Storage.get(sStorageAppId);
 
             if (oStorageEntry) {
                 Application.store(oStorageEntry);
@@ -255,47 +226,39 @@ sap.ui.define([
         };
 
         /**
-         * @param {string} sAppId
-         * @param {object} oFrom
+         * @param {string} sStorageAppId
+         * @param {object} oApplicationContainer
          * @param {boolean} bHardDestroy
          * @returns {Promise} Resolves when the app is destroyed.
          */
-        this.destroyApplication = async function (sAppId, oFrom, bHardDestroy) {
-            const oStorageEntry = Storage.get(sAppId);
-
-            if (!sAppId || !oFrom) {
-                return;
-            }
+        this._destroyApplication = async function (sStorageAppId, oApplicationContainer, bHardDestroy) {
+            const oStorageEntry = Storage.get(sStorageAppId);
 
-            function doDestroy () {
-                BlueBoxHandler.deleteBlueBoxByContainer(oFrom);
-                Application.destroy(oFrom);
-                AppMeta.destroy(oFrom);
-                KeepAlive.destroy(oStorageEntry);
-            }
-
-            if (bHardDestroy) {
-                Storage.removeByContainer(oFrom);
-                this.removeControl(sAppId);
-                doDestroy();
+            if (!sStorageAppId || !oApplicationContainer) {
                 return;
             }
 
-            if (oStorageEntry) {
-                Storage.removeById(sAppId);
+            // ignore stateful destroy when hard destroy is requested
+            if (oStorageEntry && !bHardDestroy) {
+                Storage.removeById(sStorageAppId);
                 if (BlueBoxHandler.isStatefulContainer(oStorageEntry.container)) {
-                    await BlueBoxHandler.statefulDestroyApp(oStorageEntry.container, sAppId);
+                    await BlueBoxHandler.statefulDestroyApp(oStorageEntry.container, sStorageAppId);
                 } else if (!BlueBoxHandler.returnUnusedKeepAliveContainer(oStorageEntry.container)) {
-                    this.removeControl(sAppId);
+                    this._removeApplicationContainerFromViewPort(sStorageAppId);
                     BlueBoxHandler.deleteBlueBoxByContainer(oStorageEntry.container);
                     oStorageEntry.container.destroy();
                 } else {
-                    await this.handleExitStateful(sAppId, oStorageEntry.container, false);
+                    await this._handleExitStateful(oStorageEntry.container, false);
                 }
                 return;
             }
 
-            this.removeControl(sAppId);
+
+            if (bHardDestroy) {
+                Storage.removeByContainer(oApplicationContainer);
+            }
+
+            this._removeApplicationContainerFromViewPort(sStorageAppId);
             /**
              * 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
@@ -309,10 +272,9 @@ sap.ui.define([
              * This mechanism was added to solve the change made in Chrome to disallow Sync XHR on
              * browser close.
              */
-            const oPromise = oFrom?.sendBeforeAppCloseEvent?.() || Promise.resolve();
-
             try {
-                await ushellUtils.promisify(oPromise);
+                const oThenable = oApplicationContainer.sendBeforeAppCloseEvent();
+                await ushellUtils.promisify(oThenable);
             } catch (sError) {
                 Log.error(
                     "FLP got a failed response from the iframe for the 'sap.ushell.services.CrossApplicationNavigation.beforeAppCloseEvent' message sent",
@@ -320,19 +282,22 @@ sap.ui.define([
                     "sap.ushell.components.applicationIntegration.AppLifeCycle.js"
                 );
             }
-            doDestroy();
+
+            BlueBoxHandler.deleteBlueBoxByContainer(oApplicationContainer);
+            Application.destroy(oApplicationContainer);
+            AppMeta.destroy(oApplicationContainer);
+            KeepAlive.destroy(oStorageEntry);
         };
 
         /**
-         * @param {string} sAppId
+         * @param {string} sStorageAppId
          */
-        this.restore = function (sAppId) {
-            const oStorageEntry = Storage.get(sAppId);
+        this._restore = function (sStorageAppId) {
+            const oStorageEntry = Storage.get(sStorageAppId);
 
             if (oStorageEntry?.stateStored) {
                 // 1) Extensions
                 RelatedServices.restore(oStorageEntry.service);
-                this.setBackNavigationChanged(true);
                 AppMeta.restore(oStorageEntry.meta);
                 // 2) Extension API
                 ShellUIServiceFactory.restore(oStorageEntry);
@@ -342,150 +307,123 @@ sap.ui.define([
         };
 
         /**
-         * @param {string} sAppId
-         */
-        this.active = function (sAppId) {
-            const oStorageEntry = Storage.get(sAppId);
-
-            if (oStorageEntry) {
-                Application.active(oStorageEntry.app);
-            }
-        };
-
-        /**
-         * @param {string} sFromId
-         * @param {object} oFrom
-         * @param {boolean} bIsHomePage
-         * @param {boolean} bForceCloseApp
+         * @param {object} oApplicationContainer
+         * @param {boolean} bNavigationToFlpComponent
+         * @param {boolean} [bForceCloseApp]
          * @returns {Promise} Resolves when the app is closed.
          */
-        this.handleExitStateful = function (sFromId, oFrom, bIsHomePage, bForceCloseApp) {
-            const sActualAppFromId = oFrom.getCurrentAppId?.();
+        this._handleExitStateful = function (oApplicationContainer, bNavigationToFlpComponent, bForceCloseApp) {
+            const sActualAppFromId = oApplicationContainer.getCurrentAppId();
 
             if (Storage.get(sActualAppFromId)) {
-                if ((RelatedServices.isBackNavigation() && !bIsHomePage) || (bForceCloseApp)) {
-                    EventBus.getInstance().publish("sap.ushell", "appClosed", oFrom);
+                if ((RelatedServices.isBackNavigation() && !bNavigationToFlpComponent) || (bForceCloseApp)) {
+                    EventBus.getInstance().publish("sap.ushell", "appClosed", oApplicationContainer);
                     Storage.removeById(sActualAppFromId);
-                    return BlueBoxHandler.statefulDestroyApp(oFrom);
+                    return BlueBoxHandler.statefulDestroyApp(oApplicationContainer);
                 }
                 // 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", oFrom);
-                return BlueBoxHandler.statefulStoreKeepAliveApp(oFrom, sActualAppFromId);
+                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(oFrom);
+            return BlueBoxHandler.statefulDestroyApp(oApplicationContainer);
         };
 
         /**
-         * @param {string} sFromId
-         * @param {object} oFrom
-         * @param {string} sToId
-         * @param {object} oTo
-         * @param {boolean} bIsHomePage
+         * @param {object} oOldApplicationContainer
+         * @param {boolean} bNavigationToFlpComponent
          * @param {boolean} bFromAfterNavigate
          * @returns {Promise} Resolves when the app is closed.
          */
-        this.handleExitApplication = async function (sFromId, oFrom, sToId, oTo, bIsHomePage, bFromAfterNavigate) {
-            function fnCloseKeepAliveIfRestricted (oApp) {
-                return (oApp.keepAliveMode === KEEP_ALIVE_MODES.RESTRICTED);
+        this._handleExitApplication = async function (oOldApplicationContainer, bNavigationToFlpComponent, bFromAfterNavigate) {
+            if (!oOldApplicationContainer) {
+                return;
             }
 
-            //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 (sToId && oTo?.getIframeReusedForApp?.()) {
-                oTo.setProperty("iframeReusedForApp", false, true);
-                PostMessageUtils.postMessageToIframeApp(oTo, "sap.ushell.sessionHandler", "afterApplicationShow", {}, false);
-            }
+            const sOldStorageAppId = oOldApplicationContainer.getCurrentAppId();
 
-            //if called from onAfterNavigate, do nothing if oFrom is stateful container, because
-            //application was already closed at the beginning of 'handleControl'
-            if (!bIsHomePage && bFromAfterNavigate && (BlueBoxHandler.isStatefulContainer(oFrom) || BlueBoxHandler.isStatefulContainerInKeepAlivePool(oFrom))) {
+            if (!sOldStorageAppId) {
                 return;
             }
 
-            if (oFrom?.getCurrentAppId?.()) {
-                sFromId = oFrom.getCurrentAppId();
+            // 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;
             }
 
-            if (sFromId && oFrom) {
-                // STATEFUL
-                if (BlueBoxHandler.isStatefulContainer(oFrom)) {
-                    await this.handleExitStateful(sFromId, oFrom, bIsHomePage);
+            // STATEFUL
+            if (BlueBoxHandler.isStatefulContainer(oOldApplicationContainer)) {
+                await this._handleExitStateful(oOldApplicationContainer, bNavigationToFlpComponent);
 
-                    //STATELESS
-                } else if (Storage.get(sFromId)) {
-                    // Back Navigation Case
-                    if (RelatedServices.isBackNavigation() && !bIsHomePage) {
-                        //check if the Iframe needs to be cached instead of destroy
-                        if (!BlueBoxHandler.returnUnusedKeepAliveContainer(oFrom)) {
-                            await this.destroyApplication(sFromId, oFrom);
-                        } else {
-                            await this.handleExitStateful(sFromId, oFrom, bIsHomePage);
-                        }
-
-                        // Forward Navigation Cases
-                    } else if (oFrom.getApplicationType() === "UI5") {
-                        // 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(sFromId);
-                        this.store(sFromId);
+            //STATELESS
+            } else if (Storage.get(sOldStorageAppId)) {
+                // Back Navigation Case
+                if (RelatedServices.isBackNavigation() && !bNavigationToFlpComponent) {
+                    //check if the Iframe needs to be cached instead of destroy
+                    if (!BlueBoxHandler.returnUnusedKeepAliveContainer(oOldApplicationContainer)) {
+                        await this._destroyApplication(sOldStorageAppId, oOldApplicationContainer);
                     } else {
-                        this.store(sFromId);
-                    }
-                    EventBus.getInstance().publish("sap.ushell", "appClosed", oFrom);
-
-                    // LEGACY STATEFUL (WebGUI)
-                } else if (oFrom.getStatefulType?.() === BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
-                    if (bIsHomePage) {
-                        await PostMessageUtils.postMessageToIframeApp(oFrom, "sap.gui", "triggerCloseSessionImmediately");
+                        await this._handleExitStateful(oOldApplicationContainer, bNavigationToFlpComponent);
                     }
 
-                    // THE REST...
+                    // Forward Navigation Cases
+                } else if (oOldApplicationContainer.getApplicationType() === "UI5") {
+                    // 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 {
-                    const bIsAppOfTypeCachable = CACHED_APP_TYPES.indexOf(oFrom.getApplicationType) >= 0;
-
-                    //destroy the application and its resources
-                    const bIsKeepAlive = this.isAppOfTypeCached(sFromId, bIsAppOfTypeCachable);
-                    if (!bIsKeepAlive) {
-                        await this.destroyApplication(sFromId, oFrom);
-                    }
+                    this._store(sOldStorageAppId);
                 }
+                EventBus.getInstance().publish("sap.ushell", "appClosed", oOldApplicationContainer);
 
-                if (bIsHomePage) {
-                    // todo: [FLPCOREANDUX-10024] Check whether we need to await the close as well
-                    this.closeKeepAliveApps(fnCloseKeepAliveIfRestricted);
+                // LEGACY STATEFUL (WebGUI)
+            } else if (oOldApplicationContainer.getStatefulType() === BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
+                if (bNavigationToFlpComponent) {
+                    await PostMessageUtils.postMessageToIframeApp(oOldApplicationContainer, "sap.gui", "triggerCloseSessionImmediately");
                 }
 
-                //handle the case of appFiner
-                if (sFromId.indexOf("Shell-appfinder-component") > 0) {
-                    EventBus.getInstance().publish("sap.ushell", "appFinderAfterNavigate");
+                // THE REST...
+            } else {
+                //destroy the application and its resources
+                const sKeepAliveMode = this._calculateKeepAliveMode(sOldStorageAppId, {}, {});
+                const bShouldBeCached = !!sKeepAliveMode;
+                if (!bShouldBeCached) {
+                    await this._destroyApplication(sOldStorageAppId, oOldApplicationContainer);
                 }
             }
-
-            EventBus.getInstance().publish("relatedServices", "resetBackNavigation");
         };
 
         /**
          * @param {function(): boolean} fnFilterApps The filter function
          * @returns {Promise} Resolves when all keep alive apps are closed.
          */
-        this.closeKeepAliveApps = function (fnFilterApps) {
+        this._closeKeepAliveApps = function (fnFilterApps) {
             try {
                 const aKeepAliveRestrictedApps = [];
 
-                Storage.forEach((oApp) => {
-                    if (fnFilterApps(oApp)) {
-                        aKeepAliveRestrictedApps.push(oApp);
+                Storage.forEach((oStorageEntry) => {
+                    if (fnFilterApps(oStorageEntry)) {
+                        aKeepAliveRestrictedApps.push(oStorageEntry);
                     }
                 });
                 const aClosePromises = aKeepAliveRestrictedApps.map((oRestrictedApp) => {
                     //check if it needs to be cached instead of destroy
                     const bDestroy = !BlueBoxHandler.returnUnusedKeepAliveContainer(oRestrictedApp.container);
                     if (bDestroy) {
-                        return this.destroyApplication(oRestrictedApp.appId, oRestrictedApp.container);
+                        // todo: [FLPCOREANDUX-10024] what is the actual difference between destroyApplication and handleExitStateful?
+                        return this._destroyApplication(oRestrictedApp.appId, oRestrictedApp.container);
                     }
 
-                    return this.handleExitStateful(oRestrictedApp.appId, oRestrictedApp.container, true, true);
+                    return this._handleExitStateful(oRestrictedApp.container, true, true);
                 });
 
                 return Promise.all(aClosePromises);
@@ -499,9 +437,21 @@ sap.ui.define([
          * @param {object} oFrom
          */
         this.onBeforeNavigate = function (sFromId, oFrom) {
-            if (sFromId && oFrom?._getIFrame?.() && oFrom?.getStatefulType?.() > BlueBoxHandler.STATEFUL_TYPES.NOT_SUPPORTED || Storage.get(sFromId)) {
-                PostMessageUtils.postMessageToIframeApp(oFrom, "sap.ushell.sessionHandler", "beforeApplicationHide", {}, false);
+            if (sFromId && oFrom && oFrom.isA("sap.ushell.components.container.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 bCached = !!Storage.get(sStorageAppId);
+                const bSessionHandlingSupported = bHasIframe && bIsSupportedType;
+
+                if (bCached || bSessionHandlingSupported) {
+                    PostMessageUtils.postMessageToIframeApp(oApplicationContainer, "sap.ushell.sessionHandler", "beforeApplicationHide", {}, false);
+                }
             }
+
         };
 
         /**
@@ -510,63 +460,128 @@ sap.ui.define([
          * @param {string} sToId
          * @param {object} oTo
          */
-        this.onAfterNavigate = function (sFromId, oFrom, sToId, oTo) { //call lifecycle interface "setInitialConfiguration"
+        this.onAfterNavigate = async function (sFromId, oFrom, sToId, oTo) { //call lifecycle interface "setInitialConfiguration"
+            if (!sToId) {
+                sToId = "";
+            }
+            if (!sFromId) {
+                sFromId = "";
+            }
             //destroy the application if not cached or marked for reuse.
-            const bIsShellApps = sToId.indexOf("Shell-appfinder-component") > 0
-                || sToId.indexOf("Shell-home-component") > 0
-                || sToId.indexOf("pages-component-container") > 0
-                || sToId.indexOf("homeApp-component-container") > 0
-                || sToId.indexOf("workPageRuntime-component-container") > 0
-                || sToId.indexOf("runtimeSwitcher-component-container") > 0;
-
-            this.handleExitApplication(sFromId, oFrom, sToId, oTo, bIsShellApps, true);
-            if (bIsShellApps) {
+            const aFlpComponentIds = [
+                "Shell-appfinder-component",
+                "Shell-home-component",
+                "pages-component-container",
+                "homeApp-component-container",
+                "workPageRuntime-component-container",
+                "runtimeSwitcher-component-container"
+            ];
+
+            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);
+
                 Application.setActiveAppContainer(undefined);
+
+                // 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);
+                }
+
+                if (Storage.get(sStorageAppId)) {
+                    this._restore(sStorageAppId);
+                }
             }
 
-            // invoke the life cycle interface "setInitialConfiguration" for the restored application
-            if (sToId) {
-                if (Storage.get(sToId)) {
-                    this.restore(sToId);
-                } else {
-                    // this application is not cached
-                    // here we can place code that handles the starting of the application in the after navigation life cycle.
+            if (bNavigationFromFlpComponent) {
+                //handle the case of appFinder
+                if (sToId.indexOf("Shell-appfinder-component") > 0) {
+                    EventBus.getInstance().publish("sap.ushell", "appFinderAfterNavigate");
+                }
+
+                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);
             }
+
+            RelatedServices.resetBackNavigationFlag();
         };
 
         /**
-         * @param {string} sAppId
-         * @param {object} oContainer
-         * @param {object} oTarget
-         * @param {string} sFixedShellHash
-         * @param {object} oKeepAliveMode
-         * @returns {boolean} Returns true if the app was stored
+         * @param {object} oOldResolvedHashFragment
+         * @param {object} oResolvedHashFragment
+         * @returns {Promise} Resolves when the after navigation was handled.
          */
-        this.storeApp = function (sAppId, oContainer, oTarget, sFixedShellHash, oKeepAliveMode) {
-            if (!this.isAppInCache(sAppId)) {
-                if (oContainer.setProperty) {
-                    oContainer.setProperty("isKeepAlive", true, true);
+        // todo: [FLPCOREANDUX-10024] should be moved to onAfterNavigate
+        this.handleAfterNavigate = async function (oResolvedHashFragment, oOldResolvedHashFragment) {
+            if (!oOldResolvedHashFragment) {
+                return;
+            }
+
+            const sAppFrameworkId = ObjectPath.get("appCapabilities.appFrameworkId", oOldResolvedHashFragment);
+            const bFromApplicationIsTR = ushellUtils.isTRApplicationType(oOldResolvedHashFragment.applicationType, sAppFrameworkId);
+            const bToApplicationIsTR = ushellUtils.isTRApplicationType(oResolvedHashFragment.applicationType);
+
+            if (bFromApplicationIsTR && !bToApplicationIsTR) {
+                const oPreviousStatefulContainer = BlueBoxHandler.getBlueBoxByUrl(oOldResolvedHashFragment.url);
+                if (oPreviousStatefulContainer && oPreviousStatefulContainer.getStatefulType() === BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
+                    return WebGUIStatefulHandler.guiStatefulCloseCurrentApp(oPreviousStatefulContainer);
                 }
-                Storage.set(sAppId, {
-                    service: {},
-                    shellHash: sFixedShellHash,
-                    appId: sAppId,
-                    stt: "loading",
-                    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: oContainer,
-                    meta: AppConfiguration.getMetadata(oTarget),
-                    app: undefined,
-                    keepAliveMode: oKeepAliveMode?.globalValue || oKeepAliveMode?.paramValue,
-                    appTarget: oTarget,
-                    ui5ComponentName: oTarget?.ui5ComponentName,
-                    enableRouterRetrigger: bEnableRouterRetrigger,
-                    stateStored: false
-                });
-                return true;
             }
-            return false;
+        };
+
+        /**
+         * @param {string} sStorageAppId
+         * @param {object} oApplicationContainer
+         * @param {object} oResolvedHashFragment
+         * @param {string} oParsedShellHash
+         * @param {string} sKeepAliveMode
+         * @returns {boolean} Returns true if the app was stored
+         */
+        this._storeApp = function (sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode) {
+            if (Storage.get(sStorageAppId)) {
+                return false;
+            }
+
+            oApplicationContainer.setProperty("isKeepAlive", true, true);
+
+            Storage.set(sStorageAppId, {
+                service: {},
+                shellHash: `#${UrlParsing.constructShellHash(oParsedShellHash)}`,
+                appId: sStorageAppId,
+                stt: "loading",
+                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),
+                app: undefined,
+                keepAliveMode: sKeepAliveMode,
+                appTarget: oResolvedHashFragment,
+                ui5ComponentName: oResolvedHashFragment.ui5ComponentName,
+                enableRouterRetrigger: bEnableRouterRetrigger,
+                stateStored: false
+            });
+
+            return true;
         };
 
         /**
@@ -584,17 +599,16 @@ sap.ui.define([
             if (!oCurrentApp) {
                 return;
             }
-            const sAppId = oCurrentApp.appId;
-            const oContainer = oCurrentApp.container;
-
-            const oStorageEntry = Storage.get(sAppId);
+            const sStorageAppId = oCurrentApp.appId;
+            const oStorageEntry = Storage.get(sStorageAppId);
 
             if (!oStorageEntry) {
+                // do not store for non-keep-alive apps
                 return;
             }
 
-            if (oContainer?.getApplicationType() === "UI5") {
-                await this.getComponentCreatedPromise(sAppId);
+            if (oStorageEntry.container.getApplicationType() === "UI5") {
+                await this._getComponentCreatedPromise(sStorageAppId);
             }
 
             // back navigation
@@ -603,97 +617,79 @@ sap.ui.define([
             AppMeta.store(oStorageEntry.meta);
             // currentState, controlManager
             KeepAlive.store(oStorageEntry);
+            // About Dialog
+            AppInfoParameters.store(oStorageEntry);
         };
 
         /**
-         * @param {string} sAppId
-         * @param {boolean} bIsAppOfTypeCachable
-         * @param {object} oKeepAliveMode
-         * @returns {boolean} Returns true if the app is of type cached.
+         * @param {string} sStorageAppId
+         * @param {object} oResolvedHashFragment
+         * @param {object} oParsedShellHash
+         * @returns {string} Returns the keep alive mode.
          */
-        this.isAppOfTypeCached = function (sAppId, bIsAppOfTypeCachable, oKeepAliveMode) {
+        this._calculateKeepAliveMode = function (sStorageAppId, oResolvedHashFragment, oParsedShellHash) {
             //generic intent currently can never be keep alive
-            if (sAppId === "application-Shell-startIntent") {
-                return false;
-            }
-
-            //handle the root intent
-            if (!bDisableHomeAppCache && sAppId.indexOf(sRootIntent) !== -1) {
-                return true;
-            }
-
-            if (!bDisableHomeAppCache && sAppId.indexOf("Shell-appfinder") !== -1) {
-                return true;
+            if (sStorageAppId === "application-Shell-startIntent") {
+                return;
             }
 
-            //In order to enable application to play with the keep alive, we read the keep attribute of the hash, if it is true application is cachable.
-            const sKeepAlive = new URLSearchParams(window.location.search).get("sap-keep-alive");
+            // 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 (oKeepAliveMode) {
-                    oKeepAliveMode.globalValue = sKeepAlive;
-                }
-                return true;
-            }
-            return false;
-        };
-
-        /**
-         * @param {object} oShellHash
-         * @param {object} oTarget
-         * @param {object} oKeepAliveMode
-         * @returns {boolean} Returns true if the app should be cached.
-         */
-        this.isCachedEnabledAsAppParameter = function (oShellHash, oTarget, oKeepAliveMode) {
-            let sKeepAlive;
-
-            //generic intent currently can never be keep alive
-            if (oShellHash?.semanticObject === "Shell" && oShellHash?.action === "startIntent") {
-                return false;
+                return sKeepAlive;
+            } else if (sKeepAlive === KEEP_ALIVE_MODES.FALSE) {
+                return;
             }
 
-            sKeepAlive = oShellHash?.params?.["sap-keep-alive"];
+            // App override in intent parameters
+            sKeepAlive = oParsedShellHash.params?.["sap-keep-alive"];
             if (sKeepAlive === KEEP_ALIVE_MODES.FULL || sKeepAlive === KEEP_ALIVE_MODES.RESTRICTED) {
-                if (oKeepAliveMode) {
-                    oKeepAliveMode.paramValue = sKeepAlive;
-                }
-                return true;
+                return sKeepAlive;
+            } else if (sKeepAlive === KEEP_ALIVE_MODES.FALSE) {
+                return;
             }
 
-            if (oTarget?.url) {
-                sKeepAlive = UriParameters.fromURL(oTarget.url).get("sap-keep-alive");
+            // 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 (oKeepAliveMode) {
-                        oKeepAliveMode.paramValue = sKeepAlive;
-                    }
-                    return true;
+                    return sKeepAlive;
+                } else if (sKeepAlive === KEEP_ALIVE_MODES.FALSE) {
+                    return;
                 }
             }
 
-            return false;
+            // if the app is a root intent, it should be kept alive (e.g. workzone advanced)
+            // can be overridden by the above checks
+            const sShellHash = UrlParsing.constructShellHash(oParsedShellHash);
+            if (sShellHash && ushellUtils.isRootIntent(sShellHash)) {
+                return KEEP_ALIVE_MODES.FULL;
+            }
         };
 
         /**
-         * @param {object} oTarget
+         * @param {object} oResolvedHashFragment
          * @returns {string} Returns the application type.
          */
-        this.calculateAppType = function (oTarget) {
-            if (oTarget.applicationType === "URL" && oTarget?.additionalInformation?.startsWith?.("SAPUI5.Component=")) {
+        this._calculateAppType = function (oResolvedHashFragment) {
+            if (oResolvedHashFragment.applicationType === "URL" && oResolvedHashFragment.additionalInformation?.startsWith?.("SAPUI5.Component=")) {
                 return "SAPUI5";
             }
-            return oTarget.applicationType;
+            return oResolvedHashFragment.applicationType;
         };
 
         /**
          * @param {object} oData
-         * @returns {Promise} Resolves when the app is reloded.
+         * @returns {Promise} Resolves when the app is reloaded.
          */
-        this.reloadCurrentApp = async function (oData) {
+        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);
-                this.destroyApplication(oData.sAppContainerId, oTmpAppContainer);
+                await this._destroyApplication(oData.sAppContainerId, oTmpAppContainer);
                 BlueBoxHandler.deleteBlueBoxByUrl(sTmpUrl);
             }
 
@@ -707,110 +703,107 @@ sap.ui.define([
 
         /**
          * @param {string} sAppId
-         * @param {object} oTarget
-         * @param {object} oShellHash
-         * @param {object} sFixedShellHash
+         * @param {object} oResolvedHashFragment
+         * @param {object} oParsedShellHash
          */
-        this.openApp = function (sAppId, oTarget, oShellHash, sFixedShellHash) {
-            const bIsAppOfTypeCachable = CACHED_APP_TYPES.indexOf(oTarget.applicationType) >= 0;
-            const oKeepAliveMode = {
-                globalValue: undefined,
-                paramValue: undefined
-            };
-            let oContainer,
-                sIntent,
-                oTmpAppContainer,
-                oContainerToUse,
+        this._openApp = async function (sAppId, oResolvedHashFragment, oParsedShellHash) {
+            let oTmpAppContainer,
+                oApplicationContainerToUse,
                 sTmpUrl;
 
             //format appId, the is the storage identifier
-            const appId = `application${sAppId}`;
+            const sStorageAppId = `application-${sAppId}`;
 
             //this case will handle the stateful containers flow.
-            oContainer = BlueBoxHandler.getBlueBoxByUrl(oTarget.url);
+            let oApplicationContainer = BlueBoxHandler.getBlueBoxByUrl(oResolvedHashFragment.url);
 
-            const bIsKeepAlive = this.isAppOfTypeCached(appId, bIsAppOfTypeCachable, oKeepAliveMode);
-            const bIsCachedByParameter = this.isCachedEnabledAsAppParameter(oShellHash, oTarget, oKeepAliveMode);
+            const sKeepAliveMode = this._calculateKeepAliveMode(sStorageAppId, oResolvedHashFragment, oParsedShellHash);
+            const bShouldBeCached = !!sKeepAliveMode;
 
-            if (BlueBoxHandler.isStatefulContainer(oContainer)) {
-                if (bIsKeepAlive || bIsCachedByParameter) {
+            if (BlueBoxHandler.isStatefulContainer(oApplicationContainer)) {
+                if (bShouldBeCached) {
                     //this is the case where we have a stateful container and keep alive
                     //is cached application
-                    if (!this.isAppInCache(appId)) {
-                        this.storeApp(appId, oContainer, oTarget, sFixedShellHash, oKeepAliveMode);
-                    }
-                    if (this.isAppInCache(appId)) {
-                        oCurrentApplication = Storage.get(appId);
+                    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: appId,
+                        appId: sStorageAppId,
                         stt: "loading",
-                        container: oContainer,
-                        meta: AppConfiguration.getMetadata(oTarget),
+                        container: oApplicationContainer,
+                        meta: AppConfiguration.getMetadata(oResolvedHashFragment),
                         app: undefined
                     };
                 }
-            } else if (bIsKeepAlive || bIsCachedByParameter) {
+            } else if (bShouldBeCached) {
                 //is cached application
-                if (!this.isAppInCache(appId)) {
-                    oContainerToUse = BlueBoxHandler.findFreeContainerForNewKeepAliveApp(oTarget);
-                    if (!oContainerToUse) {
+                let oStorageEntry = Storage.get(sStorageAppId);
+                if (!oStorageEntry) {
+                    oApplicationContainerToUse = BlueBoxHandler.findFreeContainerForNewKeepAliveApp(oResolvedHashFragment);
+                    if (!oApplicationContainerToUse) {
                         //in cFLP, there night me an existing container of the same app from a different server,
                         //so we will need to destroy it to avoid duplicate id
-                        sIntent = `${oShellHash.semanticObject}-${oShellHash.action}`;
-                        oTmpAppContainer = BlueBoxHandler.getBlueBoxById(`application-${sIntent}`) || this.getControl(sIntent);
+                        oTmpAppContainer = BlueBoxHandler.getBlueBoxById(sStorageAppId) || this._getApplicationContainerFromViewPort(sAppId);
+                        // todo: [FLPCOREANDUX-10024] this destroy/remove can be simplified
                         if (oTmpAppContainer) {
                             sTmpUrl = oTmpAppContainer.getUrl();
                             BlueBoxHandler.removeCapabilities(oTmpAppContainer);
-                            this.destroyApplication(`application-${sIntent}`, oTmpAppContainer);
+                            await this._destroyApplication(sStorageAppId, oTmpAppContainer);
                             BlueBoxHandler.deleteBlueBoxByUrl(sTmpUrl);
                         }
-                        oContainer = Application.createApplicationContainer(sAppId, oTarget);
+                        oApplicationContainer = Application.createApplicationContainer(sStorageAppId, oResolvedHashFragment);
                     } else {
-                        oContainer = oContainerToUse;
+                        oApplicationContainer = oApplicationContainerToUse;
                     }
-                    this.storeApp(appId, oContainer, oTarget, sFixedShellHash, oKeepAliveMode);
-                }
-                if (this.isAppInCache(appId)) {
-                    oCurrentApplication = Storage.get(appId);
+
+                    this._storeApp(sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode);
+                    oStorageEntry = Storage.get(sStorageAppId);
                 }
-            } else if (oTarget.applicationType === "TR" || oTarget?.appCapabilities?.appFrameworkId === "GUI") {
-                oContainer = BlueBoxHandler.getBlueBoxByUrl(oTarget.url);
-                if (oContainer?.getStatefulType && oContainer.getStatefulType() !== BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
-                    oContainer = undefined;
+
+                oCurrentApplication = oStorageEntry;
+            } else if (oResolvedHashFragment.applicationType === "TR" || oResolvedHashFragment.appCapabilities?.appFrameworkId === "GUI") {
+                oApplicationContainer = BlueBoxHandler.getBlueBoxByUrl(oResolvedHashFragment.url);
+                if (oApplicationContainer && oApplicationContainer.getStatefulType() !== BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
+                    oApplicationContainer = undefined;
                 }
 
                 //in cFLP, there night me an existing container of the same app from a different server,
                 //so we will need to destroy it to avoid duplicate id
-                if (oShellHash) {
-                    sIntent = `${oShellHash.semanticObject}-${oShellHash.action}`;
-                    oTmpAppContainer = BlueBoxHandler.getBlueBoxById(`application-${sIntent}`) || this.getControl(sIntent);
-                    if (oTmpAppContainer && (!oContainer || oTmpAppContainer !== oContainer)) {
-                        sTmpUrl = oTmpAppContainer.getUrl();
-                        BlueBoxHandler.removeCapabilities(oTmpAppContainer);
-                        this.destroyApplication(`application-${sIntent}`, oTmpAppContainer);
-                        BlueBoxHandler.deleteBlueBoxByUrl(sTmpUrl);
-                    }
+                oTmpAppContainer = BlueBoxHandler.getBlueBoxById(sStorageAppId) || this._getApplicationContainerFromViewPort(sAppId);
+                // todo: [FLPCOREANDUX-10024] this destroy/remove can be simplified
+                if (oTmpAppContainer && (!oApplicationContainer || oTmpAppContainer !== oApplicationContainer)) {
+                    sTmpUrl = oTmpAppContainer.getUrl();
+                    BlueBoxHandler.removeCapabilities(oTmpAppContainer);
+                    await this._destroyApplication(sStorageAppId, oTmpAppContainer);
+                    BlueBoxHandler.deleteBlueBoxByUrl(sTmpUrl);
                 }
 
-                if (!oContainer) {
-                    oContainer = Application.createApplicationContainer(sAppId, oTarget);
+                if (!oApplicationContainer) {
+                    oApplicationContainer = Application.createApplicationContainer(sStorageAppId, oResolvedHashFragment);
                 }
                 //create application that is not persisted and not cashed
                 oCurrentApplication = {
-                    appId: appId,
+                    appId: sStorageAppId,
                     stt: "loading",
-                    container: oContainer,
-                    meta: AppConfiguration.getMetadata(oTarget),
+                    container: oApplicationContainer,
+                    meta: AppConfiguration.getMetadata(oResolvedHashFragment),
                     app: undefined
                 };
             } else {
-                if (oContainer) {
-                    sIntent = `${oShellHash.semanticObject}-${oShellHash.action}`;
-                    this.removeApplication(sIntent);
-                } else if (oTarget.applicationType === "URL" || oTarget.applicationType === "TR" || oTarget.applicationType === "NWBC") {
+                if (oApplicationContainer) {
+                    const oApplicationContainer = this._getApplicationContainerFromViewPort(sAppId);
+
+                    if (oApplicationContainer) {
+                        this._removeApplicationContainerFromViewPort(oApplicationContainer.getId());
+                        oApplicationContainer.destroy();
+                    }
+                } else if (oResolvedHashFragment.applicationType === "URL" || oResolvedHashFragment.applicationType === "TR" || oResolvedHashFragment.applicationType === "NWBC") {
                     //Temporary fix - fix duplicate app container id in cFLP
                     //explanation: in cFLP, there might be a case where there are
                     // two apps with the same Semantic object + Action, but from different
@@ -819,23 +812,23 @@ sap.ui.define([
                     // we delete here the blue box and then create the new one.
                     // In future BLI, we will change the id of the container to be
                     // more unique.
-                    sIntent = `${oShellHash.semanticObject}-${oShellHash.action}`;
-                    oTmpAppContainer = BlueBoxHandler.getBlueBoxById(`application-${sIntent}`) || this.getControl(sIntent);
+                    oTmpAppContainer = BlueBoxHandler.getBlueBoxById(sStorageAppId) || this._getApplicationContainerFromViewPort(sAppId);
                     if (oTmpAppContainer) {
+                        // todo: [FLPCOREANDUX-10024] this destroy/remove can be simplified
                         sTmpUrl = oTmpAppContainer.getUrl();
                         BlueBoxHandler.removeCapabilities(oTmpAppContainer);
-                        this.destroyApplication(`application-${sIntent}`, oTmpAppContainer, true);
+                        await this._destroyApplication(sStorageAppId, oTmpAppContainer, true);
                         BlueBoxHandler.deleteBlueBoxByUrl(sTmpUrl);
                     }
                 }
-                oContainer = Application.createApplicationContainer(sAppId, oTarget);
+                oApplicationContainer = Application.createApplicationContainer(sStorageAppId, oResolvedHashFragment);
 
                 // //create application that is not persisted and not cashed
                 oCurrentApplication = {
-                    appId: appId,
+                    appId: sStorageAppId,
                     stt: "loading",
-                    container: oContainer,
-                    meta: AppConfiguration.getMetadata(oTarget),
+                    container: oApplicationContainer,
+                    meta: AppConfiguration.getMetadata(oResolvedHashFragment),
                     app: undefined
                 };
             }
@@ -845,7 +838,7 @@ sap.ui.define([
          * Any event one wishes to subscribe to during the AppLifeCycle.init() call should be added here.
          * Events will only be added the first time AppLifeCycle.init() is called.
          */
-        this.addEvents = (function () {
+        this._addEvents = (function () {
             let hasBeenCalled = false;
             return function () {
                 if (!hasBeenCalled) {
@@ -853,21 +846,21 @@ sap.ui.define([
 
                     // Subscribe to events.
                     EventHub.on("disableKeepAliveRestoreRouterRetrigger").do((oData) => {
-                        const sIntent = `${oData.intent.semanticObject}-${oData.intent.action}`;
-                        const sAppId = `application-${sIntent}`;
+                        const sAppId = `${oData.intent.semanticObject}-${oData.intent.action}`;
+                        const sStorageAppId = `application-${sAppId}`;
 
                         bEnableRouterRetrigger = oData.disable;
 
-                        if (Storage.get(sAppId)) {
-                            Storage.get(sAppId).enableRouterRetrigger = oData.disable;
+                        if (Storage.get(sStorageAppId)) {
+                            Storage.get(sStorageAppId).enableRouterRetrigger = oData.disable;
                         }
                     });
                     EventHub.on("setApplicationFullWidth").do((oData) => {
-                        this.setApplicationFullWidth(oData.bValue);
+                        this._setApplicationFullWidth(oData.bValue);
                     });
 
                     EventHub.on("reloadCurrentApp").do((oData) => {
-                        this.reloadCurrentApp(oData);
+                        this._reloadCurrentApp(oData);
                     });
                 }
             };
@@ -875,10 +868,9 @@ sap.ui.define([
 
         /**
          * @param {object} oInViewPortContainer
-         * @param {string} sInRootIntent
          * @param {boolean} bInDisableHomeAppCache
          */
-        this.init = function (oInViewPortContainer, sInRootIntent, bInDisableHomeAppCache) {
+        this.init = function (oInViewPortContainer, bInDisableHomeAppCache) {
             if (Container && Config.last("/core/shell/enablePersistantAppstateWhenSharing")) {
                 Container.getServiceAsync("AppState").then((oAppStateService) => {
                     fnOldTriggerEmail = URLHelper.triggerEmail.bind(URLHelper);
@@ -908,7 +900,6 @@ sap.ui.define([
             this._createGlobalShellUIService();
 
             oViewPortContainer = oInViewPortContainer;
-            sRootIntent = sInRootIntent;
             bDisableHomeAppCache = bInDisableHomeAppCache;
 
             BlueBoxHandler.init();
@@ -946,18 +937,18 @@ sap.ui.define([
                         setup: {
                             executeServiceCallFn: async function (oServiceParams) {
                                 const oSetup = oServiceParams?.oMessageData?.body;
-                                const { oContainer } = oServiceParams;
+                                const { oContainer: oApplicationContainer } = oServiceParams;
 
                                 const arrCap = [];
                                 let bIgnoreStateful = false;
                                 if (oSetup) {
-                                    const bIsSAPLegacyApplicationType = ushellUtils.isSAPLegacyApplicationType(oContainer.getApplicationType(), oContainer.getFrameworkId());
-                                    if (oContainer.getIsKeepAlive() && bIsSAPLegacyApplicationType) {
+                                    const bIsSAPLegacyApplicationType = ushellUtils.isSAPLegacyApplicationType(oApplicationContainer.getApplicationType(), oApplicationContainer.getFrameworkId());
+                                    if (oApplicationContainer.getIsKeepAlive() && bIsSAPLegacyApplicationType) {
                                         bIgnoreStateful = true;
                                     }
                                     if (oSetup.isStateful) {
                                         if (bIgnoreStateful) {
-                                            oContainer.setProperty("statefulType", -BlueBoxHandler.STATEFUL_TYPES.FLP_V2, true);
+                                            oApplicationContainer.setProperty("statefulType", -BlueBoxHandler.STATEFUL_TYPES.FLP_V2, true);
                                         } else {
                                             arrCap.push({
                                                 action: "create",
@@ -967,7 +958,7 @@ sap.ui.define([
                                                 action: "destroy",
                                                 service: "sap.ushell.services.AppLifeCycle"
                                             });
-                                            oContainer.setProperty("statefulType", BlueBoxHandler.STATEFUL_TYPES.FLP_V2, true);
+                                            oApplicationContainer.setProperty("statefulType", BlueBoxHandler.STATEFUL_TYPES.FLP_V2, true);
                                         }
                                     }
                                     if (oSetup.isIframeValid) {
@@ -977,7 +968,7 @@ sap.ui.define([
                                         arrCap.push({ action: "logout", service: "sap.ushell.sessionHandler" });
                                     }
                                     if (arrCap.length > 0) {
-                                        BlueBoxHandler.addCapabilities(oContainer, arrCap);
+                                        BlueBoxHandler.addCapabilities(oApplicationContainer, arrCap);
                                     }
                                 }
                             }
@@ -988,19 +979,19 @@ sap.ui.define([
                     oServiceCalls: {
                         loadFinished: {
                             executeServiceCallFn: async function (oServiceParams) {
-                                const { oContainer } = oServiceParams;
+                                const { oContainer: oApplicationContainer } = oServiceParams;
 
-                                if (!oContainer.getIsKeepAlive()) {
-                                    oContainer.setProperty("statefulType", BlueBoxHandler.STATEFUL_TYPES.GUI_V1, true);
+                                if (!oApplicationContainer.getIsKeepAlive()) {
+                                    oApplicationContainer.setProperty("statefulType", BlueBoxHandler.STATEFUL_TYPES.GUI_V1, true);
                                     oCurrentApplication = {
-                                        appId: oContainer.getId(),
+                                        appId: oApplicationContainer.getId(),
                                         stt: "loading",
-                                        container: oContainer,
+                                        container: oApplicationContainer,
                                         meta: undefined,
                                         app: undefined
                                     };
                                 } else {
-                                    oContainer.setProperty("statefulType", -BlueBoxHandler.STATEFUL_TYPES.GUI_V1, true);
+                                    oApplicationContainer.setProperty("statefulType", -BlueBoxHandler.STATEFUL_TYPES.GUI_V1, true);
                                 }
                                 return {};
                             }
@@ -1011,10 +1002,10 @@ sap.ui.define([
             });
 
             //TODO add unsubscribe
-            EventBus.getInstance().subscribe("sap.ushell", "appComponentLoaded", this.onComponentCreated, this);
-            EventBus.getInstance().subscribe("sap.ushell", "getAppLifeCycle", this.onGetMe, this);
+            EventBus.getInstance().subscribe("sap.ushell", "appComponentLoaded", this._onComponentCreated, this);
+            EventBus.getInstance().subscribe("sap.ushell", "getAppLifeCycle", this._onGetMe, this);
 
-            this.addEvents();
+            this._addEvents();
         };
 
         /**
@@ -1043,16 +1034,16 @@ sap.ui.define([
         };
 
         /**
-         * @param {object} oControl
+         * @param {object} oApplicationContainer
          */
-        this.addControl = function (oControl) {
-            oViewPortContainer.addCenterViewPort(oControl);
+        this._addApplicationContainerToViewPort = function (oApplicationContainer) {
+            oViewPortContainer.addCenterViewPort(oApplicationContainer);
         };
 
         /**
          * @param {string} sId
          */
-        this.removeControl = function (sId) {
+        this._removeApplicationContainerFromViewPort = function (sId) {
             const oBlueBox = BlueBoxHandler.getBlueBoxById(sId);
             const bIsStateful = BlueBoxHandler.isStatefulContainer(oBlueBox);
 
@@ -1062,38 +1053,28 @@ sap.ui.define([
         };
 
         /**
-         * @param {string} sIntent
-         */
-        this.removeApplication = function (sIntent) {
-            const oInnerControl = this.getControl(sIntent);
-
-            if (oInnerControl) {
-                this.removeControl(oInnerControl.getId());
-                oInnerControl.destroy();
-            }
-        };
-
-        /**
-         * @param {string} sIntent
+         * @param {string} sAppId
          * @returns {object} Returns the control.
          */
-        this.getControl = function (sIntent) {
-            return oViewPortContainer
-                && (oViewPortContainer.getViewPortControl("centerViewPort", `application-${sIntent}`)
-                    || oViewPortContainer.getViewPortControl("centerViewPort", `applicationShellPage-${sIntent}`));
+        this._getApplicationContainerFromViewPort = function (sAppId) {
+            if (!oViewPortContainer) {
+                return;
+            }
+            return oViewPortContainer.getViewPortControl("centerViewPort", `application-${sAppId}`)
+                || oViewPortContainer.getViewPortControl("centerViewPort", `applicationShellPage-${sAppId}`);
         };
 
         /**
          * @returns {object} Returns the view port container.
          */
-        this.getViewPortContainer = function () {
+        this._getViewPortContainer = function () {
             return oViewPortContainer;
         };
 
         /**
          * @param {string} sId
          */
-        this.navTo = function (sId) {
+        this._navTo = function (sId) {
             oViewPortContainer.navTo("centerViewPort", sId, "show");
         };
 
@@ -1113,7 +1094,7 @@ sap.ui.define([
         /**
          * @param {boolean} bIsFull
          */
-        this.setApplicationFullWidth = function (bIsFull) {
+        this._setApplicationFullWidth = function (bIsFull) {
             const oCurrent = this.getCurrentApplication();
 
             //validate that we have a valid applicationContainer
@@ -1122,69 +1103,20 @@ sap.ui.define([
             }
         };
 
-        // 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.
         /**
-         * @param {object} oResolvedHashFragment
-         * @param {object} oParsedShellHash
-         * @returns {Promise} Resolves when the component is created.
+         * Returns the global ShellUIService instance.
+         * @returns {object} The global ShellUIService instance
          */
-        this.createComponent = async function (oResolvedHashFragment, oParsedShellHash) {
-            function fnCloseKeepAliveIfSameUI5App (oApp) {
-                return (oApp.ui5ComponentName === oResolvedHashFragment.ui5ComponentName);
-            }
-
-            await this.closeKeepAliveApps(fnCloseKeepAliveIfSameUI5App);
-
-            await Application.createComponent(oResolvedHashFragment, oParsedShellHash);
+        this.getShellUIService = function () {
+            return oGlobalShellUIService;
         };
 
         /**
-         * @param {string} sAppId
-         * @param {object} oResolvedNavigationTarget
-         * @param {boolean} bIsColdStart
-         * @param {object} oShellHash
-         * @param {string} sFixedShellHash
-         * @returns {object}
          */
-        this.getAppContainer = function (sAppId, oResolvedNavigationTarget, bIsColdStart, oShellHash, sFixedShellHash) {
-            oResolvedNavigationTarget.shellUIService = oGlobalShellUIService.getInterface();
-
-            /*
-             * 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.
-             */
-            oResolvedNavigationTarget.targetNavigationMode = bIsColdStart ? "explace" : "inplace";
-
-            this.openApp(sAppId, oResolvedNavigationTarget, oShellHash, sFixedShellHash);
-            if (oGlobalShellCommunicationHandlers.length > 0) {
-                oCurrentApplication.container.registerShellCommunicationHandler(oGlobalShellCommunicationHandlers);
-            }
-            if (oGlobalIframeCommunicationHandlers.UI5APP) {
-                oCurrentApplication.container.setIframeHandlers(oGlobalIframeCommunicationHandlers.UI5APP);
+        this.resetGlobalShellUIService = function () {
+            if (oGlobalShellUIService) {
+                oGlobalShellUIService.resetService();
             }
-            return oCurrentApplication.container;
-        };
-
-        /**
-         * Returns the global ShellUIService instance.
-         * @returns {object} The global ShellUIService instance
-         */
-        this.getShellUIService = function () {
-            return oGlobalShellUIService;
         };
 
         /**
@@ -1213,66 +1145,51 @@ sap.ui.define([
          * This method sets only one container as active and de-activates all
          * other application containers around.
          *
-         * @param {object} oApplicationContainer
+         * @param {object} oTargetApplicationContainer
          *   The application container to activate. Pass <code>null</code> in
          *   case no application container must be activated.
          *
          * @private
          */
-        this.activeContainer = function (oApplicationContainer) {
-            BlueBoxHandler.forEach((oAppContainer) => {
-                if (oAppContainer && oAppContainer !== oApplicationContainer) {
+        this._activeContainer = function (oTargetApplicationContainer) {
+            BlueBoxHandler.forEach((oApplicationContainer) => {
+                if (oApplicationContainer && oApplicationContainer !== oTargetApplicationContainer) {
                     try {
-                        Log.info(`Deactivating container ${oAppContainer.getId()}`);
-                        oAppContainer.setActive(false);
+                        Log.info(`Deactivating container ${oApplicationContainer.getId()}`);
+                        oApplicationContainer.setActive(false);
                     } catch (e) {
                         /* empty */
                     }
                 }
             });
 
-            if (oApplicationContainer) {
-                Log.info(`Activating container "${oApplicationContainer.getId()}"`);
-                oApplicationContainer.setActive(true);
+            if (oTargetApplicationContainer) {
+                Log.info(`Activating container "${oTargetApplicationContainer.getId()}"`);
+                oTargetApplicationContainer.setActive(true);
             }
         };
 
         /**
          * @param {object} oApplicationContainer
-         */
-        this.showApplicationContainer = function (oApplicationContainer) {
-            this.navTo(oApplicationContainer.getId());
-            //Added this because in cases when navigating to the same id (can happen when stateful container, I need the on onAfterNavigate)
-            if (oApplicationContainer.hasStyleClass("sapUShellApplicationContainerShiftedIframe")) {
-                oApplicationContainer.toggleStyleClass("sapUShellApplicationContainerIframeHidden", false);
-            } else {
-                oApplicationContainer.toggleStyleClass("hidden", false);
-            }
-            Application.setActiveAppContainer(oApplicationContainer);
-            Log.info("New application context opened successfully in an existing transaction UI session.");
-        };
-
-        /**
-         * @param {object} oAppContainer
          * @param {object} oApplication
          * @param {function} fnOnAfterRendering
          */
-        this.publishNavigationStateEvents = function (oAppContainer, oApplication, fnOnAfterRendering) {
+        this._publishNavigationStateEvents = function (oApplicationContainer, oApplication, fnOnAfterRendering) {
             //after the app container is rendered, publish an event to notify
             //that an app was opened
-            const sId = oAppContainer.getId ? oAppContainer.getId() : "";
+            const sId = oApplicationContainer.getId ? oApplicationContainer.getId() : "";
             const appMetaData = AppConfiguration.getMetadata();
             const sIcon = appMetaData.icon;
             const sTitle = appMetaData.title;
 
             //Attach an event handler which will be called onAfterRendering
-            oAppContainer.addEventDelegate({ onAfterRendering: fnOnAfterRendering });
+            oApplicationContainer.addEventDelegate({ onAfterRendering: fnOnAfterRendering });
 
             //after the app container exit, publish an event to notify
             //that an app was closed
             const that = this;
-            const origExit = oAppContainer.exit;
-            oAppContainer.exit = function () {
+            const origExit = oApplicationContainer.exit;
+            oApplicationContainer.exit = function () {
                 if (origExit) {
                     origExit.apply(this, arguments);
                 }
@@ -1320,37 +1237,25 @@ sap.ui.define([
         };
 
         /**
-         * @param {string} sIntent
-         * @param {string} sFixedShellHash
-         * @param {string} sAppPart
-         * @param {string} sOldShellHash
+         * @param {string} sAppId
+         * @param {string} sShellHash
+         * @param {boolean} bNavigationFromHome
+         * @param {boolean} bNavigationWithInnerAppRoute
          * @returns {object}
          */
-        this.getInMemoryInstance = function (sIntent, sFixedShellHash, sAppPart, sOldShellHash) {
-            const sFullAppId = `application-${sIntent}`;
-            const oAppEntry = Storage.get(sFullAppId);
-            let sOldShellHashLowerCase = "";
-            let bNavigateToHomepage = false;
-            let bNavigatingFromHomeWithAppState;
+        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.
-                if (sOldShellHash !== null && sOldShellHash !== undefined && sOldShellHash !== "") {
-                    sOldShellHashLowerCase = sOldShellHash.toLowerCase();
-                    //All option to verify that we're navigating from the home page
-                    bNavigateToHomepage = sOldShellHashLowerCase.indexOf("shell-home") >= 0 ||
-                        sOldShellHashLowerCase.indexOf("launchpad-openflppage") >= 0 ||
-                        sOldShellHashLowerCase.indexOf("launchpad-openworkpage") >= 0 ||
-                        sOldShellHashLowerCase.indexOf("shell-appfinder") >= 0;
-                }
+                const bNavigatingFromHomeWithAppState = bNavigationFromHome && bNavigationWithInnerAppRoute;
+                // todo: [FLPCOREANDUX-10024] Add logging
 
-                bNavigatingFromHomeWithAppState = (bNavigateToHomepage &&
-                    (typeof sAppPart === "string" && sAppPart.length > 0));
-
-                if (oAppEntry.shellHash === sFixedShellHash && !bNavigatingFromHomeWithAppState) {
+                if (oAppEntry.shellHash === sShellHash && !bNavigatingFromHomeWithAppState) {
                     return {
                         isInstanceSupported: true,
                         appId: oAppEntry.appId,
@@ -1372,86 +1277,98 @@ sap.ui.define([
         };
 
         /**
-         * @param {boolean} bIsInitial
-         * @param {boolean} bIsInCache
-         * @param {string} sToId
-         * @param {object} oInnerControl
-         * @param {object} oTarget
-         * @param {string} sFixedShellHash
-         * @param {object} oKeepAliveMode
+         * @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 = function (bIsInitial, bIsInCache, sToId, oInnerControl, oTarget, sFixedShellHash, oKeepAliveMode, bNavigationInSameStatefulContainer, bReturnedFromKeepAlivePoolFLPV2) {
-            let oPromise;
-
-            oInnerControl.setProperty("iframeReusedForApp", true, true);
-            if (Storage.get(sToId) && !bIsInitial && !bReturnedFromKeepAlivePoolFLPV2) {
-                oPromise = BlueBoxHandler.statefulRestoreKeepAliveApp(oInnerControl, oTarget.url, sToId, oTarget, bNavigationInSameStatefulContainer)
-                    .then(() => {
-                        this.showApplicationContainer(oInnerControl);
-                    })
-                    .catch((vError) => {
-                        Log.error(vError?.message || vError);
-                    });
-            } else {
-                oPromise = BlueBoxHandler.statefulCreateApp(oInnerControl, oTarget.url, sToId, oTarget, bNavigationInSameStatefulContainer)
-                    .then((oResult) => {
-                        if (oResult?.deletedKeepAliveId) {
-                            Storage.removeById(oResult.deletedKeepAliveId);
-                        }
-                        this.showApplicationContainer(oInnerControl);
-                    })
-                    .catch((vError) => {
-                        Log.error(vError?.message || vError);
-                    });
+        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 (bIsInCache && !this.isAppInCache(sToId)) {
-                    this.storeApp(sToId, oInnerControl, oTarget, sFixedShellHash, oKeepAliveMode);
+                    //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) {
+            let bFullWidth;
+            const sAppType = this._calculateAppType(oResolvedHashFragment);
+            const bDefaultFullWidth = ApplicationType.getDefaultFullWidthSetting(sAppType);
 
-            return oPromise;
+            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.
+            if (bDefaultFullWidth) {
+                if (oResolvedHashFragment.fullWidth === false || oResolvedHashFragment.fullWidth === "false" ||
+                    oMetadata.fullWidth === false || oMetadata.fullWidth === "false" || bFullWidthCapability === false) {
+                    bFullWidth = false;
+                }
+            } else if (oResolvedHashFragment.fullWidth || oResolvedHashFragment.fullWidth === "true" ||
+                oMetadata.fullWidth || oMetadata.fullWidth === "true") {
+                bFullWidth = true;
+            }
+
+            if (bFullWidth === undefined) {
+                bFullWidth = bDefaultFullWidth;
+            }
+            return bFullWidth;
         };
 
         /**
-         * @param {string} sIntent
+         * formerly known as "handleControl"
          * @param {string} sAppId
-         * @param {object} oShellHash
-         * @param {object} oTarget
-         * @param {function} fnWrapper
-         * @param {string} sFixedShellHash
-         * @param {string} sOldFixedShellHash
+         * @param {object} oParsedShellHash
+         * @param {object} oResolvedHashFragment
+         * @param {string} sOldShellHash
          * @returns {Promise} Resolves when the control is handled
          */
-        this.handleControl = async function (sIntent, sAppId, oShellHash, oTarget, fnWrapper, sFixedShellHash, sOldFixedShellHash) {
+        this.handleCreateApplicationContainer = async function (sAppId, oParsedShellHash, oResolvedHashFragment, sOldShellHash) {
             let bReturnedFromKeepAlivePoolFLPV2 = false;
             let bReturnedFromKeepAlivePoolGuiV1 = false;
-            const bIsAppOfTypeCachable = CACHED_APP_TYPES.indexOf(oTarget.applicationType) >= 0;
-            const sFullAppId = `application-${sIntent}`;
-            let bIsInitial = false;
-            const oKeepAliveMode = {
-                globalValue: undefined,
-                paramValue: undefined
-            };
+            const sStorageAppId = `application-${sAppId}`;
+            let bNewlyCreatedApplicationContainer = false;
             let bNavigationInSameStatefulContainer = false;
-            let oInnerControl,
+            let oApplicationContainer,
                 bReuseStatefulContainer,
                 oCurrentAppContainer,
                 oOldAppStorageEntry,
                 oTargetAppContainer,
                 iLastValidTimeDelta,
-                oOldHash,
-                sOldFullAppId,
+                sOldStorageAppId,
                 sCurrentPageId,
                 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(oTarget.url);
+            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) ||
@@ -1462,27 +1379,30 @@ sap.ui.define([
                         `reason: ${sReason}`,
                         "sap.ushell.components.applicationIntegration.AppLifeCycle"
                     );
+
+                    // todo: [FLPCOREANDUX-10024] this destroy/remove can be simplified
                     BlueBoxHandler.removeCapabilities(oTargetAppContainer);
-                    this.destroyApplication(sFullAppId, oTargetAppContainer);
-                    BlueBoxHandler.deleteBlueBoxByUrl(oTarget.url);
+                    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
-                    sOldFixedShellHash = undefined;
+                    sOldShellHash = undefined;
                 }
             }
 
             //get the application container object of the application we are leaving
-            if (typeof sOldFixedShellHash === "string") {
-                oOldHash = oUrlParsing.parseShellHash(sOldFixedShellHash);
-                if (oOldHash) {
-                    sOldFullAppId = `application-${oOldHash.semanticObject}-${oOldHash.action}`;
-                    oOldAppStorageEntry = Storage.get(sOldFullAppId);
+            // todo: [FLPCOREANDUX-10024] GETTER of currentApplication
+            if (typeof sOldShellHash === "string") {
+                const sOldAppId = UrlParsing.getBasicHash(sOldShellHash);
+                if (sOldAppId) {
+                    sOldStorageAppId = `application-${sOldAppId}`;
+                    oOldAppStorageEntry = Storage.get(sOldStorageAppId);
                 }
                 if (oOldAppStorageEntry) {
                     oCurrentAppContainer = oOldAppStorageEntry.container;
                 } else {
-                    sCurrentPageId = oViewPortContainer.getCurrentCenterPage ? oViewPortContainer.getCurrentCenterPage() : undefined;
+                    sCurrentPageId = oViewPortContainer?.getCurrentCenterPage();
                     if (sCurrentPageId) {
                         oCurrentAppContainer = Element.getElementById(sCurrentPageId);
                     }
@@ -1493,115 +1413,70 @@ sap.ui.define([
             // 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
             bReuseStatefulContainer = BlueBoxHandler.isStatefulContainer(oCurrentAppContainer);
-            const bSourceIsKeepAliveFromPool = BlueBoxHandler.isStatefulContainerInKeepAlivePool(oCurrentAppContainer) && oCurrentAppContainer.getCurrentAppId?.().length > 0;
+            const bSourceIsKeepAliveFromPool = BlueBoxHandler.isStatefulContainerInKeepAlivePool(oCurrentAppContainer) && !!oCurrentAppContainer.getCurrentAppId();
             if (bReuseStatefulContainer || bSourceIsKeepAliveFromPool) {
-                await this.handleExitApplication(sOldFullAppId, oCurrentAppContainer, undefined, undefined, false, false);
+                await this._handleExitApplication(oCurrentAppContainer, false, false);
                 if (oCurrentAppContainer === oTargetAppContainer) {
                     bNavigationInSameStatefulContainer = true;
                 }
             }
 
             //now, we can open the new application
-            const bIsInCache = this.isAppOfTypeCached(sFullAppId, bIsAppOfTypeCachable, oKeepAliveMode) || this.isCachedEnabledAsAppParameter(oShellHash, oTarget, oKeepAliveMode);
-            //set the default full width value
-            const sAppType = this.calculateAppType(oTarget);
-            const bDefaultFullWidth = ApplicationType.getDefaultFullWidthSetting(sAppType);
-
-            oInnerControl = BlueBoxHandler.getBlueBoxByUrl(oTarget.url);
-            bReuseStatefulContainer = BlueBoxHandler.isStatefulContainer(oInnerControl);
+            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 oInnerControl in case it is not a navigation from an application to the same application
-                if (oCurrentApplication && sFullAppId !== oCurrentApplication.appId) {
-                    oInnerControl = undefined;
+                // only clear oApplicationContainer in case it is not a navigation from an application to the same application
+                if (oCurrentApplication && sStorageAppId !== oCurrentApplication.appId) {
+                    oApplicationContainer = undefined;
                 }
-                oCachedEntry = Storage.get(`application${sAppId}`);
 
-                if (oCachedEntry) {
-                    oInnerControl = oCachedEntry.container;
-                    if (!bReuseStatefulContainer && bIsInCache && oInnerControl !== undefined) {
-                        bKeptAliveApp = true;
-                    }
-                }
-            }
+                oCachedEntry = Storage.get(sStorageAppId);
+                oApplicationContainer = oCachedEntry?.container;
 
-            let bFullWidth;
-            const bFullWidthCapability = oTarget?.appCapabilities?.fullWidth;
-            const oMetadata = AppConfiguration.getMetadata(oTarget);
-            //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 oTarget are to avoid regression with the use of this field.
-            if (bDefaultFullWidth) {
-                if (oTarget.fullWidth === false || oTarget.fullWidth === "false" ||
-                    oMetadata.fullWidth === false || oMetadata.fullWidth === "false" || bFullWidthCapability === false) {
-                    bFullWidth = false;
+                if (oApplicationContainer && bShouldBeCached) {
+                    bKeptAliveApp = true;
                 }
-            } else if (oTarget.fullWidth || oTarget.fullWidth === "true" ||
-                oMetadata.fullWidth || oMetadata.fullWidth === "true") {
-                bFullWidth = true;
-            }
-
-            if (bFullWidth === undefined) {
-                bFullWidth = bDefaultFullWidth;
             }
 
+            // todo: [FLPCOREANDUX-10024] CREATE / SETTER of currentApplication
             if (bReuseStatefulContainer) {
-                if (!oInnerControl) {
-                    oInnerControl = fnWrapper(
-                        sIntent,
-                        oMetadata,
-                        oShellHash,
-                        oTarget,
-                        sAppId,
-                        bFullWidth,
-                        sFixedShellHash
-                    );
-                    if (this.isAppInCache(oInnerControl.getId())) {
-                        oCurrentApplication = Storage.get(oInnerControl.getId());
+                if (!oApplicationContainer) {
+                    oApplicationContainer = await this._createApplicationContainer(sAppId, oParsedShellHash, oResolvedHashFragment);
+
+                    // todo: [FLPCOREANDUX-10024] the following should be obsolete
+                    const oStorageEntry = Storage.get(oApplicationContainer.getId());
+                    if (oStorageEntry) {
+                        oCurrentApplication = oStorageEntry;
                     }
-                    this.navTo(oInnerControl.getId());
-                    bIsInitial = true;
+
+                    bNewlyCreatedApplicationContainer = true;
                 }
-            } else if (BlueBoxHandler.getStatefulContainerType(oTarget.url, true) !== BlueBoxHandler.STATEFUL_TYPES.GUI_V1 && oInnerControl && !bIsInCache) {
-                //this case this controller cant be reused and we need it to be embed, so delete it.
-                await this.destroyApplication(oInnerControl.getId(), oInnerControl);
+            } 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(oAppContainer)`
+                // `this.oViewPortContainer.addCenterViewPort(oApplicationContainer)`
                 // when Gui V1 Stateful Container is true, and in that case
-                // `oInnerControl` will be the component control of an existing session.
-                oInnerControl = fnWrapper(
-                    sIntent,
-                    oMetadata,
-                    oShellHash,
-                    oTarget,
-                    sAppId,
-                    bFullWidth,
-                    sFixedShellHash
-                );
-            } else if (!oInnerControl) {
+                // `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(oAppContainer)`
+                // `this.oViewPortContainer.addCenterViewPort(oApplicationContainer)`
                 // when Gui V1 Stateful Container is true, and in that case
-                // `oInnerControl` will be the component control of an existing session.
-                oInnerControl = fnWrapper(
-                    sIntent,
-                    oMetadata,
-                    oShellHash,
-                    oTarget,
-                    sAppId,
-                    bFullWidth,
-                    sFixedShellHash
-                );
+                // `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 (oInnerControl && oInnerControl.getProperty && oInnerControl.getProperty("fetchedFromCache") === true) {
-                //     InnerControl.getProperty("fetchedFromIframeCache", false, true);
-                // }
-                if (oInnerControl?.getIsFetchedFromCache?.() && oInnerControl.getStatefulType) {
-                    if (oInnerControl.getStatefulType() === -BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
+                if (oApplicationContainer.getIsFetchedFromCache()) {
+                    if (oApplicationContainer.getStatefulType() === -BlueBoxHandler.STATEFUL_TYPES.GUI_V1) {
                         bReturnedFromKeepAlivePoolGuiV1 = true;
                     } else {
                         bReuseStatefulContainer = true;
@@ -1610,22 +1485,24 @@ sap.ui.define([
                 }
             }
 
-            if (oInnerControl?.getDeffedControlCreation) {
-                await ushellUtils.promisify(oInnerControl.getDeffedControlCreation());
-            }
+            // 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 (oInnerControl.getStatefulType && oInnerControl.getStatefulType() !== BlueBoxHandler.STATEFUL_TYPES.GUI_V1 && !bReuseStatefulContainer) {
+            if (oApplicationContainer.getStatefulType() !== BlueBoxHandler.STATEFUL_TYPES.GUI_V1 && !bReuseStatefulContainer) {
                 if (bKeptAliveApp) {
-                    EventBus.getInstance().publish("launchpad", "appOpening", oTarget);
+                    EventBus.getInstance().publish("launchpad", "appOpening", oResolvedHashFragment);
                 }
-                if (this.isAppInCache(oInnerControl.getId())) {
-                    oCurrentApplication = Storage.get(oInnerControl.getId());
+                const oStorageEntry = Storage.get(oApplicationContainer.getId());
+                if (oStorageEntry) {
+                    oCurrentApplication = oStorageEntry;
                 }
-                this.navTo(oInnerControl.getId());
+
                 if (bKeptAliveApp) {
-                    EventBus.getInstance().publish("sap.ushell", "appOpened", oTarget);
+                    EventBus.getInstance().publish("sap.ushell", "appOpened", oResolvedHashFragment);
                 }
             }
 
@@ -1636,50 +1513,79 @@ sap.ui.define([
             // 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 (oInnerControl.getApplicationType() === ApplicationType.TR.type) {
-                this.activeContainer(oInnerControl);
+            if (oApplicationContainer.getApplicationType() === ApplicationType.TR.type) {
+                this._activeContainer(oApplicationContainer);
+            }
+
+            const oStorageEntry = Storage.get(sStorageAppId);
+            if (oStorageEntry) {
+                AppInfoParameters.restore(oStorageEntry);
+            } else {
+                AppInfoParameters.flush();
             }
+
+
             //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 (oTarget.appCapabilities?.appFrameworkId === "UI5") {
-                    oInnerControl.setProperty("active", true, true);
+                if (oResolvedHashFragment.appCapabilities?.appFrameworkId === "UI5") {
+                    oApplicationContainer.setProperty("active", true, true);
                 }
                 // eslint-disable-next-line max-len
-                await this.handleOpenStateful(bIsInitial, bIsInCache, `application${sAppId}`, oInnerControl, oTarget, sFixedShellHash, oKeepAliveMode, bNavigationInSameStatefulContainer, bReturnedFromKeepAlivePoolFLPV2);
-            } else if (oInnerControl.getStatefulType?.() === BlueBoxHandler.STATEFUL_TYPES.GUI_V1 || bReturnedFromKeepAlivePoolGuiV1) {
+                await this._handleOpenStateful(bNewlyCreatedApplicationContainer, bShouldBeCached, sStorageAppId, oApplicationContainer, oResolvedHashFragment, oParsedShellHash, sKeepAliveMode, bNavigationInSameStatefulContainer, bReturnedFromKeepAlivePoolFLPV2);
+
+            } 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, oInnerControl, oTarget);
+                await WebGUIStatefulHandler.guiStatefulCreateApp(this, oApplicationContainer, oResolvedHashFragment);
             }
 
             //for case of stateful container or gui v1 stateful, show the application view (make it visible)
             ushellUtils.setPerformanceMark("FLP -- centerViewPort");
-            if (oInnerControl.getApplicationType() !== ApplicationType.TR.type) {
+            if (oApplicationContainer.getApplicationType() !== ApplicationType.TR.type) {
                 // Activate container before showing it (start reacting to postMessage calls)
-                this.activeContainer(oInnerControl);
+                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 !== sFullAppId) {
+             * 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: sFullAppId,
+                    appId: sStorageAppId,
                     stt: "loading",
-                    container: oInnerControl,
-                    meta: AppConfiguration.getMetadata(oTarget),
+                    container: oApplicationContainer,
+                    meta: AppConfiguration.getMetadata(oResolvedHashFragment),
                     app: undefined
                 };
             }
         };
 
+        /**
+         */
+        this.navToCurrentApp = function () {
+            const oApplicationContainer = this.getCurrentApplication().container;
+            // todo: [FLPCOREANDUX-10024] maybe switch to 'this.getCurrentApplication().appId' instead
+            this._navTo(oApplicationContainer.getId());
+
+            // todo: [FLPCOREANDUX-10024]
+            // - Move styles into control? or at least out of here
+            // - Is this even needed? This doesn't seem to trigger the onAfterNavigate as indicated by the following comment.
+            //Added this because in cases when navigating to the same id (can happen when stateful container, I need the on onAfterNavigate)
+            //This must only be done after the _navTo as the ViewPortContainer's navTo function relies on the state of those classes.
+            if (oApplicationContainer.hasStyleClass("sapUShellApplicationContainerShiftedIframe")) {
+                oApplicationContainer.toggleStyleClass("sapUShellApplicationContainerIframeHidden", false);
+            } else {
+                oApplicationContainer.toggleStyleClass("hidden", false);
+            }
+        };
+
         /**
          * New app was created and we now have to switch the state
          * @param {string} sLaunchpadState
@@ -1710,7 +1616,8 @@ sap.ui.define([
             StateManager.switchState(sLaunchpadState, sShellModeOverride);
 
             // Restore state if it already exists
-            const oToStorageEntry = Storage.get(`application${sAppId}`);
+            const sToStorageAppId = `application-${sAppId}`;
+            const oToStorageEntry = Storage.get(sToStorageAppId);
             if (oToStorageEntry) {
                 KeepAlive.restore(oToStorageEntry);
             } else {
@@ -1729,25 +1636,256 @@ sap.ui.define([
         };
 
         /**
-         * @param {string} sHandlers
-         * @param {string} sType
+         * @returns {boolean} Whether the floating container is docked.
+         */
+        this._isFloatingContainerDocked = function () {
+            const bDocked = ShellModel.getModel().getProperty("/floatingContainer/state").includes("docked");
+            const bVisible = ShellModel.getModel().getProperty("/floatingContainer/visible");
+            return bDocked && bVisible;
+        };
+
+        /**
          */
-        this.registerIframeCommunicationHandler = function (sHandlers, sType) {
-            oGlobalIframeCommunicationHandlers[sType] = sHandlers;
+        this._sendFocusBackToShell = function () {
+            if (!Device.system.desktop) {
+                return;
+            }
+
+            sap.ui.require(["sap/ushell/renderer/AccessKeysHandler"], (AccessKeysHandler) => {
+                const sCurrentLaunchpadState = StateManager.getLaunchpadState();
+                const bDefaultShellMode = StateManager.getShellMode() === ShellMode.Default;
+                const oShellAppTitle = Element.getElementById("shellAppTitle");
+
+                if (oShellAppTitle && sCurrentLaunchpadState === LaunchpadState.App && bDefaultShellMode) {
+                    const oShellAppTitleDomRef = oShellAppTitle.getFocusDomRef();
+                    if (oShellAppTitleDomRef) {
+                        AccessKeysHandler.sendFocusBackToShell(oShellAppTitleDomRef.getAttribute("id"));
+                    }
+                }
+            });
         };
 
         /**
-         * @param {boolean} bIsBackNavigationChangedValue
+         * @param {object} oResolvedHashFragment
          */
-        this.setBackNavigationChanged = function (bIsBackNavigationChangedValue) {
-            isBackNavigationChanged = bIsBackNavigationChangedValue;
+        this._announceAppOpening = function (oResolvedHashFragment) {
+            //Screen reader: "Loading Complete"
+            window.setTimeout(() => {
+                window.setTimeout(() => {
+                    const oAccessibilityHelperLoadingComplete = document.getElementById("sapUshellLoadingAccessibilityHelper-loadingComplete");
+
+                    if (oAccessibilityHelperLoadingComplete) {
+                        oAccessibilityHelperLoadingComplete.setAttribute("aria-live", "polite");
+                        oAccessibilityHelperLoadingComplete.innerHTML = ushellResources.i18n.getText("loadingComplete");
+                        window.setTimeout(() => {
+                            oAccessibilityHelperLoadingComplete.setAttribute("aria-live", "off");
+                            oAccessibilityHelperLoadingComplete.innerHTML = "";
+                        }, 0);
+                    }
+                }, 600);
+
+                EventBus.getInstance().publish("launchpad", "appOpening", oResolvedHashFragment);
+                Log.info("app is being opened");
+            }, 0);
         };
 
         /**
-         * @returns {boolean} Whether the back navigation was changed.
+         * @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);
+            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);
+
+            await this._openApp(sAppId, oResolvedHashFragment, oParsedShellHash);
+            const oApplicationContainer = oCurrentApplication.container;
+
+            const bContainerFromCachePool = oApplicationContainer.getIsFetchedFromCache();
+
+            if (!bContainerFromCachePool) {
+                this._publishNavigationStateEvents(oApplicationContainer, oResolvedHashFragment, this.onAppAfterRendering.bind(this, oResolvedHashFragment));
+
+                if (ushellUtils.isSAPLegacyApplicationType(oApplicationContainer.getApplicationType(), oApplicationContainer.getFrameworkId())) {
+                    oApplicationContainer.addStyleClass("sapUShellApplicationContainerShiftedIframe");
+                }
+
+                if (!bFullWidth) {
+                    oApplicationContainer.addStyleClass("sapUShellApplicationContainerLimitedWidth");
+                }
+
+                // todo: [FLPCOREANDUX-10024] clarify whether this should be reactive instead of one time only
+                // todo: [FLPCOREANDUX-10024] move this block to ShellController
+                if (this._isFloatingContainerDocked() && window.matchMedia("(min-width: 106.4rem)").matches) {
+                    oApplicationContainer.addStyleClass("sapUShellDockingContainer");
+                    oApplicationContainer.removeStyleClass("sapUShellApplicationContainerLimitedWidth");
+                } else if (this._isFloatingContainerDocked()) {
+                    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
+         * @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;
+
+            const oInMemoryApplicationInstance = this._getInMemoryInstance(sIntent, sShellHash, bNavigationFromHome, bNavigationWithInnerAppRoute);
+
+            if (oInMemoryApplicationInstance.isInstanceSupported) {
+                // no destroy required
+
+            } else if (bComponentLoaded || !sTargetUi5ComponentName) {
+                if ((
+                        oResolvedHashFragment.applicationType === "URL"
+                        || ushellUtils.isSAPLegacyApplicationType(oResolvedHashFragment.applicationType)
+                    )
+                    && oInMemoryApplicationInstance.isInstanceSupported === false
+                    && oInMemoryApplicationInstance.appId
+                ) {
+                    await this._destroyApplication(oInMemoryApplicationInstance.appId, oInMemoryApplicationInstance.container);
+                }
+
+            } else { // UI5 Application
+                await this._destroyApplication(oInMemoryApplicationInstance.appId, oInMemoryApplicationInstance.container);
+                const oApplicationContainer = this._getApplicationContainerFromViewPort(sIntent);
+
+                if (oApplicationContainer) {
+                    this._removeApplicationContainerFromViewPort(oApplicationContainer.getId());
+                    oApplicationContainer.destroy();
+                }
+
+                // close all keep alive apps with the same component name
+                await this._closeKeepAliveApps((oStorageEntry) => oStorageEntry.ui5ComponentName === oResolvedHashFragment.ui5ComponentName);
+            }
+        };
+
+        /**
+         * @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);
+
+            if (bIsUI5App && !bComponentLoaded && !oInMemoryApplicationInstance.isInstanceSupported) { // 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 }
+                );
+
+                // 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);
+            }
+        };
+
+        /**
+         *
+         * @param {sap.ui.core.Component} oApplication
+         */
+        this.onAppAfterRendering = function (oApplication) {
+            // wrapped in setTimeout since "publish" is not async
+            window.setTimeout(() => {
+                EventBus.getInstance().publish("sap.ushell", "appOpened", oApplication);
+                Log.info("app was opened");
+            }, 0);
+
+            // publish the event externally
+            // TODO: cloned, frozen object!
+            const oAppOpenedEventData = this._publicEventDataFromResolutionResult(oApplication);
+
+            // Event is emitted internally (EventHub) _and_ externally (for compatibility reasons)
+            EventHub.emit("AppRendered", oAppOpenedEventData, true);
+            RendererUtils.publishExternalEvent("appOpened", oAppOpenedEventData);
+            ushellUtils.setPerformanceMark("FLP.appOpened");
+
+            const sIcon = AppMeta.getAppIcon();
+            StateManager.updateCurrentState("application.icon", Operation.Set, sIcon);
+        };
+
+        /**
+         * Only for testing
+         * @param {sap.ui.core.Control} oNewViewPortContainer
+         *
+         * @private
          */
-        this.getBackNavigationChanged = function () {
-            return isBackNavigationChanged;
+        this.setViewPortContainer = function (oNewViewPortContainer) {
+            oViewPortContainer = oNewViewPortContainer;
         };
     }