react-native-notify-kit 9.1.8

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

@@ -0,0 +1,257 @@
+/*
+ * This software has been integrated, with great appreciation, from the
+ * react-native-background-geolocation library, and was originally authored by
+ * Chris Scott @ TransistorSoft. It is published in that repository under this license,
+ * included here in it's entirety
+ *
+ * https://github.com/transistorsoft/react-native-background-geolocation/blob/master/LICENSE
+ *
+ * ----
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Chris Scott
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package io.invertase.notifee
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import app.notifee.core.EventSubscriber
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.ReactInstanceEventListener
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import com.facebook.react.jstasks.HeadlessJsTaskContext
+import com.facebook.react.jstasks.HeadlessJsTaskEventListener
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+
+class HeadlessTask {
+
+    private val mTaskQueue = ArrayList<TaskConfig>()
+    private val mIsReactContextInitialized = AtomicBoolean(false)
+    private val mWillDrainTaskQueue = AtomicBoolean(false)
+    private val mIsInitializingReactContext = AtomicBoolean(false)
+    private val mIsHeadlessJsTaskListenerRegistered = AtomicBoolean(false)
+
+    fun stopAllTasks() {
+        for (task in mTaskQueue) {
+            onFinishHeadlessTask(task.taskId)
+        }
+    }
+
+    fun onFinishHeadlessTask(taskId: Int) {
+        if (!mIsReactContextInitialized.get()) {
+            Log.w(HEADLESS_TASK_NAME, "$taskId found no ReactContext")
+            return
+        }
+        val reactContext = getReactContext(EventSubscriber.getContext())
+        if (reactContext != null) {
+            synchronized(mTaskQueue) {
+                val taskConfig = mTaskQueue.find { it.taskId == taskId }
+                if (taskConfig != null) {
+                    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext)
+                    headlessJsTaskContext.finishTask(taskConfig.reactTaskId)
+                } else {
+                    Log.w(HEADLESS_TASK_NAME, "Failed to find task: $taskId")
+                }
+            }
+        } else {
+            Log.w(
+                HEADLESS_TASK_NAME,
+                "Failed to finishHeadlessTask: $taskId -- HeadlessTask onFinishHeadlessTask " +
+                    "failed to find a ReactContext. This is unexpected",
+            )
+        }
+    }
+
+    @Throws(AssertionError::class)
+    fun startTask(context: Context, taskConfig: TaskConfig) {
+        UiThreadUtil.assertOnUiThread()
+
+        synchronized(mTaskQueue) {
+            mTaskQueue.add(taskConfig)
+        }
+
+        if (!mIsReactContextInitialized.get()) {
+            createReactContextAndScheduleTask(context)
+        } else {
+            invokeStartTask(getReactContext(context)!!, taskConfig)
+        }
+    }
+
+    @Synchronized
+    private fun invokeStartTask(reactContext: ReactContext, taskConfig: TaskConfig) {
+        if (taskConfig.reactTaskId > 0) {
+            Log.w(HEADLESS_TASK_NAME, "Task already invoked <IGNORED>: $this")
+            return
+        }
+        val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext)
+        try {
+            if (mIsHeadlessJsTaskListenerRegistered.compareAndSet(false, true)) {
+                headlessJsTaskContext.addTaskEventListener(object : HeadlessJsTaskEventListener {
+                    override fun onHeadlessJsTaskStart(taskId: Int) {}
+
+                    override fun onHeadlessJsTaskFinish(taskId: Int) {
+                        synchronized(mTaskQueue) {
+                            if (mTaskQueue.isEmpty()) return
+
+                            val config = mTaskQueue.find { it.reactTaskId == taskId }
+                            if (config != null) {
+                                Log.d(HEADLESS_TASK_NAME, "completed taskId: ${config.taskId}")
+                                mTaskQueue.remove(config)
+                                config.callback?.call()
+                            } else {
+                                Log.w(HEADLESS_TASK_NAME, "Failed to find taskId: $taskId")
+                            }
+                        }
+                    }
+                })
+            }
+            val rnTaskId = headlessJsTaskContext.startTask(taskConfig.taskConfig)
+            taskConfig.reactTaskId = rnTaskId
+            Log.d(HEADLESS_TASK_NAME, "launched taskId: $rnTaskId")
+        } catch (e: IllegalStateException) {
+            Log.e(HEADLESS_TASK_NAME, e.message, e)
+        }
+    }
+
+    private fun createReactContextAndScheduleTask(context: Context) {
+        val reactContext = getReactContext(context)
+        if (reactContext != null && !mIsInitializingReactContext.get()) {
+            mIsReactContextInitialized.set(true)
+            drainTaskQueue(reactContext)
+            return
+        }
+        if (mIsInitializingReactContext.compareAndSet(false, true)) {
+            Log.d(HEADLESS_TASK_NAME, "initialize ReactContext")
+            val reactHost = getReactHost(context)
+            val callback = object : ReactInstanceEventListener {
+                override fun onReactContextInitialized(reactCtx: ReactContext) {
+                    mIsReactContextInitialized.set(true)
+                    drainTaskQueue(reactCtx)
+                    try {
+                        val removeMethod = reactHost!!.javaClass.getMethod(
+                            "removeReactInstanceEventListener",
+                            ReactInstanceEventListener::class.java,
+                        )
+                        removeMethod.invoke(reactHost, this)
+                    } catch (e: Exception) {
+                        Log.e(HEADLESS_TASK_NAME, "reflection error A: $e", e)
+                    }
+                }
+            }
+            try {
+                val addMethod = reactHost!!.javaClass.getMethod(
+                    "addReactInstanceEventListener",
+                    ReactInstanceEventListener::class.java,
+                )
+                addMethod.invoke(reactHost, callback)
+                val startMethod = reactHost.javaClass.getMethod("start")
+                startMethod.invoke(reactHost)
+            } catch (e: Exception) {
+                Log.e(HEADLESS_TASK_NAME, "reflection error ReactHost start: ${e.message}", e)
+            }
+        }
+    }
+
+    private fun drainTaskQueue(reactContext: ReactContext) {
+        if (mWillDrainTaskQueue.compareAndSet(false, true)) {
+            Handler(Looper.getMainLooper()).postDelayed(
+                {
+                    synchronized(mTaskQueue) {
+                        for (taskConfig in mTaskQueue) {
+                            invokeStartTask(reactContext, taskConfig)
+                        }
+                    }
+                },
+                500,
+            )
+        }
+    }
+
+    class TaskConfig(
+        val taskName: String,
+        private val taskTimeout: Long,
+        params: WritableMap,
+        val callback: GenericCallback?,
+    ) {
+        val taskId: Int = getNextTaskId()
+        var reactTaskId: Int = 0
+        private val params: WritableMap
+
+        init {
+            params.putInt("taskId", taskId)
+            this.params = params
+        }
+
+        val taskConfig: HeadlessJsTaskConfig
+            get() = HeadlessJsTaskConfig(taskName, params, taskTimeout, true)
+    }
+
+    fun interface GenericCallback {
+        fun call()
+    }
+
+    companion object {
+        private const val HEADLESS_TASK_NAME = "NotifeeHeadlessJS"
+        private const val TASK_TIMEOUT = 60000
+        private val sLastTaskId = AtomicInteger(0)
+
+        @JvmStatic
+        @Synchronized
+        fun getNextTaskId(): Int = sLastTaskId.incrementAndGet()
+
+        @JvmStatic
+        fun getReactHost(context: Context): Any? {
+            val appContext = context.applicationContext
+            return try {
+                val method = appContext.javaClass.getMethod("getReactHost")
+                method.invoke(appContext)
+            } catch (e: Exception) {
+                null
+            }
+        }
+
+        @JvmStatic
+        @SuppressLint("VisibleForTests")
+        fun getReactContext(context: Context): ReactContext? {
+            val reactHost = getReactHost(context)
+            Assertions.assertNotNull(reactHost, "getReactHost() is null in New Architecture")
+            try {
+                val method = reactHost!!.javaClass.getMethod("getCurrentReactContext")
+                return method.invoke(reactHost) as? ReactContext
+            } catch (e: Exception) {
+                Log.e(
+                    HEADLESS_TASK_NAME,
+                    "Reflection error getCurrentReactContext: ${e.message}",
+                    e,
+                )
+            }
+            return null
+        }
+    }
+}

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

@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee
+
+import android.Manifest
+import android.os.Build
+import android.os.Bundle
+import app.notifee.core.Logger
+import app.notifee.core.Notifee
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+
+class NotifeeApiModule(reactContext: ReactApplicationContext) :
+    NativeNotifeeModuleSpec(reactContext), PermissionListener {
+
+    companion object {
+        const val NAME = "NotifeeApiModule"
+        private const val NOTIFICATION_TYPE_ALL = 0
+        private const val NOTIFICATION_TYPE_DISPLAYED = 1
+        private const val NOTIFICATION_TYPE_TRIGGER = 2
+
+        @JvmStatic
+        fun getMainComponent(defaultComponent: String): String {
+            return Notifee.getInstance().getMainComponent(defaultComponent)
+        }
+    }
+
+    override fun invalidate() {
+        NotifeeReactUtils.headlessTaskManager.stopAllTasks()
+        super.invalidate()
+    }
+
+    override fun cancelAllNotifications(promise: Promise) {
+        Notifee.getInstance()
+            .cancelAllNotifications(NOTIFICATION_TYPE_ALL) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun cancelDisplayedNotifications(promise: Promise) {
+        Notifee.getInstance()
+            .cancelAllNotifications(NOTIFICATION_TYPE_DISPLAYED) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun cancelTriggerNotifications(promise: Promise) {
+        Notifee.getInstance()
+            .cancelAllNotifications(NOTIFICATION_TYPE_TRIGGER) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun cancelAllNotificationsWithIds(
+        idsArray: ReadableArray,
+        notificationType: Double,
+        tag: String?,
+        promise: Promise,
+    ) {
+        val ids = ArrayList<String>(idsArray.size())
+        for (i in 0 until idsArray.size()) {
+            ids.add(idsArray.getString(i)!!)
+        }
+
+        Notifee.getInstance()
+            .cancelAllNotificationsWithIds(notificationType.toInt(), ids, tag) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun getDisplayedNotifications(promise: Promise) {
+        Notifee.getInstance()
+            .getDisplayedNotifications { e, bundleList ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundleList)
+            }
+    }
+
+    override fun getTriggerNotifications(promise: Promise) {
+        Notifee.getInstance()
+            .getTriggerNotifications { e, bundleList ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundleList)
+            }
+    }
+
+    override fun getTriggerNotificationIds(promise: Promise) {
+        Notifee.getInstance()
+            .getTriggerNotificationIds { e, stringList ->
+                NotifeeReactUtils.promiseStringListResolver(promise, e, stringList)
+            }
+    }
+
+    override fun createChannel(channelMap: ReadableMap, promise: Promise) {
+        Notifee.getInstance()
+            .createChannel(Arguments.toBundle(channelMap)) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun createChannels(channelsArray: ReadableArray, promise: Promise) {
+        val channels = ArrayList<Bundle>(channelsArray.size())
+        for (i in 0 until channelsArray.size()) {
+            channels.add(Arguments.toBundle(channelsArray.getMap(i))!!)
+        }
+
+        Notifee.getInstance()
+            .createChannels(channels) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun createChannelGroup(channelGroupMap: ReadableMap, promise: Promise) {
+        Notifee.getInstance()
+            .createChannelGroup(Arguments.toBundle(channelGroupMap)) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun createChannelGroups(channelGroupsArray: ReadableArray, promise: Promise) {
+        val channelGroups = ArrayList<Bundle>(channelGroupsArray.size())
+        for (i in 0 until channelGroupsArray.size()) {
+            channelGroups.add(Arguments.toBundle(channelGroupsArray.getMap(i))!!)
+        }
+
+        Notifee.getInstance()
+            .createChannelGroups(channelGroups) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun deleteChannel(channelId: String, promise: Promise) {
+        Notifee.getInstance()
+            .deleteChannel(channelId) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun deleteChannelGroup(channelGroupId: String, promise: Promise) {
+        Notifee.getInstance()
+            .deleteChannelGroup(channelGroupId) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun displayNotification(notification: ReadableMap, promise: Promise) {
+        Notifee.getInstance()
+            .displayNotification(Arguments.toBundle(notification)) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun openAlarmPermissionSettings(promise: Promise) {
+        Notifee.getInstance()
+            .openAlarmPermissionSettings(getCurrentActivity()) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun createTriggerNotification(
+        notificationMap: ReadableMap,
+        triggerMap: ReadableMap,
+        promise: Promise,
+    ) {
+        Notifee.getInstance()
+            .createTriggerNotification(
+                Arguments.toBundle(notificationMap),
+                Arguments.toBundle(triggerMap),
+            ) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun getChannels(promise: Promise) {
+        Notifee.getInstance()
+            .getChannels { e, bundleList ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundleList)
+            }
+    }
+
+    override fun getChannel(channelId: String, promise: Promise) {
+        Notifee.getInstance()
+            .getChannel(channelId) { e, bundle ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundle)
+            }
+    }
+
+    override fun getChannelGroups(promise: Promise) {
+        Notifee.getInstance()
+            .getChannelGroups { e, bundleList ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundleList)
+            }
+    }
+
+    override fun getChannelGroup(channelGroupId: String, promise: Promise) {
+        Notifee.getInstance()
+            .getChannel(channelGroupId) { e, bundle ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundle)
+            }
+    }
+
+    override fun isChannelCreated(channelId: String, promise: Promise) {
+        Notifee.getInstance()
+            .isChannelCreated(channelId) { e, result ->
+                NotifeeReactUtils.promiseBooleanResolver(promise, e, result)
+            }
+    }
+
+    override fun isChannelBlocked(channelId: String, promise: Promise) {
+        Notifee.getInstance()
+            .isChannelBlocked(channelId) { e, result ->
+                NotifeeReactUtils.promiseBooleanResolver(promise, e, result)
+            }
+    }
+
+    override fun getInitialNotification(promise: Promise) {
+        Notifee.getInstance()
+            .getInitialNotification(getCurrentActivity()) { e, bundle ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundle)
+            }
+    }
+
+    override fun getNotificationSettings(promise: Promise) {
+        Notifee.getInstance()
+            .getNotificationSettings { e, bundle ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundle)
+            }
+    }
+
+    override fun requestPermission(permissions: ReadableMap, promise: Promise) {
+        // permissions parameter is ignored on Android — only used by iOS
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            Notifee.getInstance()
+                .getNotificationSettings { e, bundle ->
+                    NotifeeReactUtils.promiseResolver(promise, e, bundle)
+                }
+            return
+        }
+
+        val activity = getCurrentActivity() as? PermissionAwareActivity
+        if (activity == null) {
+            Logger.d(
+                "requestPermission",
+                "Unable to get permissionAwareActivity for ${Build.VERSION.SDK_INT}",
+            )
+            Notifee.getInstance()
+                .getNotificationSettings { e, bundle ->
+                    NotifeeReactUtils.promiseResolver(promise, e, bundle)
+                }
+            return
+        }
+
+        Notifee.getInstance()
+            .setRequestPermissionCallback { e, bundle ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundle)
+            }
+
+        try {
+            activity.requestPermissions(
+                arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+                Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION,
+                this,
+            )
+        } catch (e: Exception) {
+            Logger.d(
+                "requestPermission",
+                "Failed to request POST_NOTIFICATIONS permission: ${e.message}",
+            )
+            NotifeeReactUtils.promiseResolver(promise, e)
+        }
+    }
+
+    override fun openNotificationSettings(channelId: String?, promise: Promise) {
+        Notifee.getInstance()
+            .openNotificationSettings(channelId, getCurrentActivity()) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun openBatteryOptimizationSettings(promise: Promise) {
+        Notifee.getInstance()
+            .openBatteryOptimizationSettings(getCurrentActivity()) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun isBatteryOptimizationEnabled(promise: Promise) {
+        Notifee.getInstance()
+            .isBatteryOptimizationEnabled { e, result ->
+                NotifeeReactUtils.promiseBooleanResolver(promise, e, result)
+            }
+    }
+
+    override fun getPowerManagerInfo(promise: Promise) {
+        Notifee.getInstance()
+            .getPowerManagerInfo { e, bundle ->
+                NotifeeReactUtils.promiseResolver(promise, e, bundle)
+            }
+    }
+
+    override fun openPowerManagerSettings(promise: Promise) {
+        Notifee.getInstance()
+            .openPowerManagerSettings(getCurrentActivity()) { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun stopForegroundService(promise: Promise) {
+        Notifee.getInstance()
+            .stopForegroundService { e, _ ->
+                NotifeeReactUtils.promiseResolver(promise, e)
+            }
+    }
+
+    override fun hideNotificationDrawer() {
+        NotifeeReactUtils.hideNotificationDrawer()
+    }
+
+    override fun addListener(eventName: String) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    override fun removeListeners(count: Double) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    override fun getName(): String = "NotifeeApiModule"
+
+    override fun getTypedExportedConstants(): MutableMap<String, Any> {
+        return mutableMapOf("ANDROID_API_LEVEL" to Build.VERSION.SDK_INT)
+    }
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<String>,
+        grantResults: IntArray,
+    ): Boolean {
+        return Notifee.getInstance()
+            .onRequestPermissionsResult(requestCode, permissions, grantResults)
+    }
+
+    // ─── iOS-only stubs (required by NativeNotifeeModuleSpec) ───────────────
+
+    override fun cancelNotification(notificationId: String, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    override fun cancelDisplayedNotification(notificationId: String, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    override fun cancelTriggerNotification(notificationId: String, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    override fun cancelDisplayedNotificationsWithIds(ids: ReadableArray, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    override fun cancelTriggerNotificationsWithIds(ids: ReadableArray, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    override fun getNotificationCategories(promise: Promise) {
+        promise.resolve(Arguments.createArray())
+    }
+
+    override fun setNotificationCategories(categories: ReadableArray, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    override fun setBadgeCount(count: Double, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    override fun getBadgeCount(promise: Promise) {
+        promise.resolve(0.0)
+    }
+
+    override fun incrementBadgeCount(incrementBy: Double, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    override fun decrementBadgeCount(decrementBy: Double, promise: Promise) {
+        promise.resolve(null)
+    }
+}