Releases

• FCM Mode: added top-level subtitle support and Android circularLargeIcon support in the Server SDK wire payload and client reconstruction.
• FCM Mode / Android: expanded the supported BIG_TEXT style with title and summary, and BIG_PICTURE with title, summary, and largeIcon (including explicit null to hide the expanded large icon). Other notification fields and styles remain outside the FCM Mode contract.
• FCM Mode / Android interactions: added explicit body-tap opt-out with pressAction: null; body and action press actions now carry mainComponent and launchActivityFlags alongside id and launchActivity. Actions also carry icon and the supported AndroidInput configuration; input: true requests a standard direct reply. The _v: 1 wire contract is unchanged.

• Android / foreground services: stopForegroundService() no longer cold-starts a ForegroundService just to deliver STOP when no instance is active. Repeated STOP calls are safe and idempotent; stopping a service that is neither active nor starting is a no-op. On Android 12+ (API 31+), a platform ForegroundServiceStartNotAllowedException in the defensive terminal STOP/null path is now non-fatal instead of being wrapped in a fatal error. This terminal denial handling does not suppress real START failures, unrelated errors, or configuration failures. Issue #77.
• iOS / per-notification badges: NotificationIOS.badgeCount now rejects fractional and non-finite values. Valid numeric values must be finite non-negative integers; negative values remain invalid. For immediate and trigger notifications, an absent or null badgeCount leaves the current badge unchanged, 0 still clears it, and positive integers still set it.
• FCM Mode / notification identity: preserved public notification.id in the unchanged _v: 1 payload and client reconstruction. Android display/replacement, readback, events, and cancel now use that ID instead of the Firebase messageId when it is supplied; buildFcmNotification() retains it.
• FCM Mode / iOS identity: the NSE keeps the logical NotifyKit notification ID separate from the physical APNs request identifier. Readback, events, and cancel use the logical ID, including cancellation of multiple delivered requests associated with it. Payloads without an ID keep their path-specific legacy fallback.
• FCM Mode / APNs: validated the effective apns-collapse-id (options.collapseKey ?? notification.id) against the 64-byte UTF-8 limit. Transport collapse remains independent of public notification identity and does not guarantee replacement after delivery.
• FCM Mode / iOS: the Notification Service Extension now preserves Server SDK notification.data in the delivered notification and event data while keeping APNs/FCM/NotifyKit metadata authoritative and legacy options.data behavior intact.
• FCM Mode / iOS: the extension preserves positive and zero aps.badge values and leaves an absent badge absent. Legacy/manual _v: 1 notifee_options.ios.badgeCount: null is now treated as an absent override instead of being passed to the native badge setter as NSNull, preserving the original APNs badge behavior. Numeric legacy overrides keep precedence over aps.badge; the public Server SDK options.iosBadgeCount?: number still rejects null.
• FCM Mode / Android interactions: legacy _v: 1 input: false now means no reply; other malformed legacy inputs are rejected instead of silently dropped. The internal body-tap opt-out ID is rejected as a public or wire pressAction.id.
• FCM Mode / Android interactions: malformed body and action pressAction values are rejected instead of treating a malformed body value as absent. Present non-array actions and malformed action entries are rejected, and every launchActivityFlags value is validated.

• Android / foreground services: expanded lifecycle and race regression coverage for inactive/repeated STOP, START/STOP/new START, pending START/STOP ordering, and late runner completion, while retaining regression checks for defensive SecurityException handling (#44) and same-ID notification updates (#75).
• Android / foreground-service runtime: inactive/double STOP, START/STOP/new START, pending START ordering, and same-ID update/re-post/restart paths passed on Android 10/API 29 and Android 13/API 33 emulators and a physical Pixel 9 Pro XL running Android 17/API 37. The #77 background STOP scenario passed on API 33 and API 37; the #44 defensive SecurityException regression passed on API 37. Runtime qualification used native entrypoints equivalent to the library's Android bridge calls; the literal JavaScript/headless end-to-end path was not run.
• iOS / per-notification badges: expanded validator, display, and timestamp/rolling trigger regression coverage for absent, null, zero, positive finite integers, and invalid numeric rejection before native dispatch. Physical iPhone 16e / iOS 26.5 checks passed for immediate absent/null/0/positive and real timestamp trigger null/0/positive. Negative, fractional, NaN, and ±Infinity inputs were qualified host-side only and were not sent to the device; rolling trigger device runtime was not run.
• FCM Mode / iOS badges: added production NSE helper and badge-builder coverage for absent/legacy null overrides and numeric precedence. On the same physical iPhone, the real APNs transport gate (T0) passed and B1–B8 passed 8/8 with the installed NSE: legacy null or absent with APNs absent/0/7, and legacy 3/0 overriding APNs 7. Badge-zero withdrawal was classified as iOS/SpringBoard behavior.
• FCM Mode / Batch 3: added Server SDK, client reconstruction, Android native, and iOS NSE/readback/cancel/event harness regression coverage for notification identity, distinct collapse keys, legacy _v: 1 fallbacks, and the effective APNs 64-byte UTF-8 limit.
• FCM Mode / Batch 3 Android device: on a Pixel 9 Pro XL / Android 17 API 37, qualified same-N replacement with distinct M and C values, preservation of distinct N values sharing C when both arrived, readback/cancel and PRESS by N, buildFcmNotification() identity, and the legacy no-N fallback.
• FCM Mode / Batch 3 iOS device: on an iPhone 16e / iOS 26.5, qualified N=C and N≠C through the real NSE, foreground identity, readback and PRESS by N, cancellation of multiple R values sharing N, collision safety, and the legacy no-N fallback to R. iOS ACTION_PRESS device runtime was not run.
• FCM Mode / transport collapse: an offline iOS device received only the second message after reconnection when both shared C. In a separate run, the NSE processed a second N=C push while Notification Center still showed the first push's content, confirming that transport collapse does not guarantee replacement after delivery.
• FCM Mode / Batch 2A: added Server SDK serialization and validation, client reconstruction, and Firebase Admin compatibility coverage, including _v: 1, omitted fields, explicit circularLargeIcon: false, and BIG_PICTURE.largeIcon: null.
• FCM Mode / Android: qualified Batch 2A display on a physical Pixel 9 Pro XL running Android 17/API 37, including subtitle, both circular icon settings, the absent default, both expanded styles, explicit BIG_PICTURE.largeIcon: null, and a legacy payload without the new fields. iOS subtitle device runtime was not run.
• FCM Mode / Batch 2B: added Server SDK serialization/validation, client reconstruction, normal-validator, and Firebase Admin compatibility coverage for Android interactions. Physical Pixel 9 Pro XL / Android 17/API 37 checks passed for default body tap, pressAction: null (contentIntent=null, no app opening or PRESS), configured press actions with launch flags, ACTION_PRESS without input, and direct replies (input: true and configured choices). Action icon passed the data/native path, but was not visibly rendered in the shade; an alternate mainComponent was not run on device.
• FCM Mode / Android interactions: added host regression coverage across wire serialization, reconstruction, and normal validation for malformed interaction payloads; invalid payloads do not invoke the native display module.
• FCM Mode / iOS: replaced the synthetic NSE stand-in with shared Server SDK-to-NSE fixtures and a native harness that exercises the production extension helper.

This 10.7.2 maintenance update fixes stale state when long-lived Android foreground-service notifications are updated repeatedly with the same ID.

• Fixed same-ID updates retaining stale first-notification state, which could leave later re-post and timeout paths using obsolete content. The current foreground-service state now follows the latest update submitted to Android by a platform call that returned normally. Issue #75.

This 10.7.1 maintenance update fixes Android notification timestamp preservation in FCM Mode and the Server SDK.

• Fixed Android showTimestamp and timestamp handling so buildNotifyKitPayload() preserves both fields in _v: 1 notifee_options through client reconstruction, enabling the existing Android timestamp display and sorting behavior for FCM Mode notifications. Issue #73.

This 10.7.0 update adds Expo CNG support for generating Android small notification icon resources from project-relative PNG files.

• Added android.icons config-plugin support for generating one or more density-specific Android small notification icon resources during CNG/prebuild.
• Each configured resource name can be used with notification.android.smallIcon.
• The plugin writes an Android resource-shrinker keep rule for generated icons. Only type: 'small' is supported.

This 10.6.0 update adds Android full-screen intent access reporting and fixes notification reliability across MessagingStyle person resolution, action validation, Fresco bitmap ownership, PendingIntent identity, and iOS Communication Notification avatar handling.

• Added getNotificationSettings().android.fullScreenIntent reporting for the Android access required to use full-screen intents.
• API < 29 reports ENABLED, API 29-33 reflects USE_FULL_SCREEN_INTENT, and API 34+ reflects Android's full-screen intent special app access.
• ENABLED does not guarantee that a particular notification will be presented full-screen.

• Fixed a failure path that could drop MessagingStyle notifications when Person resolution timed out or an icon could not be loaded or created.
• Recoverable MessagingStyle person failures now use an icon-less fallback that preserves the remaining Person fields and allows notification construction to continue.
• Fixed notification image handling so Fresco-owned bitmaps are copied before leaving BaseBitmapDataSubscriber.
• Fixed ReceiverService PendingIntent identity collisions across app process restarts that could route action buttons or dismiss/delete intents from older live notifications to another notification's payload.

• Fixed validation in the React Native client and Server SDK so duplicate pressAction.id values within a single notification's android.actions array are rejected.

• Fixed valid file:// sender avatars so they display their image instead of a placeholder.
• Materialized HTTPS group avatars before the communication intent is built in both direct and Notification Service Extension (NSE) paths.

• Added deterministic regression coverage for MessagingStyle Person timeouts and icon failures, Fresco bitmap ownership, full-screen intent access reporting, and ReceiverService PendingIntent identity.
• Added a physical-device smoke harness covering a notification surviving a process restart, a second notification posted from the new process, real action-button presses, and real dismiss routing; the device scenarios were validated on a Pixel 9 Pro XL running Android 17/API 37.
• Added iOS harness coverage for avatar resolution and materialization in Communication Notifications, deadline and media-cutoff handling, and one-shot NSE completion.

This 10.5.0 update fixes Firebase Admin compatibility in the Server SDK payload builder while preserving the public TTL input in seconds.

• Fixed buildNotifyKitPayload() returning Android fields in raw HTTP v1 form, which caused Firebase Admin to reject messages using options.ttl.
• Generated messages now use Firebase Admin-compatible millisecond TTL values, priority values, collapse-key naming, and routing types.

• Added local Firebase Admin compatibility coverage for TTL conversion, priority, collapse keys, token/topic/condition routing, APNs expiration, custom data, and non-enumerable payload metadata without credentials or network requests.

This 10.4.9 maintenance update fixes Android foreground event delivery during native event relay initialization and React context transitions.

• Registering onForegroundEvent() now initializes the native event relay, preventing foreground events from being missed when no other native API has been called.
• Pending notification events are requeued when the ReactContext becomes null or inactive after the flush snapshot, preventing permanent event loss while preserving FIFO ordering, the queue capacity of 10, and drop-oldest behavior.

This 10.4.8 update adds an FCM build-only helper so apps can inspect or customize a reconstructed FCM notification before displaying it manually.

• Added buildFcmNotification(remoteMessage), a build-only counterpart to handleFcmMessage().
• Reconstructs the FCM Notification without displaying it.
• Allows apps to inspect or customize the notification before calling displayNotification() manually.

This 10.4.7 maintenance update hardens the Android foreground-service STOP/null placeholder path on Android 14+ so defensive cleanup no longer reuses unsafe while-in-use foreground-service types when the app is backgrounded. Public APIs and the normal foreground-service START path are unchanged.

• Hardened the defensive foreground-service STOP/null placeholder on Android 14+ so it no longer reuses the full manifest-declared foreground-service type mask.
• Avoided reusing while-in-use types such as microphone or camera for the defensive STOP/null placeholder when a safer declared type such as shortService or dataSync is available.
• Treated a defensive SecurityException in this STOP/null path as non-fatal.

• Added foreground-service regression coverage for the defensive STOP/null path, including Robolectric coverage for microphone|dataSync, camera|dataSync, shortService|microphone, microphone-only, and defensive SecurityException handling.
• Added a smoke harness and script validated on a physical Pixel 9 Pro XL running Android 16/API 36 for the microphone|dataSync background STOP scenario.

This 10.4.6 maintenance update fixes a React Native New Architecture import-time crash in bridgeless apps by deferring NotifeeApiModule TurboModule resolution until the first native access. It also adds regression coverage and an iOS smoke scenario for early listener registration.

• Fixed an import-time crash in bridgeless apps by deferring NotifeeApiModule TurboModule resolution until the first native access.
• Early imports, such as registering notifee.onBackgroundEvent(...) in index.js, no longer call TurboModuleRegistry.getEnforcing(...) during module evaluation.
• Public APIs are unchanged.

• Added targeted NotifeeNativeModule coverage for constructor-safe lazy TurboModule resolution, idempotent native event listener setup, error propagation, and retry behavior after native emitter/listener setup failures.
• Added a listener-only iOS smoke scenario and non-terminating iOS device harness mode for validating early listener registration without invoking notification display APIs in the scenario.

This 10.4.5 maintenance update fixes Android background notification action routing and a stale React context recovery edge case in headless background tasks. It also clarifies Android scheduled trigger recovery and Expo CNG/prebuild behavior for local scheduled triggers.

• Kept Android 12+ notification actions without launchActivity or mainComponent on the ReceiverService path instead of always routing them through the launch-activity PendingIntent.

• Fixed a HeadlessTask stale ReactContext edge case where the cached initialized state could remain true while the current ReactContext was null.
• Background tasks now treat that state as stale, restart the ReactHost initialization path, and drain queued tasks only after a valid ReactContext is available.

• Clarified Android scheduled trigger reboot recovery, exact-alarm fallback behavior, and Expo CNG/prebuild manifest-merge behavior for local scheduled triggers.

• Added targeted HeadlessTask regression coverage for stale/null ReactContext recovery.
• Validated the no-launch notification action background path on a physical Pixel 9 Pro XL running Android 16.

This 10.4.4 maintenance update records Android Java guard, documentation, repository tooling, and test harness updates already validated on the maintenance branch. It does not change the public JavaScript API or notification runtime behavior.

• JDK 17 remains the minimum requirement for Android builds.
• JDK 17 and JDK 21 are the validated Android build baselines.
• JDK versions newer than the validated baselines are no longer blocked by NotifyKit before the consumer Gradle, Android Gradle Plugin, Kotlin, and React Native toolchain can evaluate compatibility.
• For Expo/EAS projects, newer JDK compatibility also depends on the consumer Expo/EAS Android toolchain.

• Clarified the Android JDK policy across installation, environment support, README, and package README documentation.
• Documented that Android builds require JDK 17 or newer, that JDK 17 and JDK 21 are the validated baselines, and that newer JDKs remain toolchain-dependent.
• Documented that JDK 8 and JDK 11 are not supported.

• Resolved the repository lockfile alert for xcode's transitive uuid dependency with a targeted Yarn resolution for xcode/uuid to uuid 11.1.1.
• xcode remains at 3.0.1. The uuid advisory was not runtime-reachable through NotifyKit notification behavior in this repository usage, and this root lockfile fix does not automatically protect all npm consumers.
• Updated the Expo smoke fixture from expo ~55.0.23 to ~55.0.26 so its Expo Metro chain resolves postcss to patched 8.5.x. This fixture tooling fix does not add a PostCSS resolution and does not enter the published react-native-notify-kit npm package.
• Updated the ws lockfile resolution used through @expo/cli from 8.20.0 to 8.20.1, within the existing ^8.12.1 range. This did not change package.json, Expo SDK, React Native, Metro, or add a ws resolution.
• The PostCSS and ws alerts were through Expo smoke fixture tooling, not NotifyKit runtime notification issues.

• Moved the xcode-backed Expo config plugin tests to Jest's node environment so xcode resolves uuid through the Node/CommonJS export path under the React Native Jest preset.
• Made scripts/test-ios-nse-helper.sh executable; the script content is unchanged.

• Passed yarn validate:all, yarn verify:ios-core, yarn smoke:expo:config, yarn tests_rn:test, yarn tests_rn:test-server, cd packages/cli && yarn test, the iOS delegate/local attachment/NSE helper harnesses, yarn test:core:android, and yarn e2e:cli-tarball.
• Passed dependency/tooling checks for the advisory follow-ups: yarn why postcss, yarn install --immutable, yarn why ws, yarn smoke:expo:config, and yarn validate:all.

• Expo prebuild, Android runtime smoke, real iOS builds, device smoke, NSE runtime, FCM/Firebase, EAS, release, publish, and tag workflows were not validated as part of this maintenance entry.

This 10.4.3 maintenance update realigns the library development target and bare React Native smoke app with React Native 0.85.3. It keeps the minimum supported React Native version at >=0.73.0 and remains New Architecture only.

• Updated the current development target to React Native 0.85.3 for the library and bare smoke app.
• Aligned bare smoke tooling with React Native 0.85.3, including @react-native/* tooling and @react-native/jest-preset.
• Aligned the bare smoke Android Gradle wrapper with the React Native 0.85.3 template.
• Refreshed the bare smoke iOS Podfile.lock to React Native 0.85.3 pods, Hermes 250829098.0.10, and RNNotifee 10.4.2.

• Validated TypeScript checks, React Native Jest tests, server Jest tests, Android unit tests, iOS core generation verification, bare Android assembleDebug, iOS pod install, and physical iPhone build/install.
• Confirmed visible local notification display on a physical iPhone.
• Public JS API unchanged.
• Runtime notification behavior unchanged.

• Expo smoke remains on Expo SDK 55 / React Native 0.83.x and was not updated as part of this step.
• Expo React Native 0.85 validation remains a separate future track and was not part of this maintenance step.
• FCM, headless/background flows, EAS, and Expo smoke were not validated as part of this step.
• iOS tap/background/killed press flow is not claimed as fully validated by this step.

This 10.4.2 patch hardens Expo CNG iOS NotifyKitNSE generation and fixes an iOS precompiled-modules header visibility issue in RNNotifee. It does not change the public JavaScript API and does not change runtime notification behavior.

If your app uses Expo CNG and a generated NotifyKitNSE, upgrading to 10.4.2 avoids stale 1.0 extension version metadata and CocoaPods host/extension use_frameworks! mismatches.

10.4.2 also avoids a reported iOS precompiled-modules build failure where NotifeeApiModule.mm could not resolve NotifeeCore+UNUserNotificationCenter.h. The import now uses the same relative NotifeeCore path style as the existing NotifeeCore.h import. This is a compile-time-only fix.

The Expo smoke iOS fixture now uses ios.forceStaticLinking for RNFBApp and RNFBMessaging, because the fixture includes RNFirebase and uses ios.useFrameworks: "static". This avoids the local RNFirebase non-modular-header failure seen under precompiled Expo Modules.

• Fixed generated NotifyKitNSE version/build metadata so the extension mirrors the parent Expo app version/build in Info.plist and Xcode build settings.
• Existing generated NotifyKitNSE targets are normalized for version/build metadata and Podfile linkage instead of requiring manual deletion/regeneration.
• Fixed NotifyKitNSE Podfile use_frameworks! inheritance so the extension matches the host target linkage, including static and dynamic frameworks.
• Expo conditional use_frameworks! Podfile lines are evaluated against Podfile.properties.json and USE_FRAMEWORKS instead of being treated as always active.
• Fixed an iOS precompiled-modules header visibility issue where NotifeeApiModule.mm could fail to resolve NotifeeCore+UNUserNotificationCenter.h.

• Validated locally with EXPO_USE_PRECOMPILED_MODULES=1, clean iOS prebuild, CocoaPods install, and physical iPhone build/install.
• Public JS API unchanged.
• NotifyKit runtime notification behavior unchanged.
• EAS iOS cloud build was not run as part of this validation and remains a separate gate requiring Apple credentials/provisioning.

This 10.4.1 patch fixes an iOS static-frameworks header visibility issue and records the latest Expo smoke fixture EAS validation work. It does not change the public JavaScript API.

• Fixed a static-frameworks header visibility issue where the public NotifeeApiModule.h header imported NotifeeCore.h. In clean Expo/EAS or CocoaPods builds using static frameworks, this could surface as 'NotifeeCore.h' file not found while compiling RNNotifee.
• The NotifeeCore dependency is now kept private to the implementation file instead of being exposed through the public API module header.

• Hardened the Expo smoke fixture for EAS validation by supporting Firebase file environment variables, enabling Corepack/Yarn 4 for the EAS development profile, making the dynamic Expo config compatible with the EAS config reader, and preserving the NotifyKit config plugin build output in the EAS archive.
• Validated Android EAS Build for the Expo smoke fixture, including Firebase file env secrets, NotifyKit config plugin resolution, RNFirebase config, Gradle build, and APK artifact generation.

• Android EAS validation was limited to the Expo smoke fixture and produced an APK artifact.
• The APK artifact was not used for a full runtime FCM smoke in that validation pass.
• EAS iOS cloud build was not part of this validation and remains a separate gate requiring Apple credentials/provisioning.
• Expo Go remains unsupported because NotifyKit requires native modules and native notification targets/capabilities.
• Existing iOS background JS PRESS marker and killed-state tap validation limits still apply.

Release focused on the first official Expo CNG integration for development builds across iOS and Android. This is support for Expo prebuild and development builds, not Expo Go.

• Added an official config plugin entry for react-native-notify-kit.
• iOS: the plugin can generate and wire the NotifyKitNSE Notification Service Extension during Expo prebuild, so Expo development builds can use the FCM Mode attachment/rich-notification path without manually creating the NSE in Xcode.
• Android: the plugin can configure NotifyKit foreground service manifest requirements when explicitly opted in through android.foregroundService.types.
• The plugin supports ios.notificationServiceExtension: true and an object form with enabled, targetName, and bundleSuffix.
• The Android foreground service config supports type-specific manifest permissions and requires specialUseSubtype when specialUse is selected.
• Expo Go is not supported because NotifyKit requires native modules and native notification targets/capabilities.

• The Expo prebuild path now creates the NSE files, Xcode target, host app dependency, .appex embed phase, bundle identifier, entitlements, and Podfile target.
• The generated NSE Podfile target is isolated from the Expo host target to avoid inheriting host modules that do not belong in the extension.
• Static framework alignment was fixed for Expo projects using Firebase and use_frameworks!.
• NotifeeExtensionHelper header imports were adjusted so RNNotifeeCore can compile inside the generated NSE under static-framework/header-map constraints.

• Android foreground service manifest configuration is available through the NotifyKit config plugin, but it is opt-in. Android remains no-op by default when android.foregroundService is omitted.
• The plugin writes app.notifee.core.ForegroundService, android:foregroundServiceType, FOREGROUND_SERVICE, type-specific FOREGROUND_SERVICE_* permissions where Android defines them, and the specialUse subtype property when required.
• The plugin does not configure Firebase, does not install RNFirebase, does not add USE_EXACT_ALARM, does not add USE_FULL_SCREEN_INTENT, and does not add Maven or extraMavenRepos workarounds.
• Android FCM Mode in Expo remains data-only: RNFirebase receives the message and the app calls notifee.handleFcmMessage(remoteMessage).

• Validated a real npm tarball install from a scratch fixture, plugin resolution from node_modules, Expo config, iOS prebuild, pod install, xcodebuild, NotifyKitNSE.appex generation, and app embedding.
• Validated Expo development build runtime smoke on iOS and Android.
• Validated iOS FCM Mode foreground delivery on a physical iPhone with a generated NSE, logical attachment metadata visible through getDisplayedNotifications(), and observed NotifyKitNSE process.
• Observed iOS visible FCM background delivery and tap-to-open, but the Expo smoke does not currently produce a reliable JS PRESS marker for iOS background tap routing.
• Validated Android Expo config, Android prebuild, expo run:android, base runtime, FCM token registration, foreground android-expo-smoke, background android-expo-smoke, visible notification display, and killed-state best-effort delivery without force-stop on a Pixel 9 Pro XL running Android 16 / SDK 36.
• Validated Android RNFirebase data-only foreground and background paths through SMOKE:FCM_ON_MESSAGE, SMOKE:FCM_FOREGROUND_HANDLE_OK, SMOKE:FOREGROUND_EVENT_DELIVERED, SMOKE:FCM_BACKGROUND_MESSAGE, and SMOKE:FCM_BACKGROUND_HANDLE_OK.
• Validated Android foreground/background delivery and tap routing in the Expo smoke app on a Pixel 9 Pro XL, including background SMOKE:BACKGROUND_EVENT_PRESS and optional foreground SMOKE:FOREGROUND_EVENT_PRESS.
• Validated the Android Expo foreground service config plugin with a real prebuild and a runtime shortService smoke on a Pixel 9 Pro XL.

• Expo Go remains unsupported.
• Android background and killed-state data-only delivery depends on FCM priority, device state, Doze, and OEM policy. Force-stop is excluded.
• Android tap validation covers the Expo smoke app on a Pixel 9 Pro XL only. It is not a guarantee for every device, OEM state, or force-stop path.
• iOS JS PRESS marker validation for visible FCM background tap remains a follow-up. iOS killed state, visual lock-screen/banner attachment rendering, textual NSE log capture, and iOS RNFirebase data-only/client-handler validation were not completed as release gates for 10.4.0.
• Android foreground service runtime validation covers shortService only. Other foreground service types were not runtime-validated, and Google Play foreground service policy compliance remains the app developer's responsibility.
• The Expo smoke app was migrated to React Native Firebase modular APIs to remove the namespaced API deprecation warning from the smoke paths. This is smoke fixture cleanup only and does not change the public NotifyKit API or add a consumer requirement.

Patch release focused on iOS notification delegate reliability and generated iOS core packaging. It does not add a public API, change JavaScript payloads, or introduce a breaking change.

• Improved UNUserNotificationCenter delegate chaining reliability with an internal idempotent rechain path. This helps NotifyKit stay in the notification callback path when another SDK assigns itself as the notification center delegate after NotifyKit, while refreshing downstream selector flags and preserving downstream forwarding for non-NotifyKit notifications.
• Preserved NotifyKit ownership for local, trigger, and FCM Mode notifications marked with __notifee_notification, including when handleRemoteNotifications is disabled for non-NotifyKit remote notifications.
• Guarded downstream delegate completion handlers so duplicate downstream completion calls do not invoke the upstream completion more than once. No downstream completion timeout or fallback behavior is introduced.
• The delegate reliability fix does not use method swizzling and does not introduce a general delegate multiplexer.

• Regenerated and verified the generated package iOS core before packing.
• Added verification that packages/react-native/ios/NotifeeCore matches the root ios/NotifeeCore source of truth and that the npm tarball includes all 17 iOS core files.

• Added iOS delegate chaining harness coverage for current delegate capture, late delegate override, explicit rechain behavior, downstream forwarding, NotifyKit-owned ownership, selector flag refresh, handleRemoteNotifications: false, FCM Mode ownership, and downstream completion one-shot behavior.

• iOS: hardened Notification Service Extension handling for FCM Mode payloads. The extension now accepts notifee_options both as the FCM Mode JSON string and as the legacy/manual APNs dictionary shape, with safe fallback for malformed or unexpected payloads.
• iOS: guarded Notification Service Extension delivery against duplicate contentHandler calls during normal-completion / timeout races.
• iOS: scoped Notification Service Extension helper state per request, reducing the risk of stale state when attachment completions arrive late.
• iOS: fixed getNotificationCategories() readback for text input notification actions.
• iOS: hardened the non-NSE local attachment downloader with explicit timeouts and safer filename-extension handling.

• Added ObjC harness coverage for NSE payload parsing/fallback and local attachment downloader behavior.
• Added iOS device smoke automation with callback-based PASS/FAIL results for local notifications, displayed-notification verification, FCM minimal delivery, and FCM iOS attachment delivery.

• Android: fixed a Kotlin compilation issue in prewarmForegroundService() on some React Native/Kotlin toolchains, reported with React Native 0.77.3, where the direct app.notifee.core.WarmupHelper reference could fail with Unresolved reference 'app'. The bridge now imports WarmupHelper explicitly. This is a compile-time fix only with no runtime behavior, public API, JavaScript payload, Gradle, or manifest changes.

• Android: internal Bundle/Parcelable reader modernization and deprecation cleanup. No public API, JavaScript payload, scheduling, Room, reboot recovery, foreground service, or PendingIntent behavior changes are intended.

• Android: pressAction: null now fully disables notification body taps. The notification body no longer opens the app, emits PRESS, or populates getInitialNotification() when the press action is explicitly opted out. Action buttons remain unaffected.
• Android: fixed getChannelGroup() delegation to use the channel group API instead of the channel API.

• Tests: expanded Android regression coverage around notification, channel, trigger parsing and manager scheduler paths.
• Tests: added Android unit and smoke coverage for PRESS / ACTION_PRESS routing, InitialNotificationEvent, Headless JS dispatch, action buttons without launchActivity, pressAction: null, and default notification body taps.

• Android: getPowerManagerInfo().activity now represents a known vendor-settings candidate rather than a PackageManager-prevalidated activity.
• Android: openPowerManagerSettings() now attempts vendor settings intents directly and safely falls back or no-ops when Android cannot resolve or start the intent.

• Android: guarded notification posting on Android 13+ when POST_NOTIFICATIONS is not granted, avoiding uncontrolled SecurityException failures and DELIVERED events when notify() is not called.
• Android: removed the protected BROADCAST_CLOSE_SYSTEM_DIALOGS permission from the library manifest so it is no longer propagated to consumer apps.
• Android: made the legacy ACTION_CLOSE_SYSTEM_DIALOGS path best-effort and SecurityException-safe on Android 11 and lower.
• Android: removed the ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS direct-request path from the Oppo/ColorOS power-manager fallback.
• Android: removed package-visibility queries from the power-manager settings helpers; vendor settings now open best-effort without requiring consumer apps to inherit <queries> declarations.
• Android: cleaned up owned lint warnings after the permission, policy, package-visibility, discouraged API, and obsolete SDK guard fixes.
• iOS: made the notification display application-state check app-extension-safe so RNNotifeeCore can compile inside a Notification Service Extension target.
• CLI/iOS: updated init-nse Podfile patching to avoid an Xcode build cycle between an embedded NotifyKitNSE.appex and React Native Firebase's [RNFB] Core Configuration phase.

• Docs: made reference generation self-contained by generating src/version.ts before TypeDoc.
• Docs: guarded reference generation against running without Git metadata, preventing degraded Defined in links.
• Docs: upgraded TypeDoc reference tooling for TypeScript 5.9 compatibility.
• Docs: included previously missing referenced API types in the generated reference: ModuleWithStatics and WebNotificationSettings.
• Docs: formatted manual MDX documentation pages.

• Tests: added an iOS/NSE hardware automation script for init-nse, pod install, RNFB cycle checks, iOS builds, FCM scenario sending, logs, reports, and cleanup.
• Tests: validated Android hardware E2E, including foreground/background FCM, killed rerun without force-stop, tap PRESS, action buttons, and BigPicture notifications.
• Tests: validated iOS/NSE hardware E2E on physical device, including foreground/background/killed FCM, NSE processing, attachment handling, and tap flow.
• Smoke app: cleaned up Android manifest lint warnings for redundant labels and data extraction rules.

• React Native: TimestampTrigger.repeatInterval for calendar-based custom repeat intervals on timestamp triggers. Timestamp triggers now support custom repeat intervals such as every 2 days, every 2 weeks, and every 3 months from the selected start timestamp.
• React Native: RepeatFrequency.MONTHLY for monthly timestamp trigger recurrence. Yearly recurrence is not supported.
• iOS: custom repeat intervals are implemented with a bounded rolling schedule of one-shot local notifications, with top-up when the app becomes active, when the user interacts with a notification, or when a rolling notification is delivered in foreground.

• iOS: removed the legacy UILocalNotification launch-options fallback from the initial-notification path. Supported iOS versions use the modern UNUserNotificationCenterDelegate / UNNotificationResponse path for notification taps and getInitialNotification().
• iOS: migrated deprecated SiriKit call intent identifiers to Apple's unified INStartCallIntentIdentifier. The public IOSIntentIdentifier.START_CALL should be used for notification category intent identifiers. Legacy START_AUDIO_CALL and START_VIDEO_CALL values remain accepted for compatibility, but now map to the unified call intent identifier. getNotificationCategories() can return START_CALL when reading back call intent categories from iOS.
• iOS: deprecated announcement and notification-summary options are now treated as compatibility no-ops on supported iOS versions. Explicit announcement authorization requests are no longer needed because announcement authorization is included by iOS on supported versions, while notification summary arguments are ignored by iOS 15+. The JS fields remain available for backward compatibility and are marked as deprecated in the TypeScript reference.
• iOS: foregroundPresentationOptions.alert is now implemented with the modern banner/list presentation options on supported iOS versions instead of calling the deprecated UNNotificationPresentationOptionAlert. The JS option remains available for backward compatibility.
• iOS behavior change: repeating TimestampTrigger notifications now use a bounded rolling schedule of one-shot local notifications instead of a native repeating UNCalendarNotificationTrigger. This makes custom repeat intervals (repeatInterval) and RepeatFrequency.MONTHLY possible, respects the selected start timestamp, and rebalances the rolling pending-notification budget across active series. Apps that relied on iOS native repeating calendar triggers being scheduled indefinitely should review the new iOS rolling-window behavior: the library keeps upcoming occurrences scheduled and tops them up when the app becomes active, when the user interacts with a notification, or when a rolling notification is delivered in foreground. iOS does not wake an app merely because a local notification was delivered while the app is killed or suspended, so the rolling window cannot be extended indefinitely unless the app runs again.
• Android: timestamp trigger recurrence now advances by repeatFrequency * repeatInterval using calendar-aware scheduling. Existing triggers without repeatInterval keep the previous behavior with interval 1.
• Tooling: yarn gen:reference now formats generated reference docs with Prettier so repeated runs are idempotent. The smoke app also has a dedicated Jest setup for a lightweight import/render gate, with owned iOS build warnings cleaned up.

• iOS: rolling timestamp triggers now rebalance the bounded pending-notification window across all active rolling series. This prevents earlier recurring triggers from consuming the entire iOS pending budget and blocking later triggers such as DAILY + repeatInterval: 2, WEEKLY + repeatInterval: 2, and MONTHLY + repeatInterval: 3 from coexisting.
• Android: cleaned up owned build/lint warnings by modernizing Gradle assignment syntax, replacing deprecated React Native activity access in the Kotlin bridge, adding an explicit action guard to RebootBroadcastReceiver, using Locale.ROOT for resource-name normalization, and removing the invalid smoke-app FOREGROUND_SERVICE_SHORT_SERVICE permission.

• Android: RepeatFrequency.MONTHLY is supported with AlarmManager. It is not supported with alarmManager: false, because WorkManager uses duration-based intervals and does not provide calendar-month recurrence semantics.
• iOS: custom repeat intervals cannot be extended indefinitely while the app remains killed/suspended and the user never interacts with notifications, because iOS does not wake the app merely when a local notification is delivered.

• Android: ResourceUtils.getFallbackSmallIconId(Context) — new public static helper that returns a resource ID guaranteed to be valid for a smallIcon. Three-layer fallback: applicationInfo.icon → applicationInfo.logo → android.R.drawable.ic_dialog_info. Never returns 0, never throws, catches any exception and falls through to the system default. Reusable from any code path that needs an emergency icon.

• Tests: ResourceUtilsFallbackIconTest — six Robolectric + Mockito unit tests covering each of the three fallback tiers, the exception-swallow branch, the null-context branch, and a "never returns 0" invariant guard across all five paths. NotificationAndroidModelSmallIconFallbackTest — three Robolectric unit tests covering the getSmallIcon() return contract when the smallIcon key is missing, unresolvable, or empty.

• Tests: validateTrigger.test.ts cases covering the three new small-timestamp error paths and a regression guard for the existing "must be in the future" message on valid-but-past epoch-ms values.

• Tests: new instrumented RebootRecoveryTest case covering the non-repeating future TIMESTAMP happy path (trigger with repeatFrequency: -1 and timestamp > now must survive a simulated reboot with its fire time preserved and the AlarmManager PendingIntent re-registered at the original timestamp). Complements existing coverage of past-stale non-repeating (within/beyond grace) and DAILY/WEEKLY repeating paths.

• Docs: new "Small icon not showing in Android release builds" subsection in the Troubleshooting section of both root README.md and packages/react-native/README.md, documenting the three common causes (asset only in src/debug/res/, R8 resource shrinking, naming mismatch) with recipes for each. New bullet in the "Behavior changes from upstream" section covering the fallback. New row in the "Bugs Fixed from Upstream Notifee" table referencing upstream invertase/notifee#733.

• Docs: New README subsection under "Quick Start > Handle events" clarifying iOS event-handler routing — tap from foreground fires onForegroundEvent, tap from background/killed fires onBackgroundEvent (because iOS reports UIApplication.applicationState == Inactive at the moment of the tap delivery, not Active). Resolves the confusion reported in upstream invertase/notifee#1155. New Troubleshooting subsection "Silent pushes and background fetch — handled by Firebase, not by this library" clarifying that the library does not hook application:didReceiveRemoteNotification:fetchCompletionHandler: and that silent-push JS execution in killed state is Firebase's responsibility, referencing upstream invertase/notifee#597. New callout at the top of docs/fcm-mode.mdx pointing users hitting upstream invertase/notifee#1133 ("onBackgroundEvent not triggered on iOS for remote notifications") to FCM Mode as the end-to-end resolution. Added explicit iOS tap-routing note (foreground/background) to docs/react-native/events.mdx; added SEO cross-reference to upstream invertase/notifee#1155 in the existing docs/react-native/ios/interaction.mdx#foreground-vs-background-routing section. Applied identically to root README.md and packages/react-native/README.md. Motivation: upstream repo archived April 7, 2026; README/npm/docs-site SEO is now the only discovery path for users still blocked by these upstream issues.

• Android: Behavior change — when android.smallIcon does not resolve to a valid resource ID at runtime (asset only in src/debug/res/, R8 resource shrinking, naming mismatch), the library now falls back to the app's launcher icon instead of letting NotificationCompat.Builder.build() throw IllegalArgumentException: Invalid notification (no valid small icon). The resolution failure is logged at level w (previously d, invisible in release logcat) with the original icon name, the three typical causes, and a pointer to the README Troubleshooting section. The log stays internal to logcat — LogEvent is not propagated to the JS layer (pre-existing architectural choice, unchanged here). Addresses the fragile code path behind upstream invertase/notifee#733.

• Android: removed spurious BOOT_COMPLETED intent-filter from NotificationAlarmReceiver in AndroidManifest.xml. The receiver does not handle boot — reboot recovery is owned exclusively by RebootBroadcastReceiver (already present and correct). The removed filter previously caused no-op wakeups on every device boot with a null-extras Intent that early-returned at NotificationAlarmReceiver.java:43. No behavior change for notification delivery.

• TypeScript: validateTrigger now produces targeted error messages when trigger.timestamp is suspiciously small (< 1e12 ms). Three cases are distinguished: day-of-month values (1–31) suggest date.getDate() usage, values in the 1e9–1e12 range suggest seconds since epoch instead of milliseconds, and other small values produce a generic "too small" message. All three messages recommend Date.now() or date.getTime(). Addresses upstream invertase/notifee#872. Previously these cases all emitted the generic "'trigger.timestamp' date must be in the future." which did not help users diagnose the root cause — a confusion between .getDate() / seconds / milliseconds.

• Docs: Linked upstream Notifee issues #1079, #1226, and #1262 to the existing 9.2.0 architectural fix entry in the "Bugs Fixed from Upstream Notifee" table (previously marked N/A (architectural)). All three are the same root cause — the pre-compiled AAR distributed via a bundled Maven repo at node_modules/@notifee/react-native/android/libs/ — and are all resolved by the single-module compile-from-source architecture introduced in 9.2.0. Added a new Troubleshooting subsection #### `Could not resolve app.notifee:core:+` — does not apply to this fork to capture direct Google searches for the error string. Applied identically to the root README.md and packages/react-native/README.md. Motivation: the upstream repo was archived on April 7, 2026 and issue commenting is no longer possible, so README/npm SEO is now the only discovery path for users still blocked by these issues.

• Docs: Added two rows to the "Bugs Fixed from Upstream Notifee" table in both README.md and packages/react-native/README.md linking upstream issues invertase/notifee#601, #1063, and #991 to the fork releases that resolved them (9.1.12 + 9.1.14 + 9.5.0 + 9.6.0 cumulative). Updated the "33 upstream bugs fixed" header counter to 35. Motivation: the upstream repo was archived on April 7, 2026, so README/npm SEO is now the only discovery path for users googling these issues.

• FCM Mode: end-to-end Firebase Cloud Messaging integration — a data-only Android payload plus an iOS alert + Notification Service Extension payload, built from a single server call. Introduces notifee.handleFcmMessage(remoteMessage) (one-liner client handler), notifee.setFcmConfig(config) (optional startup config with defaultChannelId, defaultPressAction, fallbackBehavior, and ios.suppressForegroundBanner). See the FCM Mode guide for the full architecture.
• Server SDK: new react-native-notify-kit/server subpath export — a zero-runtime-dependency Node.js / Firebase Cloud Functions helper that builds FCM HTTP v1 message payloads. Public API: buildNotifyKitPayload, buildIosApnsPayload, buildAndroidPayload, serializeNotifeeOptions. 100% unit-test coverage.
• CLI init-nse: npx react-native-notify-kit init-nse scaffolds an iOS Notification Service Extension target, patching .pbxproj and Podfile automatically. Ships in the main package — no extra install. Supports --dry-run, --force, --target-name, --ios-path, --bundle-suffix. Atomic writes with rollback on failure.
• Package exports: packages/react-native/package.json now declares a formal exports map. Public entries: ., ./server, ./jest-mock, ./react-native.config.js, ./package.json.
• Docs: new docs/fcm-mode.mdx — comprehensive FCM Mode guide covering architecture, server SDK reference, client API reference, iOS NSE setup, Android specifics, payload schema, migration from the manual pattern, troubleshooting, and known limitations.

• Client: handleFcmMessage filters out iOS attachments with missing/empty url instead of propagating to the validator.
• Client: reconstructNotification emits a console.warn when a recognized Android style type (BIG_TEXT / BIG_PICTURE) is present but the required sub-field is missing.
• Client: setFcmConfig and handleFcmMessage deep-copy the nested ios sub-object, preventing caller mutation.
• CLI: Podfile patching rolls back atomically when it cannot locate the app target's closing end.
• CLI: --bundle-suffix is validated against /^\.[A-Za-z0-9\-.]+$/.
• CLI: bundle-ID detection is scoped to the app target's own buildConfigurationList, not all targets globally.
• CLI: $(PRODUCT_NAME) / $(TARGET_NAME) variables are expanded when deriving the NSE bundle ID.
• CLI: RNFB-style INFOPLIST_FILE input path is stripped from the host target after adding the NSE to avoid an Xcode build cycle.
• CLI: Swift NSE template uses the correct with: selector label when calling NotifeeExtensionHelper.populateNotificationContent.
• iOS: RNNotifeeCore.podspec declares DEFINES_MODULE = YES so the NSE target can import RNNotifeeCore as a Swift module.

• android: getDisplayedNotifications() now exposes custom keys from Notification.extras as a top-level data field on the result, matching iOS behavior. Reserved keys (android.*, google.*, gcm.*, fcm.*, notifee*, plus from, collapse_key, message_type, message_id, aps, fcm_options) are filtered out. Note: this cannot surface custom data for FCM-auto-displayed push notifications because FCM routes those fields exclusively to the tap-action PendingIntent — use data-only messages and notifee.displayNotification() for full control on Android. (upstream: invertase/notifee#393)
• tests: GetDisplayedNotificationsDataTest — 17 Robolectric tests covering the denylist filter, prefix precision, non-string value coercion, and fcm_options exact-match parity.

• android: fixed ObjectAlreadyConsumedException: Map already consumed crash in HeadlessTask.TaskConfig when the same WritableMap instance is reused across headless events. TaskConfig.init now copies the map before mutating it. (upstream: invertase/notifee#266)
• android: RebootBroadcastReceiver, NotificationAlarmReceiver, and AlarmPermissionBroadcastReceiver now wrap their synchronous section in a try/catch/finally so PendingResult.finish() is always called, even when a failure occurs before the async callback is registered. (upstream: invertase/notifee#734)
• android: stale non-repeating trigger notifications (timestamp in the past at reboot time) no longer become "zombie" alarms that re-fire on every reboot. Within a 24-hour grace period the trigger fires once and the Room row is deleted; beyond the grace period the row is deleted silently. (upstream: invertase/notifee#734)

• android: cold-start self-healing for scheduled alarms on OEM devices that suppress BOOT_COMPLETED (Xiaomi MIUI, Oppo ColorOS, Huawei EMUI, Vivo FuntouchOS). InitProvider reads Settings.Global.BOOT_COUNT on every app init and triggers a full alarm reschedule when a boot delta is detected. A process-wide AtomicBoolean race guard prevents double-advancement when both BOOT_COMPLETED and the cold-start path race. (upstream: invertase/notifee#734)
• android: regression tests for DAILY/WEEKLY/HOURLY trigger rescheduling, including DST spring-forward and fall-back edge cases. (upstream: invertase/notifee#839, #875)
• tooling: scripts/smoke-test-734.sh — composable manual smoke-test harness for #734 covering build, Room DB dump, BOOT_COUNT reads, logcat capture, reboot, state wipe, and the destructive RebootRecoveryTest suite (gated behind --i-know).
• docs: new "OEM Background Restrictions" and expanded "Foreground Service Setup (Android 14+)" sections in the READMEs, plus a new "AlarmType guide" covering AlarmType.SET_ALARM_CLOCK — the strongest reliability guarantee Android exposes for a scheduled notification. (upstream: invertase/notifee#410, #655)

• android: resolved upstream issue invertase/notifee#549 — cancelTriggerNotifications() and createTriggerNotification() JS Promises resolved before the underlying Room database write completed, causing a race where a cancel-then-create pattern could leave inconsistent state. All five WorkDataRepository mutation methods now return ListenableFuture<Void> and are chained into the outer future at every call site. Empirical reproduction rate before fix: ~3.3% per attempt, <50 ms window. Post-fix: 0 inconsistencies across 150 attempts.
• android: fixed a reboot-recovery data-loss bug surfaced by the read-only caller audit. NotifeeAlarmManager.rescheduleNotification (invoked on BOOT_COMPLETED) fire-and-forgot the WorkDataRepository.update(...) that persists the next-fire timestamp for each recurring alarm. If Android killed the receiver's process before Room drained, the updated anchors were lost and the next reboot rescheduled from stale timestamps. The receiver now collects all per-entity update futures, combines them with Futures.allAsList, waits with an 8-second Futures.withTimeout ANR safety net, then calls pendingResult.finish().
• android: fixed an ordering bug in NotificationManager.doScheduledWork where completer.set(Result.success()) was called before the one-time trigger row was deleted from Room. The delete future now completes first.
• android: NotifeeAlarmManager.displayScheduledNotification now awaits the Room update / delete before calling BroadcastReceiver.PendingResult.finish().
• android: WorkDataRepository.insertTriggerNotification(...) helper cleanup — explicit Context parameter, removing a fragile dependency on NotifeeInitProvider having populated the singleton before the first trigger creation.

• android: BEHAVIOR CHANGE — errors from WorkDataRepository mutations (e.g. SQLiteFullException, SQLite corruption, schema migration failures) now propagate as rejections on the JS Promises for cancelTriggerNotifications, cancelTriggerNotification, createTriggerNotification, and cancelAllNotifications(ids). Previously these exceptions were silently swallowed.
• android: LATENCY CHANGE — cancelTriggerNotifications() and createTriggerNotification() Promises now resolve only after the Room write has completed. On a warm database this adds roughly 5–15 ms on a Pixel 9 Pro XL.

• android: WorkDataRepositoryFutureContractTest — JVM unit test (Mockito + CountDownLatch) verifying all five mutation methods return non-null futures that only complete after the underlying DAO call has returned. 13 tests.
• android: WorkDataRepositoryRaceTest — instrumented test under androidTest/ with 100-iteration race scenarios. Not wired into CI yet; run manually via ./gradlew :react-native-notify-kit:connectedDebugAndroidTest.
• tooling: scripts/verify-549-fix.sh — automated 5-run harness verification script that writes post-fix-549-verification.md with a strict PASS/FAIL verdict.
• tooling: TriggerRaceTestScreen.tsx harness emits one compact JSON line per scenario plus a -DONE terminator.

• android: foreground service notifications on Android 12+ (API 31+) were subject to a system-imposed display delay of up to 10 seconds because the library never called setForegroundServiceBehavior(FOREGROUND_SERVICE_IMMEDIATE). This is now set by default when asForegroundService: true. Opt out via foregroundServiceBehavior: AndroidForegroundServiceBehavior.DEFERRED. (upstream: invertase/notifee#272, invertase/notifee#1242)
• android: ANR-proofed the foreground service STOP path. When a ForegroundService instance receives a STOP intent without startForeground() having been called, the service now emits a minimal placeholder via startForeground() before stopSelf(), preventing ForegroundServiceDidNotStartInTimeException. The placeholder is immediately torn down and not visible to the user.
• android: reset stale mCurrentNotification, mCurrentHashCode, and mCurrentForegroundServiceType on the foreground service NONE early return path (API 34+).
• android: empty foregroundServiceTypes arrays that bypass the TypeScript validator (e.g. trigger notifications restored from the Room database after a library upgrade) are now treated as absent at the native layer.
• android: ForegroundService defensive STOP path fails fast with a clear error message and documentation URL when the consumer's manifest is missing required foregroundServiceType declarations on API 34+.
• android: ForegroundService NONE early return path honors Android's 5-second startForeground() contract via the same tracked-boolean defensive pattern as the STOP path.
• android: ForegroundService.stop() now logs a warning via Logger.w when startService() throws IllegalStateException and falls back to stopService().
• android: getLights() and cancelAllNotificationsWithIds() preserve exception stack traces in their error logs.
• typescript: numeric enum validators now correctly reject reverse-mapped string keys across all numeric enum types (AndroidBadgeIconType, AndroidDefaults, AndroidFlags, AndroidGroupAlertBehavior, AndroidImportance, AndroidVisibility, AndroidForegroundServiceType, AndroidForegroundServiceBehavior, RepeatFrequency, AlarmType). Previously, strings like importance: "HIGH" passed validation but were silently ignored by Bundle.getInt().
• tests: setPlatform test helper no longer fails silently on repeated calls within a single test block.
• ios: didReceiveNotificationResponse:withCompletionHandler: now calls the completion handler immediately after emitting the PRESS/ACTION_PRESS event, instead of delaying it by 15 seconds via dispatch_after.
• ios: requestPermission: propagates the NSError from requestAuthorizationWithOptions:completionHandler: to the JS promise. Previously the error was silently swallowed.
• ios: displayNotification: and createTriggerNotification: now capture and log errors from contentByUpdatingWithProvider:error:. On failure, the notification is displayed with the original content rather than potentially nil content.
• ios: getBadgeCount: calls the completion block with (nil, 0) when running in an app extension, preventing the JS promise from hanging.
• ios: fixed a race in NotifeeCoreDelegateHolder.didReceiveNotifeeCoreEvent: where a notification event could be silently dropped when the weak delegate reference was zeroed while the delegateRespondsTo bitfield still indicated it was available. Locked path now checks the resolved delegate for nil and falls back to buffering.
• ios: added @synchronized(self) guards around all access to hasListeners and pendingCoreEvents in NotifeeApiModule.mm.
• ios: replaced placeholder // update me with logic comment on the empty messaging_didReceiveRemoteNotification: handler with documentation explaining the intent.
• ios: Notification Service Extension attachment downloads now cap the NSURLSession request and resource timeouts at 25 seconds, leaving a 5-second margin before the NSE budget expires.

• android: new AndroidForegroundServiceBehavior enum (DEFAULT, IMMEDIATE, DEFERRED) and foregroundServiceBehavior property on NotificationAndroid.
• android: android.os.Trace instrumentation on the foreground service notification path — custom trace sections visible in Perfetto traces.
• android: notifee.prewarmForegroundService() opt-in API for manual warmup control. Idempotent, safe to call multiple times. Resolves immediately as a no-op on iOS.
• android: Baseline Profile shipped in the library AAR covering the foreground service notification cold-start path. AGP 8.3+ merges it automatically.

• android: InitProvider now pre-loads critical foreground service classes and pre-warms the INotificationManager Binder proxy on a low-priority background thread during app startup. Opt out via <meta-data android:name="notifee_init_warmup_enabled" android:value="false" />.
• android: androidx.profileinstaller:profileinstaller:1.4.1 is now a transitive (api) dependency of the library.

• android: pressAction now defaults to { id: 'default', launchActivity: 'default' } when omitted. Previously, notifications without an explicit pressAction displayed correctly but tapping them did nothing. Apps that want a non-tappable notification can pass pressAction: null explicitly. Implemented via a reserved sentinel id (__NOTIFEE_OPT_OUT__) at the TS→native boundary.
• ios: BEHAVIOR CHANGE — EventType.DELIVERED is now emitted to onForegroundEvent for all Notifee-owned notifications displayed in foreground, not just trigger notifications. Previously the willPresentNotification: guard suppressed DELIVERED for immediate-display notifications. Android already behaved this way, so this also closes a long-standing iOS/Android asymmetry. DELIVERED emission in displayNotification:withBlock: is now gated to non-foreground states. Known limitation: trigger notifications firing in background/killed still do not emit DELIVERED on iOS (platform limitation).

• android: fixed NotificationManager.displayNotification() producing a tap-less PendingIntent when pressAction is absent from the notification bundle. Native path now synthesizes the default press action bundle.
• ios: fixed potential loss of notification events at cold start when the RN bridge takes longer than 1 second to initialize. Replaced dispatch_after(1 sec) + dispatch_once with an event-driven synchronous flush triggered when setDelegate: installs a valid delegate.
• ios: corrected error message in validateIOSPermissions for the badge field (was 'alert' badge a boolean value.).

• Removed unused .buckconfig (Buck no longer used by RN since 0.74).
• Removed unused .flowconfig (project is TypeScript-only).
• android: removed unused EventBus annotation processor and eventBusIndex build option.

• ios: PRESS events from notification taps while the app was in background were incorrectly routed to onForegroundEvent instead of onBackgroundEvent. Three issues were addressed: a leftover dispatch_after(1 second) from the TurboModule migration (9.1.0), an incorrect == UIApplicationStateBackground check (iOS reports Inactive at the moment of tap — changed to != UIApplicationStateActive), and a main-thread violation where applicationState was being read on a background thread. (#5)

• android: internal architecture change — collapsed the standalone NotifeeCore AAR into the React Native bridge as a single Android library module. The bundled local Maven repo at packages/react-native/android/libs/ and the frozen coordinate app.notifee:core:202108261754 are gone. Core Java sources now live at packages/react-native/android/src/main/java/app/notifee/core/ and are compiled from source. No public API changes. Migration from 9.1.x requires zero code changes.

• android: FAIL_ON_PROJECT_REPOS rejection on React Native 0.74+. The library no longer injects a Maven repository into the consumer's rootProject.allprojects.
• android: stale Gradle cache serving outdated bytecode after yarn upgrade. With the frozen Maven coordinate gone, the bytecode is rebuilt from source on every consumer build.

• ios: fixed duplicate symbols linker error when using Notification Service Extension ($NotifeeExtension = true) with static frameworks (use_frameworks! :linkage => :static). Added s.exclude_files in the $NotifeeExtension branch of RNNotifee.podspec so NotifeeExtensionHelper.{h,m} is compiled only by RNNotifeeCore.

• Updated README (root and npm) to reflect upstream archival: the original invertase/notifee repository was officially archived on April 7, 2026, and its README now recommends react-native-notify-kit as a community-maintained drop-in replacement.

• ios: willPresentNotification: fallback no longer silently drops foreground notifications when no original UNUserNotificationCenterDelegate was captured. Previously the fallback path called completionHandler(UNNotificationPresentationOptionNone), which told iOS to display nothing. It now returns the platform default presentation options (banner, sound, list, badge on iOS 14+). Affects apps using react-native-notify-kit without a library that also sets a UNUserNotificationCenter delegate — e.g. apps without @react-native-firebase/messaging, or apps using a different push provider. Apps using RN Firebase are unaffected.
• ios: resolved upstream issue invertase/notifee#828 — "All notifications are dismissed when the app is opened". Verified on a real device with four FCM pushes sent in sequence; all four remained after app tap and backgrounding.

• android: pressAction.launchActivity now defaults to 'default' at the native layer when pressAction.id === 'default' and launchActivity is not explicitly set. Closes a gap where native code paths bypassing the JS validator (trigger notifications restored from Room after reboot, headless tasks, future bridge changes) could reach native with launchActivity unset. No user-facing behavior change for apps using the standard JS API.
• android: fixed a pre-existing upstream bug in NotificationPendingIntent where String comparisons on line 155-157 used != (reference equality) instead of .equals(). Dormant before this release because the null guard above always short-circuited — surfaced by the new native-layer default for launchActivity.

• android: fixed AbstractMethodError on RoomDatabase.createOpenHelper when consumer apps resolved androidx.room:room-runtime < 2.6.0. Root cause: the core AAR's Maven POM was empty (published via raw artifact() instead of from(components.release)), so Room and all other core dependencies were invisible to Gradle dependency resolution. The fix:

  • Core AAR publishes a proper POM via from(components.release) with android.publishing.singleVariant("release"), exposing Room 2.8.4 and all runtime dependencies.
  • React Native bridge module declares room-runtime:2.8.4, sqlite:2.6.2, and sqlite-framework:2.6.2 as api dependencies.
  • Fixed fresco incorrectly scoped as api in core build.gradle — changed to implementation.
  • Aligned guava (33.3.1 → 33.5.0) and work-runtime (2.8.0 → 2.11.1) versions between core and bridge.

  Note for consumers with custom dependency pinning: the core AAR POM now exposes its runtime dependencies. If you have resolutionStrategy.force or strictly constraints on any of these, verify compatibility after upgrading.

• Softened tone in "Why this fork" README section.
• Added Trademark Notice section to README.

• Synced npm README with changelog formatting updates.

• android: update Room 2.5.0 → 2.8.4, WorkManager 2.8.0 → 2.11.1, Guava 33.3.1 → 33.5.0.
• android: cleaned up ProGuard rules — removed redundant entries, consolidated keep rules, suppressed pre-existing build warnings with targeted @SuppressWarnings annotations.
• android: fixed raw Class type usage in NotificationManager (now Class<?>).
• ios: align NotifeeCore Xcode project deployment target from iOS 10.0 to iOS 15.1, matching the podspec.

• android: fixed ProGuard keep rules using { <init>(...); } (constructor-only) instead of { *; } (all members) — classes annotated with @Keep or @KeepForSdk could have non-constructor members stripped by R8.
• android: fixed WakeLock leak in PowerManagerUtils.lightUpScreenIfNeeded — acquire() without timeout or release() prevented the device from sleeping; now uses acquire(3000L).
• android: fixed potential NPE in NotificationAndroidModel.getDefaults when the defaults array is present but empty.
• android: added -keeppackagenames app.notifee.core.** to ProGuard rules to prevent -repackageclasses from relocating InitProvider and sub-package classes.
• android: fixed missing return after null context check in IntentUtils.startActivityOnUiThread.

• android: ongoing now defaults to true when asForegroundService: true and ongoing is not explicitly set. Prevents foreground service notifications from being dismissed on Android 13, matching pre-Android 13 behavior. (upstream: invertase/notifee#1248)
• android: on Android 14+, foreground service notifications are automatically re-posted when dismissed by the user. Android 14 ignores FLAG_ONGOING_EVENT for most foreground service types (except mediaPlayback, phoneCall, and enterprise DPC); the library detects the dismissal and immediately re-displays the notification. (upstream: invertase/notifee#1248)

• android: fixed DST (daylight saving time) shifting repeating notifications by ±1 hour — replaced fixed-millisecond arithmetic with Calendar.add(). (upstream: invertase/notifee#875)
• android: fixed repeating trigger timestamp not persisted to database after recalculation — after reboot, notifications could fire at stale times.

• android: BREAKING — removed hardcoded foregroundServiceType="shortService" from the library's AndroidManifest.xml. Apps using asForegroundService: true on Android 14+ must now declare their own foregroundServiceType on app.notifee.core.ForegroundService in their app manifest. See the "Foreground Service Setup" section in the README for migration instructions. (upstream: invertase/notifee#1108)

• android: implemented onTimeout(int) (API 34) and onTimeout(int, int) (API 35+) in ForegroundService to gracefully stop the service when Android's foreground service timeout fires. Previously the missing handler caused an ANR crash when using shortService. (upstream: invertase/notifee#703)
• android: added early abort with clear error logging when foregroundServiceType is not declared on Android 14+, preventing Android's cryptic MissingForegroundServiceTypeException crash.
• android: fixed bitwise & used instead of logical && in ForegroundService.onStartCommand() null check.
• android: replaced deprecated stopForeground(boolean) with stopForeground(STOP_FOREGROUND_REMOVE) on API 33+ via compat helper.
• android: added synchronized blocks around ForegroundService static field cleanup to prevent races between the STOP handler, headless task completion callback, and onTimeout() paths.
• android: ForegroundService.onTimeout() now emits a TYPE_FG_TIMEOUT (9) event via EventBus with the notification data, startId, and fgsType — previously the service died silently with no event reaching JS.

• android: changed default AlarmType from SET_EXACT to SET_EXACT_AND_ALLOW_WHILE_IDLE for better Doze mode compatibility. (upstream: invertase/notifee#961)
• android: AlarmManager is now the default backend for trigger notifications instead of WorkManager, ensuring reliable delivery when the app is killed. Developers can opt out with alarmManager: false in the trigger config. (upstream: invertase/notifee#961)

• fixed getNotificationSettings() returning DENIED instead of NOT_DETERMINED on Android 13+ before the user has responded to the POST_NOTIFICATIONS permission dialog — now uses SharedPreferences to track whether requestPermission() has been called. (upstream: invertase/notifee#1237)
• fixed trigger notifications not firing on Android 14-15 when app is killed — added goAsync() to NotificationAlarmReceiver, RebootBroadcastReceiver, and AlarmPermissionBroadcastReceiver. (upstream: invertase/notifee#1100)
• fixed ContextHolder not initialized in NotificationAlarmReceiver, causing potential NullPointerException on OEM Android 14+ implementations.
• fixed SCHEDULE_EXACT_ALARM permission denial silently dropping scheduled alarms — now falls back to inexact alarm via setAndAllowWhileIdle with a warning log.
• added SecurityException catch around AlarmManager scheduling — if exact alarm permission is revoked between check and call, falls back to inexact alarm instead of crashing.
• fixed potential NPE in alarm scheduling when PendingIntent creation fails.
• fixed getInitialNotification() returning null when notification has no pressAction configured — InitialNotificationEvent sticky event is now posted regardless. (upstream: invertase/notifee#1128)
• added event buffering in NotifeeReactUtils to prevent foreground press events from being silently dropped when the React instance is not yet ready. (upstream: invertase/notifee#1279)
• fixed AlarmType.SET using RTC instead of RTC_WAKEUP, which prevented the device from waking to show the notification. (upstream: invertase/notifee#961)

• fixed getInitialNotification() returning null on cold start due to deprecated UIApplicationLaunchOptionsLocalNotificationKey check. (upstream: invertase/notifee#1128)
• added setNotificationConfig({ ios: { handleRemoteNotifications: false } }) opt-out flag to prevent Notifee from intercepting remote notification tap handlers — restores onNotificationOpenedApp() and getInitialNotification() for React Native Firebase Messaging. (upstream: invertase/notifee#912)
• fixed completionHandler not being called on notification dismiss path in didReceiveNotificationResponse:, preventing potential handler leaks.
• fixed completionHandler not being called in willPresentNotification: fallback path when no original delegate is available.
• added missing return after forwarding to _originalDelegate in didReceiveNotificationResponse:.

• fixed Maven metadata checksums for published Android artifacts.

• added compatibility section to README documenting supported React Native versions.

• fixed Maven metadata checksums for published Android artifacts.
• aligned package LICENSE with root repository LICENSE.

• Renamed package from @notifee/react-native to react-native-notify-kit across all source, configs, and documentation.
• android: replaced deprecated Kotlin APIs with current equivalents — currentActivity → getCurrentActivity(), TurboReactPackage → BaseReactPackage, hasActiveCatalystInstance() → hasActiveReactInstance().
• Moved Jest tests from tests_react_native/ into packages/react-native/__tests__/.
• Renamed tests_react_native_new/ to apps/smoke/.
• Simplified GitHub Actions CI by removing stale workflows.

• Removed --provenance flag from publishConfig to allow local npm publish.
• Excluded test files from root tsconfig.json and fixed lint formatting.

• Removed notifee_platform_interface package and its associated tests and dependencies (Flutter support dropped).

Initial fork release targeting React Native 0.84 with TurboModule (JSI) architecture.

• android: migrated React Native bridge from legacy NativeModule to Kotlin TurboModule with JSI bindings.
• ios: migrated React Native bridge from legacy NativeModule to TurboModule with JSI bindings.
• Added React Native 0.84 smoke-test app with updated Jest configuration.

• android: prevent headless task double-invocation (a799167)

• ios: copy iOS NotifeeCore library more carefully during build (68f230f)

• android: remove semantic-release test commit (0b4ecdf)

• android: semantic-release test commit (cf5c7a9)

• fix(android): fix another new architecture issue via elimination of race condition between headlessJS task and react-native background startup that resulted in null ReactContext (#1176)

• fix(android): preserve new-arch classnames used in backwards-compat logic (#1149 special credit to @mbpictures)

This fixes Notifee when used in react-native 0.76 in new architecture + release mode when used in an android background headlessJS context

This the minimum version that supports upcoming react-native 0.76 by default.

Older notifee versions will only work if you disable disable New Architecture / disable bridgless mode

• fix(android): forward-port getReactContext to new arch bridgeless mode (#1127 Thanks @Eclipses-Saros!)
• fix(jest): add missing createChannels method to official mock definitions (#1123)
• docs(android): clarify foregroundServiceType AndroidManifest example

• fix(android): add guava transitive dep to module deps (#1116)

Notifee no longer uses the GMS libraries and thus should be compatible with open source distribution channels like F-Droid now. Thanks @meypod!

• feat(android): Remove all gms usages and use guava instead (#510)
• test(ci, ios): simplify simulator / app interaction
• test(ci, ios): try more powerful runner, possible de-flake
• test(ci, ios): allow more time for e2e test

• fix(ios): use new icon badge APIs / correctly clear badge
• test(ci): use current path to ccache
• test(ci, ios): increase yarn install timeout to stop flakes
• test(ios): commit current pod lockfile
• style(lint, ios): fix various lint warnings
• style(lint): clean up warnings from yarn validate:all:js
• test(ci): use iPhone 16 now, 15 does not exist for Xcode 16
• test(ci): use hashFiles with specific paths vs globs
• docs: fix typo "AlarmManger" to "AlarmManager" (#1101)

• fix(android): rn74 compatibility support invalidate alongside deprecated onCatalystInstanceDestroy

improperly released, 9.0.2 released immediately after

BREAKING CHANGES!

Android 14+ requires two changes to avoid crashes or Play Store rejection

1. The USE_FULL_SCREEN_INTENT permission is not longer included by default as most apps do not need it. If you need it you must now manually add the permission to AndroidManifest.xml

2. Foreground Service Types are a strict requirement for Android 14 and require Play Store approval. You must use compileSdk 34 or higher for this release. If you need foreground service types you will need to specify the exact foreground service type permissions in your AndroidManifest.xml and you must replace the service definition in AndroidManifest.xml and you must use the new optional foregroundServiceTypes parameter in the foreground service API call

Thanks to all the contributors that proposed these fixes so that Notifee continues to work well on Android 14 - handling the platform security changes as Google makes new releases is not easy, and they always change the Nofitication API surface API. Notifee would not work without the community contributions.

Note, v8.0.0 was published 2 years ago as an alpha on npmjs.com but is unused. However, the version number was consumed by that alpha publish so we have skipped to v9.

• fix(android)!: Remove USE_FULL_SCREEN_INTENT permission from package manifest for Android 14 compat (#1027)
• feat(android)!: allow adding foreground service types dynamically
• feat(android): add Android 15 FOREGROUND_SERVICE_TYPE_MEDIA_PROCESSING
• fix(types): add cancelAllNotifications optional android tag property (#1087)
• build(android): minimal set of changes for compileSdk 34
• test(lint): check native code formatting in CI
• style(lint): result of auto-formatting yarn format:all
• style(lint): constrain formatting globs, add formatting check run scripts
• docs(android): note apps must now manually add USE_FULL_SCREEN_INTENT if needed

Unreleased

alpha publish from 2022, never made non-alpha, never in use, but version number consumed

• feat: group support to communication push #1017
• fix(iOS): Allow the original delegate to handle non-Notifee notifications first #985
• fix: Remove EventSubcriptionVendor type usage as it's removed in RN0.73 #1001
• fix(android): fix an issue when using inexact alarms #981
• style(lint): fix lint errors from previous commits #1073 q- test(ci, ios): ios build behaving strangely - tune timeouts
• test(example): minimum changes to get example working
• test(ci): remove log compression pre-artifact upload
• test(ci): use codecov action vs bash uploader
• test(ci, ios): switch to macos-14 / apple silicon, iPhone 14
• test(ci, android): use ubuntu+nested-virt+reactive-circus for emulator tests
• test(ci): forward port from GITHUB_OUTPUT vs set-output
• test(ci): bump actions to current versions
• test(ci): use github built-in concurrency controls
• style(lint): ignore pubspec.lock files when looking for changes
• test(android): two alarm manager tests hanging
• build(deps, ios): Podfile.lock version bumps in test app
• build(deps): yarn includes information about itself in package.json
• docs(CONTRIBUTING): auto tag for gh release, point to repo for changelog

• Fix packaging error / missing dist/version.js #934

• [Android]: Fix compatibility with android-gradle-plugin 8 (reat-native 0.73+) #907
• Dev and Test: lots of CI and test updates so all checks are green again and current versions of developer tools work while developing in the repository

• [Android]: Adds the ability to create all types of alarms with Android, affects the TimestampTriggerAlarmManager API type and deprecates property allowWhileIdle (Addresses issue #655))).
• [iOS]: Fixes an issue where the UI thread was getting blocked when creating a notification with attachments (Fixes #234))).
• [Android/iOS]: BREAKING CHANGE: For Expo, there is no config plugin anymore, please remove the plugin from app.config.js (See issue #799 for more info).

• [iOS]: Adds image caching for the avatar for Communication Notifications (PR #742))).

• [Android]: Fixes an issue with foreground PRESS event being treated as a background event (Fixes #621).
• [Android]: Fixes an issue where the event details of a notification were incorrect and were from another notification (Fixes #637 and #651).

• No changes, used to force npm registry to update for the previous version to appear.

• [Android]: Fixes an issue with interval triggers firing immediately (Fixes #696).
• [Android]: Fixes an issue with progress notification with indeterminate set to true (Fixes #682).
• [Android]: Android flag Flag_NO_CLEAR is now supported but can get the same behaviour with ongoing set to true (Fixes #674).
• [Android/iOS]: Fixes a ts error with latest React Native version 0.71+ (Fixes #708).
• [Android]: Fixes an issue where if autoCancel is set to false, for Android actions this was ignored for Android 12 and above (Fixes #697).
• [Android]: Remove unused android dependenecy okhttp3 which was reported to have been causing a problem (Fixes #699).

• [Android]: Updates the Android EventBus dependency to comply with the Google Play Store requirements (Fixes #668).

• [Android]: Fixes an issue when setting a custom launchActivity to ensure the correct activity is launched when a notification is pressed when app is closed (Fixes #646).
• [Android]: Fixes an issue with Android lights when parsing colors as strings for trigger notifications (Fixes #618).
• [Android]: Fixes an issue with jest mock where some mocks were not returning the correct type (Fixes #636).
• [Android]: Adds a new TYPE_FG_ALREADY_EXIST event type for foreground services (PR #634).
• [iOS]: Removes a debug console.log statement that was commited to the main branch (PR #617).

• [Android]: Fixes an issue for Android 11 and lower to ensure notification drawer is closed when a quick action is pressed. (Fixes #614).
• [Android]: Fixes an issue where the initial notification was not set if the app opened via a quick action (PR #605).

• [Android]: Fixes an issue for Android 12 with quick actions when the app is in the background (Fixes #404).
• [Android]: Prevents a NullPointerException to occur when a background service is triggered (Fixes #592).

• [iOS]: Supports communication notifications on iOS (PR #526).

• [Android]: Fixes an issue when calling requestPermissions for Android 12 or lower (Fixes #555).

• [Android]: Fixes an issue that was introduced in v6.0.0 to support targetSdkVersion 33 (Fixes #547).

• [Android]: Fixes an issue that was introduced in v6.0.0 (Fixes #528).

• [iOS]: BREAKING CHANGE: Notifee now handles response events (PRESSED, ACTION_PRESSED, DISMISSED) for remote notifications on iOS (PR #236).

  • This allows quick actions from remote notifications to be supported without the need of a NSE [Learn More]

  onNotificationOpenedApp and getInitialNotification from RNFB Messaging will no longer trigger as notifee will handle the event. Should not require any code changes to these RNFB event handlers, as events on Android will continue to work as normal

• [Android] BREAKING CHANGE: Added support for requesting permission on Android 13 via requestPermission, the minimum compileSdkVersion required has increased to 33. And, to support this feature, the targetSdkVersion must also be increased to 33.

• [iOS]: Adds new interruptionLevel property to NotificationIOS which provides the option to display time-sensitive notifications (Fixes #287).

• [Android]: Adds new loopSound and flags properties to NotificationAndroid to support custom flags and to loop the sound when a push notification is displayed (Fixes #454).

• [Android]: Fixes a compile issue for monorepos where sometimes app.notifee:core:+ cannot be found (Fixes #350).
• [iOS]: Adds new list and banner options to IOSForegroundPresentationOptions on iOS. These new options should be used as a replacement for the alert option which is now deprecated in notifee; notifee will fallback to using Apple's UNNotificationPresentationOptionAlert option for iOS 13 when either banner or list is set to true. There are no breaking changes, but we encourage you to update your project as soon as you can if you set custom IOSForegroundPresentationOptions. To learn more, view the Foreground Notifications documentation (Enhancement #382).

• [Android]: Fixes an issue when creating a one-time trigger notifications with AlarmManager (Fixes #445).

• [Android]: Fixes an issue when recreating the trigger notifications after a reboot with AlarmManager (Fixes #422).
• [Android]: Fixes an issue around displaying a heads-up notification on Xiaomi devices by adding the permission ACCESS_NOTIFICATION_POLICY to the AndroidManifest (Fixes #296).

• [Android]: Elimates the need to add the local maven repository manually to your project (PR #414).
• [Android]: Implements support to light up the screen when a notification is displayed. Introduces a new property lightUpScreen on the NotificationAndroid interface (PR #403).

• [Android]: Allows repeatFrequency to be set to -1 when creating notifications (Fixes #384).
• [Android]: Fixes an issue with rescheduling notifications with alarm manager (Fixes #384).

• [Android]: Fixes a build issue introduced in version 5.2.0 (PR #384).

• [Android]: Fixes a compiling issue for some project configurations with error message "Project with path ':app' could not be found in project ':notifee_react-native'" (Fixes #288).
• [Android]: Fixes an issue where the current version of Notifee does not build when using an expo managed app with the expo plugin (Fixes #314).
• [Web]: Basic support for react-native-web - notifications do not work on web yet, but the package is now compatible with web (PR #369)

• [Android]: Introduces new APIs to help manage Android 12 limitations when creating trigger notifications:
• canScheduleExactAlarms
• openAlarmPermissionSettings

And, the ability to check if your app has permissions to create trigger notifications by calling getNotificationSettings().

To learn more, see Triggers documentation for Android.

• [Android]: Fixes an issue when canceling trigger notifications created via AlarmManager to prevent "Maximum limit of concurrent alarms 500 reached for uid" error being thrown (Fixes #349).

• [iOS]: Fixes an issue with NotificationSettings returning the wrong property name for authorizationStatus on iOS (Fixes #333).

• [Android]: Fixes an issue where quick actions always opens the app on Android 12 (Fixes #315).
• [Android]: Fixes an issue where a quick action with an id of default failed to open the app.

• [Android/iOS] BREAKING CHANGE: Added support for checking permissions on Android which introduces a breaking change to requestPermission and getNotificationSettings APIs.

Both APIs have been updated to return an object of type NotificationSettings, in replace of NotificationSettingsIOS.

NotificationSettings consists of two properties authorizationStatus and ios, where ios is a nested object of type NotificationSettingsIOS.

To learn more, see Permissions documentation for iOS, and Android.

• [Android]: Add support to set largeIcon for AndroidStyle.BIGPICTURE to null (Fixes #270)
• [Android]: Fixes an issue with Android 12 when tapping on a notification (Fixes #250)
• [Android]: Fixes an issue when an action is pressed where the notification drawer would remain open with the notification (Fixes #268)

• [Android]: Fixes an issue with repeating trigger notifications where the next notification was scheduled at the incorrect time, causing the notification to infinitely display (Fixes #252).

• [Android]: BREAKING CHANGE : the minimum compileSdkVersion required has increased to 31, to fix an issue with Android 12 where the app will crash due to a missing Intent immutability flag (Fixes #238). You do not need to alter targetSdkVersion or anything else - but you must increase compileSdkVersion to 31. Please note, JDK11 is strongly recommended when using compile or target sdk 31. Please note, we do not correctly handle the new "exact alarm" Android 12 restrictions so we recommend staying on targetSdkVersion 30 for now.

• [Android]: Fixes an issue with buildtools to support gradle plugin 4.2+ (Fixes #211)
• [iOS]: Fixes an issue that was introduced in the previous patch when calling setBadgeCount with 0 (Fixes #212)

• [iOS]: Fix iOS API availability guards, and all compile warnings (Fixes #204)

• [Android]: Include support for expo managed projects [Learn More]]
• [Android]: Adds support for Android 12

• [Android]: Fixes an issue where the wrong quick action was triggered when fired in quick succession (Fixes #121)
• [Android]: Fixes an issue where notifications created by FCM were not being removed from the notification tray when cancelled (Fixes #120)
• [iOS]: Compiled module no longer depends on a XCFramework, as part of the migration to fully open source the library. [Learn More]

• [Android]: BREAKING CHANGE - the minimum SDK version has been updated from 16 to 20, providing backwards notification compatibility up to Android 4.4W.
• [Android]: Fixes an issue with getDisplayedNotifications where the id returned is not the original notification id. (Fixes #381)
• [Android]: Fixes an issue with displaying a notification with android.tag (Fixes #382)
• [Android]: Introduces support to cancel a notification with a tag
• Removed licensing validation and related code - Notifee is now free and fully open source. [Learn More]

• [Android]: BREAKING CHANGE - you must add a new maven local repository to your android/build.gradle file. (Fixes #151). See step #2 in the installation guide

• [Android]: Fixes an issue where getInitialNotification was sometimes throwing an error leading to a crash if activity was null. (Fixes #374)

• [Android]: Fixes an issue where the initial notification wasn't being populated for full-screen actions.
• [iOS]: Introduces a new method signature for NotifeeExtensionHelper.populateNotificationContent where the request is passed down as well as the bestAttemptContent. View the Remote Notification Support documentation for more information.
• [iOS]: Adds a note in the reference documentation that getInitialNotification() for iOS is deprecated in favour of onForegroundEvent.

• [Android]: Fixes an issue on Android to prevent cancelDisplayedNotifications cancelling trigger notifications. (Fixes #349)

• [Android/iOS]: Introduces the following APIs:
  • getDisplayedNotifications
  • getTriggerNotifications
  • isChannelBlocked
  • isChannelCreated
  • cancelAllNotifications(ids)
  • cancelDisplayedNotifications(ids)
  • cancelTriggerNotifications(ids)
• BREAKING: Fixes an issue when setting a custom sound on a notification channel (Fixes #341). Sounds now must be specified without the file extension, previously it was optional. If you were using custom sounds on Android>7 prior to this, you will need to create a new notification channel or the reference to your custom sound on the channel will likely not survive app updates. We apologize for the inconvenience

• [Android]: Fixes an issue where an error is thrown when the intent was null in rare cases for foreground service events.

• [Android]: Fixes an issue where an error is thrown when using trigger notifications with AlarmManager on Android 8 & 7

• [Android]: Support Alarm Manager for trigger notifications.
• [iOS]: Xcode 12.4 and above is now supported

• [Android/iOS]: Fix npm bundle to exclude example app

• [Android/iOS]: Include support for jest tests by including a jest-mock.js file.
• [Android]: Add an extra safety check to prevent app from crashing if a launchActivity property is set to an invalid activity class.

• [Android/iOS]: Allows title, body, and subtitle to be set to undefined in addition to string values to prevent an empty space on Android.
• [Android/iOS]: Updated validation to only throw an error for platform-specific properties if the app is running the same platform (Feature enhancement #297).
• [iOS]: Xcode 12.5 is required on iOS.

• [Android]: Fixed an issue with jwt gradle build dependency.

• [Android]: Implemented support for notifee.hideNotificationDrawer (Feature enhancement #200).

• [Android]: Added support for fullScreenAction on NotificationAndroid (Feature enhancement #45).

• [Android]: Fixed an issue where sometimes the app would throw an exception when the user changes the notification blocked state for either a channel or the entire application (Fixes #237).

• [Android]: Fixed an issue where sometimes the foreground service failed to stop when calling resolve due to an issue with hot reloading. It can be stopped by notifee.stopForegroundService(). To learn more, view the Foreground Service documentation.

• [Android]: Fixed an issue with Notifee's build script where sometimes an error would occur that the target variant task already existed.

• [iOS]: Includes a Notification Service Extension Helper to take advantage of Notifee with remote notifications. To learn more, view the Remote Notification Support documentation.

• [iOS]: Enforce v1.10+ of CocoaPods (Fixes #230).

• [Android]: Includes a solution to fix an error due to a potential race condition that occurs when the user changes the notification blocked state for either a channel or the entire application (Fixes #237).

• [Android]: Implemented support for circularLargeIcon on NotificationAndroid (Feature enhancement #199).
• [iOS]: Prevent badge count from clearing notifications from the tray when it reaches 0 (Fixes #214).

• NOTE: Version bump.

• [Android]: Fixed an issue with license validation on Android 6 (Fixes #87)
• [iOS]: Added support for Apple Silicon (arm64) and Mac Catalyst builds (Fixes #162, #215)

• [Android]: Added additional logs to help with debugging license validation issues.
• [Android/iOS]: Fixed an issue where sometimes the NotifeeApiModule would fail to resolve this.native due to the context changing.

• [Android]: Fixed an issue where sometimes the largeIcon wouldn't show when the app is closed.
• [Android/iOS]: Fixed an issue to show a more descriptive warning if the background event handler isn't set via onBackgroundEvent.

• [Android]: Implemented additional support to help with background restrictions on Android, includes two new methods getPowerManagerInfo and openPowerManagerSettings.
• [Android]: Fixed an issue with subtitle where the default value was causing two dots on some devices.
• [Android/iOS]: Added support to cancel either a displayed or a trigger notification.

• [Android]: Fixed an issue where isBatteryOptimizationEnabled was returning the result as an object instead of a boolean.
• [Android]: Fixed an issue where openBatteryOptimizationSettings was sometimes throwing an exception for Samsung and Oppo phones on Android versions 6.0.
• [iOS]: Fixed an issue when a notification is pressed while the app is in the background on iOS 14, which sometimes would cause the app to crash.

• [Android]: Fixed an issue where trigger notifications created with v0.12.x and below would cause the app to crash when upgrading to v0.13.x.

• [iOS]: Added support to handle remote urls for Attachments.
• [iOS]: Added iOS support for repeatFrequency on TimestampTrigger. See Triggers.

• [Android]: Added support for repeatFrequency on TimestampTrigger to be able to create hourly, daily or weekly trigger notifications. See Triggers.
• [Android]: Implemented support to help with background restrictions on Android, includes two methods isBatteryOptimizationEnabled and openBatteryOptimizationSettings. See Background Restrictions.
• [Android]: Fixed an issue when creating a trigger notification, where sometimes the input data would reach the maximum number of bytes allowed.

• [Android]: Fixed an issue where pressAction with the default id failed to open the app when the notification was pressed.
• [Android]: Fixed an issue with gradle plugin 4.1 and Build.VERSION_NAME which prevented the app from building.

• [iOS]: Fixed an issue where the DELIVERED foreground event wasn't being sent for trigger notifications.
• [iOS]: Fixed an issue with the iOS module that sent events before the JS bundle was ready.

• [iOS]: Fixed an issue with the iOS module that prevented the library from compiling.

• [Android]: lightColor and sound are now returned when calling getChannel or getChannels.
• BREAKING: TimeTrigger has been removed, in favour of TimestampTrigger and IntervalTrigger.
• [iOS]: Trigger Notifications are now supported on iOS. See Triggers.

• [Android]: Fixed an issue with cancelNotification for trigger notifications.
• [Android]: Fixed an issue with remote verification on devices less than or equal to 20
• [iOS]: Call original delegate when intercepting notification response on iOS

• [Android]: Add support for Trigger Notifications on Android. See Triggers.
• [Android]: Fixed an issue with getChannels and getChannelGroups where the methods were throwing an error
• [iOS]: Fixed an issue with iOS 14 where sometimes the app would freeze briefly when receiving an push notification

• [Android]: Fixed an issue with sounds for Android versions < 8.0 (API level 26)
• [Android]: Fixed an issue with notifee.config.json where sometimes the script could not find the 'app' gradle project automatically.

• [iOS]: Add support for iOS onBackgroundEvent.
• [iOS]: Pool JS events until RN Bridge is ready.
• [Android]: Allow multiple onBackgroundEvent observers when inside a foreground service task.

• [iOS]: Add support for iOS notification attachments. See iOS Attachments.

• [iOS]: Fixed an issue where notifications would sometimes not appear in the foreground.

• [Android]: Fixed an issue where the Headless task key was incorrect for the foreground service task.update

• [Android]: Implemented support for launchActivityFlags - allowing you to customise the launch behaviour of your activities.
  • See AndroidLaunchActivityFlag for supported flags.

• [Android]: Fixed an issue with Android proguard rules that may have prevented the library from being used when minified.

• [Android]: notifee.config.json now supports specifying options for build flavours & types.
  • See this comment comment for an example.
• [TypeScript]: Reworked type definitions to fix minor definition issues.
• BREAKING: Importance has now been renamed to AndroidImportance and is no longer supported on iOS (replaced with foregroundPresentationOptions).
• [iOS]: Implemented support for ios.foregroundPresentationOptions to control foreground notification behaviour on iOS
  • See the iOS appearance guide for more information.
• [Android]: Fixed an issue where creating multiple channel or channelGroups would fail to create.
• [Android]: requestPermission now correctly resolves a dummy instance of IOSNotificationSettings (previously null on Android) for cross-platform compatibility.
• [Android]: largeIcon & picture (from big picture style) now supports React Native asset loading, e.g. largeIcon: require('./image.png').

Versions 0.0.1 through 0.5.1 were published to npm between 2020-01-27 and 2020-05-08 as private / early-access iterations and never received public release notes. Notifee was publicly launched with 0.6.0 on 2020-06-07 — that is why the history on this page starts there.

For the authoritative record of those early publications, see the npm version list on the package registry. Neither the upstream invertase/notifee repository nor this fork carries release notes for that window; no GitHub releases or git tags exist for versions older than 3.0.1.