@sapui5/sap.ushell 1.141.3 → 1.143.0

package/src/main/js/sap/ushell/renderer/Shell.controller.js

@@ -43,7 +43,8 @@ sap.ui.define([
     "sap/ushell/renderers/fiori2/History", // restore deprecated globals
     "sap/ushell/renderer/RendererManagedComponents",
     "sap/ushell/ui5service/ShellUIServiceFactory",
-    "sap/ushell/navigation/NavigationState"
+    "sap/ushell/navigation/NavigationState",
+    "sap/ushell/utils/SmartBusiness"
 ], (
     History,
     Log,
@@ -84,7 +85,8 @@ sap.ui.define([
     DeprecatedHistory, // restore deprecated globals
     RendererManagedComponents,
     ShellUIServiceFactory,
-    NavigationState
+    NavigationState,
+    SmartBusiness
 ) => {
     "use strict";
 
@@ -402,12 +404,23 @@ sap.ui.define([
             this.oShellNavigationInternal.registerExtraRouter(oRouter);
             this.oShellNavigationInternal.registerNavigationFilter(this._handleEmptyHash.bind(this));
             // must be after event registration (for synchronous nav target resolver calls)
+
+            // For the direct app start the Smart Business navigation filter has to be registered before the init
+            // as the init triggers the first treatHashChanged that runs the navigation filters
+            const fnHandleSmartBusiness = this._handleSmartBusiness.bind(this);
+            this.oShellNavigationInternal.registerNavigationFilter(fnHandleSmartBusiness);
+
             this.oShellNavigationInternal.init(this.doHashChange.bind(this));
 
+            // As the Smart Business navigation filter triggers a navigation it should run after the other
+            // navigation filters, so unregister it again and register at the last position.
+            this.oShellNavigationInternal.unregisterNavigationFilter(fnHandleSmartBusiness);
+
             this.oShellNavigationInternal.registerNavigationFilter(this._disableSourceAppRouter.bind(this));
 
             this.oShellNavigationInternal.registerNavigationFilter(this.handleDataLoss.bind(this));
             this.oShellNavigationInternal.registerNavigationFilter(this._unblockUI.bind(this));
+            this.oShellNavigationInternal.registerNavigationFilter(fnHandleSmartBusiness);
 
             AppLifeCycleAI.registerHandleHashChange(this.oShellNavigationInternal);
             // enable the direct app start and tests to wait for the initialization
@@ -614,6 +627,85 @@ sap.ui.define([
             return this.oShellNavigationInternal.NavigationFilterStatus.Continue;
         },
 
+        /**
+         * Navigation filter for Smart Business
+         * Changes the navigation parameters based on parameter sap-ssb-eval-id
+         *
+         * @param {string} sTargetIntent The target intent
+         * @returns {string} The NavigationFilterStatus
+         *
+         * @private
+         */
+        _handleSmartBusiness: function (sTargetIntent) {
+            if (!sTargetIntent.includes("sap-ssb-eval-id")) {
+                return this.oShellNavigationInternal.NavigationFilterStatus.Continue;
+            }
+
+            // the navigation filter has to return a status synchronously,
+            // therefore the filter function itself must not be async
+
+            // skip the next data loss filter as it was handled already before
+            this.bSkipNextDataLossCheck = true;
+
+            (async () => {
+                let oParsedShellHash = UrlParsing.parseShellHash(sTargetIntent);
+
+                try {
+                    const Navigation = await Container.getServiceAsync("Navigation");
+                    oParsedShellHash = await SmartBusiness.resolveEvaluationId(oParsedShellHash);
+
+                    const oTarget = {
+                        target: {
+                            semanticObject: oParsedShellHash.semanticObject,
+                            action: oParsedShellHash.action,
+                            contextRaw: oParsedShellHash.contextRaw
+                        },
+                        params: oParsedShellHash.params,
+                        appSpecificRoute: oParsedShellHash.appSpecificRoute,
+                        writeHistory: false
+                    };
+
+                    Navigation.navigate(oTarget);
+                } catch (oError) {
+                    this.bSkipNextDataLossCheck = false;
+
+                    // If the resolution of the evaluation ID crashes during direct start,
+                    // make sure that the direct start result is not used by the next navigation
+                    if (window["sap-ushell-async-libs-promise-directstart"]) {
+                        delete window["sap-ushell-async-libs-promise-directstart"];
+                    }
+
+                    const sEvaluationId = oParsedShellHash.params["sap-ssb-eval-id"] && oParsedShellHash.params["sap-ssb-eval-id"][0];
+                    const sLogMessage = `Failed to execute Smart Business navigation for evaluation ID ${sEvaluationId}`;
+
+                    // As this error handling is not part of the normal navigation flow's error handling
+                    // this has to be triggered explicitly.
+                    NavigationState.endNavigation();
+
+                    // If the previous page was dirty the dirty state handler must not interfere with the back navigation
+                    const bEnableHashChange = !bPreviousPageDirty;
+
+                    this.hashChangeFailure(
+                        this.history.getHistoryLength(),
+                        {
+                            title: ushellResources.i18n.getText("error"),
+                            message: ushellResources.i18n.getText("failed_to_open_app_missing_configuration_or_role_assignment"),
+                            technicalMessage: sLogMessage
+                        },
+                        {
+                            info: ushellResources.i18n.getText("cannot_resolve_navigation_target_details", [sTargetIntent]),
+                            technicalMessage: oError
+                        },
+                        "sap.ushell.renderer.Shell.controller",
+                        bEnableHashChange
+                    );
+                }
+            })();
+
+            // The navigation filter triggers the new navigation.
+            return this.oShellNavigationInternal.NavigationFilterStatus.Custom;
+        },
+
         // Make sure that UI is unblocked during navigation.
         // The header and menu are blocked when an embedded ui5 app shows a modal popup.
         // However, such a block does not prevent navigation via the browser url and back/forward button navigation.
@@ -834,6 +926,18 @@ sap.ui.define([
          * @private
          */
         handleDataLoss: function (targetIntent, currentIntent) {
+            /**
+             * This should be used if a different navigation filter does a custom navigation after the data loss check,
+             * to prevent a second data loss popup.
+             *
+             * Dirty state providers only get deregistered after the navigation (filters) are processed (application exit).
+             * Therefore a registered dirty state provider will be called a second time during the same navigation filter cycle.
+             */
+            if (this.bSkipNextDataLossCheck) {
+                this.bSkipNextDataLossCheck = false;
+                return this.oShellNavigationInternal.NavigationFilterStatus.Continue;
+            }
+
             const oShellNavigationHashChanger = this.oShellNavigationInternal.hashChanger;
             const bReloadApplication = oShellNavigationHashChanger.getReloadApplication();
 
@@ -883,6 +987,7 @@ sap.ui.define([
             // The OPA iframe handler overwrites some hasher methods which results in a confused ushell navigation flow.
             const bIsDirty = Container.getDirtyFlag();
             const bIsAsyncDirtyStateProviderSet = Container.isAsyncDirtyStateProviderSet();
+
             if (!bIsAsyncDirtyStateProviderSet && !bIsDirty) {
                 bPreviousPageDirty = bIsDirty;
                 return this.oShellNavigationInternal.NavigationFilterStatus.Continue;
@@ -1207,12 +1312,14 @@ sap.ui.define([
                 return oDeferred.promise();
             }
 
-            const sFixedShellHash = UrlParsing.ensureLeadingHash(sShellHash);
-            const sFixedOldShellHash = UrlParsing.ensureLeadingHash(sOldShellHash);
+            const sFullShellHash = `${sShellHash}${sInnerAppRoute ?? ""}`;
+            const oParsedHash = UrlParsing.parseShellHash(sFullShellHash, true);
+            const sOldFullShellHash = `${sOldShellHash}${sOldInnerAppRoute ?? ""}`;
+            const oOldParsedHash = UrlParsing.parseShellHash(sOldFullShellHash, true);
 
             // todo [FLPCOREANDUX-10024] where does this oParseError come from?
             if (oParseError) {
-                Log.error(`Error when parsing the hash: '${sFixedShellHash}'`, oParseError);
+                Log.error(`Error when parsing the hash: '${sFullShellHash}'`, oParseError);
                 this.hashChangeFailure(
                     this.history.getHistoryLength(),
                     oParseError.message,
@@ -1228,7 +1335,7 @@ sap.ui.define([
 
             const fnResolveInteraction = this._notifyAsyncStep();
 
-            this._doHashChange(sFixedShellHash, sInnerAppRoute, sFixedOldShellHash)
+            this._doHashChange(oParsedHash, oOldParsedHash)
                 .catch(() => {
                     EventHub.emit("doHashChangeError", Date.now());
                 })
@@ -1243,12 +1350,21 @@ sap.ui.define([
             return oDeferred.promise();
         },
 
-        _doHashChange: async function (sShellHash, sInnerAppRoute, sOldShellHash) {
+        _doHashChange: async function (oParsedHash, oOldParsedHash) {
+            // todo: [FLPCOREANDUX-10024] simplify Renderer History
             // save current history length to handle errors (in case)
             const iOriginalHistoryLength = this.history.getHistoryLength();
 
             // track hash change
-            this.history.hashChange(sShellHash, sOldShellHash);
+            const sShellHashWithoutAppRoute = UrlParsing.constructShellHash({
+                ...oParsedHash,
+                appSpecificRoute: undefined
+            }, true);
+            const sOldShellHashWithoutAppRoute = UrlParsing.constructShellHash({
+                ...oOldParsedHash,
+                appSpecificRoute: undefined
+            }, true);
+            this.history.hashChange(sShellHashWithoutAppRoute, sOldShellHashWithoutAppRoute);
 
             // we save the current-application before resolving the next navigation's fragment,
             // as in cases of navigation in a new window we need to set it back for the app-configuration to be consistent
@@ -1256,17 +1372,14 @@ sap.ui.define([
 
             try {
                 // NOTE: AppConfiguration.setCurrentApplication was called with the currently resolved target.
-                const oResult = await this._resolveHashFragment(sShellHash, sInnerAppRoute);
+                const oResolvedHashFragment = await this._resolveHashFragment(oParsedHash);
 
                 // Only for testing
-                if (!oResult && window.QUnit !== undefined) {
+                if (!oResolvedHashFragment && window.QUnit !== undefined) {
                     // return without navigation if no result was returned.
                     return;
                 }
 
-                const oResolvedHashFragment = oResult.resolvedHashFragment;
-                const oParsedShellHash = oResult.parsedShellHash;
-
                 // todo: [FLPCOREANDUX-10024] is this a real life use case?
                 /*
                  * A null navigationMode indicates that no hashFragment was resolved.
@@ -1293,7 +1406,7 @@ sap.ui.define([
 
                 const bOpenedViaNWBC = await this._openAppViaNWBC(oResolvedHashFragment, oOldResolvedHashFragment);
                 if (bOpenedViaNWBC === true) {
-                    this.logOpenAppAction(oResolvedHashFragment, sInnerAppRoute).catch(() => {
+                    this.logOpenAppAction(oResolvedHashFragment, oParsedHash).catch(() => {
                         Log.info("NWBC application was not logged.", undefined, "sap.ushell.renderer.Shell.controller");
                     });
 
@@ -1303,7 +1416,7 @@ sap.ui.define([
 
                 if (oResolvedHashFragment.navigationMode === NavigationMode.newWindow) {
                     // add the app to application usage log
-                    this.logOpenAppAction(oResolvedHashFragment, sInnerAppRoute).catch(() => {
+                    this.logOpenAppAction(oResolvedHashFragment, oParsedHash).catch(() => {
                         Log.info("Application in new window was not logged.", undefined, "sap.ushell.renderer.Shell.controller");
                     });
                     await this._openAppExplace(oResolvedHashFragment, oOldResolvedHashFragment);
@@ -1313,7 +1426,7 @@ sap.ui.define([
                 }
 
                 // Handle "/core/shell/model/migrationConfig"
-                const bHandledViaMigrationConfig = this._rewriteRootIntentForMigrationConfig(oResolvedHashFragment, sShellHash);
+                const bHandledViaMigrationConfig = this._rewriteRootIntentForMigrationConfig(oResolvedHashFragment, oParsedHash);
                 if (bHandledViaMigrationConfig) {
                     StateManager.applyStalledChanges(); // no changes were done by the source application
                     return;
@@ -1323,12 +1436,13 @@ sap.ui.define([
                 try {
                     const bPreviousIsInitialNavigation = this.oShellNavigationInternal.isInitialNavigation();
                     try {
-                        await this._openAppInplace(oParsedShellHash, sShellHash, oResolvedHashFragment, sOldShellHash, sInnerAppRoute, oOldResolvedHashFragment);
+                        await this._openAppInplace(oParsedHash, oResolvedHashFragment, oOldParsedHash, oOldResolvedHashFragment);
                     } catch (oError) {
+                        const sShellHash = UrlParsing.constructShellHash(oParsedHash, true);
                         Log.error(`Application initialization for intent "${sShellHash}" failed.`, oError);
 
                         // assumption is that the resolvedHashFragment already contains the componentHandle
-                        const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment);
+                        const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment, oParsedHash);
                         this.oShellNavigationInternal.setIsInitialNavigation(bPreviousIsInitialNavigation);
                         await this.hashChangeFailure(
                             iOriginalHistoryLength,
@@ -1339,6 +1453,7 @@ sap.ui.define([
                         );
                     }
                 } catch (oError) {
+                    const sShellHash = UrlParsing.constructShellHash(oParsedHash, true);
                     Log.error("Failed to open application", oError, "sap.ushell.renderer.Shell.controller");
 
                     const sErrorReason = ushellResources.i18n.getText("cannot_load_ui5_component_details", [sShellHash]);
@@ -1361,6 +1476,7 @@ sap.ui.define([
                     );
                 }
             } catch (oError) {
+                const sShellHash = UrlParsing.constructShellHash(oParsedHash, true);
                 Log.error("Hash change handling failed. Could not open app.", oError, "sap.ushell.renderer.Shell.controller");
                 const sErrorReason = ushellResources.i18n.getText("cannot_resolve_navigation_target_details", [sShellHash]);
                 // eslint-disable-next-line max-len
@@ -1386,22 +1502,24 @@ sap.ui.define([
             }
         },
 
-        _rewriteRootIntentForMigrationConfig: function (oResolvedHashFragment, sShellHash) {
+        _rewriteRootIntentForMigrationConfig: function (oResolvedHashFragment, oParsedHash) {
             // In case of empty hash, if there is a resolved target, set the flag to false, from now on the rootIntent
             // will be an empty hash. Otherwise, change hash to rootIntent to trigger normal resolution.
             if (Config.last("/core/shell/model/migrationConfig")) {
                 oConfig.migrationConfig = false;
                 this._getConfigModel().setProperty("/migrationConfig", false);
 
-                // todo: [FLPCOREANDUX-10024] is this an actual use case? oResolvedHashFragment seems to be always defined
-                if (oResolvedHashFragment && sShellHash === "#") {
-                    oConfig.rootIntent = "";
-                } else if (sShellHash === "#") {
-                    window.setTimeout(() => {
-                        hasher.setHash(oConfig.rootIntent);
-                    }, 0);
+                if (UrlParsing.isEmptyHash(oParsedHash)) {
+                    // todo: [FLPCOREANDUX-10024] is this an actual use case? oResolvedHashFragment seems to be always defined
+                    if (oResolvedHashFragment) {
+                        oConfig.rootIntent = "";
+                    } else {
+                        window.setTimeout(() => {
+                            hasher.setHash(oConfig.rootIntent);
+                        }, 0);
 
-                    return true;
+                        return true;
+                    }
                 }
             }
             return false;
@@ -1409,7 +1527,7 @@ sap.ui.define([
 
         _openAppExplace: async function (oResolvedHashFragment, oOldResolvedHashFragment) {
             // Call relevant for Legacy-UI apps that are launched "standalone"; in case of "embedded in new window", the URL doesn't need adaptions.
-            oResolvedHashFragment.url = UrlPostProcessing.processUrl(
+            oResolvedHashFragment.url = await UrlPostProcessing.processUrl(
                 oResolvedHashFragment.url,
                 oResolvedHashFragment.applicationType,
                 true, // bForExplaceNavigation
@@ -1443,15 +1561,12 @@ sap.ui.define([
         /**
          * Callback registered with NavService. Triggered on navigation requests
          *
-         * @param {string} sShellHash the hash fragment to parse (must start with "#")
-         * @param {string|null} sInnerAppRoute the inner app route starting with '&/'
-         * @returns {Promise<{ resolvedHashFragment: object , parsedShellHash: object }>} Resolves with an object containing the resolved hash fragment (i.e., the result of
-         *   {@link sap.ushell.services.NavTargetResolutionInternal#resolveHashFragment}), the parsed shell hash obtained via
-         *   {@link sap.ushell.services.URLParsing#parseShellHash}, and a boolean value indicating whether application dependencies
-         *   <b>and</b> core-ext-light were loaded earlier. The promise is rejected with an error message in case errors occur.
+         * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash The parsed shell hash
+         * @returns {Promise<object>} Resolves with an object containing the resolved hash fragment (i.e., the result of
+         *   {@link sap.ushell.services.NavTargetResolutionInternal#resolveHashFragment})
          */
-        _resolveHashFragment: async function (sShellHash, sInnerAppRoute) {
-            const oParsedShellHash = UrlParsing.parseShellHash(sShellHash) || {}; // might be empty in tests
+        _resolveHashFragment: async function (oParsedHash) {
+            const sShellHash = UrlParsing.constructShellHash(oParsedHash, true);
             const oConfig = this._getConfig(); // for testing
             let oResolvedHashFragment;
 
@@ -1469,7 +1584,7 @@ sap.ui.define([
             } else {
                 // Perform target resolution as normal...
                 const NavTargetResolutionInternal = await Container.getServiceAsync("NavTargetResolutionInternal");
-                oResolvedHashFragment = await ushellUtils.promisify(NavTargetResolutionInternal.resolveHashFragment(sShellHash + (sInnerAppRoute ?? "")));
+                oResolvedHashFragment = await ushellUtils.promisify(NavTargetResolutionInternal.resolveHashFragment(sShellHash));
             }
 
             // Only for testing: return without result if the NavTargetResolutionInternal resolved nothing
@@ -1487,7 +1602,7 @@ sap.ui.define([
             AppConfiguration.setCurrentApplication(oResolvedHashFragment);
 
             // add application config to the application properties
-            const sBasicHash = UrlParsing.getBasicHash(sShellHash);
+            const sBasicHash = UrlParsing.constructBasicHash(oParsedHash);
             if (oConfig?.applications?.[sBasicHash]) {
                 oResolvedHashFragment.applicationConfiguration = oConfig.applications[sBasicHash];
             }
@@ -1497,7 +1612,7 @@ sap.ui.define([
 
             // Override navigation mode for root intent.
             // Shell home should be opened in embedded mode to allow a new window to be opened from GUI applications.
-            if (`${oParsedShellHash.semanticObject}-${oParsedShellHash.action}` === oConfig.rootIntent) {
+            if (UrlParsing.isRootIntent(oParsedHash)) {
                 oResolvedHashFragment.navigationMode = NavigationMode.embedded;
             }
 
@@ -1515,10 +1630,7 @@ sap.ui.define([
 
             ushellUtils.setPerformanceMark("FLP-ShellController-resolveHashFragment-end");
 
-            return {
-                resolvedHashFragment: oResolvedHashFragment,
-                parsedShellHash: oParsedShellHash
-            };
+            return oResolvedHashFragment;
         },
 
         /**
@@ -1586,15 +1698,13 @@ sap.ui.define([
         /**
          * Performs navigation based on the given resolved hash fragment.
          *
-         * @param {object} oParsedShellHash the parsed shell hash obtained via {@link sap.ushell.services.URLParsing} service.
-         * @param {string} sShellHash the hash fragment to navigate to. It must start with "#" (i.e., fixed).
+         * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash the parsed shell hash.
          * @param {object} oResolvedHashFragment the hash fragment resolved via {@link sap.ushell.services.NavTargetResolutionInternal#resolveHashFragment}
-         * @param {string} sOldShellHash the old hash fragment. It must start with "#" (i.e., fixed).
-         * @param {string|null} sInnerAppRoute the inner app route.
+         * @param {sap.ushell.services.URLParsing.DecomposedHash} oOldParsedShellHash the old parsed shell hash.
          *
          * @returns {Promise} Navigation Promise
          */
-        _openAppInplace: async function (oParsedShellHash, sShellHash, oResolvedHashFragment, sOldShellHash, sInnerAppRoute) {
+        _openAppInplace: async function (oParsedHash, oResolvedHashFragment, oOldParsedShellHash) {
             // The url template resolution allows to set the appSpecificRoute to be set via parameter.
             // Therefore we need to update the innerAppRoute before actually opening the app.
             if (oResolvedHashFragment.replaceHashBeforeOpenAppInplace) {
@@ -1648,12 +1758,12 @@ sap.ui.define([
 
             AppLifeCycleAI.resetGlobalShellUIService();
 
-            const bNavigationFromHome = this._isFLPIntent(sOldShellHash);
+            // historically this also includes the app finder
+            const bNavigationFromHome = this._isFLPIntent(oOldParsedShellHash);
 
             const oApplicationHandle = await AppLifeCycleAI.startApplication(
-                oParsedShellHash,
                 oResolvedHashFragment,
-                sInnerAppRoute || "",
+                oParsedHash,
                 bNavigationFromHome
             );
 
@@ -1667,11 +1777,8 @@ sap.ui.define([
                 return ShellNavigationInternal.toExternal({ target: { shellHash: sNavigationRedirectHash } }, undefined, false);
             }
 
-            const oShellConfig = this._getConfig();
-
-            const sBasicShellHash = UrlParsing.getBasicHash(sShellHash);
             // this only targets the overwritten rootIntent (e.g. workzone advanced)
-            const bIsNavToHome = sShellHash === "#" || (oShellConfig.rootIntent && sBasicShellHash === UrlParsing.getBasicHash(oShellConfig.rootIntent));
+            const bIsNavToHome = UrlParsing.isEmptyHash(oParsedHash) || UrlParsing.isRootIntent(oParsedHash);
             await oApplicationHandle.navTo(bIsNavToHome); // todo: [FLPCOREANDUX-10024] triggers appLoaded event and switches the state
 
             // todo: [FLPCOREANDUX-10024] Move this into the regular flow
@@ -1680,7 +1787,7 @@ sap.ui.define([
              * Normally FESR record is closed on the "AppRendered" event, but for some cases (stateful container, etc.)
              * the application container is not re-rendered and EmbeddedNavigationDone is additionally fired to close the record.
              */
-            const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment);
+            const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment, oParsedHash);
             EventHub.emit("CloseFesrRecord", { time: Date.now(), technicalName: oMetadata.technicalName });
             return;
         },
@@ -1839,10 +1946,6 @@ sap.ui.define([
             EventHub.emit("openedAppInNewWindow", Date.now());
         },
 
-        _isShellHomeIntent: function (sIntent) {
-            return sIntent === "#" || sIntent === oConfig.rootIntent;
-        },
-
         /**
          * Shows an error message and navigates to the previous page.
          *
@@ -1956,14 +2059,14 @@ sap.ui.define([
             }
             this._setSideNavigationVisible(true);
 
-            const sAppHash = this.oShellNavigationInternal.hashChanger.getAppHash();
-            const sInnerAppRoute = sAppHash ? `&/${sAppHash}` : null;
+            const sShellHash = oResolvedHashFragment.sFixedShellHash;
+            const oParsedHash = UrlParsing.parseShellHash(sShellHash);
 
-            this.logOpenAppAction(oResolvedHashFragment, sInnerAppRoute).catch(() => {
-                Log.info("Opened application was not logged.", undefined, "sap.ushell.renderer.Shell.controller");
+            this.logOpenAppAction(oResolvedHashFragment, oParsedHash).catch((oError) => {
+                Log.info("Opened application was not logged.", oError, "sap.ushell.renderer.Shell.controller");
             });
 
-            this._notifyUITracer(oResolvedHashFragment);
+            this._notifyUITracer(oResolvedHashFragment, oParsedHash);
         },
 
         externalSearchTriggered: function (sChannelId, sEventId, oData) {
@@ -1988,55 +2091,48 @@ sap.ui.define([
          * Logs an application to the recent activities.
          *
          * @param {object} oResolvedHashFragment The resolved target intent
-         * @param {string} sInnerAppRoute The inner app route part of the intent
+         * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash The decomposed shell hash
          * @returns {Promise} A promise that is resolved once the action is logged
          * @throws {Error} If the application was not logged.
          */
-        logOpenAppAction: async function (oResolvedHashFragment, sInnerAppRoute) {
+        logOpenAppAction: async function (oResolvedHashFragment, oParsedHash) {
             const bEnableRecentActivity = Config.last("/core/shell/enableRecentActivity") && Config.last("/core/shell/enableRecentActivityLogging");
             if (!bEnableRecentActivity) {
                 throw new Error("Tracking of RecentActivity is disabled.");
             }
 
-            const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment);
-            // If the app is kept alive in the background, the fixedShellHash is often not supplied.
-            // In these cases, we then try to get the hash from the current location.
-            const sShellHash = oResolvedHashFragment.sFixedShellHash || this._getCurrentLocationHash();
+            const oMetadata = AppConfiguration.getMetadata(oResolvedHashFragment, oParsedHash);
+
             const oRecentEntry = {
                 title: oMetadata.title,
                 appType: AppType.APP, // default app type the shell adds is 'Application'
-                url: sInnerAppRoute ? sShellHash + sInnerAppRoute : sShellHash
+                url: UrlParsing.constructShellHash(oParsedHash, true)
             };
 
-            const oParsed = UrlParsing.parseShellHash(sShellHash);
-            if (oParsed) {
-                // This is the key that determines whether an existing activity should be updated or added.
+            // This is the key that determines whether an existing activity should be updated or added.
 
-                // In theory we could use the full hash without parameters here, however this causes the same application to be logged
-                // multiple times with the same title, confusing the user.
+            // In theory we could use the full hash without parameters here, however this causes the same application to be logged
+            // multiple times with the same title, confusing the user.
 
-                // Therefore we choose to update a previous entry in case just the parameters change. This might cause a bit of
-                // confusion in case another target mapping is opened, as the title of a previously logged entry would be updated
-                // instead of having a new title added to the recent activities (same target mapping but different title).
+            // Therefore we choose to update a previous entry in case just the parameters change. This might cause a bit of
+            // confusion in case another target mapping is opened, as the title of a previously logged entry would be updated
+            // instead of having a new title added to the recent activities (same target mapping but different title).
 
-                // Perhaps this could be further fixed by hashing a target mapping on the client before returning the resolution
-                // result, and using the hash as the id.
-                oRecentEntry.appId = `#${UrlParsing.constructShellHash({
-                    semanticObject: oParsed.semanticObject,
-                    action: oParsed.action
-                })}`;
-            } else {
-                oRecentEntry.appId = sShellHash;
-            }
+            // Perhaps this could be further fixed by hashing a target mapping on the client before returning the resolution
+            // result, and using the hash as the id.
+            oRecentEntry.appId = UrlParsing.constructBasicHash(oParsedHash, true);
 
             // The recent activity for searches is done in a different way, see this._logSearchActivity
-            if (sShellHash && sShellHash.indexOf("#Action-search") === -1 && sShellHash.indexOf("#Shell-startIntent") === -1) {
-                await ushellUtils.awaitTimeout(1500);
-                await this._logRecentActivity(oRecentEntry);
-                return;
+            const aSpecialCases = [
+                "#Action-search",
+                "#Shell-startIntent"
+            ];
+            if (aSpecialCases.includes(oRecentEntry.appId)) {
+                throw new Error("RecentActivity was not logged.");
             }
 
-            throw new Error("RecentActivity was not logged.");
+            await ushellUtils.awaitTimeout(1500);
+            await this._logRecentActivity(oRecentEntry);
         },
 
         /**
@@ -2044,13 +2140,19 @@ sap.ui.define([
          * a corresponding event on the event hub.
          *
          * @param {object} oResolvedHashFragment - the result of the NavTargetResolutionInternal service
+         * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash - the parsed shell hash
          */
-        _notifyUITracer: function (oResolvedHashFragment) {
+        _notifyUITracer: function (oResolvedHashFragment, oParsedHash) {
             try {
-                const sApplicationId =
-                    oResolvedHashFragment.reservedParameters?.["sap-fiori-id"]?.[0] ||
-                    oResolvedHashFragment.reservedParameters?.["sap-ui-app-id-hint"]?.[0] ||
-                    oResolvedHashFragment.ui5ComponentName;
+                const sApplicationId = oResolvedHashFragment.reservedParameters?.["sap-fiori-id"]?.[0]
+                    || oResolvedHashFragment.reservedParameters?.["sap-ui-app-id-hint"]?.[0]
+                    || oResolvedHashFragment.ui5ComponentName;
+
+                const oParsedHashWithoutInnerAppRoute = {
+                    ...oParsedHash,
+                    appSpecificRoute: undefined
+                };
+                const sHash = UrlParsing.constructShellHash(oParsedHashWithoutInnerAppRoute, true);
 
                 EventHub.emit("UITracer.trace", {
                     reason: "NavigateApp",
@@ -2058,7 +2160,7 @@ sap.ui.define([
                     data: {
                         applicationId: sApplicationId || "",
                         applicationType: oResolvedHashFragment.applicationType || "",
-                        hash: oResolvedHashFragment.sFixedShellHash || "",
+                        hash: sHash,
                         targetNavigationMode: oResolvedHashFragment.targetNavigationMode || "",
                         providerId: oResolvedHashFragment.contentProviderId || "",
                         targetUrl: oResolvedHashFragment.url || ""
@@ -2436,8 +2538,8 @@ sap.ui.define([
             EventHub.emit("showNotifications", bSelected);
         },
 
-        _isFLPIntent: function (sHash) {
-            const sBasicHash = UrlParsing.getBasicHash(sHash);
+        _isFLPIntent: function (oParsedHash) {
+            const sBasicHash = UrlParsing.constructBasicHash(oParsedHash);
             const aFLPIntents = [
                 "Shell-home",
                 "Shell-appfinder",

package/src/main/js/sap/ushell/renderer/Shell.view.js

@@ -489,7 +489,7 @@ sap.ui.define([
             const addDanglingControl = this.addDanglingControl.bind(this);
             let oUserActionsMenuAvatar;
             if (Config.last("/core/shellBar/enabled")) {
-                sap.ui.require(["sap/ushell/gen/ui5/webcomponents/dist/Avatar", "sap/m/Image"], (AvatarWC, Image) => {
+                sap.ui.require(["sap/f/gen/ui5/webcomponents/dist/Avatar", "sap/m/Image"], (AvatarWC, Image) => {
                     oUserActionsMenuAvatar = new AvatarWC({
                         id: "userActionsMenuHeaderButton",
                         icon: "sap-icon://person-placeholder",