expo-notifications 0.24.2 → 0.26.0

package/android/src/main/java/expo/modules/notifications/notifications/channels/NotificationChannelManagerModule.kt

@@ -1,79 +1,73 @@
 package expo.modules.notifications.notifications.channels
 
-import android.content.Context
 import android.os.Build
+import android.os.Bundle
 import androidx.annotation.RequiresApi
-import expo.modules.core.ExportedModule
-import expo.modules.core.ModuleRegistry
-import expo.modules.core.Promise
 import expo.modules.core.arguments.ReadableArguments
-import expo.modules.core.interfaces.ExpoMethod
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ModuleNotFoundException
 import expo.modules.notifications.notifications.channels.managers.NotificationsChannelManager
 import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer
 import expo.modules.notifications.notifications.enums.NotificationImportance
-import java.util.Collections
 import java.util.Objects
 
 /**
  * An exported module responsible for exposing methods for managing notification channels.
  */
-open class NotificationChannelManagerModule(context: Context?) : ExportedModule(context) {
+open class NotificationChannelManagerModule : Module() {
   private lateinit var channelManager: NotificationsChannelManager
   private lateinit var channelSerializer: NotificationsChannelSerializer
 
-  override fun onCreate(moduleRegistry: ModuleRegistry) {
-    val provider = moduleRegistry.getModule(NotificationsChannelsProvider::class.java)
-    channelManager = provider.channelManager
-    channelSerializer = provider.channelSerializer
-  }
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationChannelManager")
 
-  override fun getName(): String = "ExpoNotificationChannelManager"
+    OnCreate {
+      val provider = appContext.legacyModule<NotificationsChannelsProvider>()
+        ?: throw ModuleNotFoundException(NotificationsChannelsProvider::class)
 
-  @ExpoMethod
-  fun getNotificationChannelAsync(channelId: String, promise: Promise) {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-      promise.resolve(null)
-      return
+      channelManager = provider.channelManager
+      channelSerializer = provider.channelSerializer
     }
-    val notificationChannel = channelManager.getNotificationChannel(channelId)
-    promise.resolve(channelSerializer.toBundle(notificationChannel))
-  }
 
-  @ExpoMethod
-  fun getNotificationChannelsAsync(promise: Promise) {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-      promise.resolve(Collections.EMPTY_LIST)
-      return
+    AsyncFunction("getNotificationChannelsAsync") {
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+        return@AsyncFunction emptyList<Bundle>()
+      }
+
+      return@AsyncFunction channelManager
+        .notificationChannels
+        .map(channelSerializer::toBundle)
     }
-    val serializedChannels = channelManager
-      .notificationChannels
-      .map(channelSerializer::toBundle)
-    promise.resolve(serializedChannels)
-  }
 
-  @ExpoMethod
-  fun setNotificationChannelAsync(channelId: String, channelOptions: ReadableArguments, promise: Promise) {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-      promise.resolve(null)
-      return
+    AsyncFunction("getNotificationChannelAsync") { channelId: String ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val notificationChannel = channelManager.getNotificationChannel(channelId)
+        channelSerializer.toBundle(notificationChannel)
+      } else {
+        null
+      }
+    }
+
+    AsyncFunction("setNotificationChannelAsync") { channelId: String, channelOptions: ReadableArguments ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val channel = channelManager.createNotificationChannel(
+          channelId,
+          getNameFromOptions(channelOptions),
+          getImportanceFromOptions(channelOptions),
+          channelOptions
+        )
+        channelSerializer.toBundle(channel)
+      } else {
+        null
+      }
     }
-    val channel = channelManager.createNotificationChannel(
-      channelId,
-      getNameFromOptions(channelOptions),
-      getImportanceFromOptions(channelOptions),
-      channelOptions
-    )
-    promise.resolve(channelSerializer.toBundle(channel))
-  }
 
-  @ExpoMethod
-  fun deleteNotificationChannelAsync(channelId: String, promise: Promise) {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-      promise.resolve(null)
-      return
+    AsyncFunction("deleteNotificationChannelAsync") { channelId: String ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        channelManager.deleteNotificationChannel(channelId)
+      }
     }
-    channelManager.deleteNotificationChannel(channelId)
-    promise.resolve(null)
   }
 
   private fun getNameFromOptions(channelOptions: ReadableArguments): CharSequence {

package/android/src/main/java/expo/modules/notifications/notifications/emitting/NotificationsEmitter.kt

@@ -1,12 +1,10 @@
 package expo.modules.notifications.notifications.emitting
 
-import android.content.Context
 import android.os.Bundle
-import expo.modules.core.ExportedModule
-import expo.modules.core.ModuleRegistry
-import expo.modules.core.Promise
-import expo.modules.core.interfaces.ExpoMethod
 import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ModuleNotFoundException
 import expo.modules.notifications.notifications.NotificationSerializer
 import expo.modules.notifications.notifications.interfaces.NotificationListener
 import expo.modules.notifications.notifications.interfaces.NotificationManager
@@ -17,28 +15,31 @@ private const val NEW_MESSAGE_EVENT_NAME = "onDidReceiveNotification"
 private const val NEW_RESPONSE_EVENT_NAME = "onDidReceiveNotificationResponse"
 private const val MESSAGES_DELETED_EVENT_NAME = "onNotificationsDeleted"
 
-open class NotificationsEmitter(context: Context) : ExportedModule(context), NotificationListener {
+open class NotificationsEmitter : Module(), NotificationListener {
   private lateinit var notificationManager: NotificationManager
   private var lastNotificationResponse: NotificationResponse? = null
   private var eventEmitter: EventEmitter? = null
-  override fun getName(): String = "ExpoNotificationsEmitter"
 
-  override fun onCreate(moduleRegistry: ModuleRegistry) {
-    eventEmitter = moduleRegistry.getModule(EventEmitter::class.java)
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationsEmitter")
 
-    // Register the module as a listener in NotificationManager singleton module.
-    // Deregistration happens in onDestroy callback.
-    notificationManager = requireNotNull(moduleRegistry.getSingletonModule("NotificationManager", NotificationManager::class.java))
-    notificationManager.addListener(this)
-  }
+    OnCreate {
+      eventEmitter = appContext.legacyModule<EventEmitter>()
+        ?: throw ModuleNotFoundException(EventEmitter::class)
 
-  override fun onDestroy() {
-    notificationManager.removeListener(this)
-  }
+      // Register the module as a listener in NotificationManager singleton module.
+      // Deregistration happens in onDestroy callback.
+      notificationManager = requireNotNull(appContext.legacyModuleRegistry.getSingletonModule("NotificationManager", NotificationManager::class.java))
+      notificationManager.addListener(this@NotificationsEmitter)
+    }
 
-  @ExpoMethod
-  fun getLastNotificationResponseAsync(promise: Promise) {
-    promise.resolve(lastNotificationResponse?.let(NotificationSerializer::toBundle))
+    OnDestroy {
+      notificationManager.removeListener(this@NotificationsEmitter)
+    }
+
+    AsyncFunction("getLastNotificationResponseAsync") {
+      lastNotificationResponse?.let(NotificationSerializer::toBundle)
+    }
   }
 
   /**

package/android/src/main/java/expo/modules/notifications/notifications/handling/NotificationsHandler.kt

@@ -1,22 +1,33 @@
 package expo.modules.notifications.notifications.handling
 
-import android.content.Context
 import android.os.Handler
 import android.os.HandlerThread
-import expo.modules.core.ExportedModule
 import expo.modules.core.ModuleRegistry
-import expo.modules.core.Promise
-import expo.modules.core.arguments.ReadableArguments
-import expo.modules.core.interfaces.ExpoMethod
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.notifications.NotificationWasAlreadyHandledException
 import expo.modules.notifications.notifications.interfaces.NotificationListener
 import expo.modules.notifications.notifications.interfaces.NotificationManager
 import expo.modules.notifications.notifications.model.Notification
 import expo.modules.notifications.notifications.model.NotificationBehavior
+import expo.modules.notifications.toLegacyPromise
 
-private const val SHOULD_SHOW_ALERT_KEY = "shouldShowAlert"
-private const val SHOULD_PLAY_SOUND_KEY = "shouldPlaySound"
-private const val SHOULD_SET_BADGE_KEY = "shouldSetBadge"
-private const val PRIORITY_KEY = "priority"
+class NotificationBehaviourRecord : Record {
+  @Field
+  val shouldShowAlert: Boolean = false
+
+  @Field
+  val shouldPlaySound: Boolean = false
+
+  @Field
+  val shouldSetBadge: Boolean = false
+
+  @Field
+  val priority: String? = null
+}
 
 /**
  * [NotificationListener] responsible for managing app's reaction to incoming
@@ -27,7 +38,7 @@ private const val PRIORITY_KEY = "priority"
  * which are responsible: one for each notification. This module serves as holder
  * for all of them and a proxy through which app responds with the behavior.
  */
-open class NotificationsHandler(context: Context) : ExportedModule(context), NotificationListener {
+open class NotificationsHandler : Module(), NotificationListener {
   private lateinit var notificationManager: NotificationManager
   private lateinit var moduleRegistry: ModuleRegistry
 
@@ -43,31 +54,35 @@ open class NotificationsHandler(context: Context) : ExportedModule(context), Not
 
   private val tasksMap = mutableMapOf<String, SingleNotificationHandlerTask>()
 
-  override fun getName(): String = "ExpoNotificationsHandlerModule"
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationsHandlerModule")
 
-  override fun onCreate(moduleRegistry: ModuleRegistry) {
-    this.moduleRegistry = moduleRegistry
+    OnCreate {
+      moduleRegistry = appContext.legacyModuleRegistry
 
-    // Register the module as a listener in NotificationManager singleton module.
-    // Deregistration happens in onDestroy callback.
-    notificationManager = requireNotNull(moduleRegistry.getSingletonModule("NotificationManager", NotificationManager::class.java))
-    notificationManager.addListener(this)
-    notificationsHandlerThread = HandlerThread("NotificationsHandlerThread - " + this.javaClass.toString())
-    notificationsHandlerThread.start()
-    handler = Handler(notificationsHandlerThread.looper)
-  }
+      // Register the module as a listener in NotificationManager singleton module.
+      // Deregistration happens in onDestroy callback.
+      notificationManager = requireNotNull(moduleRegistry.getSingletonModule("NotificationManager", NotificationManager::class.java))
+      notificationManager.addListener(this@NotificationsHandler)
+      notificationsHandlerThread = HandlerThread("NotificationsHandlerThread - " + this.javaClass.toString())
+      notificationsHandlerThread.start()
+      handler = Handler(notificationsHandlerThread.looper)
+    }
+
+    OnDestroy {
+      notificationManager.removeListener(this@NotificationsHandler)
 
-  override fun onDestroy() {
-    notificationManager.removeListener(this)
+      tasksMap.values.forEach(SingleNotificationHandlerTask::stop)
 
-    tasksMap.values.forEach(SingleNotificationHandlerTask::stop)
+      // We don't have to use `quitSafely` here, cause all tasks were stopped
+      notificationsHandlerThread.quit()
+    }
 
-    // We don't have to use `quitSafely` here, cause all tasks were stopped
-    notificationsHandlerThread.quit()
+    AsyncFunction("handleNotificationAsync", this@NotificationsHandler::handleNotificationAsync)
   }
 
   /**
-   * Called by the app with [ReadableArguments] representing requested behavior
+   * Called by the app with [NotificationBehaviourRecord] representing requested behavior
    * that should be applied to the notification.
    *
    * @param identifier Identifier of the task which asked for behavior.
@@ -75,18 +90,16 @@ open class NotificationsHandler(context: Context) : ExportedModule(context), Not
    * @param promise    Promise to resolve once the notification is successfully presented
    * or fails to be presented.
    */
-  @ExpoMethod
-  fun handleNotificationAsync(identifier: String, behavior: ReadableArguments, promise: Promise) {
+  private fun handleNotificationAsync(identifier: String, behavior: NotificationBehaviourRecord, promise: Promise) {
     val task = tasksMap[identifier]
-    if (task == null) {
-      promise.reject("ERR_NOTIFICATION_HANDLED", "Failed to handle notification $identifier, it has already been handled.")
-      return
+      ?: throw NotificationWasAlreadyHandledException(identifier)
+
+    with(behavior) {
+      task.handleResponse(
+        NotificationBehavior(shouldShowAlert, shouldPlaySound, shouldSetBadge, priority),
+        promise.toLegacyPromise()
+      )
     }
-    val shouldShowAlert = behavior.getBoolean(SHOULD_SHOW_ALERT_KEY)
-    val shouldPlaySound = behavior.getBoolean(SHOULD_PLAY_SOUND_KEY)
-    val shouldSetBadge = behavior.getBoolean(SHOULD_SET_BADGE_KEY)
-    val priorityOverride = behavior.getString(PRIORITY_KEY)
-    task.handleResponse(NotificationBehavior(shouldShowAlert, shouldPlaySound, shouldSetBadge, priorityOverride), promise)
   }
 
   /**
@@ -96,6 +109,7 @@ open class NotificationsHandler(context: Context) : ExportedModule(context), Not
    * @param notification Notification received
    */
   override fun onNotificationReceived(notification: Notification) {
+    val context = appContext.reactContext ?: return
     val task = SingleNotificationHandlerTask(context, handler, moduleRegistry, notification, this)
     tasksMap[task.identifier] = task
     task.start()

package/android/src/main/java/expo/modules/notifications/notifications/presentation/ExpoNotificationPresentationModule.kt

@@ -0,0 +1,113 @@
+package expo.modules.notifications.notifications.presentation
+
+import android.content.Context
+import android.os.Bundle
+import expo.modules.core.arguments.ReadableArguments
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ResultReceiverBody
+import expo.modules.notifications.createDefaultResultReceiver
+import expo.modules.notifications.notifications.ArgumentsNotificationContentBuilder
+import expo.modules.notifications.notifications.NotificationSerializer
+import expo.modules.notifications.notifications.interfaces.NotificationTrigger
+import expo.modules.notifications.notifications.model.Notification
+import expo.modules.notifications.notifications.model.NotificationContent
+import expo.modules.notifications.notifications.model.NotificationRequest
+import expo.modules.notifications.service.NotificationsService
+import expo.modules.notifications.service.NotificationsService.Companion.dismiss
+import expo.modules.notifications.service.NotificationsService.Companion.dismissAll
+import expo.modules.notifications.service.NotificationsService.Companion.getAllPresented
+import expo.modules.notifications.service.NotificationsService.Companion.present
+
+open class ExpoNotificationPresentationModule : Module() {
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  protected fun createResultReceiver(body: ResultReceiverBody) =
+    createDefaultResultReceiver(null, body)
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationPresenter")
+
+    AsyncFunction("presentNotificationAsync") { identifier: String, payload: ReadableArguments, promise: Promise ->
+      val content = ArgumentsNotificationContentBuilder(context).setPayload(payload).build()
+      val request = createNotificationRequest(identifier, content, null)
+      val notification = Notification(request)
+      present(
+        context,
+        notification,
+        null,
+        createResultReceiver { resultCode: Int, resultData: Bundle? ->
+          if (resultCode == NotificationsService.SUCCESS_CODE) {
+            promise.resolve(identifier)
+          } else {
+            val e = resultData?.getSerializable(NotificationsService.EXCEPTION_KEY) as? Exception
+            promise.reject("ERR_NOTIFICATION_PRESENTATION_FAILED", "Notification could not be presented.", e)
+          }
+        }
+      )
+    }
+
+    AsyncFunction("getPresentedNotificationsAsync") { promise: Promise ->
+      getAllPresented(
+        context,
+        createResultReceiver { resultCode: Int, resultData: Bundle? ->
+          val notifications = resultData?.getParcelableArrayList<Notification>(NotificationsService.NOTIFICATIONS_KEY)
+          if (resultCode == NotificationsService.SUCCESS_CODE && notifications != null) {
+            promise.resolve(serializeNotifications(notifications))
+          } else {
+            val e = resultData?.getSerializable(NotificationsService.EXCEPTION_KEY) as? Exception
+            promise.reject("ERR_NOTIFICATIONS_FETCH_FAILED", "A list of displayed notifications could not be fetched.", e)
+          }
+        }
+      )
+    }
+
+    AsyncFunction("dismissNotificationAsync", this@ExpoNotificationPresentationModule::dismissNotificationAsync)
+
+    AsyncFunction("dismissAllNotificationsAsync", this@ExpoNotificationPresentationModule::dismissAllNotificationsAsync)
+  }
+
+  protected open fun dismissNotificationAsync(identifier: String, promise: Promise) {
+    dismiss(
+      context,
+      arrayOf(identifier),
+      createResultReceiver { resultCode: Int, resultData: Bundle? ->
+        if (resultCode == NotificationsService.SUCCESS_CODE) {
+          promise.resolve(null)
+        } else {
+          val e = resultData?.getSerializable(NotificationsService.EXCEPTION_KEY) as? Exception
+          promise.reject("ERR_NOTIFICATION_DISMISSAL_FAILED", "Notification could not be dismissed.", e)
+        }
+      }
+    )
+  }
+
+  protected open fun dismissAllNotificationsAsync(promise: Promise) {
+    dismissAll(
+      context,
+      createResultReceiver { resultCode: Int, resultData: Bundle? ->
+        if (resultCode == NotificationsService.SUCCESS_CODE) {
+          promise.resolve(null)
+        } else {
+          val e = resultData?.getSerializable(NotificationsService.EXCEPTION_KEY) as? Exception
+          promise.reject("ERR_NOTIFICATIONS_DISMISSAL_FAILED", "Notifications could not be dismissed.", e)
+        }
+      }
+    )
+  }
+
+  protected open fun createNotificationRequest(
+    identifier: String,
+    content: NotificationContent,
+    trigger: NotificationTrigger?
+  ): NotificationRequest {
+    return NotificationRequest(identifier, content, null)
+  }
+
+  protected open fun serializeNotifications(notifications: Collection<Notification>): List<Bundle> {
+    return notifications.map(NotificationSerializer::toBundle)
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/presentation/builders/ExpoNotificationBuilder.java

@@ -283,11 +283,7 @@ public class ExpoNotificationBuilder extends ChannelAwareNotificationBuilder {
     try {
       ApplicationInfo ai = getContext().getPackageManager().getApplicationInfo(getContext().getPackageName(), PackageManager.GET_META_DATA);
       if (ai.metaData.containsKey(META_DATA_DEFAULT_COLOR_KEY)) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-          return getContext().getResources().getColor(ai.metaData.getInt(META_DATA_DEFAULT_COLOR_KEY), null);
-        } else {
-          return getContext().getResources().getColor(ai.metaData.getInt(META_DATA_DEFAULT_COLOR_KEY));
-        }
+        return getContext().getResources().getColor(ai.metaData.getInt(META_DATA_DEFAULT_COLOR_KEY), null);
       }
     } catch (PackageManager.NameNotFoundException | Resources.NotFoundException | ClassCastException e) {
       Log.e("expo-notifications", "Could not have fetched default notification color.");