react-native-notify-kit 9.1.8

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

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee
+
+import androidx.annotation.Keep
+import app.notifee.core.event.BlockStateEvent
+import app.notifee.core.event.ForegroundServiceEvent
+import app.notifee.core.event.LogEvent
+import app.notifee.core.event.NotificationEvent
+import app.notifee.core.interfaces.EventListener
+import com.facebook.react.bridge.Arguments
+
+@Keep
+class NotifeeEventSubscriber : EventListener {
+
+    companion object {
+        const val NOTIFICATION_EVENT_KEY = "app.notifee.notification-event"
+        const val FOREGROUND_NOTIFICATION_TASK_KEY = "app.notifee.foreground-service-headless-task"
+
+        private const val KEY_TYPE = "type"
+        private const val KEY_DETAIL = "detail"
+        private const val KEY_BLOCKED = "blocked"
+        private const val KEY_HEADLESS = "headless"
+        private const val KEY_NOTIFICATION = "notification"
+        private const val KEY_DETAIL_PRESS_ACTION = "pressAction"
+        private const val KEY_DETAIL_INPUT = "input"
+    }
+
+    override fun onNotificationEvent(notificationEvent: NotificationEvent) {
+        val eventMap = Arguments.createMap()
+        val eventDetailMap = Arguments.createMap()
+        eventMap.putInt(KEY_TYPE, notificationEvent.type)
+
+        eventDetailMap.putMap(
+            KEY_NOTIFICATION,
+            Arguments.fromBundle(notificationEvent.notification.toBundle()),
+        )
+
+        notificationEvent.extras?.let { extras ->
+            extras.getBundle(KEY_DETAIL_PRESS_ACTION)?.let { pressAction ->
+                eventDetailMap.putMap(KEY_DETAIL_PRESS_ACTION, Arguments.fromBundle(pressAction))
+            }
+            extras.getString(KEY_DETAIL_INPUT)?.let { input ->
+                eventDetailMap.putString(KEY_DETAIL_INPUT, input)
+            }
+        }
+
+        eventMap.putMap(KEY_DETAIL, eventDetailMap)
+
+        if (NotifeeReactUtils.isAppInForeground()) {
+            eventMap.putBoolean(KEY_HEADLESS, false)
+            NotifeeReactUtils.sendEvent(NOTIFICATION_EVENT_KEY, eventMap)
+        } else {
+            eventMap.putBoolean(KEY_HEADLESS, true)
+            NotifeeReactUtils.startHeadlessTask(NOTIFICATION_EVENT_KEY, eventMap, 60000, null)
+        }
+    }
+
+    override fun onLogEvent(logEvent: LogEvent) {
+        // LogEvent callbacks are emitted by NotifeeCore logging, but the React Native layer
+        // does not currently forward them to JS or headless tasks, so this subscriber
+        // intentionally ignores them.
+    }
+
+    override fun onBlockStateEvent(blockStateEvent: BlockStateEvent) {
+        val eventMap = Arguments.createMap()
+        val eventDetailMap = Arguments.createMap()
+
+        val type = blockStateEvent.type
+        eventMap.putInt(KEY_TYPE, type)
+
+        if (type == BlockStateEvent.TYPE_CHANNEL_BLOCKED ||
+            type == BlockStateEvent.TYPE_CHANNEL_GROUP_BLOCKED
+        ) {
+            val mapKey =
+                if (type == BlockStateEvent.TYPE_CHANNEL_BLOCKED) "channel" else "channelGroup"
+            blockStateEvent.channelOrGroupBundle?.let { bundle ->
+                eventDetailMap.putMap(mapKey, Arguments.fromBundle(bundle))
+            }
+        }
+
+        if (type == BlockStateEvent.TYPE_APP_BLOCKED) {
+            eventDetailMap.putBoolean(KEY_BLOCKED, blockStateEvent.isBlocked)
+        }
+
+        eventMap.putMap(KEY_DETAIL, eventDetailMap)
+
+        if (NotifeeReactUtils.isAppInForeground()) {
+            eventMap.putBoolean(KEY_HEADLESS, false)
+            NotifeeReactUtils.sendEvent(NOTIFICATION_EVENT_KEY, eventMap)
+        } else {
+            eventMap.putBoolean(KEY_HEADLESS, true)
+            NotifeeReactUtils.startHeadlessTask(
+                NOTIFICATION_EVENT_KEY,
+                eventMap,
+                0,
+                blockStateEvent::setCompletionResult,
+            )
+        }
+    }
+
+    override fun onForegroundServiceEvent(foregroundServiceEvent: ForegroundServiceEvent) {
+        val notificationBundle = foregroundServiceEvent.notification
+
+        val eventMap = Arguments.createMap()
+        eventMap.putMap(KEY_NOTIFICATION, Arguments.fromBundle(notificationBundle.toBundle()))
+
+        NotifeeReactUtils.startHeadlessTask(
+            FOREGROUND_NOTIFICATION_TASK_KEY,
+            eventMap,
+            0,
+            foregroundServiceEvent::setCompletionResult,
+        )
+    }
+}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee
+
+import app.notifee.core.InitProvider
+import app.notifee.core.Notifee
+import com.facebook.react.modules.systeminfo.ReactNativeVersion
+
+class NotifeeInitProvider : InitProvider() {
+
+    override fun onCreate(): Boolean {
+        val result = super.onCreate()
+        Notifee.initialize(NotifeeEventSubscriber())
+        return result
+    }
+
+    private fun getApplicationVersionString(): String {
+        val context = this.context ?: return "unknown"
+        return try {
+            val pInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+            pInfo.versionName ?: "unknown"
+        } catch (e: Exception) {
+            "unknown"
+        }
+    }
+
+    private fun getReactNativeVersionString(): String {
+        val versionMap = ReactNativeVersion.VERSION
+        val major = versionMap["major"] as Int
+        val minor = versionMap["minor"] as Int
+        val patch = versionMap["patch"] as Int
+        val prerelease = versionMap["prerelease"] as? String
+
+        return buildString {
+            append("$major.$minor.$patch")
+            if (prerelease != null) {
+                append(".$prerelease")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class NotifeePackage : BaseReactPackage() {
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == NotifeeApiModule.NAME) {
+            NotifeeApiModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            mapOf(
+                NotifeeApiModule.NAME to ReactModuleInfo(
+                    NotifeeApiModule.NAME,
+                    NotifeeApiModule.NAME,
+                    false, // canOverrideExistingModule
+                    false, // needsEagerInit
+                    false, // isCxxModule
+                    true,  // isTurboModule
+                ),
+            )
+        }
+    }
+}

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

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee
+
+import android.annotation.SuppressLint
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ProcessLifecycleOwner
+import app.notifee.core.EventSubscriber
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.lang.reflect.Method
+
+object NotifeeReactUtils {
+
+    val headlessTaskManager = HeadlessTask()
+
+    fun promiseResolver(promise: Promise, e: Exception?, bundle: Bundle?) {
+        if (e != null) {
+            promise.reject(e)
+        } else if (bundle != null) {
+            promise.resolve(Arguments.fromBundle(bundle))
+        } else {
+            promise.resolve(null)
+        }
+    }
+
+    fun promiseResolver(promise: Promise, e: Exception?, bundleList: List<Bundle>?) {
+        if (e != null) {
+            promise.reject(e)
+        } else {
+            val writableArray: WritableArray = Arguments.createArray()
+            bundleList?.forEach { bundle ->
+                writableArray.pushMap(Arguments.fromBundle(bundle))
+            }
+            promise.resolve(writableArray)
+        }
+    }
+
+    fun promiseBooleanResolver(promise: Promise, e: Exception?, value: Boolean?) {
+        if (e != null) {
+            promise.reject(e)
+        } else {
+            promise.resolve(value)
+        }
+    }
+
+    fun promiseStringListResolver(promise: Promise, e: Exception?, stringList: List<String>?) {
+        if (e != null) {
+            promise.reject(e)
+        } else {
+            val writableArray: WritableArray = Arguments.createArray()
+            stringList?.forEach { str ->
+                writableArray.pushString(str)
+            }
+            promise.resolve(writableArray)
+        }
+    }
+
+    fun promiseResolver(promise: Promise, e: Exception?) {
+        if (e != null) {
+            promise.reject(e)
+        } else {
+            promise.resolve(null)
+        }
+    }
+
+    fun startHeadlessTask(
+        taskName: String,
+        taskData: com.facebook.react.bridge.WritableMap,
+        taskTimeout: Long,
+        taskCompletionCallback: HeadlessTask.GenericCallback?,
+    ) {
+        val config = HeadlessTask.TaskConfig(taskName, taskTimeout, taskData, taskCompletionCallback)
+        headlessTaskManager.startTask(EventSubscriber.getContext(), config)
+    }
+
+    fun sendEvent(eventName: String, eventMap: com.facebook.react.bridge.WritableMap) {
+        try {
+            val reactContext = HeadlessTask.getReactContext(EventSubscriber.getContext()) ?: return
+            if (!reactContext.hasActiveReactInstance()) return
+
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName, eventMap)
+        } catch (e: Exception) {
+            Log.e("SEND_EVENT", "", e)
+        }
+    }
+
+    fun isAppInForeground(): Boolean {
+        return ProcessLifecycleOwner.get()
+            .lifecycle
+            .currentState
+            .isAtLeast(Lifecycle.State.RESUMED)
+    }
+
+    @SuppressLint("WrongConstant")
+    fun hideNotificationDrawer() {
+        val context = EventSubscriber.getContext()
+        try {
+            val service = context.getSystemService("statusbar")
+            val statusbarManager = Class.forName("android.app.StatusBarManager")
+            val methodName = if (Build.VERSION.SDK_INT >= 17) "collapsePanels" else "collapse"
+            val collapse: Method = statusbarManager.getMethod(methodName)
+            collapse.isAccessible = true
+            collapse.invoke(service)
+        } catch (e: Exception) {
+            Log.e("HIDE_NOTIF_DRAWER", "", e)
+        }
+    }
+}

package/dist/NotifeeApiModule.d.ts

@@ -0,0 +1,53 @@
+import { Module } from './types/Module';
+import { AndroidChannel, AndroidChannelGroup, NativeAndroidChannel, NativeAndroidChannelGroup } from './types/NotificationAndroid';
+import { InitialNotification, Notification, Event, TriggerNotification, DisplayedNotification, NotificationSettings } from './types/Notification';
+import { PowerManagerInfo } from './types/PowerManagerInfo';
+import { Trigger } from './types/Trigger';
+import NotifeeNativeModule, { NativeModuleConfig } from './NotifeeNativeModule';
+import { IOSNotificationCategory, IOSNotificationPermissions } from './types/NotificationIOS';
+export default class NotifeeApiModule extends NotifeeNativeModule implements Module {
+    constructor(config: NativeModuleConfig);
+    getTriggerNotificationIds: () => Promise<string[]>;
+    getTriggerNotifications: () => Promise<TriggerNotification[]>;
+    getDisplayedNotifications: () => Promise<DisplayedNotification[]>;
+    isChannelBlocked: (channelId: string) => Promise<boolean>;
+    isChannelCreated: (channelId: string) => Promise<boolean>;
+    cancelAllNotifications: (notificationIds?: string[], tag?: string) => Promise<void>;
+    cancelDisplayedNotifications: (notificationIds?: string[], tag?: string) => Promise<void>;
+    cancelTriggerNotifications: (notificationIds?: string[]) => Promise<void>;
+    cancelNotification: (notificationId: string, tag?: string) => Promise<void>;
+    cancelDisplayedNotification: (notificationId: string, tag?: string) => Promise<void>;
+    cancelTriggerNotification: (notificationId: string) => Promise<void>;
+    createChannel: (channel: AndroidChannel) => Promise<string>;
+    createChannels: (channels: AndroidChannel[]) => Promise<void>;
+    createChannelGroup: (channelGroup: AndroidChannelGroup) => Promise<string>;
+    createChannelGroups: (channelGroups: AndroidChannelGroup[]) => Promise<void>;
+    deleteChannel: (channelId: string) => Promise<void>;
+    deleteChannelGroup: (channelGroupId: string) => Promise<void>;
+    displayNotification: (notification: Notification) => Promise<string>;
+    openAlarmPermissionSettings: () => Promise<void>;
+    createTriggerNotification: (notification: Notification, trigger: Trigger) => Promise<string>;
+    getChannel: (channelId: string) => Promise<NativeAndroidChannel | null>;
+    getChannels: () => Promise<NativeAndroidChannel[]>;
+    getChannelGroup: (channelGroupId: string) => Promise<NativeAndroidChannelGroup | null>;
+    getChannelGroups: () => Promise<NativeAndroidChannelGroup[]>;
+    getInitialNotification: () => Promise<InitialNotification | null>;
+    onBackgroundEvent: (observer: (event: Event) => Promise<void>) => void;
+    onForegroundEvent: (observer: (event: Event) => void) => (() => void);
+    openNotificationSettings: (channelId?: string) => Promise<void>;
+    requestPermission: (permissions?: IOSNotificationPermissions) => Promise<NotificationSettings>;
+    registerForegroundService(runner: (notification: Notification) => Promise<void>): void;
+    setNotificationCategories: (categories: IOSNotificationCategory[]) => Promise<void>;
+    getNotificationCategories: () => Promise<IOSNotificationCategory[]>;
+    getNotificationSettings: () => Promise<NotificationSettings>;
+    getBadgeCount: () => Promise<number>;
+    setBadgeCount: (count: number) => Promise<void>;
+    incrementBadgeCount: (incrementBy?: number) => Promise<void>;
+    decrementBadgeCount: (decrementBy?: number) => Promise<void>;
+    isBatteryOptimizationEnabled: () => Promise<boolean>;
+    openBatteryOptimizationSettings: () => Promise<void>;
+    getPowerManagerInfo: () => Promise<PowerManagerInfo>;
+    openPowerManagerSettings: () => Promise<void>;
+    stopForegroundService: () => Promise<void>;
+    hideNotificationDrawer: () => void;
+}