react-native-notify-kit 10.9.1 → 10.10.1

package/README.md

@@ -55,6 +55,10 @@ This fork fills the gap: it preserves all of Notifee's advanced features, migrat
 
 The native core (NotifeeCore) is compiled from source as part of the bridge module (since 9.2.0) and the public API is **100% compatible** with the original `@notifee/react-native` — migration is a safe, drop-in replacement.
 
+**10.10.1 iOS NSE and Android permission fixes — [#95](https://github.com/marcocrupi/react-native-notify-kit/issues/95), [#92](https://github.com/marcocrupi/react-native-notify-kit/issues/92):** Expo and bare CLI NSE generators now set `$NotifeeExtension = true` before autolinking so only `RNNotifeeCore` is compiled, incremental `expo prebuild` keeps React Native's `RCTNewArchEnabled` entry in the NSE `Info.plist`, iOS delegate forwarding contains duplicate-peer and synchronous delegate cycles, and Android `requestPermission()` starts on the main thread.
+
+**10.10.0 Android permissions:** new `shouldShowRequestPermissionRationale()` query for Android's current recommendation to show explanatory UI before requesting notification permission. The result does not determine whether another permission dialog can appear.
+
 **10.9.1 Android fixes — [#88](https://github.com/marcocrupi/react-native-notify-kit/issues/88):** `getInitialNotification()` no longer replays consumed identifiable interactions; new interactions, including taps reusing a notification ID, remain available. Supported recovery and native full-screen capture use the [documented one-shot and latest-wins semantics and limits](https://docs.page/marcocrupi/react-native-notify-kit/react-native/events#android-consumption-and-recovery). Related upstream [notifee#880](https://github.com/invertase/notifee/issues/880) is not claimed fully resolved by this qualification.
 
 ## Installation
@@ -423,6 +427,11 @@ cd ios && pod install
 
 The CLI scaffolds a Swift NSE target (default name: `NotifyKitNSE`), patches your Podfile, and wires `.pbxproj`. Open your `.xcworkspace` in Xcode, verify the NSE target's signing, and build. Expo users should use the config plugin instead of running `init-nse` against generated native folders. See [docs/fcm-mode.mdx#ios-nse-setup](docs/fcm-mode.mdx#ios-nse-setup) for the full CLI reference (target name, bundle suffix, `--dry-run`, `--force`).
 
+
+Both generators set `$NotifeeExtension = true` globally before autolinking so the host uses `RNNotifeeCore` rather than compiling a second core. Existing literal `true` is preserved; conflicting or conditional flag settings stop generation before the Podfile is written. Ruby with its standard `Ripper` parser (part of the CocoaPods toolchain) is needed to validate an existing flag configuration.
+
+For an existing bare NSE, review your Podfile and add an unconditional `$NotifeeExtension = true` after its Ruby header comments and before requires/autolinking, then run `pod install`. Keep the existing target and custom service files. The CLI still rejects an existing target without `--force`; `--force` overwrites generated files and is not needed for this Podfile repair. `$NotifeeCoreFromSources` remains a separate development configuration. Native cycle containment prevents recursive forwarding; it does not make duplicate-core builds supported or recover a delegate already lost by another SDK.
+
 ### Manual setup
 
 For bare React Native projects with non-standard iOS paths or heavily-customized Xcode configurations where automation cannot patch the project cleanly:
@@ -532,7 +541,7 @@ This fork is a complete migration to React Native's **New Architecture**:
 - **Single Android module** — the original Notifee shipped a pre-compiled AAR bundled inside the npm tarball under a frozen Maven coordinate; this fork compiles the core from source as part of the React Native bridge module on every consumer build. Eliminates the `FAIL_ON_PROJECT_REPOS` issue on RN 0.74+ and the Gradle cache staleness bug that could serve outdated bytecode after `yarn upgrade`.
 - **Expo CNG development builds** — iOS FCM Mode NSE automation and Android foreground service manifest configuration are available through the config plugin. Android Expo FCM smoke validation uses RNFirebase data-only messages plus `notifee.handleFcmMessage`.
 - **Core notification logic (NotifeeCore) is unchanged** — the public API is fully compatible with the original Notifee
-- **35 upstream bugs fixed** — see [Bugs Fixed from Upstream Notifee](#bugs-fixed-from-upstream-notifee) below
+- **36 upstream bugs fixed** — see [Bugs Fixed from Upstream Notifee](#bugs-fixed-from-upstream-notifee) below
 - **Reliable trigger notifications** — AlarmManager is the default backend instead of WorkManager, with automatic fallback when exact alarm permission is not granted
 - **Custom repeat intervals for timestamp triggers** — `TimestampTrigger.repeatInterval` supports calendar-based recurrences such as every 2 days, every 2 weeks, or every 3 months from a selected start timestamp. On iOS, repeating timestamp triggers now use a bounded rolling schedule of one-shot local notifications instead of native repeating calendar triggers; this enables custom repeat intervals and start-date-respecting recurrence, but apps that relied on native iOS repeating triggers being scheduled indefinitely should review the iOS notes in the [Triggers guide](docs/react-native/triggers.mdx#custom-repeat-intervals).
 - **New API: `setNotificationConfig()`** — opt-out flag to prevent Notifee from intercepting iOS remote notification handlers (see [New APIs](#new-apis) below)
@@ -582,6 +591,7 @@ This fork fixes the following bugs that were never resolved in the original Noti
 | `ObjectAlreadyConsumedException` in headless task when the same `WritableMap` is reused or the `taskConfig` accessor is read twice — `TaskConfig.init` mutated the caller's map instead of copying it first. Latent in most apps but observed in production by upstream users with high-frequency headless events                                                                                                                                                                                                    | Android  | [#266](https://github.com/invertase/notifee/issues/266)                                                                                                                         | 9.6.0                                                                                                                                              |
 | `getDisplayedNotifications()` returned no `data` field on Android, breaking iOS/Android API symmetry where iOS exposes custom keys via `parseDataFromUserInfo:` (see platform limitation note below — the fix is API parity for app-posted notifications, not a workaround for FCM background auto-display)                                                                                                                                                                                                          | Android  | [#393](https://github.com/invertase/notifee/issues/393)                                                                                                                         | 9.7.0                                                                                                                                              |
 | Small icon resolution failure in release builds causes `IllegalArgumentException` at `NotificationCompat.Builder.build()` — library now falls back to the app launcher icon and logs a warning instead of failing the notification display                                                                                                                                                                                                                                                                           | Android  | [#733](https://github.com/invertase/notifee/issues/733)                                                                                                                         | 10.1.0                                                                                                                                             |
+| Android 13+ `requestPermission()` can fail with `NullPointerException` in `View.dispatchCancelPendingInputEvents()` — `Activity.requestPermissions()` was started on the native modules thread instead of the UI thread                                                                                                                                                                                                                                                                                              | Android  | [#1064](https://github.com/invertase/notifee/issues/1064)                                                                                                                       | 10.10.1                                                                                                                                            |
 
 > **Important note on `getDisplayedNotifications()` and FCM custom data on Android.**
 >
@@ -923,6 +933,20 @@ if (settings.android.fullScreenIntent === AndroidNotificationSetting.DISABLED) {
 notification will be presented full-screen. See [Android Behaviour: Full-screen](https://docs.page/marcocrupi/react-native-notify-kit/react-native/android/behaviour#full-screen)
 for the full requirements and presentation behavior.
 
+### `shouldShowRequestPermissionRationale` (Android)
+
+`await notifee.shouldShowRequestPermissionRationale()` queries Android's current recommendation
+for explanatory UI before requesting `POST_NOTIFICATIONS`. It does not request permission or
+change request history. `false` does not prove permanent denial or whether another dialog can
+appear, even when `getNotificationSettings()` reports `DENIED`.
+
+On Android 13+ it returns the current Activity's platform result; without an Activity it rejects
+with `ERR_NO_ACTIVITY`. Other native failures reject. Below API 33 and on other platforms it
+resolves `false` (not applicable). Query again after returning from Settings. Target SDK,
+permission declarations and system policy affect Android's behavior. See
+[Android Permissions: Explaining a permission request](https://docs.page/marcocrupi/react-native-notify-kit/react-native/android/permissions#explaining-a-permission-request)
+for a consumer example and platform limitations.
+
 ### `setNotificationConfig` (iOS)
 
 Controls whether Notifee intercepts remote (push) notification tap events on iOS.

package/android/src/main/kotlin/io/invertase/notifee/NotifeeApiModule.kt

@@ -15,6 +15,7 @@ import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.modules.core.PermissionAwareActivity
 import com.facebook.react.modules.core.PermissionListener
 
@@ -233,6 +234,29 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) :
             }
     }
 
+    override fun shouldShowRequestPermissionRationale(promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            promise.resolve(false)
+            return
+        }
+
+        try {
+            val activity = getReactApplicationContext().getCurrentActivity()
+            if (activity == null) {
+                promise.reject(
+                    "ERR_NO_ACTIVITY",
+                    "A current Activity is required to query notification permission rationale.",
+                )
+                return
+            }
+            promise.resolve(
+                activity.shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS),
+            )
+        } catch (e: Exception) {
+            promise.reject(e)
+        }
+    }
+
     override fun requestPermission(permissions: ReadableMap, promise: Promise) {
         // permissions parameter is ignored on Android — only used by iOS
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
@@ -261,18 +285,22 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) :
                 NotifeeReactUtils.promiseResolver(promise, e, bundle)
             }
 
-        try {
-            activity.requestPermissions(
-                arrayOf(Manifest.permission.POST_NOTIFICATIONS),
-                Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION,
-                this,
-            )
-        } catch (e: Exception) {
-            Logger.d(
-                "requestPermission",
-                "Failed to request POST_NOTIFICATIONS permission: ${e.message}",
-            )
-            NotifeeReactUtils.promiseResolver(promise, e)
+        // starting the permission activity walks the view tree, so it must not run on the
+        // native modules thread while the UI thread changes it
+        UiThreadUtil.runOnUiThread {
+            try {
+                activity.requestPermissions(
+                    arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+                    Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION,
+                    this,
+                )
+            } catch (e: Exception) {
+                Logger.d(
+                    "requestPermission",
+                    "Failed to request POST_NOTIFICATIONS permission: ${e.message}",
+                )
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
         }
     }
 

package/android/src/test/java/io/invertase/notifee/PermissionRationaleTest.java

@@ -0,0 +1,144 @@
+package io.invertase.notifee;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import android.Manifest;
+import android.app.Activity;
+import android.os.Build;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+/** Bridge behavior only: mocked platform recommendations are not Android dialog evidence. */
+@RunWith(RobolectricTestRunner.class)
+@Config(
+    manifest = Config.NONE,
+    sdk = {24, 32, 33, 36})
+public class PermissionRationaleTest {
+  private ReactApplicationContext context;
+  private Activity activity;
+  private NotifeeApiModule module;
+  private Promise promise;
+
+  @Before
+  public void setUp() {
+    context = mock(ReactApplicationContext.class);
+    activity = mock(Activity.class);
+    when(context.getCurrentActivity()).thenReturn(activity);
+    module = new NotifeeApiModule(context);
+    promise = mock(Promise.class);
+  }
+
+  private void query(Promise target) throws Exception {
+    module.shouldShowRequestPermissionRationale(target);
+  }
+
+  @Test
+  public void returnsCurrentPlatformRecommendationWithoutOtherActivityCalls() throws Exception {
+    when(activity.shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS))
+        .thenReturn(true, false, true);
+    for (boolean platformValue : new boolean[] {true, false, true}) {
+      Promise result = mock(Promise.class);
+      query(result);
+      verify(result).resolve(Build.VERSION.SDK_INT < 33 ? false : platformValue);
+      verifyNoMoreInteractions(result);
+    }
+    if (Build.VERSION.SDK_INT >= 33) {
+      verify(activity, times(3))
+          .shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS);
+    }
+    verifyNoMoreInteractions(activity);
+  }
+
+  @Test
+  public void missingActivityIsUnavailableOn33AndNotApplicableBefore33() throws Exception {
+    when(context.getCurrentActivity()).thenReturn(null);
+    query(promise);
+    if (Build.VERSION.SDK_INT >= 33) {
+      verify(promise)
+          .reject(
+              "ERR_NO_ACTIVITY",
+              "A current Activity is required to query notification permission rationale.");
+    } else {
+      verify(promise).resolve(false);
+    }
+    verifyNoMoreInteractions(promise);
+    verifyNoInteractions(activity);
+  }
+
+  @Test
+  public void nativeFailureRejectsRatherThanInventingANegativeRecommendation() throws Exception {
+    RuntimeException failure = new SecurityException("platform query failed");
+    when(activity.shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS))
+        .thenThrow(failure);
+    query(promise);
+    if (Build.VERSION.SDK_INT >= 33) {
+      verify(promise).reject(failure);
+    } else {
+      verify(promise).resolve(false);
+    }
+    verifyNoMoreInteractions(promise);
+  }
+
+  @Test
+  public void activityLookupFailureRejectsAndALaterQueryCanRecover() throws Exception {
+    SecurityException failure = new SecurityException("Activity lookup failed");
+    when(context.getCurrentActivity()).thenThrow(failure).thenReturn(activity);
+    query(promise);
+    if (Build.VERSION.SDK_INT >= 33) {
+      verify(promise).reject(failure);
+    } else {
+      verify(promise).resolve(false);
+    }
+    Promise recovered = mock(Promise.class);
+    query(recovered);
+    verify(recovered).resolve(false);
+    verifyNoMoreInteractions(promise, recovered);
+  }
+
+  @Test
+  public void doesNotConsultOrMutateCorePermissionHistory() throws Exception {
+    try (org.mockito.MockedStatic<app.notifee.core.Notifee> core =
+        mockStatic(app.notifee.core.Notifee.class)) {
+      query(promise);
+      core.verifyNoInteractions();
+    }
+  }
+
+  @Test
+  public void currentActivityIsLookedUpAgainAfterLifecycleChange() throws Exception {
+    when(activity.shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS))
+        .thenReturn(true);
+    query(promise);
+    when(context.getCurrentActivity()).thenReturn(null);
+    Promise unavailable = mock(Promise.class);
+    query(unavailable);
+    Activity replacement = mock(Activity.class);
+    when(context.getCurrentActivity()).thenReturn(replacement);
+    Promise refreshed = mock(Promise.class);
+    query(refreshed);
+    verify(refreshed).resolve(false);
+    if (Build.VERSION.SDK_INT >= 33) {
+      verify(promise).resolve(true);
+      verify(unavailable)
+          .reject(
+              "ERR_NO_ACTIVITY",
+              "A current Activity is required to query notification permission rationale.");
+      verify(replacement)
+          .shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS);
+    } else {
+      verify(promise).resolve(false);
+      verify(unavailable).resolve(false);
+    }
+  }
+}

package/android/src/test/java/io/invertase/notifee/RequestPermissionThreadTest.java

@@ -0,0 +1,102 @@
+package io.invertase.notifee;
+
+import static org.junit.Assert.assertSame;
+import static org.mockito.AdditionalMatchers.aryEq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import android.Manifest;
+import android.app.Activity;
+import android.os.Looper;
+import app.notifee.core.Notifee;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.Shadows;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.LooperMode;
+
+/** TurboModule promise methods run on the native modules thread, not on the main thread. */
+@RunWith(RobolectricTestRunner.class)
+@Config(
+    manifest = Config.NONE,
+    sdk = {33, 36})
+@LooperMode(LooperMode.Mode.PAUSED)
+public class RequestPermissionThreadTest {
+  private static final String[] POST_NOTIFICATIONS = {Manifest.permission.POST_NOTIFICATIONS};
+
+  private PermissionAwareActivity activity;
+  private NotifeeApiModule module;
+  private ReadableMap permissions;
+  private Promise promise;
+
+  @Before
+  public void setUp() {
+    ReactApplicationContext context = mock(ReactApplicationContext.class);
+    Activity currentActivity =
+        mock(Activity.class, withSettings().extraInterfaces(PermissionAwareActivity.class));
+    activity = (PermissionAwareActivity) currentActivity;
+    when(context.getCurrentActivity()).thenReturn(currentActivity);
+    module = new NotifeeApiModule(context);
+    permissions = mock(ReadableMap.class);
+    promise = mock(Promise.class);
+  }
+
+  private void requestFromModulesThread() throws InterruptedException {
+    Thread modulesThread = new Thread(() -> module.requestPermission(permissions, promise));
+    modulesThread.start();
+    modulesThread.join();
+  }
+
+  @Test
+  public void startsThePermissionActivityOnTheMainThread() throws Exception {
+    AtomicReference<Thread> requestThread = new AtomicReference<>();
+    doAnswer(
+            invocation -> {
+              requestThread.set(Thread.currentThread());
+              return null;
+            })
+        .when(activity)
+        .requestPermissions(any(), anyInt(), any());
+
+    requestFromModulesThread();
+    verify(activity, never()).requestPermissions(any(), anyInt(), any());
+
+    Shadows.shadowOf(Looper.getMainLooper()).idle();
+    verify(activity)
+        .requestPermissions(
+            aryEq(POST_NOTIFICATIONS),
+            eq(Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION),
+            same(module));
+    assertSame(Looper.getMainLooper().getThread(), requestThread.get());
+    verifyNoMoreInteractions(promise);
+  }
+
+  @Test
+  public void aRequestThatThrowsOnTheMainThreadStillRejects() throws Exception {
+    IllegalStateException failure = new IllegalStateException("activity is finishing");
+    doThrow(failure).when(activity).requestPermissions(any(), anyInt(), any());
+
+    requestFromModulesThread();
+    Shadows.shadowOf(Looper.getMainLooper()).idle();
+
+    verify(promise).reject(failure);
+    verifyNoMoreInteractions(promise);
+  }
+}

package/cli/dist/commands/initNse.js

@@ -94,6 +94,17 @@ async function initNse(opts) {
             '  Use --force to overwrite or --target-name to use a different name.');
         process.exit(1);
     }
+    // Validate all Podfile changes before --force can overwrite consumer NSE
+    // templates, and before a dry run reports a configuration as repairable.
+    const podfilePath = path.join(projectInfo.iosDir, 'Podfile');
+    try {
+        if (fs.existsSync(podfilePath))
+            (0, patchPodfile_1.patchPodfile)(podfilePath, targetName, true);
+    }
+    catch (e) {
+        logger.error(`Failed during NSE Podfile preflight: ${e instanceof Error ? e.message : String(e)}`);
+        return process.exit(2);
+    }
     if (dryRun) {
         logger.info('[DRY RUN] Would perform the following actions:');
         logger.info(`  iOS project: ${absIosDir}`);
@@ -107,7 +118,6 @@ async function initNse(opts) {
         return;
     }
     // 4. Create backups (PID-stamped to avoid collision with parallel runs)
-    const podfilePath = path.join(projectInfo.iosDir, 'Podfile');
     const backups = [];
     const templateDirCreated = !dirExists; // Track if WE created the dir (for rollback)
     const bakSuffix = `.bak.${process.pid}.${Date.now()}`;

package/cli/dist/lib/notifeeExtensionFlag.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNotifeeExtensionFlag = ensureNotifeeExtensionFlag;
+const child_process_1 = require("child_process");
+// Keep the Expo/CLI copies identical: each is shipped through a separate build.
+// Parse, never execute, consumer Ruby. A line scanner cannot distinguish a
+// top-level assignment from continuations, interpolation, heredocs or blocks.
+const FLAG_PREFLIGHT = String.raw `
+require 'ripper'
+require 'json'
+source = STDIN.read
+ast = Ripper.sexp(source)
+def walk(node, &block)
+  return unless node.is_a?(Array)
+  yield node
+  node.each { |child| walk(child, &block) if child.is_a?(Array) }
+end
+def flag_tokens(node)
+  tokens = []
+  walk(node) { |part| tokens << part if part[0] == :@gvar && part[1] == '$NotifeeExtension' }
+  tokens
+end
+def evaluation?(node)
+  found = false
+  walk(node) do |part|
+    if [:@ident, :@const].include?(part[0]) &&
+        %w[target abstract_target pod podspec use_native_modules! use_expo_modules! use_react_native! Specification eval instance_eval class_eval module_eval from_file from_string].include?(part[1])
+      found = true
+    end
+    found = true if part[0] == :@tstring_content && part[1].include?('.podspec')
+  end
+  found
+end
+# Only a bounded prelude is provably safe before an existing true flag. Unknown
+# helpers and dynamic dispatch can evaluate podspecs even without a named call.
+def literal?(node)
+  return true if node.nil? || node == false
+  return false unless node.is_a?(Array)
+  return node.all? { |part| literal?(part) } unless node[0].is_a?(Symbol)
+  case node[0]
+  when :@int, :@float, :@rational, :@imaginary, :@tstring_content, :@label, :@ident
+    true
+  when :@kw
+    %w[true false nil].include?(node[1])
+  when :var_ref, :string_literal, :string_content, :symbol_literal, :symbol,
+       :array, :hash, :assoclist_from_args, :assoc_new, :args_add_block, :arg_paren
+    node.drop(1).all? { |part| literal?(part) }
+  else
+    false
+  end
+end
+def safe_prelude?(node)
+  return true if node[0] == :void_stmt
+  if node[0] == :assign
+    lhs = node[1]
+    return lhs && lhs[0] == :var_field &&
+      [:@ident, :@gvar, :@ivar, :@cvar, :@const].include?(lhs[1][0]) && literal?(node[2])
+  end
+  allowed = %w[require require_relative platform source project workspace install! use_frameworks!]
+  if node[0] == :command
+    return allowed.include?(node[1][1]) && literal?(node[2])
+  end
+  if node[0] == :method_add_arg && node[1][0] == :fcall
+    return allowed.include?(node[1][1][1]) && literal?(node[2])
+  end
+  false
+end
+unless ast
+  puts JSON.generate({ error: 'Ruby syntax could not be parsed', line: 1 })
+  exit
+end
+has_eval = false
+flag_text = nil
+walk(ast) do |part|
+  has_eval = true if part[0] == :@ident && %w[eval instance_eval class_eval module_eval].include?(part[1])
+  flag_text ||= part if part[0] == :@tstring_content && part[1].include?('$NotifeeExtension')
+end
+if has_eval && flag_text
+  puts JSON.generate({ error: 'dynamic Ruby evaluation mentions the flag', line: flag_text[2][0] })
+  exit
+end
+all = flag_tokens(ast)
+accepted = []
+evaluating = false
+error = nil
+(ast[1] || []).each do |statement|
+  tokens = flag_tokens(statement)
+  unless tokens.empty?
+    lhs = statement[1] if statement[0] == :assign
+    rhs = statement[2] if statement[0] == :assign
+    literal_true = lhs && lhs[0] == :var_field && lhs[1][0] == :@gvar &&
+      lhs[1][1] == '$NotifeeExtension' && rhs && rhs[0] == :var_ref && rhs[1][0] == :@kw && rhs[1][1] == 'true'
+    if !literal_true || tokens.length != 1
+      error = { error: 'conflicting or ambiguous configuration; only unconditional literal true is supported', line: tokens[0][2][0] }
+      break
+    end
+    if evaluating && accepted.empty?
+      error = { error: 'assignment follows possible target/autolinking or podspec evaluation', line: tokens[0][2][0] }
+      break
+    end
+    accepted.concat(tokens)
+  end
+  evaluating ||= evaluation?(statement) || !safe_prelude?(statement)
+end
+puts JSON.generate(error || { assigned: !accepted.empty?, references: all.length })
+`;
+function ensureNotifeeExtensionFlag(contents) {
+    if (contents.includes('$NotifeeExtension')) {
+        let result;
+        try {
+            result = JSON.parse((0, child_process_1.execFileSync)('ruby', ['-e', FLAG_PREFLIGHT], {
+                input: contents,
+                encoding: 'utf8',
+                timeout: 10_000,
+                maxBuffer: 16 * 1024 * 1024,
+            }));
+        }
+        catch {
+            throw new Error('NotifyKit NSE: $NotifeeExtension at line 1: Ruby (Ripper) preflight unavailable. ' +
+                'Use the Ruby toolchain required by CocoaPods; no changes were written.');
+        }
+        if (result.error) {
+            throw new Error(`NotifyKit NSE: $NotifeeExtension at line ${result.line}: ${result.error}. ` +
+                'Set $NotifeeExtension = true in the Podfile header before autolinking; no changes were written.');
+        }
+        if (result.assigned)
+            return contents;
+    }
+    // Insert after Ruby's shebang, magic comments and other leading comments.
+    // Keep every original byte, including a BOM and a header without final LF.
+    const bom = contents.startsWith('\uFEFF') ? '\uFEFF' : '';
+    const text = contents.slice(bom.length);
+    const lines = text.split('\n');
+    let headerEnd = 0;
+    let blockComment = false;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (/^=begin(?:\s|$)/.test(line))
+            blockComment = true;
+        if (!blockComment && !/^\s*(?:#.*)?$/.test(line))
+            break;
+        headerEnd += line.length + (index < lines.length - 1 ? 1 : 0);
+        if (/^=end(?:\s|$)/.test(line))
+            blockComment = false;
+    }
+    const separator = headerEnd > 0 && text[headerEnd - 1] !== '\n' ? '\n' : '';
+    return (bom +
+        text.slice(0, headerEnd) +
+        separator +
+        '$NotifeeExtension = true\n' +
+        text.slice(headerEnd));
+}

package/cli/dist/lib/patchPodfile.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchPodfile = patchPodfile;
 exports.patchPodfileForNotifyKitNse = patchPodfileForNotifyKitNse;
 exports.getPatchedPodfile = getPatchedPodfile;
+const notifeeExtensionFlag_1 = require("./notifeeExtensionFlag");
 const fs = __importStar(require("fs"));
 const DEFAULT_PACKAGE_PATH_FROM_IOS = '../node_modules/react-native-notify-kit';
 const RNFB_INFO_PLIST_INPUT_PATH = '$(BUILT_PRODUCTS_DIR)/$(INFOPLIST_PATH)';
@@ -60,8 +61,8 @@ function patchPodfile(podfilePath, targetName, dryRun) {
     return true;
 }
 function patchPodfileForNotifyKitNse(podfileText, options) {
-    let patched = podfileText;
-    let changed = false;
+    let patched = (0, notifeeExtensionFlag_1.ensureNotifeeExtensionFlag)(podfileText);
+    let changed = patched !== podfileText;
     const packagePathFromIos = options.packagePathFromIos ?? DEFAULT_PACKAGE_PATH_FROM_IOS;
     // Idempotency check — skip commented lines (# prefix)
     if (!hasUncommentedTarget(patched, options.targetName)) {

package/cli/package.json

@@ -1 +1 @@
-{"version":"10.9.1"}
+{"version":"10.10.1"}

package/dist/NotifeeApiModule.d.ts

@@ -36,6 +36,7 @@ export default class NotifeeApiModule extends NotifeeNativeModule implements Mod
     onBackgroundEvent: (observer: (event: Event) => Promise<void>) => void;
     onForegroundEvent: (observer: (event: Event) => void) => (() => void);
     openNotificationSettings: (channelId?: string) => Promise<void>;
+    shouldShowRequestPermissionRationale: () => Promise<boolean>;
     requestPermission: (permissions?: IOSNotificationPermissions) => Promise<NotificationSettings>;
     registerForegroundService(runner: (notification: Notification) => Promise<void>): void;
     setNotificationCategories: (categories: IOSNotificationCategory[]) => Promise<void>;

package/dist/NotifeeApiModule.js

@@ -373,6 +373,12 @@ export default class NotifeeApiModule extends NotifeeNativeModule {
         }
         return Promise.resolve();
     };
+    shouldShowRequestPermissionRationale = () => {
+        if (isAndroid) {
+            return this.native.shouldShowRequestPermissionRationale();
+        }
+        return Promise.resolve(false);
+    };
     requestPermission = (permissions = {}) => {
         if (isAndroid) {
             return this.native.requestPermission({}).then(({ authorizationStatus, android, }) => {