react-native-notify-kit 10.10.0 → 10.10.1

package/README.md

@@ -55,6 +55,8 @@ 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.
@@ -425,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:
@@ -534,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)
@@ -584,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.**
 >

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
 
@@ -284,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/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.10.0"}
+{"version":"10.10.1"}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "10.10.0";
+export declare const version = "10.10.1";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '10.10.0';
+export const version = '10.10.1';
 //# sourceMappingURL=version.js.map