@amazon-devices/expo-notifications 2.0.9000000000-rn-83

package/android/src/main/java/expo/modules/notifications/service/delegates/Base64Serialization.kt

@@ -0,0 +1,33 @@
+package expo.modules.notifications.service.delegates
+
+import android.util.Base64
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.IOException
+import java.io.InvalidClassException
+import java.io.ObjectInputStream
+import java.io.ObjectOutputStream
+import java.io.Serializable
+
+@Throws(IOException::class)
+fun Serializable.encodedInBase64(): String =
+  ByteArrayOutputStream().use { byteArrayOutputStream ->
+    ObjectOutputStream(byteArrayOutputStream).use { objectOutputStream ->
+      objectOutputStream.writeObject(this)
+      Base64.encodeToString(byteArrayOutputStream.toByteArray(), Base64.NO_WRAP)
+    }
+  }
+
+@Throws(IOException::class, ClassNotFoundException::class, InvalidClassException::class)
+inline fun <reified T> String.asBase64EncodedObject(): T =
+  ByteArrayInputStream(
+    Base64.decode(this, Base64.NO_WRAP)
+  ).use { byteArrayInputStream ->
+    ObjectInputStream(byteArrayInputStream).use { ois ->
+      val o = ois.readObject()
+      if (o is T) {
+        return o
+      }
+      throw InvalidClassException("Expected serialized object to be an instance of ${T::class.java}. Found: $o")
+    }
+  }

package/android/src/main/java/expo/modules/notifications/service/delegates/ExpoCategoriesDelegate.kt

@@ -0,0 +1,21 @@
+package expo.modules.notifications.service.delegates
+
+import android.content.Context
+import expo.modules.notifications.notifications.model.NotificationCategory
+import expo.modules.notifications.service.interfaces.CategoriesDelegate
+
+class ExpoCategoriesDelegate(protected val context: Context) : CategoriesDelegate {
+  private val mStore = SharedPreferencesNotificationCategoriesStore(context)
+
+  override fun getCategories(): Collection<NotificationCategory> {
+    return mStore.allNotificationCategories
+  }
+
+  override fun setCategory(category: NotificationCategory): NotificationCategory? {
+    return mStore.saveNotificationCategory(category)
+  }
+
+  override fun deleteCategory(identifier: String): Boolean {
+    return mStore.removeNotificationCategory(identifier)
+  }
+}

package/android/src/main/java/expo/modules/notifications/service/delegates/ExpoHandlingDelegate.kt

@@ -0,0 +1,146 @@
+package expo.modules.notifications.service.delegates
+
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ProcessLifecycleOwner
+import expo.modules.notifications.notifications.NotificationManager
+import expo.modules.notifications.notifications.model.Notification
+import expo.modules.notifications.notifications.model.NotificationResponse
+import expo.modules.notifications.service.NotificationForwarderActivity
+import expo.modules.notifications.service.NotificationsService
+import expo.modules.notifications.service.interfaces.HandlingDelegate
+import java.lang.ref.WeakReference
+import java.util.*
+
+class ExpoHandlingDelegate(protected val context: Context) : HandlingDelegate {
+  companion object {
+    const val OPEN_APP_INTENT_ACTION = "expo.modules.notifications.OPEN_APP_ACTION"
+
+    protected var sPendingNotificationResponses: MutableCollection<NotificationResponse> = ArrayList()
+
+    /**
+     * A weak map of listeners -> reference. Used to check quickly whether given listener
+     * is already registered and to iterate over when notifying of new token.
+     */
+    protected var sListenersReferences = WeakHashMap<NotificationManager, WeakReference<NotificationManager>>()
+
+    /**
+     * Used only by [NotificationManager] instances. If you look for a place to register
+     * your listener, use [NotificationManager] singleton module.
+     *
+     * Purposefully the argument is expected to be a [NotificationManager] and just a listener.
+     *
+     * This class doesn't hold strong references to listeners, so you need to own your listeners.
+     *
+     * @param listener A listener instance to be informed of new push device tokens.
+     */
+    fun addListener(listener: NotificationManager) {
+      if (sListenersReferences.containsKey(listener)) {
+        // Listener is already registered
+        return
+      }
+
+      sListenersReferences[listener] = WeakReference(listener)
+      if (!sPendingNotificationResponses.isEmpty()) {
+        val responseIterator = sPendingNotificationResponses.iterator()
+        while (responseIterator.hasNext()) {
+          listener.onNotificationResponseReceived(responseIterator.next())
+          responseIterator.remove()
+        }
+      }
+    }
+
+    /**
+     * Create a PendingIntent to open app in foreground.
+     * We actually start two Activities
+     *   - the foreground main Activity
+     *   - the background [NotificationForwarderActivity] Activity that send notification clicked events through broadcast
+     */
+    fun createPendingIntentForOpeningApp(context: Context, broadcastIntent: Intent, notificationResponse: NotificationResponse): PendingIntent {
+      var intentFlags = PendingIntent.FLAG_UPDATE_CURRENT
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        // The intent may include `RemoteInput` from `TextInputNotificationAction`.
+        // For intent with RemoteInput, it should be mutable.
+        intentFlags = intentFlags or PendingIntent.FLAG_MUTABLE
+      }
+
+      val backgroundActivityIntent = Intent(context, NotificationForwarderActivity::class.java)
+      backgroundActivityIntent.data = broadcastIntent.data
+      backgroundActivityIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK
+      backgroundActivityIntent.putExtras(broadcastIntent)
+      val requestCode = broadcastIntent.component?.className?.hashCode() ?: NotificationsService::class.java.hashCode()
+      return PendingIntent.getActivity(context, requestCode, backgroundActivityIntent, intentFlags)
+    }
+
+    fun openAppToForeground(context: Context, notificationResponse: NotificationResponse) {
+      (getNotificationActionLauncher(context) ?: getMainActivityLauncher(context))?.let { intent ->
+        NotificationsService.setNotificationResponseToIntent(intent, notificationResponse)
+        context.startActivity(intent)
+        return
+      }
+
+      Log.w("expo-notifications", "No launch intent found for application. Interacting with the notification won't open the app. The implementation uses `getLaunchIntentForPackage` to find appropriate activity.")
+    }
+
+    private fun getNotificationActionLauncher(context: Context): Intent? {
+      Intent(OPEN_APP_INTENT_ACTION).also { intent ->
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        intent.setPackage(context.applicationContext.packageName)
+        context.packageManager.resolveActivity(intent, 0)?.let {
+          return intent
+        }
+      }
+      return null
+    }
+
+    private fun getMainActivityLauncher(context: Context) =
+      context.packageManager.getLaunchIntentForPackage(context.packageName)
+  }
+
+  fun isAppInForeground() = ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)
+
+  fun getListeners() = sListenersReferences.values.mapNotNull { it.get() }
+
+  override fun handleNotification(notification: Notification) {
+    if (isAppInForeground()) {
+      getListeners().forEach {
+        it.onNotificationReceived(notification)
+      }
+    } else if (notification.shouldPresent()) {
+      NotificationsService.present(context, notification)
+    }
+  }
+
+  /**
+   * If the app is backgrounded, a notification is only presented if
+   * the title and or text is present. If both are null or empty, this is a "data-only" or "silent"
+   * notification that should not be presented to the user.
+   */
+  private fun Notification.shouldPresent(): Boolean {
+    return !(notificationRequest.content.title.isNullOrEmpty() && notificationRequest.content.text.isNullOrEmpty())
+  }
+
+  override fun handleNotificationResponse(notificationResponse: NotificationResponse) {
+    if (notificationResponse.action.opensAppToForeground()) {
+      openAppToForeground(context, notificationResponse)
+    }
+
+    if (getListeners().isEmpty()) {
+      sPendingNotificationResponses.add(notificationResponse)
+    } else {
+      getListeners().forEach {
+        it.onNotificationResponseReceived(notificationResponse)
+      }
+    }
+  }
+
+  override fun handleNotificationsDropped() {
+    getListeners().forEach {
+      it.onNotificationsDropped()
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/service/delegates/ExpoPresentationDelegate.kt

@@ -0,0 +1,193 @@
+package expo.modules.notifications.service.delegates
+
+import android.app.NotificationManager
+import android.content.Context
+import android.media.RingtoneManager
+import android.net.Uri
+import android.os.Bundle
+import android.os.Parcel
+import android.provider.Settings
+import android.service.notification.StatusBarNotification
+import android.util.Log
+import android.util.Pair
+import androidx.core.app.NotificationManagerCompat
+import expo.modules.notifications.notifications.enums.NotificationPriority
+import expo.modules.notifications.notifications.model.Notification
+import expo.modules.notifications.notifications.model.NotificationBehavior
+import expo.modules.notifications.notifications.model.NotificationContent
+import expo.modules.notifications.notifications.model.NotificationRequest
+import expo.modules.notifications.notifications.presentation.builders.CategoryAwareNotificationBuilder
+import expo.modules.notifications.notifications.presentation.builders.ExpoNotificationBuilder
+import expo.modules.notifications.service.interfaces.PresentationDelegate
+import org.json.JSONException
+import org.json.JSONObject
+import java.util.*
+
+open class ExpoPresentationDelegate(
+  protected val context: Context
+) : PresentationDelegate {
+  companion object {
+    protected const val ANDROID_NOTIFICATION_ID = 0
+
+    protected const val INTERNAL_IDENTIFIER_SCHEME = "expo-notifications"
+    protected const val INTERNAL_IDENTIFIER_AUTHORITY = "foreign_notifications"
+    protected const val INTERNAL_IDENTIFIER_TAG_KEY = "tag"
+    protected const val INTERNAL_IDENTIFIER_ID_KEY = "id"
+
+    /**
+     * Tries to parse given identifier as an internal foreign notification identifier
+     * created by us in [getInternalIdentifierKey].
+     *
+     * @param identifier String identifier of the notification
+     * @return Pair of (notification tag, notification id), if the identifier could be parsed. null otherwise.
+     */
+    fun parseNotificationIdentifier(identifier: String): Pair<String?, Int>? {
+      try {
+        val parsedIdentifier = Uri.parse(identifier)
+        if (INTERNAL_IDENTIFIER_SCHEME == parsedIdentifier.scheme && INTERNAL_IDENTIFIER_AUTHORITY == parsedIdentifier.authority) {
+          val tag = parsedIdentifier.getQueryParameter(INTERNAL_IDENTIFIER_TAG_KEY)
+          val id = parsedIdentifier.getQueryParameter(INTERNAL_IDENTIFIER_ID_KEY)!!.toInt()
+          return Pair(tag, id)
+        }
+      } catch (e: NullPointerException) {
+        Log.e("expo-notifications", "Malformed foreign notification identifier: $identifier", e)
+      } catch (e: NumberFormatException) {
+        Log.e("expo-notifications", "Malformed foreign notification identifier: $identifier", e)
+      } catch (e: UnsupportedOperationException) {
+        Log.e("expo-notifications", "Malformed foreign notification identifier: $identifier", e)
+      }
+      return null
+    }
+
+    /**
+     * Creates an identifier for given [StatusBarNotification]. It's supposed to be parsable
+     * by [parseNotificationIdentifier].
+     *
+     * @param notification Notification to be identified
+     * @return String identifier
+     */
+    protected fun getInternalIdentifierKey(notification: StatusBarNotification): String {
+      return with(Uri.parse("$INTERNAL_IDENTIFIER_SCHEME://$INTERNAL_IDENTIFIER_AUTHORITY").buildUpon()) {
+        notification.tag?.let {
+          this.appendQueryParameter(INTERNAL_IDENTIFIER_TAG_KEY, it)
+        }
+        this.appendQueryParameter(INTERNAL_IDENTIFIER_ID_KEY, notification.id.toString())
+        this.toString()
+      }
+    }
+  }
+
+  /**
+   * Callback called to present the system UI for a notification.
+   *
+   * If the notification behavior is set to not show any alert,
+   * we (may) play a sound, but then bail out early. You cannot
+   * set badge count without showing a notification.
+   */
+  override fun presentNotification(notification: Notification, behavior: NotificationBehavior?) {
+    if (behavior != null && !behavior.shouldShowAlert()) {
+      if (behavior.shouldPlaySound()) {
+        RingtoneManager.getRingtone(
+          context,
+          notification.notificationRequest.content.sound ?: Settings.System.DEFAULT_NOTIFICATION_URI
+        ).play()
+      }
+      return
+    }
+    NotificationManagerCompat.from(context).notify(
+      notification.notificationRequest.identifier,
+      getNotifyId(notification.notificationRequest),
+      createNotification(notification, behavior)
+    )
+  }
+
+  protected open fun getNotifyId(request: NotificationRequest?): Int {
+    return ANDROID_NOTIFICATION_ID
+  }
+
+  /**
+   * Callback called to fetch a collection of currently displayed notifications.
+   *
+   * **Note:** This feature is only supported on Android 23+.
+   *
+   * @return A collection of currently displayed notifications.
+   */
+  override fun getAllPresentedNotifications(): Collection<Notification> {
+    val notificationManager = (context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager)
+    return notificationManager.activeNotifications.mapNotNull { getNotification(it) }
+  }
+
+  override fun dismissNotifications(identifiers: Collection<String>) {
+    identifiers.forEach { identifier ->
+      val foreignNotification = parseNotificationIdentifier(identifier)
+      if (foreignNotification != null) {
+        // Foreign notification identified by us
+        NotificationManagerCompat.from(context).cancel(foreignNotification.first, foreignNotification.second)
+      } else {
+        // If the notification exists, let's assume it's ours, we have no reason to believe otherwise
+        val existingNotification = this.getAllPresentedNotifications().find { it.notificationRequest.identifier == identifier }
+        NotificationManagerCompat.from(context).cancel(identifier, getNotifyId(existingNotification?.notificationRequest))
+      }
+    }
+  }
+
+  override fun dismissAllNotifications() = NotificationManagerCompat.from(context).cancelAll()
+
+  protected open fun createNotification(notification: Notification, notificationBehavior: NotificationBehavior?): android.app.Notification =
+    CategoryAwareNotificationBuilder(context, SharedPreferencesNotificationCategoriesStore(context)).also {
+      it.setNotification(notification)
+      it.setAllowedBehavior(notificationBehavior)
+    }.build()
+
+  protected open fun getNotification(statusBarNotification: StatusBarNotification): Notification? {
+    val notification = statusBarNotification.notification
+    notification.extras.getByteArray(ExpoNotificationBuilder.EXTRAS_MARSHALLED_NOTIFICATION_REQUEST_KEY)?.let {
+      try {
+        with(Parcel.obtain()) {
+          this.unmarshall(it, 0, it.size)
+          this.setDataPosition(0)
+          val request: NotificationRequest = NotificationRequest.CREATOR.createFromParcel(this)
+          this.recycle()
+          val notificationDate = Date(statusBarNotification.postTime)
+          return Notification(request, notificationDate)
+        }
+      } catch (e: Exception) {
+        // Let's catch all the exceptions -- there's nothing we can do here
+        // and we'd rather return an array with a single, naively reconstructed notification
+        // than throw an exception and return none.
+        val message = "Could not have unmarshalled NotificationRequest from (${statusBarNotification.tag}, ${statusBarNotification.id})."
+        Log.e("expo-notifications", message)
+      }
+    }
+
+    // We weren't able to reconstruct the notification from our data, which means
+    // it's either not our notification or we couldn't have unmarshaled it from
+    // the byte array. Let's do what we can.
+    val content = NotificationContent.Builder()
+      .setTitle(notification.extras.getString(android.app.Notification.EXTRA_TITLE))
+      .setText(notification.extras.getString(android.app.Notification.EXTRA_TEXT))
+      .setSubtitle(notification.extras.getString(android.app.Notification.EXTRA_SUB_TEXT)) // using deprecated field
+      .setPriority(NotificationPriority.fromNativeValue(notification.priority)) // using deprecated field
+      .setVibrationPattern(notification.vibrate) // using deprecated field
+      .setSound(notification.sound)
+      .setAutoDismiss(notification.flags and android.app.Notification.FLAG_AUTO_CANCEL != 0)
+      .setSticky(notification.flags and android.app.Notification.FLAG_ONGOING_EVENT != 0)
+      .setBody(fromBundle(notification.extras))
+      .build()
+    val request = NotificationRequest(getInternalIdentifierKey(statusBarNotification), content, null)
+    return Notification(request, Date(statusBarNotification.postTime))
+  }
+
+  protected open fun fromBundle(bundle: Bundle): JSONObject {
+    return JSONObject().also { json ->
+      for (key in bundle.keySet()) {
+        try {
+          json.put(key, JSONObject.wrap(bundle[key]))
+        } catch (e: JSONException) {
+          // can't do anything about it apart from logging it
+          Log.d("expo-notifications", "Error encountered while serializing Android notification extras: " + key + " -> " + bundle[key], e)
+        }
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/service/delegates/ExpoSchedulingDelegate.kt

@@ -0,0 +1,117 @@
+package expo.modules.notifications.service.delegates
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import androidx.core.app.AlarmManagerCompat
+import expo.modules.notifications.notifications.interfaces.SchedulableNotificationTrigger
+import expo.modules.notifications.notifications.model.Notification
+import expo.modules.notifications.notifications.model.NotificationRequest
+import expo.modules.notifications.service.NotificationsService
+import expo.modules.notifications.service.interfaces.SchedulingDelegate
+import java.io.IOException
+import java.io.InvalidClassException
+
+class ExpoSchedulingDelegate(protected val context: Context) : SchedulingDelegate {
+  protected val store = SharedPreferencesNotificationsStore(context)
+  protected val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+
+  override fun setupScheduledNotifications() {
+    store.allNotificationRequests.forEach {
+      try {
+        scheduleNotification(it)
+      } catch (e: Exception) {
+        Log.w("expo-notifications", "Notification ${it.identifier} could not have been scheduled: ${e.message}")
+        e.printStackTrace()
+      }
+    }
+  }
+
+  override fun getAllScheduledNotifications(): Collection<NotificationRequest> =
+    store.allNotificationRequests
+
+  override fun getScheduledNotification(identifier: String): NotificationRequest? = try {
+    store.getNotificationRequest(identifier)
+  } catch (e: IOException) {
+    null
+  } catch (e: ClassNotFoundException) {
+    null
+  } catch (e: NullPointerException) {
+    null
+  }
+
+  override fun scheduleNotification(request: NotificationRequest) {
+    // If the trigger is empty, handle receive immediately and return.
+    if (request.trigger == null) {
+      NotificationsService.receive(context, Notification(request))
+      return
+    }
+
+    if (request.trigger !is SchedulableNotificationTrigger) {
+      throw IllegalArgumentException("Notification request \"${request.identifier}\" does not have a schedulable trigger (it's ${request.trigger}). Refusing to schedule.")
+    }
+
+    (request.trigger as SchedulableNotificationTrigger).nextTriggerDate().let { nextTriggerDate ->
+      if (nextTriggerDate == null) {
+        Log.d("expo-notifications", "Notification request \"${request.identifier}\" will not trigger in the future, removing.")
+        NotificationsService.removeScheduledNotification(context, request.identifier)
+      } else {
+        store.saveNotificationRequest(request)
+        setupAlarm(nextTriggerDate.time, NotificationsService.createNotificationTrigger(context, request.identifier))
+      }
+    }
+  }
+
+  override fun triggerNotification(identifier: String) {
+    try {
+      val notificationRequest: NotificationRequest = store.getNotificationRequest(identifier)!!
+      NotificationsService.receive(context, Notification(notificationRequest))
+      NotificationsService.schedule(context, notificationRequest)
+    } catch (e: ClassNotFoundException) {
+      Log.e("expo-notifications", "An exception occurred while triggering notification " + identifier + ", removing. " + e.message)
+      e.printStackTrace()
+      NotificationsService.removeScheduledNotification(context, identifier)
+    } catch (e: InvalidClassException) {
+      Log.e("expo-notifications", "An exception occurred while triggering notification " + identifier + ", removing. " + e.message)
+      e.printStackTrace()
+      NotificationsService.removeScheduledNotification(context, identifier)
+    } catch (e: NullPointerException) {
+      Log.e("expo-notifications", "An exception occurred while triggering notification " + identifier + ", removing. " + e.message)
+      e.printStackTrace()
+      NotificationsService.removeScheduledNotification(context, identifier)
+    }
+  }
+
+  override fun removeScheduledNotifications(identifiers: Collection<String>) {
+    identifiers.forEach {
+      alarmManager.cancel(NotificationsService.createNotificationTrigger(context, it))
+      store.removeNotificationRequest(it)
+    }
+  }
+
+  override fun removeAllScheduledNotifications() {
+    store.removeAllNotificationRequests().forEach {
+      alarmManager.cancel(NotificationsService.createNotificationTrigger(context, it))
+    }
+  }
+
+  private fun setupAlarm(triggerAtMillis: Long, operation: PendingIntent) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S || alarmManager.canScheduleExactAlarms()) {
+      AlarmManagerCompat.setExactAndAllowWhileIdle(
+        alarmManager,
+        AlarmManager.RTC_WAKEUP,
+        triggerAtMillis,
+        operation
+      )
+    } else {
+      AlarmManagerCompat.setAndAllowWhileIdle(
+        alarmManager,
+        AlarmManager.RTC_WAKEUP,
+        triggerAtMillis,
+        operation
+      )
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/service/delegates/FirebaseMessagingDelegate.kt

@@ -0,0 +1,126 @@
+package expo.modules.notifications.service.delegates
+
+import android.content.Context
+import com.google.firebase.messaging.RemoteMessage
+import expo.modules.notifications.notifications.JSONNotificationContentBuilder
+import expo.modules.notifications.notifications.RemoteMessageSerializer
+import expo.modules.notifications.notifications.background.BackgroundRemoteNotificationTaskConsumer
+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.notifications.model.triggers.FirebaseNotificationTrigger
+import expo.modules.notifications.service.NotificationsService
+import expo.modules.notifications.service.interfaces.FirebaseMessagingDelegate
+import expo.modules.notifications.tokens.interfaces.FirebaseTokenListener
+import org.json.JSONObject
+import java.lang.ref.WeakReference
+import java.util.*
+
+open class FirebaseMessagingDelegate(protected val context: Context) : FirebaseMessagingDelegate {
+  companion object {
+    // Unfortunately we cannot save state between instances of a service other way
+    // than by static properties. Fortunately, using weak references we can
+    // be somehow sure instances of PushTokenListeners won't be leaked by this component.
+    /**
+     * We store this value to be able to inform new listeners of last known token.
+     */
+    protected var sLastToken: String? = null
+
+    /**
+     * A weak map of listeners -> reference. Used to check quickly whether given listener
+     * is already registered and to iterate over when notifying of new token.
+     */
+    protected val sTokenListenersReferences = WeakHashMap<FirebaseTokenListener, WeakReference<FirebaseTokenListener?>?>()
+
+    /**
+     * Used only by [FirebaseTokenListener] instances. If you look for a place to register
+     * your listener, use [FirebaseTokenListener] singleton module.
+     *
+     * Purposefully the argument is expected to be a [FirebaseTokenListener] and just a listener.
+     *
+     * This class doesn't hold strong references to listeners, so you need to own your listeners.
+     *
+     * @param listener A listener instance to be informed of new push device tokens.
+     */
+    @JvmStatic
+    fun addTokenListener(listener: FirebaseTokenListener) {
+      // Checks whether this listener has already been registered
+      if (!sTokenListenersReferences.containsKey(listener)) {
+        sTokenListenersReferences[listener] = WeakReference(listener)
+        // Since it's a new listener and we know of a last valid token, let's let them know.
+        if (sLastToken != null) {
+          listener.onNewToken(sLastToken)
+        }
+      }
+    }
+
+    /**
+     * A weak map of task consumers -> reference. Used to check quickly whether given task
+     * is already registered and to iterate over when notifying of new notification received
+     * while the app is not in the foreground.
+     */
+    protected var sBackgroundTaskConsumerReferences = WeakHashMap<BackgroundRemoteNotificationTaskConsumer, WeakReference<BackgroundRemoteNotificationTaskConsumer>>()
+
+    /**
+     * Background tasks are registered in [BackgroundRemoteNotificationTaskConsumer] instances.
+     *
+     * @param taskConsumer A task instance to be executed when a notification is received while the * app is not in the foreground
+     */
+    fun addBackgroundTaskConsumer(taskConsumer: BackgroundRemoteNotificationTaskConsumer) {
+      if (sBackgroundTaskConsumerReferences.containsKey(taskConsumer)) {
+        return
+      }
+      sBackgroundTaskConsumerReferences[taskConsumer] = WeakReference(taskConsumer)
+    }
+  }
+
+  /**
+   * Called on new token, dispatches it to [NotificationsService.sTokenListenersReferences].
+   *
+   * @param token New device push token.
+   */
+  override fun onNewToken(token: String) {
+    for (listenerReference in sTokenListenersReferences.values) {
+      listenerReference?.get()?.onNewToken(token)
+    }
+    sLastToken = token
+  }
+
+  fun getBackgroundTasks() = sBackgroundTaskConsumerReferences.values.mapNotNull { it.get() }
+
+  override fun onMessageReceived(remoteMessage: RemoteMessage) {
+    NotificationsService.receive(context, createNotification(remoteMessage))
+    getBackgroundTasks().forEach {
+      it.scheduleJob(RemoteMessageSerializer.toBundle(remoteMessage))
+    }
+  }
+
+  protected fun createNotification(remoteMessage: RemoteMessage): Notification {
+    val identifier = getNotificationIdentifier(remoteMessage)
+    val payload = JSONObject(remoteMessage.data as Map<*, *>)
+    val content = JSONNotificationContentBuilder(context).setPayload(payload).build()
+    val request = createNotificationRequest(identifier, content, FirebaseNotificationTrigger(remoteMessage))
+    return Notification(request, Date(remoteMessage.sentTime))
+  }
+
+  /**
+   * To match iOS behavior, we want to assign the remote message's tag as the notification ID.
+   * If a notification comes in with the same tag as a notification that is already in the tray,
+   * the existing notification is replaced, but the ID can remain constant.
+   */
+  protected fun getNotificationIdentifier(remoteMessage: RemoteMessage): String {
+    return remoteMessage.data?.get("tag") ?: remoteMessage.messageId ?: UUID.randomUUID().toString()
+  }
+
+  protected open fun createNotificationRequest(
+    identifier: String,
+    content: NotificationContent,
+    notificationTrigger: FirebaseNotificationTrigger
+  ): NotificationRequest {
+    return NotificationRequest(identifier, content, notificationTrigger)
+  }
+
+  override fun onDeletedMessages() {
+    NotificationsService.handleDropped(context)
+  }
+}