@dashx/react-native 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,64 @@
 
 All notable changes to `@dashx/react-native` are documented in this file. Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), versions follow [SemVer](https://semver.org/).
 
+## [1.5.0] — 2026-10-28
+
+### Required upgrade steps
+
+1. **Bump the dashx-ios pod tag to 1.6.1 in your `ios/Podfile`**. `pod install` refuses the upgrade otherwise, because the podspec floor is now `>= 1.6.1`:
+
+   ```ruby
+   pod 'DashX/SDK', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.6.1'
+   ```
+
+### Breaking
+
+- **Automatic events are renamed by the native SDKs**, now dashx-ios 1.6.1 and dashx-android 1.5.0. Screen views are `$screen` with the screen name in `$screen_name` (was `Screen Viewed` with `name`), `dx_deep_link_opened` is `Deep Link Opened` and `dx_notification_navigated` is `Push Notification Tapped`, with their data unchanged. Reports, flows or filters on the old names or the `name` key need updating. Lifecycle event names and keys are unchanged.
+
+### Added
+
+- **`DashX.enableLifecycleTracking()` on Android.** Previously iOS only (a no-op on Android). It now registers the dashx-android activity lifecycle callbacks with the application context. Call it after `configure`. With dashx-android 1.5.0 these are app-level: one launch event per cold start, `Application Opened` with `from_background` on return and `Application Backgrounded` on leaving, not one per Activity change.
+- **`DashX.trackNavigation(navigationRef)`** for React Navigation. Sends a screen view for the current route once the `NavigationContainer` is ready, then one per change of the focused route's name, and returns a function that stops tracking. Screen views go through `DashX.screen`, which the native SDKs record as `$screen` with the route name in `$screen_name`. Route params are not sent. Works with any React Navigation version through its container ref, without a dependency on `@react-navigation/*`. Prefer it over native screen tracking: React Native screens are routes, not native view controllers or activities.
+
+## [1.4.1] — 2026-05-06
+
+### Required upgrade steps
+
+1. **Bump the dashx-ios pod tag to 1.5.1 in your `ios/Podfile`** — `pod install` will refuse the upgrade otherwise (the podspec floor is now `>= 1.5.1`):
+
+   ```ruby
+   pod 'DashX/SDK', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.5.1'
+   ```
+
+   The floor is required because earlier dashx-ios versions either fall back to silent-push on the backend (pre-1.3.0, throttled by iOS) or omit `.timeSensitive` from the authorization request (pre-1.5.1, causing `interruption-level: time-sensitive` payloads to silently downgrade and stay filterable by Focus / Reduce Interruptions / Scheduled Summary on iOS 18 / 26).
+
+2. **Wire `fallbackToSettings: true` somewhere in your permission UI** to recover existing iOS users — fresh installs are auto-fixed by the upgrade, but users who already granted notification permission under the old SDK keep an `.authorized` state without the time-sensitive entitlement, and Apple's `requestAuthorization` is a one-shot grant that can't be silently upgraded. They have to flip the **Time Sensitive Notifications** toggle in iOS Settings themselves.
+
+   ```js
+   // From a "Notifications acting up?" affordance, or as a one-time
+   // post-upgrade prompt:
+   await DashX.requestNotificationPermission({ fallbackToSettings: true });
+   ```
+
+   When the user is already determined (granted or denied on iOS / permanently denied on Android), this opens the system notification settings page instead of firing a futile `requestAuthorization`. Without this step, your existing iOS users will keep experiencing the original "intermittent / second attempt works" symptom even after upgrading to 1.4.1.
+
+### Migration
+
+- **Consumers who subclass `DashXReactNativeModuleImpl`** and override `requestNotificationPermission(promise:)` need to update the override signature to `requestNotificationPermission(fallbackToSettings: Boolean, promise: Promise)`. Otherwise Kotlin's override resolution silently drops to the impl's version and your custom logic stops running. Same applies to anyone subclassing the new-arch / old-arch `DashXReactNativeModule` wrappers. Most consumers don't subclass these — flagged here for the few that do.
+
+### Added
+
+- **`DashX.requestNotificationPermission({ fallbackToSettings })`.** Optional flag, default `false`. When `true`, the SDK detects platform-specific dead-ends and opens the system notification-settings page instead of firing a futile prompt:
+  - **iOS** — already granted or denied (iOS no-ops `requestAuthorization` in that state).
+  - **Android** — `POST_NOTIFICATIONS` permanently denied (Android 13+, two-strikes rule). `requestPermissions()` auto-resolves DENIED without UI in that state.
+
+  Existing call sites (`DashX.requestNotificationPermission()` with no arguments) compile and behave unchanged.
+
+### Fixed
+
+- **Foreground push duplicate-display race in `DashXNotificationHandler.handleRemoteNotification`.** Now short-circuits when the payload already carries `aps.alert`, letting iOS render the notification natively via NSE / `willPresent` instead of racing a duplicate `UNUserNotificationCenter.add(...)` against it. Without the short-circuit the local re-add could clobber the NSE-attached image or briefly flicker on screen.
+- **Suspension race in the image-attached reconstruction path.** The `fetchCompletionHandler` now fires only after the async image download and the local `add()` both complete, with a 25-second budget under iOS's background-push limit. Previously the handler fired immediately while the download was still in flight, letting iOS suspend the process before the notification actually displayed.
+
 ## [1.4.0] — 2026-04-27
 
 ### Changed

package/DashXReactNative.podspec

@@ -21,10 +21,13 @@ Pod::Spec.new do |s|
   install_modules_dependencies(s)
 
   # DashX iOS SDK — consumers must provide the source in their Podfile:
-  #   pod 'DashX/SDK', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.5.0'
+  #   pod 'DashX/SDK', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.6.1'
   # For local development:
   #   pod 'DashX', :path => '../dashx-ios'
-  s.dependency "DashX/SDK"
+  #
+  # Floor of 1.6.1, the first release whose automatic event names match
+  # dashx-android 1.5.0 ($screen, Deep Link Opened, Push Notification Tapped).
+  s.dependency "DashX/SDK", ">= 1.6.1"
 
   # Hard dependency so that `canImport(FirebaseMessaging)`
   # evaluates at this pod's compile time, where consumer-Podfile pods aren't

package/README.md

@@ -1,6 +1,6 @@
 <p align="center">
     <br />
-    <a href="https://dashx.com"><img src="https://raw.githubusercontent.com/dashxhq/brand-book/master/assets/logo-black-text-color-icon@2x.png" alt="DashX" height="40" /></a>
+    <a href="https://dashx.com"><img src="https://raw.githubusercontent.com/dashxhq/dashx-brand-book/master/assets/logo-black-text-color-icon@2x.png" alt="DashX" height="40" /></a>
     <br />
     <br />
     <strong>Your All-in-One Product Stack</strong>
@@ -46,6 +46,44 @@ yarn add @dashx/react-native
 
 For detailed documentation, visit [React Native SDK documentation](https://docs.dashx.com/sdks/client-side/react-native-sdk).
 
+## Automatic events
+
+### App lifecycle
+
+On iOS and Android, call `enableLifecycleTracking()` after `configure` to send these events:
+
+- `Application Installed` and `Application Updated` on the first launch of a new install or build
+- `Application Opened` on launch and when returning to the foreground (`from_background`)
+- `Application Backgrounded` when the app leaves the foreground (`session_length`, in seconds)
+- `Application Crashed` on an uncaught native exception (iOS only)
+
+```js
+DashX.configure({ publicKey: 'YOUR_PUBLIC_KEY' });
+DashX.enableLifecycleTracking();
+```
+
+### Screen views with React Navigation
+
+React Native screens are routes rather than native screens, so track them from the navigation container. `trackNavigation` sends `DashX.screen(route.name)`, recorded as `$screen` with the route name in `$screen_name`, for the first route and then whenever the focused route's name changes. Route params are not sent. Call it from `onReady` so the first screen is captured; it returns a function that stops tracking.
+
+```jsx
+import { NavigationContainer, useNavigationContainerRef } from '@react-navigation/native';
+import DashX from '@dashx/react-native';
+
+export default function App() {
+  const navigationRef = useNavigationContainerRef();
+
+  return (
+    <NavigationContainer
+      ref={navigationRef}
+      onReady={() => DashX.trackNavigation(navigationRef)}
+    >
+      {/* ... */}
+    </NavigationContainer>
+  );
+}
+```
+
 ## Deep linking and push navigation
 
 See the [Deep Linking & Push Navigation](https://docs.dashx.com/apps/messaging/deep-linking) guide for setup instructions, payload fields, and code examples.

package/__tests__/index.test.js

@@ -579,3 +579,124 @@ describe('onLinkReceived', () => {
     expect(subscription).toBeDefined();
   });
 });
+
+// --- enableLifecycleTracking ---
+
+describe('enableLifecycleTracking', () => {
+  it.each(['ios', 'android'])('calls native on %s', (os) => {
+    const { Platform } = require('react-native');
+    Platform.OS = os;
+    DashX.enableLifecycleTracking();
+    expect(mockNativeModule.enableLifecycleTracking).toHaveBeenCalledTimes(1);
+    Platform.OS = 'ios';
+  });
+});
+
+// --- trackNavigation ---
+
+function createNavigationRef({ ready = true, routeName = 'Home' } = {}) {
+  const listeners = [];
+  const ref = {
+    ready,
+    route: routeName ? { name: routeName } : undefined,
+    addListener: jest.fn((event, callback) => {
+      listeners.push({ event, callback });
+      return jest.fn(() => {
+        const index = listeners.findIndex((l) => l.callback === callback);
+        if (index !== -1) listeners.splice(index, 1);
+      });
+    }),
+    getCurrentRoute: jest.fn(() => ref.route),
+    isReady: jest.fn(() => ref.ready),
+    navigate(name, params) {
+      ref.route = { name, params };
+      ref.emitState();
+    },
+    emitState() {
+      listeners
+        .filter((l) => l.event === 'state')
+        .forEach((l) => l.callback({ data: { state: {} } }));
+    },
+  };
+  return ref;
+}
+
+describe('trackNavigation', () => {
+  it('sends the current route once when the ref is ready', () => {
+    const ref = createNavigationRef();
+    DashX.trackNavigation(ref);
+    expect(mockNativeModule.screen).toHaveBeenCalledTimes(1);
+    expect(mockNativeModule.screen).toHaveBeenCalledWith('Home', null);
+    expect(ref.addListener).toHaveBeenCalledWith('state', expect.any(Function));
+  });
+
+  it('waits for readiness before sending the first screen', () => {
+    const ref = createNavigationRef({ ready: false });
+    DashX.trackNavigation(ref);
+    expect(ref.getCurrentRoute).not.toHaveBeenCalled();
+    expect(mockNativeModule.screen).not.toHaveBeenCalled();
+
+    ref.ready = true;
+    ref.emitState();
+    expect(mockNativeModule.screen).toHaveBeenCalledTimes(1);
+    expect(mockNativeModule.screen).toHaveBeenCalledWith('Home', null);
+  });
+
+  it('does not resend when the route name is unchanged', () => {
+    const ref = createNavigationRef();
+    DashX.trackNavigation(ref);
+    ref.emitState();
+    ref.navigate('Home', { tab: 'feed' });
+    expect(mockNativeModule.screen).toHaveBeenCalledTimes(1);
+  });
+
+  it('sends the new route name on a route change, without params', () => {
+    const ref = createNavigationRef();
+    DashX.trackNavigation(ref);
+    ref.navigate('Profile', { userId: 'u_1' });
+    ref.navigate('Home');
+    expect(mockNativeModule.screen.mock.calls).toEqual([
+      ['Home', null],
+      ['Profile', null],
+      ['Home', null],
+    ]);
+  });
+
+  it('stops sending after unsubscribe', () => {
+    const ref = createNavigationRef();
+    const stop = DashX.trackNavigation(ref);
+    stop();
+    ref.navigate('Profile');
+    expect(mockNativeModule.screen).toHaveBeenCalledTimes(1);
+  });
+
+  it('resolves a plain React ref through current', () => {
+    const navigation = createNavigationRef();
+    DashX.trackNavigation({ current: navigation });
+    navigation.navigate('Profile');
+    expect(mockNativeModule.screen.mock.calls).toEqual([
+      ['Home', null],
+      ['Profile', null],
+    ]);
+  });
+
+  it('warns and returns a no-op when a plain ref has a null current', () => {
+    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const stop = DashX.trackNavigation({ current: null });
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('navigationRef.current is null')
+    );
+    expect(() => stop()).not.toThrow();
+    expect(mockNativeModule.screen).not.toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
+  it('throws on a value that is not a navigation ref', () => {
+    expect(() => DashX.trackNavigation(null)).toThrow(
+      'navigationRef must be a NavigationContainer ref'
+    );
+    expect(() => DashX.trackNavigation({ current: {} })).toThrow(
+      'navigationRef must be a NavigationContainer ref'
+    );
+  });
+});

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +1,2 @@
-#Mon Apr 06 11:08:39 IST 2026
+#Wed Oct 28 17:37:15 IST 2026
 gradle.version=8.14.3

package/android/build.gradle

@@ -109,7 +109,7 @@ dependencies {
     // Ensure Firebase Messaging types are available for FCM service subclass
     implementation 'com.google.firebase:firebase-messaging-ktx:23.1.2'
 
-    implementation "com.dashx:dashx-android:1.2.8"
+    implementation "com.dashx:dashx-android:1.5.0"
 
     // Unit tests for `util/Utils.kt` — JVM-only, no Robolectric. The RN
     // `react-android` artifact is pulled in at test runtime (not as a

package/android/src/main/java/com/dashx/rn/sdk/DashXReactNativeModuleImpl.kt

@@ -5,12 +5,15 @@ import android.app.Activity
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.content.Context
+import android.content.Intent
 import android.content.pm.PackageManager
 import android.os.Build
+import android.provider.Settings
 import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
 import com.dashx.rn.sdk.util.*
 import com.dashx.android.DashX
+import com.dashx.android.DashXActivityLifecycleCallbacks
 import com.dashx.android.DashXLog
 import com.dashx.android.DashXLog.LogLevel
 import com.dashx.android.data.Asset
@@ -275,12 +278,16 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
         )
     }
 
-    // --- iOS-only methods: no-op stubs on Android (JS guards prevent these from being called) ---
-
     fun enableLifecycleTracking() {
-        // iOS-only; no-op on Android
+        // The SDK's tracking flags are unsynchronized statics read on the main thread.
+        val application = reactContext.applicationContext
+        UiThreadUtil.runOnUiThread {
+            DashXActivityLifecycleCallbacks.enableActivityLifecycleTracking(application)
+        }
     }
 
+    // --- iOS-only methods: no-op stubs on Android (JS guards prevent these from being called) ---
+
     fun enableAdTracking() {
         // iOS-only; no-op on Android
     }
@@ -330,7 +337,7 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
         )
     }
 
-    fun requestNotificationPermission(promise: Promise) {
+    fun requestNotificationPermission(fallbackToSettings: Boolean, promise: Promise) {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
             promise.resolve(PERMISSION_AUTHORIZED)
             return
@@ -345,14 +352,36 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
             return
         }
 
-        val activity = reactContext.currentActivity as? PermissionAwareActivity
+        val activity = reactContext.currentActivity
         if (activity == null) {
             promise.reject(E_UNSPECIFIED, "No current activity to request permission from")
             return
         }
 
-        reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-            .edit()
+        // "Permanently denied" detection on Android 13+: we asked at least
+        // once before AND the system says we shouldn't show a rationale.
+        // In that state `requestPermissions()` auto-resolves DENIED without
+        // any UI, so re-prompting is futile — Settings is the only path.
+        val prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val previouslyRequested = prefs.getBoolean(KEY_PERMISSION_REQUESTED, false)
+        val permanentlyDenied = previouslyRequested && !ActivityCompat.shouldShowRequestPermissionRationale(
+            activity,
+            Manifest.permission.POST_NOTIFICATIONS
+        )
+
+        if (fallbackToSettings && permanentlyDenied) {
+            openAppNotificationSettings()
+            promise.resolve(PERMISSION_DENIED)
+            return
+        }
+
+        val permAwareActivity = activity as? PermissionAwareActivity
+        if (permAwareActivity == null) {
+            promise.reject(E_UNSPECIFIED, "Activity does not support permission requests")
+            return
+        }
+
+        prefs.edit()
             .putBoolean(KEY_PERMISSION_REQUESTED, true)
             .apply()
 
@@ -363,13 +392,21 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
             true
         }
 
-        activity.requestPermissions(
+        permAwareActivity.requestPermissions(
             arrayOf(Manifest.permission.POST_NOTIFICATIONS),
             NOTIFICATION_PERMISSION_REQUEST_CODE,
             listener
         )
     }
 
+    private fun openAppNotificationSettings() {
+        val intent = Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS).apply {
+            putExtra(Settings.EXTRA_APP_PACKAGE, reactContext.packageName)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+        reactContext.startActivity(intent)
+    }
+
     fun getNotificationPermissionStatus(promise: Promise) {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
             promise.resolve(PERMISSION_AUTHORIZED)

package/android/src/newarch/java/com/dashx/rn/sdk/DashXReactNativeModule.kt

@@ -69,8 +69,8 @@ class DashXReactNativeModule(reactContext: ReactApplicationContext) :
 
     override fun fetchAsset(assetId: String, promise: Promise) = impl.fetchAsset(assetId, promise)
 
-    override fun requestNotificationPermission(promise: Promise) =
-        impl.requestNotificationPermission(promise)
+    override fun requestNotificationPermission(fallbackToSettings: Boolean, promise: Promise) =
+        impl.requestNotificationPermission(fallbackToSettings, promise)
 
     override fun getNotificationPermissionStatus(promise: Promise) =
         impl.getNotificationPermissionStatus(promise)

package/android/src/oldarch/java/com/dashx/rn/sdk/DashXReactNativeModule.kt

@@ -87,8 +87,8 @@ class DashXReactNativeModule(reactContext: ReactApplicationContext) :
     fun fetchAsset(assetId: String, promise: Promise) = impl.fetchAsset(assetId, promise)
 
     @ReactMethod
-    fun requestNotificationPermission(promise: Promise) =
-        impl.requestNotificationPermission(promise)
+    fun requestNotificationPermission(fallbackToSettings: Boolean, promise: Promise) =
+        impl.requestNotificationPermission(fallbackToSettings, promise)
 
     @ReactMethod
     fun getNotificationPermissionStatus(promise: Promise) =

package/index.d.ts

@@ -85,6 +85,21 @@ export interface ProcessURLOptions {
   forwardToLinkHandler?: boolean;
 }
 
+export interface NavigationRouteLike {
+  name: string;
+  params?: object;
+}
+
+/**
+ * The subset of a React Navigation `NavigationContainer` ref used by
+ * `trackNavigation`, so this package does not depend on `@react-navigation/*`.
+ */
+export interface NavigationContainerLike {
+  addListener(event: 'state', callback: (event: unknown) => void): () => void;
+  getCurrentRoute(): NavigationRouteLike | undefined;
+  isReady?(): boolean;
+}
+
 export interface DashXInstance {
   /**
    * Initialize the SDK with your public key and optional configuration.
@@ -206,10 +221,38 @@ export interface DashXInstance {
   fetchAsset(assetId: string): Promise<AssetResponse>;
 
   /**
-   * Enable automatic app lifecycle event tracking (iOS only).
+   * Enable automatic app lifecycle events (install, update, open, background)
+   * on iOS and Android. Call after `configure`.
    */
   enableLifecycleTracking(): void;
 
+  /**
+   * Send a screen view for each React Navigation route change. Sends the
+   * current route once the container is ready, then `screen(route.name)`
+   * whenever the focused route's name changes (params are not sent).
+   * Returns a function that stops tracking.
+   *
+   * Call it from `NavigationContainer`'s `onReady` so the first screen is
+   * captured. A ref from `useNavigationContainerRef()` or
+   * `createNavigationContainerRef()` may also be passed before the container
+   * mounts.
+   *
+   * @example
+   * const navigationRef = useNavigationContainerRef();
+   *
+   * <NavigationContainer
+   *   ref={navigationRef}
+   *   onReady={() => DashX.trackNavigation(navigationRef)}
+   * >
+   *   ...
+   * </NavigationContainer>
+   */
+  trackNavigation(
+    navigationRef:
+      | NavigationContainerLike
+      | { current: NavigationContainerLike | null }
+  ): () => void;
+
   /**
    * Enable IDFA/ATT ad tracking and request the App Tracking Transparency permission (iOS only).
    */
@@ -235,9 +278,19 @@ export interface DashXInstance {
 
   /**
    * Request push notification permission from the user.
+   *
+   * @param options.fallbackToSettings — when `true`, if the user has previously
+   *   granted or denied permission, opens the system notification settings
+   *   page so they can enable Time Sensitive notifications (or re-enable
+   *   notifications). Defaults to `false`. Use this to recover users who
+   *   granted permission before the SDK started requesting `.timeSensitive`,
+   *   since iOS won't silently add new options to an existing grant.
+   *
    * Resolves with a NotificationPermissionStatus integer.
    */
-  requestNotificationPermission(): Promise<NotificationPermissionStatus>;
+  requestNotificationPermission(options?: {
+    fallbackToSettings?: boolean
+  }): Promise<NotificationPermissionStatus>;
 
   /**
    * Get the current push notification permission status without prompting.

package/index.js

@@ -184,10 +184,63 @@ const DashX = {
   },
 
   enableLifecycleTracking() {
-    if (Platform.OS !== 'ios') return;
     return getNativeDashX().enableLifecycleTracking();
   },
 
+  trackNavigation(navigationRef) {
+    if (!navigationRef || typeof navigationRef !== 'object') {
+      throw new Error(
+        'DashX.trackNavigation: navigationRef must be a NavigationContainer ref'
+      );
+    }
+
+    // A ref from createNavigationContainerRef / useNavigationContainerRef
+    // queues listeners until the container mounts; a plain useRef does not.
+    const navigation =
+      typeof navigationRef.addListener === 'function'
+        ? navigationRef
+        : navigationRef.current;
+
+    if (!navigation) {
+      console.warn(
+        'DashX.trackNavigation: navigationRef.current is null. Call it from NavigationContainer onReady, or pass a ref from useNavigationContainerRef().'
+      );
+      return () => {};
+    }
+    if (
+      typeof navigation.addListener !== 'function' ||
+      typeof navigation.getCurrentRoute !== 'function'
+    ) {
+      throw new Error(
+        'DashX.trackNavigation: navigationRef must be a NavigationContainer ref'
+      );
+    }
+
+    let lastRouteName = null;
+    let active = true;
+
+    const trackCurrentRoute = () => {
+      if (!active) return;
+      // getCurrentRoute() logs an error on a container ref that is not ready.
+      if (typeof navigation.isReady === 'function' && !navigation.isReady()) {
+        return;
+      }
+      const route = navigation.getCurrentRoute();
+      const routeName = route && route.name;
+      if (!routeName || routeName === lastRouteName) return;
+      lastRouteName = routeName;
+      DashX.screen(routeName);
+    };
+
+    const removeListener = navigation.addListener('state', trackCurrentRoute);
+    trackCurrentRoute();
+
+    return () => {
+      active = false;
+      if (typeof removeListener === 'function') removeListener();
+    };
+  },
+
   enableAdTracking() {
     if (Platform.OS !== 'ios') return;
     return getNativeDashX().enableAdTracking();
@@ -218,8 +271,9 @@ const DashX = {
     );
   },
 
-  requestNotificationPermission() {
-    return getNativeDashX().requestNotificationPermission();
+  requestNotificationPermission(options) {
+    const fallbackToSettings = Boolean(options && options.fallbackToSettings);
+    return getNativeDashX().requestNotificationPermission(fallbackToSettings);
   },
 
   getNotificationPermissionStatus() {