expo-notifications 0.24.1 → 0.24.2

package/CHANGELOG.md

@@ -10,6 +10,10 @@
 
 ### 💡 Others
 
+## 0.24.2 — 2023-09-18
+
+_This version does not introduce any user-facing changes._
+
 ## 0.24.1 — 2023-09-15
 
 ### 💡 Others

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '0.24.1'
+version = '0.24.2'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -70,7 +70,7 @@ android {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 21
-    versionName '0.24.1'
+    versionName '0.24.2'
   }
 
   lintOptions {

package/android/src/main/java/expo/modules/notifications/badge/BadgeHelper.kt

@@ -0,0 +1,24 @@
+package expo.modules.notifications.badge
+
+import android.content.Context
+import android.util.Log
+import me.leolin.shortcutbadger.ShortcutBadgeException
+import me.leolin.shortcutbadger.ShortcutBadger
+
+object BadgeHelper {
+  var badgeCount = 0
+    get() = synchronized(this) { field }
+    private set(value) = synchronized(this) { field = value }
+
+  fun setBadgeCount(context: Context, badgeCount: Int): Boolean {
+    return try {
+      ShortcutBadger.applyCountOrThrow(context.applicationContext, badgeCount)
+      BadgeHelper.badgeCount = badgeCount
+      true
+    } catch (e: ShortcutBadgeException) {
+      Log.d("expo-notifications", "Could not have set badge count: ${e.message}", e)
+      e.printStackTrace()
+      false
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/badge/BadgeModule.kt

@@ -1,37 +1,20 @@
 package expo.modules.notifications.badge
 
 import android.content.Context
-import android.util.Log
 import expo.modules.core.ExportedModule
 import expo.modules.core.Promise
 import expo.modules.core.interfaces.ExpoMethod
-import me.leolin.shortcutbadger.ShortcutBadgeException
-import me.leolin.shortcutbadger.ShortcutBadger
 
 class BadgeModule(context: Context) : ExportedModule(context) {
   override fun getName(): String = "ExpoBadgeModule"
 
   @ExpoMethod
   fun getBadgeCountAsync(promise: Promise) {
-    promise.resolve(badgeCount)
+    promise.resolve(BadgeHelper.badgeCount)
   }
 
   @ExpoMethod
   fun setBadgeCountAsync(badgeCount: Int, promise: Promise) {
-    try {
-      ShortcutBadger.applyCountOrThrow(context.applicationContext, badgeCount)
-      BadgeModule.badgeCount = badgeCount
-      promise.resolve(true)
-    } catch (e: ShortcutBadgeException) {
-      Log.d("expo-notifications", "Could not have set badge count: ${e.message}", e)
-      e.printStackTrace()
-      promise.resolve(false)
-    }
-  }
-
-  companion object {
-    var badgeCount = 0
-      get() = synchronized(this) { field }
-      set(value) = synchronized(this) { field = value }
+    promise.resolve(BadgeHelper.setBadgeCount(context, badgeCount))
   }
 }

package/android/src/main/java/expo/modules/notifications/notifications/background/ExpoBackgroundNotificationTasksModule.kt

@@ -0,0 +1,44 @@
+package expo.modules.notifications.notifications.background
+
+import android.content.Context
+import expo.modules.core.ExportedModule
+import expo.modules.core.ModuleRegistry
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.ExpoMethod
+import expo.modules.interfaces.taskManager.TaskManagerInterface
+
+class ExpoBackgroundNotificationTasksModule(context: Context?) : ExportedModule(context) {
+  private lateinit var taskManager: TaskManagerInterface
+  override fun getName(): String = "ExpoBackgroundNotificationTasksModule"
+
+  override fun onCreate(moduleRegistry: ModuleRegistry) {
+    taskManager = moduleRegistry.getModule(TaskManagerInterface::class.java)
+  }
+
+  @ExpoMethod
+  fun registerTaskAsync(taskName: String?, promise: Promise) {
+    try {
+      taskManager.registerTask(
+        taskName,
+        BackgroundRemoteNotificationTaskConsumer::class.java,
+        emptyMap()
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(e)
+    }
+  }
+
+  @ExpoMethod
+  fun unregisterTaskAsync(taskName: String?, promise: Promise) {
+    try {
+      taskManager.unregisterTask(
+        taskName,
+        BackgroundRemoteNotificationTaskConsumer::class.java
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(e)
+    }
+  }
+}

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

@@ -0,0 +1,77 @@
+package expo.modules.notifications.notifications.channels
+
+import android.content.Context
+import android.os.Build
+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.notifications.notifications.channels.managers.NotificationsChannelGroupManager
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelGroupSerializer
+
+/**
+ * An exported module responsible for exposing methods for managing notification channel groups.
+ */
+class NotificationChannelGroupManagerModule(context: Context) : ExportedModule(context) {
+  private lateinit var groupManager: NotificationsChannelGroupManager
+  private lateinit var groupSerializer: NotificationsChannelGroupSerializer
+
+  override fun onCreate(moduleRegistry: ModuleRegistry) {
+    val provider = moduleRegistry.getModule(NotificationsChannelsProvider::class.java)
+    groupManager = provider.groupManager
+    groupSerializer = provider.groupSerializer
+  }
+
+  override fun getName(): String = "ExpoNotificationChannelGroupManager"
+
+  @ExpoMethod
+  fun getNotificationChannelGroupAsync(groupId: String, promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      promise.resolve(null)
+      return
+    }
+    val group = groupManager.getNotificationChannelGroup(groupId)
+    promise.resolve(groupSerializer.toBundle(group))
+  }
+
+  @ExpoMethod
+  fun getNotificationChannelGroupsAsync(promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      promise.resolve(null)
+      return
+    }
+    val serializedChannels = groupManager
+      .notificationChannelGroups
+      .map(groupSerializer::toBundle)
+    promise.resolve(serializedChannels)
+  }
+
+  @ExpoMethod
+  fun setNotificationChannelGroupAsync(groupId: String, groupOptions: ReadableArguments, promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      promise.resolve(null)
+      return
+    }
+    val group = groupManager.createNotificationChannelGroup(
+      groupId,
+      getNameFromOptions(groupOptions),
+      groupOptions
+    )
+    promise.resolve(groupSerializer.toBundle(group))
+  }
+
+  @ExpoMethod
+  fun deleteNotificationChannelGroupAsync(groupId: String, promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      promise.resolve(null)
+      return
+    }
+    groupManager.deleteNotificationChannelGroup(groupId)
+    promise.resolve(null)
+  }
+
+  private fun getNameFromOptions(groupOptions: ReadableArguments): String {
+    return groupOptions.getString(NotificationsChannelGroupSerializer.NAME_KEY)
+  }
+}

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

@@ -0,0 +1,89 @@
+package expo.modules.notifications.notifications.channels
+
+import android.content.Context
+import android.os.Build
+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.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) {
+  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 getName(): String = "ExpoNotificationChannelManager"
+
+  @ExpoMethod
+  fun getNotificationChannelAsync(channelId: String, promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      promise.resolve(null)
+      return
+    }
+    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
+    }
+    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
+    }
+    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
+    }
+    channelManager.deleteNotificationChannel(channelId)
+    promise.resolve(null)
+  }
+
+  private fun getNameFromOptions(channelOptions: ReadableArguments): CharSequence {
+    return channelOptions.getString(NotificationsChannelSerializer.NAME_KEY)
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  private fun getImportanceFromOptions(channelOptions: ReadableArguments): Int {
+    val enumValue = channelOptions.getInt(NotificationsChannelSerializer.IMPORTANCE_KEY, NotificationImportance.DEFAULT.enumValue)
+    val importance = Objects.requireNonNull(NotificationImportance.fromEnumValue(enumValue))
+    return importance.nativeValue
+  }
+}

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

@@ -0,0 +1,77 @@
+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.notifications.notifications.NotificationSerializer
+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.NotificationResponse
+
+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 {
+  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)
+
+    // 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)
+  }
+
+  override fun onDestroy() {
+    notificationManager.removeListener(this)
+  }
+
+  @ExpoMethod
+  fun getLastNotificationResponseAsync(promise: Promise) {
+    promise.resolve(lastNotificationResponse?.let(NotificationSerializer::toBundle))
+  }
+
+  /**
+   * Callback called when [NotificationManager] gets notified of a new notification.
+   * Emits a [NEW_MESSAGE_EVENT_NAME] event.
+   *
+   * @param notification Notification received
+   */
+  override fun onNotificationReceived(notification: Notification) {
+    eventEmitter?.emit(NEW_MESSAGE_EVENT_NAME, NotificationSerializer.toBundle(notification))
+  }
+
+  /**
+   * Callback called when [NotificationManager] gets notified of a new notification response.
+   * Emits a [NEW_RESPONSE_EVENT_NAME] event.
+   *
+   * @param response Notification response received
+   * @return Whether notification has been handled
+   */
+  override fun onNotificationResponseReceived(response: NotificationResponse): Boolean {
+    lastNotificationResponse = response
+    eventEmitter?.let {
+      it.emit(NEW_RESPONSE_EVENT_NAME, NotificationSerializer.toBundle(response))
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Callback called when [NotificationManager] gets informed of the fact of message dropping.
+   * Emits a [MESSAGES_DELETED_EVENT_NAME] event.
+   */
+  override fun onNotificationsDropped() {
+    eventEmitter?.emit(MESSAGES_DELETED_EVENT_NAME, Bundle.EMPTY)
+  }
+}

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

@@ -0,0 +1,113 @@
+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.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
+
+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"
+
+/**
+ * [NotificationListener] responsible for managing app's reaction to incoming
+ * notification.
+ *
+ *
+ * It is responsible for managing lifecycles of [SingleNotificationHandlerTask]s
+ * 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 {
+  private lateinit var notificationManager: NotificationManager
+  private lateinit var moduleRegistry: ModuleRegistry
+
+  /**
+   * [HandlerThread] which is the host to the notifications handler.
+   */
+  private lateinit var notificationsHandlerThread: HandlerThread
+
+  /**
+   * [Handler] on which lifecycle events are executed.
+   */
+  private lateinit var handler: Handler
+
+  private val tasksMap = mutableMapOf<String, SingleNotificationHandlerTask>()
+
+  override fun getName(): String = "ExpoNotificationsHandlerModule"
+
+  override fun onCreate(moduleRegistry: ModuleRegistry) {
+    this.moduleRegistry = moduleRegistry
+
+    // 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)
+  }
+
+  override fun onDestroy() {
+    notificationManager.removeListener(this)
+
+    tasksMap.values.forEach(SingleNotificationHandlerTask::stop)
+
+    // We don't have to use `quitSafely` here, cause all tasks were stopped
+    notificationsHandlerThread.quit()
+  }
+
+  /**
+   * Called by the app with [ReadableArguments] representing requested behavior
+   * that should be applied to the notification.
+   *
+   * @param identifier Identifier of the task which asked for behavior.
+   * @param behavior   Behavior to apply to the notification.
+   * @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) {
+    val task = tasksMap[identifier]
+    if (task == null) {
+      promise.reject("ERR_NOTIFICATION_HANDLED", "Failed to handle notification $identifier, it has already been handled.")
+      return
+    }
+    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)
+  }
+
+  /**
+   * Callback called by [NotificationManager] to inform its listeners of new messages.
+   * Starts up a new [SingleNotificationHandlerTask] which will take it on from here.
+   *
+   * @param notification Notification received
+   */
+  override fun onNotificationReceived(notification: Notification) {
+    val task = SingleNotificationHandlerTask(context, handler, moduleRegistry, notification, this)
+    tasksMap[task.identifier] = task
+    task.start()
+  }
+
+  /**
+   * Callback called once [SingleNotificationHandlerTask] finishes.
+   * A cue for removal of the task.
+   *
+   * @param task Task that just fulfilled its responsibility.
+   */
+  fun onTaskFinished(task: SingleNotificationHandlerTask) {
+    tasksMap.remove(task.identifier)
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/handling/SingleNotificationHandlerTask.java

@@ -17,7 +17,7 @@ import expo.modules.notifications.service.NotificationsService;
 /**
  * A "task" responsible for managing response to a single notification.
  */
-/* package */ class SingleNotificationHandlerTask {
+public class SingleNotificationHandlerTask {
   /**
    * Name of the event asking the delegate for behavior.
    */

package/android/src/main/java/expo/modules/notifications/serverregistration/ServerRegistrationModule.kt

@@ -0,0 +1,29 @@
+package expo.modules.notifications.serverregistration
+
+import android.content.Context
+import expo.modules.core.ExportedModule
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.ExpoMethod
+
+open class ServerRegistrationModule(context: Context) : ExportedModule(context) {
+  protected val installationId = InstallationId(context)
+  private val mRegistrationInfo = RegistrationInfo(context)
+
+  override fun getName(): String = "NotificationsServerRegistrationModule"
+
+  @ExpoMethod
+  open fun getInstallationIdAsync(promise: Promise) {
+    promise.resolve(installationId.orCreateUUID)
+  }
+
+  @ExpoMethod
+  fun getRegistrationInfoAsync(promise: Promise) {
+    promise.resolve(mRegistrationInfo.get())
+  }
+
+  @ExpoMethod
+  fun setRegistrationInfoAsync(registrationInfo: String?, promise: Promise) {
+    mRegistrationInfo.set(registrationInfo)
+    promise.resolve(null)
+  }
+}

package/android/src/main/java/expo/modules/notifications/tokens/PushTokenModule.kt

@@ -0,0 +1,98 @@
+package expo.modules.notifications.tokens
+
+import android.content.Context
+import android.os.Bundle
+import com.google.firebase.messaging.FirebaseMessaging
+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.notifications.tokens.interfaces.PushTokenListener
+import expo.modules.notifications.tokens.interfaces.PushTokenManager
+
+private const val NEW_TOKEN_EVENT_NAME = "onDevicePushToken"
+private const val NEW_TOKEN_EVENT_TOKEN_KEY = "devicePushToken"
+private const val REGISTRATION_FAIL_CODE = "E_REGISTRATION_FAILED"
+private const val UNREGISTER_FOR_NOTIFICATIONS_FAIL_CODE = "E_UNREGISTER_FOR_NOTIFICATIONS_FAILED"
+
+class PushTokenModule(context: Context) : ExportedModule(context), PushTokenListener {
+  private lateinit var tokenManager: PushTokenManager
+  private var eventEmitter: EventEmitter? = null
+  override fun getName(): String = "ExpoPushTokenManager"
+
+  override fun onCreate(moduleRegistry: ModuleRegistry) {
+    eventEmitter = moduleRegistry.getModule(EventEmitter::class.java)
+
+    // Register the module as a listener in PushTokenManager singleton module.
+    // Deregistration happens in onDestroy callback.
+    tokenManager = requireNotNull(
+      moduleRegistry.getSingletonModule("PushTokenManager", PushTokenManager::class.java)
+    )
+    tokenManager.addListener(this)
+  }
+
+  override fun onDestroy() {
+    tokenManager.removeListener(this)
+  }
+
+  /**
+   * Fetches Firebase push token and resolves the promise.
+   *
+   * @param promise Promise to be resolved with the token.
+   */
+  @ExpoMethod
+  fun getDevicePushTokenAsync(promise: Promise) {
+    FirebaseMessaging.getInstance().token
+      .addOnCompleteListener { task ->
+        if (!task.isSuccessful) {
+          val exception = task.exception
+          if (exception == null) {
+            promise.reject(REGISTRATION_FAIL_CODE, "Fetching the token failed.")
+          } else {
+            promise.reject(REGISTRATION_FAIL_CODE, "Fetching the token failed: ${exception.message}", exception)
+          }
+          return@addOnCompleteListener
+        }
+        val token = task.result
+        if (token == null) {
+          promise.reject(REGISTRATION_FAIL_CODE, "Fetching the token failed. Invalid token.")
+          return@addOnCompleteListener
+        }
+
+        promise.resolve(token)
+        onNewToken(token)
+      }
+  }
+
+  @ExpoMethod
+  fun unregisterForNotificationsAsync(promise: Promise) {
+    FirebaseMessaging.getInstance().deleteToken()
+      .addOnCompleteListener { task ->
+        if (!task.isSuccessful) {
+          val exception = task.exception
+          if (exception == null) {
+            promise.reject(UNREGISTER_FOR_NOTIFICATIONS_FAIL_CODE, "Unregistering for notifications failed.")
+          } else {
+            promise.reject(UNREGISTER_FOR_NOTIFICATIONS_FAIL_CODE, "Unregistering for notifications failed: ${exception.message}", exception)
+          }
+          return@addOnCompleteListener
+        }
+        promise.resolve(null)
+      }
+  }
+
+  /**
+   * Callback called when [PushTokenManager] gets notified of a new token.
+   * Emits a [NEW_TOKEN_EVENT_NAME] event.
+   *
+   * @param token New push token.
+   */
+  override fun onNewToken(token: String) {
+    eventEmitter?.let {
+      val eventBody = Bundle()
+      eventBody.putString(NEW_TOKEN_EVENT_TOKEN_KEY, token)
+      it.emit(NEW_TOKEN_EVENT_NAME, eventBody)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-notifications",
-  "version": "0.24.1",
+  "version": "0.24.2",
   "description": "Notifications module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -57,5 +57,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "2bd82552d004cba40601572c8f141f063150620c"
+  "gitHead": "62f76105dfb436f7144440d6e6077d4ff3263842"
 }

package/android/src/main/java/expo/modules/notifications/notifications/background/ExpoBackgroundNotificationTasksModule.java

@@ -1,50 +0,0 @@
-package expo.modules.notifications.notifications.background;
-
-import android.content.Context;
-
-import expo.modules.core.ExportedModule;
-import expo.modules.core.ModuleRegistry;
-import expo.modules.core.Promise;
-import expo.modules.core.interfaces.ExpoMethod;
-import expo.modules.interfaces.taskManager.TaskManagerInterface;
-
-import java.util.Collections;
-
-public class ExpoBackgroundNotificationTasksModule extends ExportedModule {
-  private TaskManagerInterface mTaskManager;
-
-  public ExpoBackgroundNotificationTasksModule(Context context) {
-    super(context);
-  }
-
-  @Override
-  public String getName() {
-    return "ExpoBackgroundNotificationTasksModule";
-  }
-
-  @Override
-  public void onCreate(ModuleRegistry moduleRegistry) {
-    mTaskManager = moduleRegistry.getModule(TaskManagerInterface.class);
-  }
-
-  @ExpoMethod
-  public void registerTaskAsync(String taskName, final Promise promise) {
-    try {
-      mTaskManager.registerTask(
-          taskName, BackgroundRemoteNotificationTaskConsumer.class, Collections.emptyMap());
-      promise.resolve(null);
-    } catch (Exception e) {
-      promise.reject(e);
-    }
-  }
-
-  @ExpoMethod
-  public void unregisterTaskAsync(String taskName, final Promise promise) {
-    try {
-      mTaskManager.unregisterTask(taskName, BackgroundRemoteNotificationTaskConsumer.class);
-      promise.resolve(null);
-    } catch (Exception e) {
-      promise.reject(e);
-    }
-  }
-}

package/android/src/main/java/expo/modules/notifications/notifications/channels/NotificationChannelGroupManagerModule.java

@@ -1,98 +0,0 @@
-package expo.modules.notifications.notifications.channels;
-
-import android.app.NotificationChannelGroup;
-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.arguments.ReadableArguments;
-import expo.modules.core.interfaces.ExpoMethod;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import expo.modules.notifications.notifications.channels.managers.NotificationsChannelGroupManager;
-import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelGroupSerializer;
-
-import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelGroupSerializer.NAME_KEY;
-
-/**
- * An exported module responsible for exposing methods for managing notification channel groups.
- */
-public class NotificationChannelGroupManagerModule extends ExportedModule {
-  private final static String EXPORTED_NAME = "ExpoNotificationChannelGroupManager";
-
-  private NotificationsChannelGroupManager mGroupManager;
-  private NotificationsChannelGroupSerializer mGroupSerializer;
-
-  public NotificationChannelGroupManagerModule(Context context) {
-    super(context);
-  }
-
-  @Override
-  public void onCreate(ModuleRegistry moduleRegistry) {
-    NotificationsChannelsProvider provider = moduleRegistry.getModule(NotificationsChannelsProvider.class);
-    mGroupManager = provider.getGroupManager();
-    mGroupSerializer = provider.getGroupSerializer();
-  }
-
-  @Override
-  public String getName() {
-    return EXPORTED_NAME;
-  }
-
-  @ExpoMethod
-  public void getNotificationChannelGroupAsync(String groupId, Promise promise) {
-    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.O) {
-      promise.resolve(null);
-      return;
-    }
-
-    NotificationChannelGroup group = mGroupManager.getNotificationChannelGroup(groupId);
-    promise.resolve(mGroupSerializer.toBundle(group));
-  }
-
-  @ExpoMethod
-  public void getNotificationChannelGroupsAsync(Promise promise) {
-    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.O) {
-      promise.resolve(null);
-      return;
-    }
-
-    List<NotificationChannelGroup> existingChannels = mGroupManager.getNotificationChannelGroups();
-    List<Bundle> serializedChannels = new ArrayList<>(existingChannels.size());
-    for (NotificationChannelGroup channelGroup : existingChannels) {
-      serializedChannels.add(mGroupSerializer.toBundle(channelGroup));
-    }
-    promise.resolve(serializedChannels);
-  }
-
-  @ExpoMethod
-  public void setNotificationChannelGroupAsync(String groupId, ReadableArguments groupOptions, Promise promise) {
-    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.O) {
-      promise.resolve(null);
-      return;
-    }
-
-    NotificationChannelGroup group = mGroupManager.createNotificationChannelGroup(groupId, getNameFromOptions(groupOptions), groupOptions);
-    promise.resolve(mGroupSerializer.toBundle(group));
-  }
-
-  @ExpoMethod
-  public void deleteNotificationChannelGroupAsync(String groupId, Promise promise) {
-    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.O) {
-      promise.resolve(null);
-      return;
-    }
-
-    mGroupManager.deleteNotificationChannelGroup(groupId);
-    promise.resolve(null);
-  }
-
-
-  protected CharSequence getNameFromOptions(ReadableArguments groupOptions) {
-    return groupOptions.getString(NAME_KEY);
-  }
-}

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

@@ -1,109 +0,0 @@
-package expo.modules.notifications.notifications.channels;
-
-import android.app.NotificationChannel;
-import android.content.Context;
-import android.os.Build;
-import android.os.Bundle;
-
-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 java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Objects;
-
-import androidx.annotation.RequiresApi;
-import expo.modules.notifications.notifications.channels.managers.NotificationsChannelManager;
-import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer;
-import expo.modules.notifications.notifications.enums.NotificationImportance;
-
-import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.IMPORTANCE_KEY;
-import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.NAME_KEY;
-
-/**
- * An exported module responsible for exposing methods for managing notification channels.
- */
-public class NotificationChannelManagerModule extends ExportedModule {
-  private final static String EXPORTED_NAME = "ExpoNotificationChannelManager";
-
-  private NotificationsChannelManager mChannelManager;
-  private NotificationsChannelSerializer mChannelSerializer;
-
-  public NotificationChannelManagerModule(Context context) {
-    super(context);
-  }
-
-  @Override
-  public void onCreate(ModuleRegistry moduleRegistry) {
-    NotificationsChannelsProvider provider = moduleRegistry.getModule(NotificationsChannelsProvider.class);
-    mChannelManager = provider.getChannelManager();
-    mChannelSerializer = provider.getChannelSerializer();
-  }
-
-  @Override
-  public String getName() {
-    return EXPORTED_NAME;
-  }
-
-  @ExpoMethod
-  public void getNotificationChannelAsync(String channelId, Promise promise) {
-    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.O) {
-      promise.resolve(null);
-      return;
-    }
-
-    promise.resolve(mChannelSerializer.toBundle(mChannelManager.getNotificationChannel(channelId)));
-  }
-
-  @ExpoMethod
-  public void getNotificationChannelsAsync(Promise promise) {
-    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.O) {
-      promise.resolve(Collections.EMPTY_LIST);
-      return;
-    }
-
-    List<NotificationChannel> existingChannels = mChannelManager.getNotificationChannels();
-    List<Bundle> serializedChannels = new ArrayList<>(existingChannels.size());
-    for (NotificationChannel channel : existingChannels) {
-      serializedChannels.add(mChannelSerializer.toBundle(channel));
-    }
-    promise.resolve(serializedChannels);
-  }
-
-  @ExpoMethod
-  public void setNotificationChannelAsync(String channelId, ReadableArguments channelOptions, Promise promise) {
-    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.O) {
-      promise.resolve(null);
-      return;
-    }
-
-    NotificationChannel channel = mChannelManager.createNotificationChannel(channelId, getNameFromOptions(channelOptions), getImportanceFromOptions(channelOptions), channelOptions);
-    promise.resolve(mChannelSerializer.toBundle(channel));
-  }
-
-  @ExpoMethod
-  public void deleteNotificationChannelAsync(String channelId, Promise promise) {
-    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.O) {
-      promise.resolve(null);
-      return;
-    }
-
-    mChannelManager.deleteNotificationChannel(channelId);
-    promise.resolve(null);
-  }
-
-  protected CharSequence getNameFromOptions(ReadableArguments channelOptions) {
-    return channelOptions.getString(NAME_KEY);
-  }
-
-  @RequiresApi(api = Build.VERSION_CODES.N)
-  protected int getImportanceFromOptions(ReadableArguments channelOptions) {
-    int enumValue = channelOptions.getInt(IMPORTANCE_KEY, NotificationImportance.DEFAULT.getEnumValue());
-    NotificationImportance importance = Objects.requireNonNull(NotificationImportance.fromEnumValue(enumValue));
-    return importance.getNativeValue();
-  }
-}

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

@@ -1,98 +0,0 @@
-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.notifications.notifications.NotificationSerializer;
-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.NotificationResponse;
-
-public class NotificationsEmitter extends ExportedModule implements NotificationListener {
-  private final static String EXPORTED_NAME = "ExpoNotificationsEmitter";
-
-  private final static String NEW_MESSAGE_EVENT_NAME = "onDidReceiveNotification";
-  private final static String NEW_RESPONSE_EVENT_NAME = "onDidReceiveNotificationResponse";
-  private final static String MESSAGES_DELETED_EVENT_NAME = "onNotificationsDeleted";
-
-  private NotificationManager mNotificationManager;
-  private NotificationResponse mLastNotificationResponse;
-  private EventEmitter mEventEmitter;
-
-  public NotificationsEmitter(Context context) {
-    super(context);
-  }
-
-  @Override
-  public String getName() {
-    return EXPORTED_NAME;
-  }
-
-  @Override
-  public void onCreate(ModuleRegistry moduleRegistry) {
-    mEventEmitter = moduleRegistry.getModule(EventEmitter.class);
-
-    // Register the module as a listener in NotificationManager singleton module.
-    // Deregistration happens in onDestroy callback.
-    mNotificationManager = moduleRegistry.getSingletonModule("NotificationManager", NotificationManager.class);
-    mNotificationManager.addListener(this);
-  }
-
-  @Override
-  public void onDestroy() {
-    mNotificationManager.removeListener(this);
-  }
-
-  @ExpoMethod
-  public void getLastNotificationResponseAsync(Promise promise) {
-    promise.resolve(mLastNotificationResponse != null ? NotificationSerializer.toBundle(mLastNotificationResponse) : null);
-  }
-
-  /**
-   * Callback called when {@link NotificationManager} gets notified of a new notification.
-   * Emits a {@link NotificationsEmitter#NEW_MESSAGE_EVENT_NAME} event.
-   *
-   * @param notification Notification received
-   */
-  @Override
-  public void onNotificationReceived(Notification notification) {
-    if (mEventEmitter != null) {
-      mEventEmitter.emit(NEW_MESSAGE_EVENT_NAME, NotificationSerializer.toBundle(notification));
-    }
-  }
-
-  /**
-   * Callback called when {@link NotificationManager} gets notified of a new notification response.
-   * Emits a {@link NotificationsEmitter#NEW_RESPONSE_EVENT_NAME} event.
-   *
-   * @param response Notification response received
-   * @return Whether notification has been handled
-   */
-  @Override
-  public boolean onNotificationResponseReceived(NotificationResponse response) {
-    mLastNotificationResponse = response;
-    if (mEventEmitter != null) {
-      mEventEmitter.emit(NEW_RESPONSE_EVENT_NAME, NotificationSerializer.toBundle(response));
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Callback called when {@link NotificationManager} gets informed of the fact of message dropping.
-   * Emits a {@link NotificationsEmitter#MESSAGES_DELETED_EVENT_NAME} event.
-   */
-  @Override
-  public void onNotificationsDropped() {
-    if (mEventEmitter != null) {
-      mEventEmitter.emit(MESSAGES_DELETED_EVENT_NAME, Bundle.EMPTY);
-    }
-  }
-}

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

@@ -1,136 +0,0 @@
-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 java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-import expo.modules.notifications.notifications.emitting.NotificationsEmitter;
-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.notifications.model.NotificationResponse;
-
-/**
- * {@link NotificationListener} responsible for managing app's reaction to incoming
- * notification.
- * <p>
- * It is responsible for managing lifecycles of {@link SingleNotificationHandlerTask}s
- * 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.
- */
-public class NotificationsHandler extends ExportedModule implements NotificationListener {
-  private final static String EXPORTED_NAME = "ExpoNotificationsHandlerModule";
-
-  private static final String SHOULD_SHOW_ALERT_KEY = "shouldShowAlert";
-  private static final String SHOULD_PLAY_SOUND_KEY = "shouldPlaySound";
-  private static final String SHOULD_SET_BADGE_KEY = "shouldSetBadge";
-  private static final String PRIORITY_KEY = "priority";
-
-  private NotificationManager mNotificationManager;
-  private ModuleRegistry mModuleRegistry;
-
-  /**
-   * {@link HandlerThread} which is the host to the notifications handler.
-   */
-  private HandlerThread mNotificationsHandlerThread = null;
-
-  /**
-   * {@link Handler} on which lifecycle events are executed.
-   */
-  private Handler mHandler = null;
-
-  private Map<String, SingleNotificationHandlerTask> mTasksMap = new HashMap<>();
-
-  public NotificationsHandler(Context context) {
-    super(context);
-  }
-
-  @Override
-  public String getName() {
-    return EXPORTED_NAME;
-  }
-
-  @Override
-  public void onCreate(ModuleRegistry moduleRegistry) {
-    mModuleRegistry = moduleRegistry;
-
-    // Register the module as a listener in NotificationManager singleton module.
-    // Deregistration happens in onDestroy callback.
-    mNotificationManager = moduleRegistry.getSingletonModule("NotificationManager", NotificationManager.class);
-    mNotificationManager.addListener(this);
-
-    mNotificationsHandlerThread = new HandlerThread("NotificationsHandlerThread - " + this.getClass().toString());
-    mNotificationsHandlerThread.start();
-    mHandler = new Handler(mNotificationsHandlerThread.getLooper());
-  }
-
-  @Override
-  public void onDestroy() {
-    mNotificationManager.removeListener(this);
-    Collection<SingleNotificationHandlerTask> tasks = mTasksMap.values();
-    for (SingleNotificationHandlerTask task : tasks) {
-      task.stop();
-    }
-
-    // We don't have to use `quitSafely` here, cause all tasks were stopped
-    mNotificationsHandlerThread.quit();
-  }
-
-  /**
-   * Called by the app with {@link ReadableArguments} representing requested behavior
-   * that should be applied to the notification.
-   *
-   * @param identifier Identifier of the task which asked for behavior.
-   * @param behavior   Behavior to apply to the notification.
-   * @param promise    Promise to resolve once the notification is successfully presented
-   *                   or fails to be presented.
-   */
-  @ExpoMethod
-  public void handleNotificationAsync(String identifier, final ReadableArguments behavior, Promise promise) {
-    SingleNotificationHandlerTask task = mTasksMap.get(identifier);
-    if (task == null) {
-      String message = String.format("Failed to handle notification %s, it has already been handled.", identifier);
-      promise.reject("ERR_NOTIFICATION_HANDLED", message);
-      return;
-    }
-    boolean shouldShowAlert = behavior.getBoolean(SHOULD_SHOW_ALERT_KEY);
-    boolean shouldPlaySound = behavior.getBoolean(SHOULD_PLAY_SOUND_KEY);
-    boolean shouldSetBadge = behavior.getBoolean(SHOULD_SET_BADGE_KEY);
-    String priorityOverride = behavior.getString(PRIORITY_KEY);
-    task.handleResponse(new NotificationBehavior(shouldShowAlert, shouldPlaySound, shouldSetBadge, priorityOverride), promise);
-  }
-
-  /**
-   * Callback called by {@link NotificationManager} to inform its listeners of new messages.
-   * Starts up a new {@link SingleNotificationHandlerTask} which will take it on from here.
-   *
-   * @param notification Notification received
-   */
-  @Override
-  public void onNotificationReceived(Notification notification) {
-    SingleNotificationHandlerTask task = new SingleNotificationHandlerTask(getContext(), mHandler, mModuleRegistry, notification, this);
-    mTasksMap.put(task.getIdentifier(), task);
-    task.start();
-  }
-
-  /**
-   * Callback called once {@link SingleNotificationHandlerTask} finishes.
-   * A cue for removal of the task.
-   *
-   * @param task Task that just fulfilled its responsibility.
-   */
-  void onTaskFinished(SingleNotificationHandlerTask task) {
-    mTasksMap.remove(task.getIdentifier());
-  }
-}

package/android/src/main/java/expo/modules/notifications/serverregistration/ServerRegistrationModule.java

@@ -1,41 +0,0 @@
-package expo.modules.notifications.serverregistration;
-
-import android.content.Context;
-
-import expo.modules.core.ExportedModule;
-import expo.modules.core.Promise;
-import expo.modules.core.interfaces.ExpoMethod;
-
-public class ServerRegistrationModule extends ExportedModule {
-  private static final String EXPORTED_NAME = "NotificationsServerRegistrationModule";
-
-  protected InstallationId mInstallationId;
-  private RegistrationInfo mRegistrationInfo;
-
-  public ServerRegistrationModule(Context context) {
-    super(context);
-    mInstallationId = new InstallationId(context);
-    mRegistrationInfo = new RegistrationInfo(context);
-  }
-
-  @Override
-  public String getName() {
-    return EXPORTED_NAME;
-  }
-
-  @ExpoMethod
-  public void getInstallationIdAsync(Promise promise) {
-    promise.resolve(mInstallationId.getOrCreateUUID());
-  }
-
-  @ExpoMethod
-  public void getRegistrationInfoAsync(Promise promise) {
-    promise.resolve(mRegistrationInfo.get());
-  }
-
-  @ExpoMethod
-  public void setRegistrationInfoAsync(String registrationInfo, Promise promise) {
-    mRegistrationInfo.set(registrationInfo);
-    promise.resolve(null);
-  }
-}

package/android/src/main/java/expo/modules/notifications/tokens/PushTokenModule.java

@@ -1,116 +0,0 @@
-package expo.modules.notifications.tokens;
-
-import android.content.Context;
-import android.os.Bundle;
-
-import com.google.android.gms.tasks.OnCompleteListener;
-import com.google.android.gms.tasks.Task;
-import com.google.firebase.messaging.FirebaseMessaging;
-
-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 androidx.annotation.NonNull;
-import expo.modules.notifications.tokens.interfaces.PushTokenListener;
-import expo.modules.notifications.tokens.interfaces.PushTokenManager;
-
-public class PushTokenModule extends ExportedModule implements PushTokenListener {
-  private final static String EXPORTED_NAME = "ExpoPushTokenManager";
-
-  private final static String NEW_TOKEN_EVENT_NAME = "onDevicePushToken";
-  private final static String NEW_TOKEN_EVENT_TOKEN_KEY = "devicePushToken";
-
-  private final static String REGISTRATION_FAIL_CODE = "E_REGISTRATION_FAILED";
-  private final static String UNREGISTER_FOR_NOTIFICATIONS_FAIL_CODE = "E_UNREGISTER_FOR_NOTIFICATIONS_FAILED";
-
-  private PushTokenManager mPushTokenManager;
-  private EventEmitter mEventEmitter;
-
-  public PushTokenModule(Context context) {
-    super(context);
-  }
-
-  @Override
-  public String getName() {
-    return EXPORTED_NAME;
-  }
-
-
-  @Override
-  public void onCreate(ModuleRegistry moduleRegistry) {
-    mEventEmitter = moduleRegistry.getModule(EventEmitter.class);
-
-    // Register the module as a listener in PushTokenManager singleton module.
-    // Deregistration happens in onDestroy callback.
-    mPushTokenManager = moduleRegistry.getSingletonModule("PushTokenManager", PushTokenManager.class);
-    mPushTokenManager.addListener(this);
-  }
-
-  @Override
-  public void onDestroy() {
-    mPushTokenManager.removeListener(this);
-  }
-
-  /**
-   * Fetches Firebase push token and resolves the promise.
-   *
-   * @param promise Promise to be resolved with the token.
-   */
-  @ExpoMethod
-  public void getDevicePushTokenAsync(final Promise promise) {
-    FirebaseMessaging.getInstance().getToken()
-        .addOnCompleteListener(new OnCompleteListener<String>() {
-          @Override
-          public void onComplete(@NonNull Task<String> task) {
-            if (!task.isSuccessful() || task.getResult() == null) {
-              if (task.getException() == null) {
-                promise.reject(REGISTRATION_FAIL_CODE, "Fetching the token failed.");
-              } else {
-                promise.reject(REGISTRATION_FAIL_CODE, "Fetching the token failed: " + task.getException().getMessage(), task.getException());
-              }
-              return;
-            }
-
-            String token = task.getResult();
-
-            promise.resolve(token);
-            onNewToken(token);
-          }
-        });
-  }
-
-  @ExpoMethod
-  public void unregisterForNotificationsAsync(final Promise promise) {
-    FirebaseMessaging.getInstance().deleteToken()
-      .addOnCompleteListener(task -> {
-        if (!task.isSuccessful()) {
-          if (task.getException() == null) {
-            promise.reject(UNREGISTER_FOR_NOTIFICATIONS_FAIL_CODE, "Unregistering for notifications failed.");
-          } else {
-            promise.reject(UNREGISTER_FOR_NOTIFICATIONS_FAIL_CODE, "Unregistering for notifications failed: " + task.getException().getMessage(), task.getException());
-          }
-          return;
-        }
-
-        promise.resolve(null);
-      });
-  }
-
-  /**
-   * Callback called when {@link PushTokenManager} gets notified of a new token.
-   * Emits a {@link PushTokenModule#NEW_TOKEN_EVENT_NAME} event.
-   *
-   * @param token New push token.
-   */
-  @Override
-  public void onNewToken(String token) {
-    if (mEventEmitter != null) {
-      Bundle eventBody = new Bundle();
-      eventBody.putString(NEW_TOKEN_EVENT_TOKEN_KEY, token);
-      mEventEmitter.emit(NEW_TOKEN_EVENT_NAME, eventBody);
-    }
-  }
-}