@shopgate/engage 7.30.0 → 7.30.1-beta.2

package/core/actions/grantPermissions.js

@@ -1,22 +1,33 @@
 import event from '@shopgate/pwa-core/classes/Event';
 import { openAppSettings } from '@shopgate/engage/core/commands';
 import { showModal } from '@shopgate/engage/core/actions';
-import { PERMISSION_STATUS_DENIED, PERMISSION_STATUS_GRANTED, PERMISSION_STATUS_NOT_DETERMINED, PERMISSION_STATUS_NOT_SUPPORTED, APP_EVENT_APPLICATION_WILL_ENTER_FOREGROUND, availablePermissionsIds } from '@shopgate/engage/core/constants';
+import { getIsAndroidApp } from '@shopgate/engage/core/selectors';
+import { PERMISSION_ID_LOCATION, PERMISSION_ID_BACKGROUND_LOCATION, PERMISSION_ID_CAMERA, PERMISSION_STATUS_DENIED, PERMISSION_STATUS_GRANTED, PERMISSION_STATUS_NOT_DETERMINED, PERMISSION_STATUS_NOT_SUPPORTED, PERMISSION_USAGE_ALWAYS, APP_EVENT_APPLICATION_WILL_ENTER_FOREGROUND, availablePermissionsIds } from '@shopgate/engage/core/constants';
 import { logger, hasSGJavaScriptBridge, hasWebBridge } from '@shopgate/engage/core/helpers';
 import { softOptInShown, softOptInSelected, hardOptInShown, hardOptInSelected } from "../action-creators";
 import requestAppPermission from "./requestAppPermission";
 import requestAppPermissionStatus from "./requestAppPermissionStatus";
 import { createMockedPermissions } from "../helpers/appPermissions";
 
+// List of permissions that need a timing based user interaction check on Android, since we can't
+// reliably handle this in the native layer.
+const ANDROID_PERMISSIONS_WITH_USER_INTERACTION_CHECK = [PERMISSION_ID_LOCATION, PERMISSION_ID_BACKGROUND_LOCATION, PERMISSION_ID_CAMERA];
+
 /**
  * Determines the current state of a specific permission for an app feature. If not already
  * happened, the user will be prompted to grant permissions.
+ *
  * The action returns a promise which resolves with a boolean value, that indicates the state.
+ *
+ * When the "resolveWithData" option is set to TRUE, the promise will resolve with an object
+ * containing the permission status and additional data, instead of a boolean value.
  * @param {Object} options Action options.
  * @param {string} options.permissionId The id of the permission to request.
+ * @param {Object} [options.permissionOptions={}] Additional options for the permission request.
  * @param {boolean} [options.useSettingsModal=false] Whether in case of declined permissions a modal
  * shall be presented, which redirects to the app settings.
- * @param {boolean} [options.useRationaleModal=false] Whether a rational modal should be shown
+ * @param {boolean} [options.useRationaleModal=false] Whether a rational modal should be shown that
+ * describes why the permission is needed before requesting the permission.
  * @param {Object} [options.rationaleModal={}] Options for the rationale modal.
  * @param {string} options.rationaleModal.title Modal title.
  * @param {string} options.rationaleModal.message Modal message.
@@ -31,14 +42,16 @@ import { createMockedPermissions } from "../helpers/appPermissions";
  * @param {Object} options.modal.params Additional parameters for i18n strings.
  * @param {boolean} [options.requestPermissions=true] If set to TRUE no permissions will be
  * requested if not already granted,
- * @param {boolean} [options.resolveWithData=false] If set to TRUE the Promise will resolve with
- * data if available (e.g. geolocation).
+ * @param {boolean} [options.resolveWithData=true] When set to TRUE the promise will resolve with
+ * an object containing the permission status and whether the opt-in dialog was shown,
+ * instead of a boolean value.
  * @param {Object} [options.meta={}] Additional meta data used for opt-in tracking actions
  * @return { Function } A redux thunk.
  */
-const grantPermissions = (options = {}) => dispatch => new Promise(async resolve => {
+const grantPermissions = (options = {}) => (dispatch, getState) => new Promise(async resolve => {
   const {
     permissionId,
+    permissionOptions,
     useSettingsModal = false,
     useRationaleModal = false,
     rationaleModal: rationaleModalOptions = {},
@@ -48,6 +61,8 @@ const grantPermissions = (options = {}) => dispatch => new Promise(async resolve
     meta = {}
   } = options;
   let dispatchMock;
+  let optInRequested = false;
+  const isAndroidApp = getIsAndroidApp(getState());
   if (!hasSGJavaScriptBridge() || hasWebBridge()) {
     /**
      * The fallbackStatus will be used at browsers that don't support the permissions API. By
@@ -60,30 +75,54 @@ const grantPermissions = (options = {}) => dispatch => new Promise(async resolve
   }
   if (!availablePermissionsIds.includes(permissionId)) {
     logger.error('grandPermissions: %s is no valid permission id', permissionId);
-    resolve(false);
+    resolve(resolveWithData ? {
+      success: false,
+      optInRequested
+    } : false);
     return;
   }
   let status;
+  let appPermissionOptions;
   let data;
 
   // Check the current status of the camera permissions.
   ({
-    status
+    status,
+    options: appPermissionOptions
   } = await dispatch(requestAppPermissionStatus({
     permissionId,
     dispatchMock
   })));
 
+  // When the location permission is requested for "always" usage and the permissions where already
+  // granted for "whenInUse" we need to trigger the permission request again to get extended
+  // permissions.
+  const upgradeLocationPermission = permissionId === PERMISSION_ID_LOCATION && permissionOptions?.usage === PERMISSION_USAGE_ALWAYS && status === PERMISSION_STATUS_GRANTED;
+
   // Stop the process when the permission type is not supported.
   if (status === PERMISSION_STATUS_NOT_SUPPORTED) {
-    resolve(false);
+    resolve(resolveWithData ? {
+      success: false,
+      optInRequested,
+      status,
+      ...(appPermissionOptions ? {
+        options: appPermissionOptions
+      } : {})
+    } : false);
     return;
   }
 
   // The user never seen the permissions dialog yet, or temporary denied the permissions (Android).
-  if (status === PERMISSION_STATUS_NOT_DETERMINED) {
+  if (status === PERMISSION_STATUS_NOT_DETERMINED || upgradeLocationPermission) {
     if (!requestPermissions) {
-      resolve(false);
+      resolve(resolveWithData ? {
+        success: false,
+        optInRequested,
+        status,
+        ...(appPermissionOptions ? {
+          options: appPermissionOptions
+        } : {})
+      } : false);
       return;
     }
     if (useRationaleModal) {
@@ -101,7 +140,14 @@ const grantPermissions = (options = {}) => dispatch => new Promise(async resolve
         meta
       }));
       if (requestAllowed === false) {
-        resolve(false);
+        resolve(resolveWithData ? {
+          success: false,
+          optInRequested,
+          status,
+          ...(appPermissionOptions ? {
+            options: appPermissionOptions
+          } : {})
+        } : false);
         return;
       }
     }
@@ -109,15 +155,42 @@ const grantPermissions = (options = {}) => dispatch => new Promise(async resolve
       permissionId,
       meta
     }));
+    const tsBeforeRequest = Date.now();
+    let nativeRequestDuration;
 
     // Trigger the native permissions dialog.
     ({
       status,
-      data
+      data,
+      options: appPermissionOptions,
+      duration: nativeRequestDuration
     } = await dispatch(requestAppPermission({
       permissionId,
-      dispatchMock
+      dispatchMock,
+      ...(permissionOptions ? {
+        options: permissionOptions
+      } : {})
     })));
+    let wasUserInteraction = true;
+
+    /**
+     * On iOS it's not possible to get "notDetermined" status for "always" location permissions.
+     * So we might run into this decision branch of the code for when "always" permissions are
+     * requested, even if we don't know if a dialog will be shown.
+     * We can only guess that the user interacted with the dialog and if we might need to show
+     * the settings modal.
+     *
+     * Additionally, at some permissions requests on Android we can't prevent that the
+     * getPermissions request returns "notDetermined" since there is an user option to ask for
+     * permission acceptance every time its needed. So we also need to try a user interaction guess.
+     */
+    if (upgradeLocationPermission || isAndroidApp && ANDROID_PERMISSIONS_WITH_USER_INTERACTION_CHECK.includes(permissionId)) {
+      // When available, use the duration of the native request as heuristic for user interaction.
+      // It's more accurate, since it won't include the time that communication with the app takes.
+      const requestDuration = typeof nativeRequestDuration === 'number' ? nativeRequestDuration : Date.now() - tsBeforeRequest;
+      wasUserInteraction = requestDuration > 1000;
+    }
+    optInRequested = wasUserInteraction;
     dispatch(hardOptInSelected({
       permissionId,
       status,
@@ -126,19 +199,45 @@ const grantPermissions = (options = {}) => dispatch => new Promise(async resolve
 
     // The user denied the permissions within the native dialog.
     if ([PERMISSION_STATUS_DENIED, PERMISSION_STATUS_NOT_DETERMINED].includes(status)) {
-      resolve(false);
-      return;
+      if (wasUserInteraction) {
+        resolve(resolveWithData ? {
+          success: false,
+          optInRequested,
+          status,
+          ...(appPermissionOptions ? {
+            options: appPermissionOptions
+          } : {})
+        } : false);
+        return;
+      }
     }
   }
   if (status === PERMISSION_STATUS_GRANTED) {
-    resolve(resolveWithData && data ? data : true);
+    resolve(resolveWithData ? {
+      success: true,
+      optInRequested,
+      status,
+      ...(appPermissionOptions ? {
+        options: appPermissionOptions
+      } : {}),
+      ...(data !== undefined ? {
+        data
+      } : {})
+    } : true);
     return;
   }
 
   // The user permanently denied the permissions before.
   if (status === PERMISSION_STATUS_DENIED) {
     if (!useSettingsModal) {
-      resolve(false);
+      resolve(resolveWithData ? {
+        success: false,
+        optInRequested,
+        status,
+        ...(appPermissionOptions ? {
+          options: appPermissionOptions
+        } : {})
+      } : false);
       return;
     }
 
@@ -153,7 +252,14 @@ const grantPermissions = (options = {}) => dispatch => new Promise(async resolve
 
     // The user just closed the modal.
     if (!openSettings) {
-      resolve(false);
+      resolve(resolveWithData ? {
+        success: false,
+        optInRequested,
+        status,
+        ...(appPermissionOptions ? {
+          options: appPermissionOptions
+        } : {})
+      } : false);
       return;
     }
 
@@ -168,6 +274,14 @@ const grantPermissions = (options = {}) => dispatch => new Promise(async resolve
         permissionId
       })));
       resolve(status === PERMISSION_STATUS_GRANTED);
+      resolve(resolveWithData ? {
+        success: status === PERMISSION_STATUS_GRANTED,
+        optInRequested,
+        status,
+        ...(appPermissionOptions ? {
+          options: appPermissionOptions
+        } : {})
+      } : status === PERMISSION_STATUS_GRANTED);
     };
 
     /**

package/core/actions/grantPushPermissions.d.ts

@@ -0,0 +1,24 @@
+import type { UnknownAction } from 'redux';
+import type { ThunkAction } from 'redux-thunk';
+
+export type { GrantPermissionsOptions, GrantPermissionsResult } from './grantPermissions';
+export type { GrantPermissionsOptions, GrantPermissionsResult };
+
+/**
+ * Determines the current state of the push permissions.
+ * If not already happened, the user will be prompted to grant permissions.
+ *
+ * The action returns a promise which resolves with a boolean value, that indicates the state.
+ *
+ * When the "resolveWithData" option is set to TRUE, the promise will resolve with an object
+ * containing the permission status and additional data, instead of a boolean value.
+ */
+declare function grantPushPermissions<State = unknown>(
+  options: Omit<GrantPermissionsOptions, 'permissionId'> & { resolveWithData: true }
+): ThunkAction<Promise<GrantPermissionsResult>, State, unknown, UnknownAction>;
+
+declare function grantPushPermissions<State = unknown>(
+  options?: Omit<GrantPermissionsOptions, 'permissionId'> & { resolveWithData?: false | undefined }
+): ThunkAction<Promise<boolean>, State, unknown, UnknownAction>;
+
+export default grantPushPermissions;

package/core/actions/grantPushPermissions.js

@@ -22,15 +22,20 @@ import grantPermissions from "./grantPermissions";
  * @param {string} options.modal.dismiss Label for the dismiss button.
  * @param {Object} options.modal.params Additional parameters for i18n strings.
  * @param {Object} [options.meta={}] Additional meta data used for opt-in tracking actions
+ * @param {boolean} [options.resolveWithData=true] When set to TRUE the promise will resolve with
+ * an object containing the permission status and whether the opt-in dialog was shown,
+ * instead of a boolean value.
  * @return { Function } A redux thunk.
  */
 const grantPushPermissions = (options = {}) => dispatch => {
   const {
+    permissionId,
     useSettingsModal = true,
     useRationaleModal = false,
     modal = {},
     rationaleModal = {},
-    meta = {}
+    meta = {},
+    ...rest
   } = options;
   return dispatch(grantPermissions({
     permissionId: PERMISSION_ID_PUSH,
@@ -40,10 +45,12 @@ const grantPushPermissions = (options = {}) => dispatch => {
       title: null,
       message: 'permissions.access_denied.push_message',
       confirm: 'permissions.access_denied.settings_button',
+      dismiss: 'modal.dismiss',
       ...modal
     },
     rationaleModal,
-    meta
+    meta,
+    ...rest
   }));
 };
 export default grantPushPermissions;

package/core/actions/requestAppPermission.js

@@ -8,6 +8,8 @@ import { appPermissionStatusReceived } from "../action-creators";
  * Additionally it propagates the received status via the APP_PERMISSION_STATUS_RECEIVED action.
  * @param {Object} params The action params
  * @param {string} params.permissionId The desired app permission id
+ * @param {Object} [params.options={}] Additional options for the permission request.
+ * E.g. the usage object for geolocation permissions.
  * @param {Function} [params.dispatchMock=null] An optional mock for the request dispatch logic.
  * Usually used when PWA is running inside a browser and app command logic can be simulated via
  * browser APIs like for geolocation access.
@@ -15,6 +17,7 @@ import { appPermissionStatusReceived } from "../action-creators";
  */
 const requestAppPermission = ({
   permissionId,
+  options: requestOptions,
   dispatchMock: dispatchMockParam
 }) => async dispatch => {
   let dispatchMock = dispatchMockParam;
@@ -26,11 +29,15 @@ const requestAppPermission = ({
   const [{
     status,
     options,
-    data
+    data,
+    duration
   } = {
     status: PERMISSION_STATUS_NOT_SUPPORTED
   }] = (await requestAppPermissions([{
-    permissionId
+    permissionId,
+    ...(requestOptions ? {
+      options: requestOptions
+    } : {})
   }], dispatchMock)) ?? [];
   dispatch(appPermissionStatusReceived({
     permissionId,
@@ -39,7 +46,9 @@ const requestAppPermission = ({
   }));
   return {
     status,
-    data
+    options,
+    data,
+    duration
   };
 };
 export default requestAppPermission;

package/core/actions/requestAppPermissionStatus.js

@@ -36,7 +36,8 @@ const requestAppPermissionStatus = ({
     options
   }));
   return {
-    status
+    status,
+    options
   };
 };
 export default requestAppPermissionStatus;

package/core/config/config.reducers.js

@@ -6,7 +6,7 @@ import { REQUEST_CORE_CONFIG, RECEIVE_CORE_CONFIG, ERROR_CORE_CONFIG, CONFIG_LIF
  * @param {Object} action The action object.
  * @return {Object} The new state.
  */
-export default function config(state = {}, action) {
+export default function config(state = {}, action = {}) {
   switch (action.type) {
     case REQUEST_CORE_CONFIG:
       return {

package/core/config/config.selectors.js

@@ -1,12 +1,17 @@
 import { createSelector } from 'reselect';
 
+// Use a shared empty object so selectors that fall back to "no config"
+// remain referentially stable across calls with the same state value.
+// Fixes reselect warning about selector returning new value each time.
+const EMPTY_CONFIG = {};
+
 /**
  * Retrieves the config state from the store.
  * @param {Object} state The current application state.
  * @return {Object} The locations state.
  */
 function getState(state) {
-  return state?.settings?.config || {};
+  return state?.settings?.config || EMPTY_CONFIG;
 }
 
 /**

package/core/constants/index.js

@@ -45,4 +45,27 @@ export const EMPTY_OBJECT = Object.freeze({});
  * Helper constant that can be used as a return value in Redux selectors to prevent
  * unnecessary re-renders.
  */
-export const EMPTY_ARRAY = Object.freeze([]);
+export const EMPTY_ARRAY = Object.freeze([]);
+
+/**
+ * Virtual route to trigger a location permission request to the app.
+ */
+export const PERMISSION_REQUEST_ROUTE_LOCATION = '/permissions/location';
+/**
+ * Virtual route to trigger a background location permission request to the app.
+ */
+export const PERMISSION_REQUEST_ROUTE_LOCATION_BACKGROUND = '/permissions/location_background';
+/**
+ * Virtual route to trigger a push permission request to the app.
+ */
+export const PERMISSION_REQUEST_ROUTE_PUSH = '/permissions/push';
+/**
+ * Virtual route to trigger an app tracking transparency permission request to the app.
+ */
+export const PERMISSION_REQUEST_ROUTE_TRACKING = '/permissions/tracking';
+
+/**
+ * Virtual route to trigger a camera permission request to the app.
+ */
+export const PERMISSION_REQUEST_ROUTE_CAMERA = '/permissions/camera';
+export const PERMISSION_REQUEST_ROUTES = [PERMISSION_REQUEST_ROUTE_LOCATION, PERMISSION_REQUEST_ROUTE_LOCATION_BACKGROUND, PERMISSION_REQUEST_ROUTE_PUSH, PERMISSION_REQUEST_ROUTE_TRACKING, PERMISSION_REQUEST_ROUTE_CAMERA];

package/core/reducers/app.js

@@ -10,8 +10,7 @@ const defaultState = {
  * @param {Object} action The action object.
  * @returns {Object} The new state.
  */
-export default function app(state = defaultState, action) {
-  /* eslint-disable no-param-reassign */
+export default function app(state = defaultState, action = {}) {
   const producer = produce(draft => {
     switch (action.type) {
       case PWA_DID_APPEAR:
@@ -28,7 +27,5 @@ export default function app(state = defaultState, action) {
         break;
     }
   });
-  /* eslint-enable no-param-reassign */
-
   return producer(state);
 }

package/core/reducers/merchantSettings.js

@@ -21,8 +21,7 @@ const defaultState = {
  * @param {Object} action The action object.
  * @returns {Object} The new state.
  */
-export default function merchantSettings(state = defaultState, action) {
-  /* eslint-disable no-param-reassign */
+export default function merchantSettings(state = defaultState, action = {}) {
   const producer = produce(draft => {
     switch (action.type) {
       case RECEIVE_MERCHANT_SETTINGS:
@@ -36,7 +35,5 @@ export default function merchantSettings(state = defaultState, action) {
         break;
     }
   });
-
-  /* eslint-enable no-param-reassign */
   return producer(state);
 }

package/core/reducers/shopSettings.js

@@ -27,8 +27,7 @@ const defaultState = {
  * @param {Object} action The action object.
  * @returns {Object} The new state.
  */
-export default function shopSettings(state = defaultState, action) {
-  /* eslint-disable no-param-reassign */
+export default function shopSettings(state = defaultState, action = {}) {
   const producer = produce(draft => {
     switch (action.type) {
       case RECEIVE_SHOP_SETTINGS:
@@ -40,17 +39,15 @@ export default function shopSettings(state = defaultState, action) {
         }
       case ERROR_SHOP_SETTINGS:
         {
-          draft = {
+          Object.assign(draft, {
             ...defaultState,
             ...state
-          };
+          });
           break;
         }
       default:
         break;
     }
   });
-
-  /* eslint-enable no-param-reassign */
   return producer(state);
 }

package/core/router/permissionRouteRedirectHandler.js

@@ -0,0 +1,117 @@
+import { showModal } from '@shopgate/engage/core/actions';
+import { logger } from "../helpers";
+import { PERMISSION_REQUEST_ROUTE_LOCATION, PERMISSION_REQUEST_ROUTE_LOCATION_BACKGROUND, PERMISSION_REQUEST_ROUTE_PUSH, PERMISSION_REQUEST_ROUTE_TRACKING, PERMISSION_REQUEST_ROUTE_CAMERA, PERMISSION_STATUS_GRANTED } from "../constants";
+import { grantPushPermissions, grantAppTrackingTransparencyPermission, grantGeolocationPermissions, grantCameraPermissions } from "../actions";
+
+/**
+ * @typedef {import('redux-thunk').ThunkDispatch<
+ *   import('../store').RootState,
+ *   any,
+ *   import('redux').AnyAction
+ * >} AppDispatch
+ */
+
+/**
+ * @typedef {import('../actions/grantPermissions').GrantPermissionsResult} GrantPermissionsResult
+ */
+
+/**
+ * Handler for redirect collection handlers related to permission requests.
+ * @param {{ action: any, dispatch: AppDispatch }} params Handler params
+ */
+export const permissionRouteRedirectHandler = async ({
+  action,
+  dispatch
+}) => {
+  const {
+    route: {
+      pathname
+    } = {}
+  } = action;
+
+  /**
+   * @type {GrantPermissionsResult | undefined}
+   */
+  let result;
+  let grantedMessage;
+  const metaBase = {
+    context: 'permissionRoute'
+  };
+  switch (pathname) {
+    case PERMISSION_REQUEST_ROUTE_LOCATION:
+      {
+        result = await dispatch(grantGeolocationPermissions({
+          useSettingsModal: true,
+          resolveWithData: true,
+          meta: {
+            ...metaBase,
+            permission: 'location'
+          }
+        }));
+        grantedMessage = 'permissions.accessGranted.locationMessage';
+        break;
+      }
+    case PERMISSION_REQUEST_ROUTE_LOCATION_BACKGROUND:
+      {
+        result = await dispatch(grantGeolocationPermissions({
+          useSettingsModal: true,
+          requireBackgroundAccess: true,
+          resolveWithData: true,
+          meta: {
+            ...metaBase,
+            permission: 'backgroundLocation'
+          }
+        }));
+        grantedMessage = 'permissions.accessGranted.backgroundLocationMessage';
+        break;
+      }
+    case PERMISSION_REQUEST_ROUTE_PUSH:
+      {
+        result = await dispatch(grantPushPermissions({
+          useSettingsModal: true,
+          resolveWithData: true,
+          meta: {
+            ...metaBase,
+            permission: 'push'
+          }
+        }));
+        grantedMessage = 'permissions.accessGranted.pushMessage';
+        break;
+      }
+    case PERMISSION_REQUEST_ROUTE_TRACKING:
+      {
+        result = await dispatch(grantAppTrackingTransparencyPermission({
+          useSettingsModal: true,
+          resolveWithData: true,
+          meta: {
+            ...metaBase,
+            permission: 'tracking'
+          }
+        }));
+        grantedMessage = 'permissions.accessGranted.trackingMessage';
+        break;
+      }
+    case PERMISSION_REQUEST_ROUTE_CAMERA:
+      {
+        result = await dispatch(grantCameraPermissions({
+          useSettingsModal: true,
+          resolveWithData: true,
+          meta: {
+            ...metaBase,
+            permission: 'camera'
+          }
+        }));
+        grantedMessage = 'permissions.accessGranted.cameraMessage';
+        break;
+      }
+    default:
+      logger.warn('Unknown permission request route', pathname);
+  }
+  if (result?.status === PERMISSION_STATUS_GRANTED && result?.optInRequested === false) {
+    dispatch(showModal({
+      message: grantedMessage,
+      confirm: 'modal.ok',
+      dismiss: ''
+    }));
+  }
+};

package/core/subscriptions/app.js

@@ -1,14 +1,15 @@
 import { appWillStart$ } from '@shopgate/engage/core/streams';
-import { configuration } from '@shopgate/engage/core/collections';
+import { configuration, redirects } from '@shopgate/engage/core/collections';
 import { hasNewServices, appSupportsAndroidEdgeToEdge, updateAndroidNavigationBarColor } from '@shopgate/engage/core/helpers';
 import { CONFIGURATION_COLLECTION_KEY_BASE_URL } from '@shopgate/engage/core/constants';
 import { appConfig } from '@shopgate/engage';
 import { reloadApp$ } from "../streams";
 import { reloadApp } from "../action-creators";
+import { PERMISSION_REQUEST_ROUTE_LOCATION, PERMISSION_REQUEST_ROUTE_LOCATION_BACKGROUND, PERMISSION_REQUEST_ROUTE_PUSH, PERMISSION_REQUEST_ROUTE_TRACKING, PERMISSION_REQUEST_ROUTE_CAMERA } from "../constants";
+import { permissionRouteRedirectHandler } from "../router/permissionRouteRedirectHandler";
 const {
   androidNavigationBarDefaultColor
 } = appConfig;
-
 /**
  * App subscriptions
  * @param {Function} subscribe The subscribe function
@@ -29,6 +30,13 @@ export default function app(subscribe) {
         color: androidNavigationBarDefaultColor
       });
     }
+
+    // Register redirects for app permission request routes
+    redirects.set(PERMISSION_REQUEST_ROUTE_LOCATION, permissionRouteRedirectHandler);
+    redirects.set(PERMISSION_REQUEST_ROUTE_LOCATION_BACKGROUND, permissionRouteRedirectHandler);
+    redirects.set(PERMISSION_REQUEST_ROUTE_PUSH, permissionRouteRedirectHandler);
+    redirects.set(PERMISSION_REQUEST_ROUTE_TRACKING, permissionRouteRedirectHandler);
+    redirects.set(PERMISSION_REQUEST_ROUTE_CAMERA, permissionRouteRedirectHandler);
   });
   subscribe(reloadApp$, () => {
     // A deployed app can only be reloaded on the base url. So we first set this as current route

package/development/reducers/settings.js

@@ -21,8 +21,7 @@ const initialState = {
  * @param {Object} action The redux action.
  * @returns {Object}
  */
-export default function settingsReducer(state = initialState, action) {
-  /* eslint-disable no-param-reassign */
+export default function settingsReducer(state = initialState, action = {}) {
   const producer = produce(/** @param {DevToolsSettingsState} draft The draft */draft => {
     switch (action.type) {
       case DEVELOPMENT_TOOLS_TOGGLE_INSETS:
@@ -48,6 +47,5 @@ export default function settingsReducer(state = initialState, action) {
         break;
     }
   });
-  /* eslint-enable no-param-reassign */
   return producer(state);
 }