expo-notifications 0.28.12 → 0.28.14

package/CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ### 💡 Others
 
+## 0.28.14 — 2024-07-30
+
+### 🐛 Bug fixes
+
+- `useLastNotificationResponse` should have only one effect. ([#30653](https://github.com/expo/expo/pull/30653) by [@douglowder](https://github.com/douglowder))
+
+## 0.28.13 — 2024-07-29
+
+### 🐛 Bug fixes
+
+- [Android] map Expo and Firebase notifications correctly. ([#30615](https://github.com/expo/expo/pull/30615) by [@douglowder](https://github.com/douglowder))
+- [Android] Apply requested changes from #30615. ([#30658](https://github.com/expo/expo/pull/30615) by [@lukmccall](https://github.com/lukmccall))
+
 ## 0.28.12 — 2024-07-25
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '0.28.12'
+version = '0.28.14'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 apply from: expoModulesCorePlugin
@@ -14,7 +14,7 @@ android {
   namespace "expo.modules.notifications"
   defaultConfig {
     versionCode 21
-    versionName '0.28.12'
+    versionName '0.28.14'
   }
 
   buildFeatures {

package/android/src/main/java/expo/modules/notifications/notifications/NotificationSerializer.java

@@ -5,8 +5,11 @@ import android.os.Bundle;
 
 import androidx.annotation.Nullable;
 
+import com.google.firebase.messaging.RemoteMessage;
+
 import org.jetbrains.annotations.NotNull;
 import org.json.JSONArray;
+import org.json.JSONException;
 import org.json.JSONObject;
 import expo.modules.core.arguments.MapArguments;
 
@@ -52,11 +55,37 @@ public class NotificationSerializer {
   public static Bundle toBundle(NotificationRequest request) {
     Bundle serializedRequest = new Bundle();
     serializedRequest.putString("identifier", request.getIdentifier());
-    serializedRequest.putBundle("content", toBundle(request.getContent()));
     serializedRequest.putBundle("trigger", toBundle(request.getTrigger()));
+    Bundle content = toBundle(request.getContent());
+    Bundle existingContentData = content.getBundle("data");
+    if (existingContentData == null) {
+      FirebaseNotificationTrigger trigger = (FirebaseNotificationTrigger) request.getTrigger();
+      RemoteMessage message = trigger.getRemoteMessage();
+      RemoteMessage.Notification notification = message.getNotification();
+      Map<String, String> data = message.getData();
+      String dataBody = data.get("body");
+      String notificationBody = notification != null ? notification.getBody() : null;
+      if (isValidJSONString(dataBody) && notificationBody != null && notificationBody.equals(data.get("message"))) {
+        // Expo sends notification.body as data.message, and JSON stringifies data.body
+        content.putString("dataString", dataBody);
+      } else {
+        // The message was sent directly from Firebase or some other service,
+        // and we copy the data as is
+        content.putBundle("data", toBundle(data));
+      }
+    }
+    serializedRequest.putBundle("content", content);
     return serializedRequest;
   }
 
+  public static Bundle toBundle(Map<String, String> map) {
+    Bundle result = new Bundle();
+    for (String key: map.keySet()) {
+      result.putString(key, map.get(key));
+    }
+    return result;
+  }
+
   public static Bundle toBundle(NotificationContent content) {
     Bundle serializedContent = new Bundle();
     serializedContent.putString("title", content.getTitle());
@@ -65,7 +94,7 @@ public class NotificationSerializer {
     if (content.getColor() != null) {
       serializedContent.putString("color", String.format("#%08X", content.getColor().intValue()));
     }
-    serializedContent.putBundle("data", toBundle(content.getBody()));
+
     if (content.getBadgeCount() != null) {
       serializedContent.putInt("badge", content.getBadgeCount().intValue());
     } else {
@@ -192,30 +221,55 @@ public class NotificationSerializer {
     return null;
   }
 
-    @NotNull
-    public static Bundle toResponseBundleFromExtras(Bundle extras) {
-      Bundle serializedContent = new Bundle();
-      serializedContent.putString("title", extras.getString("title"));
+  @NotNull
+  public static Bundle toResponseBundleFromExtras(Bundle extras) {
+    Bundle serializedContent = new Bundle();
+    serializedContent.putString("title", extras.getString("title"));
+    String body = extras.getString("body");
+    String projectId = extras.getString("projectId");
+    if (projectId != null && isValidJSONString(body) ) {
+      // If projectId is set in the bundle, and the body is a JSON string,
+      // the notification was sent by the Expo notification service,
+      // so we do the expected remapping of fields
+      serializedContent.putString("dataString", body);
       serializedContent.putString("body", extras.getString("message"));
-      serializedContent.putString("dataString", extras.getString("body"));
+    } else {
+      // The notification came directly from Firebase or some other service,
+      // so we copy the data as is from the extras bundle
+      serializedContent.putBundle("data", extras);
+    }
 
-      Bundle serializedTrigger = new Bundle();
-      serializedTrigger.putString("type", "push");
-      serializedTrigger.putString("channelId", extras.getString("channelId"));
+    Bundle serializedTrigger = new Bundle();
+    serializedTrigger.putString("type", "push");
+    serializedTrigger.putString("channelId", extras.getString("channelId"));
 
-      Bundle serializedRequest = new Bundle();
-      serializedRequest.putString("identifier", extras.getString("google.message_id"));
-      serializedRequest.putBundle("trigger", serializedTrigger);
-      serializedRequest.putBundle("content", serializedContent);
+    Bundle serializedRequest = new Bundle();
+    serializedRequest.putString("identifier", extras.getString("google.message_id"));
+    serializedRequest.putBundle("trigger", serializedTrigger);
+    serializedRequest.putBundle("content", serializedContent);
 
-      Bundle serializedNotification = new Bundle();
-      serializedNotification.putLong("date", extras.getLong("google.sent_time"));
-      serializedNotification.putBundle("request", serializedRequest);
+    Bundle serializedNotification = new Bundle();
+    serializedNotification.putLong("date", extras.getLong("google.sent_time"));
+    serializedNotification.putBundle("request", serializedRequest);
 
-      Bundle serializedResponse = new Bundle();
-      serializedResponse.putString("actionIdentifier", "expo.modules.notifications.actions.DEFAULT");
-      serializedResponse.putBundle("notification", serializedNotification);
+    Bundle serializedResponse = new Bundle();
+    serializedResponse.putString("actionIdentifier", "expo.modules.notifications.actions.DEFAULT");
+    serializedResponse.putBundle("notification", serializedNotification);
 
-      return serializedResponse;
+    return serializedResponse;
+  }
+
+  public static boolean isValidJSONString(String test) {
+    try {
+      new JSONObject(test);
+    } catch (JSONException objectEx) {
+      try {
+        new JSONArray(test);
+      } catch (JSONException arrayEx) {
+        return false;
+      }
     }
+    return true;
+  }
+
 }

package/android/src/main/java/expo/modules/notifications/notifications/debug/DebugLogging.kt

@@ -0,0 +1,86 @@
+package expo.modules.notifications.notifications.debug
+
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.google.firebase.messaging.RemoteMessage
+import expo.modules.notifications.BuildConfig
+import expo.modules.notifications.notifications.model.Notification
+import java.util.function.Consumer
+
+object DebugLogging {
+  @JvmStatic
+  fun logBundle(caller: String, bundleToLog: Bundle) {
+    if (!BuildConfig.DEBUG) {
+      // Do not log in release/production builds
+      return
+    }
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+      return
+    }
+    Log.i("expo-notifications", "$caller:\n${bundleString(caller, bundleToLog, 0)}")
+  }
+
+  @RequiresApi(Build.VERSION_CODES.N)
+  private fun bundleString(ignoredCaller: String, bundleToLog: Bundle, indent: Int): String {
+    return buildString {
+      bundleToLog.keySet().forEach(
+        Consumer { key: String ->
+          val value = bundleToLog[key]
+          if (value is Bundle) {
+            append("${" ".repeat(indent)}${key}\n")
+            append(bundleString(ignoredCaller, value, indent + 2))
+          } else {
+            val stringValue = value?.toString() ?: "(null)"
+            append("${" ".repeat(indent)}$key: $stringValue\n")
+          }
+        }
+      )
+    }
+  }
+
+  fun logRemoteMessage(caller: String, message: RemoteMessage) {
+    if (!BuildConfig.DEBUG) {
+      // Do not log for release/production builds
+      return
+    }
+    val logMessage =
+      """
+      $caller:
+        notification.channelId: ${message.notification?.channelId}
+        notification.vibrateTimings: ${message.notification?.vibrateTimings?.contentToString()}
+        notification.body: ${message.notification?.body}
+        notification.color: ${message.notification?.color}
+        notification.sound: ${message.notification?.sound}
+        notification.title: ${message.notification?.title}
+        notification.collapseKey: ${message.collapseKey}
+        data: ${message.data}
+      """.trimIndent()
+
+    Log.i("expo-notifications", logMessage)
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  fun logNotification(caller: String, notification: Notification) {
+    if (!BuildConfig.DEBUG) {
+      // Do not log for release/production builds
+      return
+    }
+    val logMessage =
+      """
+      $caller:
+        notification.notificationRequest.content.title: ${notification.notificationRequest.content.title}
+        notification.notificationRequest.content.subtitle: ${notification.notificationRequest.content.subtitle}
+        notification.notificationRequest.content.text: ${notification.notificationRequest.content.text}
+        notification.notificationRequest.content.sound: ${notification.notificationRequest.content.sound}
+        notification.notificationRequest.content.body: ${notification.notificationRequest.content.body}
+        notification.notificationRequest.content.color: ${notification.notificationRequest.content.color}
+        notification.notificationRequest.content.vibrationPattern: ${notification.notificationRequest.content.vibrationPattern.contentToString()}
+        notification.notificationRequest.trigger.notificationChannel: ${notification.notificationRequest.trigger.notificationChannel}
+        notification.notificationRequest.identifier: ${notification.notificationRequest.identifier}
+      """.trimIndent()
+
+    Log.i("expo-notifications", logMessage)
+  }
+}

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

@@ -4,6 +4,7 @@ import android.os.Bundle
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.notifications.notifications.NotificationSerializer
+import expo.modules.notifications.notifications.debug.DebugLogging
 import expo.modules.notifications.notifications.interfaces.NotificationListener
 import expo.modules.notifications.notifications.interfaces.NotificationManager
 import expo.modules.notifications.notifications.model.Notification
@@ -49,7 +50,9 @@ open class NotificationsEmitter : Module(), NotificationListener {
    * @param notification Notification received
    */
   override fun onNotificationReceived(notification: Notification) {
-    sendEvent(NEW_MESSAGE_EVENT_NAME, NotificationSerializer.toBundle(notification))
+    val bundle = NotificationSerializer.toBundle(notification)
+    DebugLogging.logBundle("NotificationsEmitter.onNotificationReceived", bundle)
+    sendEvent(NEW_MESSAGE_EVENT_NAME, bundle)
   }
 
   /**
@@ -60,13 +63,17 @@ open class NotificationsEmitter : Module(), NotificationListener {
    * @return Whether notification has been handled
    */
   override fun onNotificationResponseReceived(response: NotificationResponse): Boolean {
-    lastNotificationResponseBundle = NotificationSerializer.toBundle(response)
+    val bundle = NotificationSerializer.toBundle(response)
+    DebugLogging.logBundle("NotificationsEmitter.onNotificationResponseReceived", bundle)
+    lastNotificationResponseBundle = bundle
     sendEvent(NEW_RESPONSE_EVENT_NAME, lastNotificationResponseBundle)
     return true
   }
 
   override fun onNotificationResponseIntentReceived(extras: Bundle?) {
-    lastNotificationResponseBundle = NotificationSerializer.toResponseBundleFromExtras(extras)
+    val bundle = NotificationSerializer.toResponseBundleFromExtras(extras)
+    DebugLogging.logBundle("NotificationsEmitter.onNotificationResponseIntentReceived", bundle)
+    lastNotificationResponseBundle = bundle
     sendEvent(NEW_RESPONSE_EVENT_NAME, lastNotificationResponseBundle)
   }
 

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

@@ -10,6 +10,7 @@ import android.net.Uri
 import android.os.*
 import android.util.Log
 import androidx.core.app.RemoteInput
+import expo.modules.notifications.BuildConfig
 import expo.modules.notifications.notifications.model.*
 import expo.modules.notifications.service.delegates.ExpoCategoriesDelegate
 import expo.modules.notifications.service.delegates.ExpoHandlingDelegate
@@ -644,7 +645,12 @@ open class NotificationsService : BroadcastReceiver() {
         // If we ended up here, the callbacks must have completed successfully
         receiver?.send(SUCCESS_CODE, resultData)
       } catch (e: Exception) {
-        Log.e("expo-notifications", "Action ${intent.action} failed: ${e.message}")
+        if (BuildConfig.DEBUG) {
+          // Log stack trace for debugging
+          Log.e("expo-notifications", "Action ${intent.action} failed: ${e.message}\n${e.stackTraceToString()}")
+        } else {
+          Log.e("expo-notifications", "Action ${intent.action} failed: ${e.message}")
+        }
         e.printStackTrace()
 
         receiver?.send(ERROR_CODE, Bundle().also { it.putSerializable(EXCEPTION_KEY, e) })

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

@@ -1,22 +1,14 @@
 package expo.modules.notifications.service.delegates;
 
 import android.app.Activity;
-import android.app.NotificationChannel;
-import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
-import android.os.Parcel;
 import android.util.Log;
 
-import androidx.core.app.NotificationCompat;
-
-import java.util.Objects;
-
 import expo.modules.core.interfaces.ReactActivityLifecycleListener;
 import expo.modules.notifications.notifications.NotificationManager;
-import expo.modules.notifications.notifications.model.Notification;
-import expo.modules.notifications.notifications.model.NotificationResponse;
+import expo.modules.notifications.notifications.debug.DebugLogging;
 
 public class ExpoNotificationLifecycleListener implements ReactActivityLifecycleListener {
 
@@ -45,6 +37,7 @@ public class ExpoNotificationLifecycleListener implements ReactActivityLifecycle
                     Log.d("ReactNativeJS", "[native] ExpoNotificationLifecycleListener contains an unmarshaled notification response. Skipping.");
                     return;
                 }
+                DebugLogging.logBundle("ExpoNotificationLifeCycleListener.onCreate:", extras);
                 mNotificationManager.onNotificationResponseFromExtras(extras);
             }
         }
@@ -68,6 +61,7 @@ public class ExpoNotificationLifecycleListener implements ReactActivityLifecycle
                 intent.removeExtra("notificationResponse");
                 return ReactActivityLifecycleListener.super.onNewIntent(intent);
             }
+            DebugLogging.logBundle("ExpoNotificationLifeCycleListener.onNewIntent:", extras);
             mNotificationManager.onNotificationResponseFromExtras(extras);
         }
         return ReactActivityLifecycleListener.super.onNewIntent(intent);

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

@@ -1,10 +1,12 @@
 package expo.modules.notifications.service.delegates
 
 import android.content.Context
+import android.os.Build
 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.debug.DebugLogging
 import expo.modules.notifications.notifications.model.Notification
 import expo.modules.notifications.notifications.model.NotificationContent
 import expo.modules.notifications.notifications.model.NotificationRequest
@@ -90,7 +92,12 @@ open class FirebaseMessagingDelegate(protected val context: Context) : FirebaseM
   fun getBackgroundTasks() = sBackgroundTaskConsumerReferences.values.mapNotNull { it.get() }
 
   override fun onMessageReceived(remoteMessage: RemoteMessage) {
-    NotificationsService.receive(context, createNotification(remoteMessage))
+    DebugLogging.logRemoteMessage("FirebaseMessagingDelegate.onMessageReceived: message", remoteMessage)
+    val notification = createNotification(remoteMessage)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      DebugLogging.logNotification("FirebaseMessagingDelegate.onMessageReceived: notification", notification)
+    }
+    NotificationsService.receive(context, notification)
     getBackgroundTasks().forEach {
       it.scheduleJob(RemoteMessageSerializer.toBundle(remoteMessage))
     }

package/build/NotificationsEmitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotificationsEmitter.d.ts","sourceRoot":"","sources":["../src/NotificationsEmitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAuB,MAAM,mBAAmB,CAAC;AAEpF,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAY3E,eAAO,MAAM,yBAAyB,+CAA+C,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GACtC,YAAY,CAEd;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,YAAY,CAElF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAC9C,YAAY,CAQd;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,YAAY,EAAE,YAAY,QAExE;AAGD;;GAEG;AACH,wBAAsB,gCAAgC,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAO7F"}
+{"version":3,"file":"NotificationsEmitter.d.ts","sourceRoot":"","sources":["../src/NotificationsEmitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAuB,MAAM,mBAAmB,CAAC;AAEpF,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAY3E,eAAO,MAAM,yBAAyB,+CAA+C,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GACtC,YAAY,CAQd;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,YAAY,CAElF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAC9C,YAAY,CAQd;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,YAAY,EAAE,YAAY,QAExE;AAGD;;GAEG;AACH,wBAAsB,gCAAgC,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAO7F"}

package/build/NotificationsEmitter.js

@@ -1,6 +1,6 @@
 import { EventEmitter, UnavailabilityError } from 'expo-modules-core';
 import NotificationsEmitterModule from './NotificationsEmitterModule';
-import { mapNotificationResponse } from './utils/mapNotificationResponse';
+import { mapNotification, mapNotificationResponse } from './utils/mapNotificationResponse';
 // Web uses SyntheticEventEmitter
 const emitter = new EventEmitter(NotificationsEmitterModule);
 const didReceiveNotificationEventName = 'onDidReceiveNotification';
@@ -33,7 +33,10 @@ export const DEFAULT_ACTION_IDENTIFIER = 'expo.modules.notifications.actions.DEF
  * @header listen
  */
 export function addNotificationReceivedListener(listener) {
-    return emitter.addListener(didReceiveNotificationEventName, listener);
+    return emitter.addListener(didReceiveNotificationEventName, (notification) => {
+        const mappedNotification = mapNotification(notification);
+        listener(mappedNotification);
+    });
 }
 /**
  * Listeners registered by this method will be called whenever some notifications have been dropped by the server.

package/build/NotificationsEmitter.js.map

@@ -1 +1 @@
-{"version":3,"file":"NotificationsEmitter.js","sourceRoot":"","sources":["../src/NotificationsEmitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAgB,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGpF,OAAO,0BAA0B,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,iCAAiC;AACjC,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,0BAA0B,CAAC,CAAC;AAE7D,MAAM,+BAA+B,GAAG,0BAA0B,CAAC;AACnE,MAAM,6BAA6B,GAAG,wBAAwB,CAAC;AAC/D,MAAM,uCAAuC,GAAG,kCAAkC,CAAC;AAEnF,eAAe;AACf,MAAM,CAAC,MAAM,yBAAyB,GAAG,4CAA4C,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,+BAA+B,CAC7C,QAAuC;IAEvC,OAAO,OAAO,CAAC,WAAW,CAAe,+BAA+B,EAAE,QAAQ,CAAC,CAAC;AACtF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,+BAA+B,CAAC,QAAoB;IAClE,OAAO,OAAO,CAAC,WAAW,CAAO,6BAA6B,EAAE,QAAQ,CAAC,CAAC;AAC5E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,uCAAuC,CACrD,QAA+C;IAE/C,OAAO,OAAO,CAAC,WAAW,CACxB,uCAAuC,EACvC,CAAC,QAA8B,EAAE,EAAE;QACjC,MAAM,cAAc,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QACzD,QAAQ,CAAC,cAAc,CAAC,CAAC;IAC3B,CAAC,CACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,8BAA8B,CAAC,YAA0B;IACvE,OAAO,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;AAC3C,CAAC;AAED,eAAe;AACf;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,gCAAgC;IACpD,IAAI,CAAC,0BAA0B,CAAC,gCAAgC,EAAE;QAChE,MAAM,IAAI,mBAAmB,CAAC,mBAAmB,EAAE,kCAAkC,CAAC,CAAC;KACxF;IACD,MAAM,QAAQ,GAAG,MAAM,0BAA0B,CAAC,gCAAgC,EAAE,CAAC;IACrF,MAAM,cAAc,GAAG,QAAQ,CAAC,CAAC,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAC/E,OAAO,cAAc,CAAC;AACxB,CAAC","sourcesContent":["import { EventEmitter, Subscription, UnavailabilityError } from 'expo-modules-core';\n\nimport { Notification, NotificationResponse } from './Notifications.types';\nimport NotificationsEmitterModule from './NotificationsEmitterModule';\nimport { mapNotificationResponse } from './utils/mapNotificationResponse';\n\n// Web uses SyntheticEventEmitter\nconst emitter = new EventEmitter(NotificationsEmitterModule);\n\nconst didReceiveNotificationEventName = 'onDidReceiveNotification';\nconst didDropNotificationsEventName = 'onNotificationsDeleted';\nconst didReceiveNotificationResponseEventName = 'onDidReceiveNotificationResponse';\n\n// @docsMissing\nexport const DEFAULT_ACTION_IDENTIFIER = 'expo.modules.notifications.actions.DEFAULT';\n\n/**\n * Listeners registered by this method will be called whenever a notification is received while the app is running.\n * @param listener A function accepting a notification ([`Notification`](#notification)) as an argument.\n * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.\n * @example Registering a notification listener using a React hook:\n * ```jsx\n * import React from 'react';\n * import * as Notifications from 'expo-notifications';\n *\n * export default function App() {\n *   React.useEffect(() => {\n *     const subscription = Notifications.addNotificationReceivedListener(notification => {\n *       console.log(notification);\n *     });\n *     return () => subscription.remove();\n *   }, []);\n *\n *   return (\n *     // Your app content\n *   );\n * }\n * ```\n * @header listen\n */\nexport function addNotificationReceivedListener(\n  listener: (event: Notification) => void\n): Subscription {\n  return emitter.addListener<Notification>(didReceiveNotificationEventName, listener);\n}\n\n/**\n * Listeners registered by this method will be called whenever some notifications have been dropped by the server.\n * Applicable only to Firebase Cloud Messaging which we use as a notifications service on Android. It corresponds to `onDeletedMessages()` callback.\n * More information can be found in [Firebase docs](https://firebase.google.com/docs/cloud-messaging/android/receive#override-ondeletedmessages).\n * @param listener A callback function.\n * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.\n * @header listen\n */\nexport function addNotificationsDroppedListener(listener: () => void): Subscription {\n  return emitter.addListener<void>(didDropNotificationsEventName, listener);\n}\n\n/**\n * Listeners registered by this method will be called whenever a user interacts with a notification (for example, taps on it).\n * @param listener A function accepting notification response ([`NotificationResponse`](#notificationresponse)) as an argument.\n * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.\n * @example Register a notification responder listener:\n * ```jsx\n * import React from 'react';\n * import { Linking } from 'react-native';\n * import * as Notifications from 'expo-notifications';\n *\n * export default function Container() {\n *   React.useEffect(() => {\n *     const subscription = Notifications.addNotificationResponseReceivedListener(response => {\n *       const url = response.notification.request.content.data.url;\n *       Linking.openURL(url);\n *     });\n *     return () => subscription.remove();\n *   }, []);\n *\n *   return (\n *     // Your app content\n *   );\n * }\n * ```\n * @header listen\n */\nexport function addNotificationResponseReceivedListener(\n  listener: (event: NotificationResponse) => void\n): Subscription {\n  return emitter.addListener<NotificationResponse>(\n    didReceiveNotificationResponseEventName,\n    (response: NotificationResponse) => {\n      const mappedResponse = mapNotificationResponse(response);\n      listener(mappedResponse);\n    }\n  );\n}\n\n/**\n * Removes a notification subscription returned by an `addNotificationListener` call.\n * @param subscription A subscription returned by `addNotificationListener` method.\n * @header listen\n */\nexport function removeNotificationSubscription(subscription: Subscription) {\n  emitter.removeSubscription(subscription);\n}\n\n// @docsMissing\n/**\n * @header listen\n */\nexport async function getLastNotificationResponseAsync(): Promise<NotificationResponse | null> {\n  if (!NotificationsEmitterModule.getLastNotificationResponseAsync) {\n    throw new UnavailabilityError('ExpoNotifications', 'getLastNotificationResponseAsync');\n  }\n  const response = await NotificationsEmitterModule.getLastNotificationResponseAsync();\n  const mappedResponse = response ? mapNotificationResponse(response) : response;\n  return mappedResponse;\n}\n"]}
+{"version":3,"file":"NotificationsEmitter.js","sourceRoot":"","sources":["../src/NotificationsEmitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAgB,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGpF,OAAO,0BAA0B,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE3F,iCAAiC;AACjC,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,0BAA0B,CAAC,CAAC;AAE7D,MAAM,+BAA+B,GAAG,0BAA0B,CAAC;AACnE,MAAM,6BAA6B,GAAG,wBAAwB,CAAC;AAC/D,MAAM,uCAAuC,GAAG,kCAAkC,CAAC;AAEnF,eAAe;AACf,MAAM,CAAC,MAAM,yBAAyB,GAAG,4CAA4C,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,+BAA+B,CAC7C,QAAuC;IAEvC,OAAO,OAAO,CAAC,WAAW,CACxB,+BAA+B,EAC/B,CAAC,YAA0B,EAAE,EAAE;QAC7B,MAAM,kBAAkB,GAAG,eAAe,CAAC,YAAY,CAAC,CAAC;QACzD,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IAC/B,CAAC,CACF,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,+BAA+B,CAAC,QAAoB;IAClE,OAAO,OAAO,CAAC,WAAW,CAAO,6BAA6B,EAAE,QAAQ,CAAC,CAAC;AAC5E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,uCAAuC,CACrD,QAA+C;IAE/C,OAAO,OAAO,CAAC,WAAW,CACxB,uCAAuC,EACvC,CAAC,QAA8B,EAAE,EAAE;QACjC,MAAM,cAAc,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QACzD,QAAQ,CAAC,cAAc,CAAC,CAAC;IAC3B,CAAC,CACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,8BAA8B,CAAC,YAA0B;IACvE,OAAO,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;AAC3C,CAAC;AAED,eAAe;AACf;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,gCAAgC;IACpD,IAAI,CAAC,0BAA0B,CAAC,gCAAgC,EAAE;QAChE,MAAM,IAAI,mBAAmB,CAAC,mBAAmB,EAAE,kCAAkC,CAAC,CAAC;KACxF;IACD,MAAM,QAAQ,GAAG,MAAM,0BAA0B,CAAC,gCAAgC,EAAE,CAAC;IACrF,MAAM,cAAc,GAAG,QAAQ,CAAC,CAAC,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAC/E,OAAO,cAAc,CAAC;AACxB,CAAC","sourcesContent":["import { EventEmitter, Subscription, UnavailabilityError } from 'expo-modules-core';\n\nimport { Notification, NotificationResponse } from './Notifications.types';\nimport NotificationsEmitterModule from './NotificationsEmitterModule';\nimport { mapNotification, mapNotificationResponse } from './utils/mapNotificationResponse';\n\n// Web uses SyntheticEventEmitter\nconst emitter = new EventEmitter(NotificationsEmitterModule);\n\nconst didReceiveNotificationEventName = 'onDidReceiveNotification';\nconst didDropNotificationsEventName = 'onNotificationsDeleted';\nconst didReceiveNotificationResponseEventName = 'onDidReceiveNotificationResponse';\n\n// @docsMissing\nexport const DEFAULT_ACTION_IDENTIFIER = 'expo.modules.notifications.actions.DEFAULT';\n\n/**\n * Listeners registered by this method will be called whenever a notification is received while the app is running.\n * @param listener A function accepting a notification ([`Notification`](#notification)) as an argument.\n * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.\n * @example Registering a notification listener using a React hook:\n * ```jsx\n * import React from 'react';\n * import * as Notifications from 'expo-notifications';\n *\n * export default function App() {\n *   React.useEffect(() => {\n *     const subscription = Notifications.addNotificationReceivedListener(notification => {\n *       console.log(notification);\n *     });\n *     return () => subscription.remove();\n *   }, []);\n *\n *   return (\n *     // Your app content\n *   );\n * }\n * ```\n * @header listen\n */\nexport function addNotificationReceivedListener(\n  listener: (event: Notification) => void\n): Subscription {\n  return emitter.addListener<Notification>(\n    didReceiveNotificationEventName,\n    (notification: Notification) => {\n      const mappedNotification = mapNotification(notification);\n      listener(mappedNotification);\n    }\n  );\n}\n\n/**\n * Listeners registered by this method will be called whenever some notifications have been dropped by the server.\n * Applicable only to Firebase Cloud Messaging which we use as a notifications service on Android. It corresponds to `onDeletedMessages()` callback.\n * More information can be found in [Firebase docs](https://firebase.google.com/docs/cloud-messaging/android/receive#override-ondeletedmessages).\n * @param listener A callback function.\n * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.\n * @header listen\n */\nexport function addNotificationsDroppedListener(listener: () => void): Subscription {\n  return emitter.addListener<void>(didDropNotificationsEventName, listener);\n}\n\n/**\n * Listeners registered by this method will be called whenever a user interacts with a notification (for example, taps on it).\n * @param listener A function accepting notification response ([`NotificationResponse`](#notificationresponse)) as an argument.\n * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.\n * @example Register a notification responder listener:\n * ```jsx\n * import React from 'react';\n * import { Linking } from 'react-native';\n * import * as Notifications from 'expo-notifications';\n *\n * export default function Container() {\n *   React.useEffect(() => {\n *     const subscription = Notifications.addNotificationResponseReceivedListener(response => {\n *       const url = response.notification.request.content.data.url;\n *       Linking.openURL(url);\n *     });\n *     return () => subscription.remove();\n *   }, []);\n *\n *   return (\n *     // Your app content\n *   );\n * }\n * ```\n * @header listen\n */\nexport function addNotificationResponseReceivedListener(\n  listener: (event: NotificationResponse) => void\n): Subscription {\n  return emitter.addListener<NotificationResponse>(\n    didReceiveNotificationResponseEventName,\n    (response: NotificationResponse) => {\n      const mappedResponse = mapNotificationResponse(response);\n      listener(mappedResponse);\n    }\n  );\n}\n\n/**\n * Removes a notification subscription returned by an `addNotificationListener` call.\n * @param subscription A subscription returned by `addNotificationListener` method.\n * @header listen\n */\nexport function removeNotificationSubscription(subscription: Subscription) {\n  emitter.removeSubscription(subscription);\n}\n\n// @docsMissing\n/**\n * @header listen\n */\nexport async function getLastNotificationResponseAsync(): Promise<NotificationResponse | null> {\n  if (!NotificationsEmitterModule.getLastNotificationResponseAsync) {\n    throw new UnavailabilityError('ExpoNotifications', 'getLastNotificationResponseAsync');\n  }\n  const response = await NotificationsEmitterModule.getLastNotificationResponseAsync();\n  const mappedResponse = response ? mapNotificationResponse(response) : response;\n  return mappedResponse;\n}\n"]}

package/build/useLastNotificationResponse.d.ts

@@ -1,4 +1,5 @@
 import { NotificationResponse } from './Notifications.types';
+type MaybeNotificationResponse = NotificationResponse | null | undefined;
 /**
  * A React hook always returns the notification response that was received most recently
  * (a notification response designates an interaction with a notification, such as tapping on it).
@@ -35,5 +36,6 @@ import { NotificationResponse } from './Notifications.types';
  * ```
  * @header listen
  */
-export default function useLastNotificationResponse(): NotificationResponse | null | undefined;
+export default function useLastNotificationResponse(): MaybeNotificationResponse;
+export {};
 //# sourceMappingURL=useLastNotificationResponse.d.ts.map

package/build/useLastNotificationResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLastNotificationResponse.d.ts","sourceRoot":"","sources":["../src/useLastNotificationResponse.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAK7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,UAAU,2BAA2B,4CA0BlD"}
+{"version":3,"file":"useLastNotificationResponse.d.ts","sourceRoot":"","sources":["../src/useLastNotificationResponse.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAM7D,KAAK,yBAAyB,GAAG,oBAAoB,GAAG,IAAI,GAAG,SAAS,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,UAAU,2BAA2B,8BA0ClD"}

package/build/useLastNotificationResponse.js

@@ -1,7 +1,5 @@
-import { useEffect, useLayoutEffect, useState } from 'react';
-import { addNotificationResponseReceivedListener } from './NotificationsEmitter';
-import NotificationsEmitterModule from './NotificationsEmitterModule';
-import { mapNotificationResponse } from './utils/mapNotificationResponse';
+import { useLayoutEffect, useState } from 'react';
+import { addNotificationResponseReceivedListener, getLastNotificationResponseAsync, } from './NotificationsEmitter';
 /**
  * A React hook always returns the notification response that was received most recently
  * (a notification response designates an interaction with a notification, such as tapping on it).
@@ -40,24 +38,33 @@ import { mapNotificationResponse } from './utils/mapNotificationResponse';
  */
 export default function useLastNotificationResponse() {
     const [lastNotificationResponse, setLastNotificationResponse] = useState(undefined);
+    // Pure function that returns the new response if it is different from the previous,
+    // otherwise return the previous response
+    const newResponseIfNeeded = (prevResponse, newResponse) => {
+        // If the new response is undefined or null, no need for update
+        if (!newResponse) {
+            return prevResponse;
+        }
+        // If the previous response is undefined or null and the new response is not, we should update
+        if (!prevResponse) {
+            return newResponse;
+        }
+        return prevResponse.notification.request.identifier !==
+            newResponse.notification.request.identifier
+            ? newResponse
+            : prevResponse;
+    };
     // useLayoutEffect ensures the listener is registered as soon as possible
     useLayoutEffect(() => {
-        const subscription = addNotificationResponseReceivedListener((response) => {
-            const mappedResponse = mapNotificationResponse(response);
-            setLastNotificationResponse(mappedResponse);
-        });
+        // Get the last response first, in case it was set earlier (even in native code on startup)
+        // before this renders
+        getLastNotificationResponseAsync?.().then((response) => setLastNotificationResponse((prevResponse) => newResponseIfNeeded(prevResponse, response)));
+        // Set up listener for responses that come in, and set the last response if needed
+        const subscription = addNotificationResponseReceivedListener((response) => setLastNotificationResponse((prevResponse) => newResponseIfNeeded(prevResponse, response)));
         return () => {
             subscription.remove();
         };
     }, []);
-    // On each mount of this hook we fetch last notification response
-    // from the native module which is an "always active listener"
-    // and always returns the most recent response.
-    useEffect(() => {
-        NotificationsEmitterModule.getLastNotificationResponseAsync?.().then((response) => {
-            setLastNotificationResponse(response);
-        });
-    }, []);
     return lastNotificationResponse;
 }
 //# sourceMappingURL=useLastNotificationResponse.js.map

package/build/useLastNotificationResponse.js.map

@@ -1 +1 @@
-{"version":3,"file":"useLastNotificationResponse.js","sourceRoot":"","sources":["../src/useLastNotificationResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAG7D,OAAO,EAAE,uCAAuC,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,0BAA0B,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,UAAU,2BAA2B;IACjD,MAAM,CAAC,wBAAwB,EAAE,2BAA2B,CAAC,GAAG,QAAQ,CAEtE,SAAS,CAAC,CAAC;IAEb,yEAAyE;IACzE,eAAe,CAAC,GAAG,EAAE;QACnB,MAAM,YAAY,GAAG,uCAAuC,CAAC,CAAC,QAAQ,EAAE,EAAE;YACxE,MAAM,cAAc,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;YACzD,2BAA2B,CAAC,cAAc,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,EAAE;YACV,YAAY,CAAC,MAAM,EAAE,CAAC;QACxB,CAAC,CAAC;IACJ,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,iEAAiE;IACjE,8DAA8D;IAC9D,+CAA+C;IAC/C,SAAS,CAAC,GAAG,EAAE;QACb,0BAA0B,CAAC,gCAAgC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;YAChF,2BAA2B,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;IACL,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO,wBAAwB,CAAC;AAClC,CAAC","sourcesContent":["import { useEffect, useLayoutEffect, useState } from 'react';\n\nimport { NotificationResponse } from './Notifications.types';\nimport { addNotificationResponseReceivedListener } from './NotificationsEmitter';\nimport NotificationsEmitterModule from './NotificationsEmitterModule';\nimport { mapNotificationResponse } from './utils/mapNotificationResponse';\n\n/**\n * A React hook always returns the notification response that was received most recently\n * (a notification response designates an interaction with a notification, such as tapping on it).\n *\n * > If you don't want to use a hook, you can use `Notifications.getLastNotificationResponseAsync()` instead.\n *\n * @return The hook may return one of these three types/values:\n * - `undefined` - until we're sure of what to return,\n * - `null` - if no notification response has been received yet,\n * - a [`NotificationResponse`](#notificationresponse) object - if a notification response was received.\n *\n * @example\n * Responding to a notification tap by opening a URL that could be put into the notification's `data`\n * (opening the URL is your responsibility and is not a part of the `expo-notifications` API):\n * ```jsx\n * import * as Notifications from 'expo-notifications';\n * import { Linking } from 'react-native';\n *\n * export default function App() {\n *   const lastNotificationResponse = Notifications.useLastNotificationResponse();\n *   React.useEffect(() => {\n *     if (\n *       lastNotificationResponse &&\n *       lastNotificationResponse.notification.request.content.data.url &&\n *       lastNotificationResponse.actionIdentifier === Notifications.DEFAULT_ACTION_IDENTIFIER\n *     ) {\n *       Linking.openURL(lastNotificationResponse.notification.request.content.data.url);\n *     }\n *   }, [lastNotificationResponse]);\n *   return (\n *     // Your app content\n *   );\n * }\n * ```\n * @header listen\n */\nexport default function useLastNotificationResponse() {\n  const [lastNotificationResponse, setLastNotificationResponse] = useState<\n    NotificationResponse | null | undefined\n  >(undefined);\n\n  // useLayoutEffect ensures the listener is registered as soon as possible\n  useLayoutEffect(() => {\n    const subscription = addNotificationResponseReceivedListener((response) => {\n      const mappedResponse = mapNotificationResponse(response);\n      setLastNotificationResponse(mappedResponse);\n    });\n    return () => {\n      subscription.remove();\n    };\n  }, []);\n\n  // On each mount of this hook we fetch last notification response\n  // from the native module which is an \"always active listener\"\n  // and always returns the most recent response.\n  useEffect(() => {\n    NotificationsEmitterModule.getLastNotificationResponseAsync?.().then((response) => {\n      setLastNotificationResponse(response);\n    });\n  }, []);\n\n  return lastNotificationResponse;\n}\n"]}
+{"version":3,"file":"useLastNotificationResponse.js","sourceRoot":"","sources":["../src/useLastNotificationResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGlD,OAAO,EACL,uCAAuC,EACvC,gCAAgC,GACjC,MAAM,wBAAwB,CAAC;AAIhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,UAAU,2BAA2B;IACjD,MAAM,CAAC,wBAAwB,EAAE,2BAA2B,CAAC,GAC3D,QAAQ,CAA4B,SAAS,CAAC,CAAC;IAEjD,oFAAoF;IACpF,yCAAyC;IACzC,MAAM,mBAAmB,GAAG,CAC1B,YAAuC,EACvC,WAAsC,EACtC,EAAE;QACF,+DAA+D;QAC/D,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO,YAAY,CAAC;SACrB;QACD,8FAA8F;QAC9F,IAAI,CAAC,YAAY,EAAE;YACjB,OAAO,WAAW,CAAC;SACpB;QACD,OAAO,YAAY,CAAC,YAAY,CAAC,OAAO,CAAC,UAAU;YACjD,WAAW,CAAC,YAAY,CAAC,OAAO,CAAC,UAAU;YAC3C,CAAC,CAAC,WAAW;YACb,CAAC,CAAC,YAAY,CAAC;IACnB,CAAC,CAAC;IAEF,yEAAyE;IACzE,eAAe,CAAC,GAAG,EAAE;QACnB,2FAA2F;QAC3F,sBAAsB;QACtB,gCAAgC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CACrD,2BAA2B,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,mBAAmB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAC3F,CAAC;QAEF,kFAAkF;QAClF,MAAM,YAAY,GAAG,uCAAuC,CAAC,CAAC,QAAQ,EAAE,EAAE,CACxE,2BAA2B,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,mBAAmB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAC3F,CAAC;QACF,OAAO,GAAG,EAAE;YACV,YAAY,CAAC,MAAM,EAAE,CAAC;QACxB,CAAC,CAAC;IACJ,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO,wBAAwB,CAAC;AAClC,CAAC","sourcesContent":["import { useLayoutEffect, useState } from 'react';\n\nimport { NotificationResponse } from './Notifications.types';\nimport {\n  addNotificationResponseReceivedListener,\n  getLastNotificationResponseAsync,\n} from './NotificationsEmitter';\n\ntype MaybeNotificationResponse = NotificationResponse | null | undefined;\n\n/**\n * A React hook always returns the notification response that was received most recently\n * (a notification response designates an interaction with a notification, such as tapping on it).\n *\n * > If you don't want to use a hook, you can use `Notifications.getLastNotificationResponseAsync()` instead.\n *\n * @return The hook may return one of these three types/values:\n * - `undefined` - until we're sure of what to return,\n * - `null` - if no notification response has been received yet,\n * - a [`NotificationResponse`](#notificationresponse) object - if a notification response was received.\n *\n * @example\n * Responding to a notification tap by opening a URL that could be put into the notification's `data`\n * (opening the URL is your responsibility and is not a part of the `expo-notifications` API):\n * ```jsx\n * import * as Notifications from 'expo-notifications';\n * import { Linking } from 'react-native';\n *\n * export default function App() {\n *   const lastNotificationResponse = Notifications.useLastNotificationResponse();\n *   React.useEffect(() => {\n *     if (\n *       lastNotificationResponse &&\n *       lastNotificationResponse.notification.request.content.data.url &&\n *       lastNotificationResponse.actionIdentifier === Notifications.DEFAULT_ACTION_IDENTIFIER\n *     ) {\n *       Linking.openURL(lastNotificationResponse.notification.request.content.data.url);\n *     }\n *   }, [lastNotificationResponse]);\n *   return (\n *     // Your app content\n *   );\n * }\n * ```\n * @header listen\n */\nexport default function useLastNotificationResponse() {\n  const [lastNotificationResponse, setLastNotificationResponse] =\n    useState<MaybeNotificationResponse>(undefined);\n\n  // Pure function that returns the new response if it is different from the previous,\n  // otherwise return the previous response\n  const newResponseIfNeeded = (\n    prevResponse: MaybeNotificationResponse,\n    newResponse: MaybeNotificationResponse\n  ) => {\n    // If the new response is undefined or null, no need for update\n    if (!newResponse) {\n      return prevResponse;\n    }\n    // If the previous response is undefined or null and the new response is not, we should update\n    if (!prevResponse) {\n      return newResponse;\n    }\n    return prevResponse.notification.request.identifier !==\n      newResponse.notification.request.identifier\n      ? newResponse\n      : prevResponse;\n  };\n\n  // useLayoutEffect ensures the listener is registered as soon as possible\n  useLayoutEffect(() => {\n    // Get the last response first, in case it was set earlier (even in native code on startup)\n    // before this renders\n    getLastNotificationResponseAsync?.().then((response) =>\n      setLastNotificationResponse((prevResponse) => newResponseIfNeeded(prevResponse, response))\n    );\n\n    // Set up listener for responses that come in, and set the last response if needed\n    const subscription = addNotificationResponseReceivedListener((response) =>\n      setLastNotificationResponse((prevResponse) => newResponseIfNeeded(prevResponse, response))\n    );\n    return () => {\n      subscription.remove();\n    };\n  }, []);\n\n  return lastNotificationResponse;\n}\n"]}

package/build/utils/mapNotificationResponse.d.ts

@@ -1,4 +1,4 @@
-import { NotificationResponse } from '../Notifications.types';
+import { Notification, NotificationResponse } from '../Notifications.types';
 /**
  * @hidden
  *
@@ -9,13 +9,31 @@ import { NotificationResponse } from '../Notifications.types';
  * @param response The raw response passed in from native code
  * @returns the mapped response.
  */
-export declare const mapNotificationResponse: (response: NotificationResponse) => NotificationResponse & {
-    notification: {
+export declare const mapNotificationResponse: (response: NotificationResponse) => {
+    notification: Notification & {
         request: {
             content: {
                 dataString?: string;
             };
         };
     };
+    actionIdentifier: string;
+    userText?: string | undefined;
+};
+/**
+ * @hidden
+ *
+ * Does any required processing of a notification from native code
+ * before it is passed to a notification listener.
+ *
+ * @param notification The raw notification passed in from native code
+ * @returns the mapped notification.
+ */
+export declare const mapNotification: (notification: Notification) => Notification & {
+    request: {
+        content: {
+            dataString?: string;
+        };
+    };
 };
 //# sourceMappingURL=mapNotificationResponse.d.ts.map

package/build/utils/mapNotificationResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapNotificationResponse.d.ts","sourceRoot":"","sources":["../../src/utils/mapNotificationResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,aAAc,oBAAoB;kBAEpD;QAAE,OAAO,EAAE;YAAE,OAAO,EAAE;gBAAE,UAAU,CAAC,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,CAAA;KAAE;CAYlE,CAAC"}
+{"version":3,"file":"mapNotificationResponse.d.ts","sourceRoot":"","sources":["../../src/utils/mapNotificationResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE5E;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,aAAc,oBAAoB;;iBAkBzD;YAAE,OAAO,EAAE;gBAAE,UAAU,CAAC,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE;;;;CAbhD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,iBAAkB,YAAY;aAE7C;QAAE,OAAO,EAAE;YAAE,UAAU,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;CAYhD,CAAC"}

package/build/utils/mapNotificationResponse.js

@@ -9,17 +9,32 @@
  * @returns the mapped response.
  */
 export const mapNotificationResponse = (response) => {
-    const mappedResponse = { ...response };
+    return {
+        ...response,
+        notification: mapNotification(response.notification),
+    };
+};
+/**
+ * @hidden
+ *
+ * Does any required processing of a notification from native code
+ * before it is passed to a notification listener.
+ *
+ * @param notification The raw notification passed in from native code
+ * @returns the mapped notification.
+ */
+export const mapNotification = (notification) => {
+    const mappedNotification = { ...notification };
     try {
-        const dataString = mappedResponse?.notification?.request?.content['dataString'];
+        const dataString = mappedNotification?.request?.content['dataString'];
         if (typeof dataString === 'string') {
-            mappedResponse.notification.request.content.data = JSON.parse(dataString);
-            delete mappedResponse.notification.request.content.dataString;
+            mappedNotification.request.content.data = JSON.parse(dataString);
+            delete mappedNotification.request.content.dataString;
         }
     }
     catch (e) {
-        console.log(`Error in response: ${e}`);
+        console.log(`Error in notification: ${e}`);
     }
-    return mappedResponse;
+    return mappedNotification;
 };
 //# sourceMappingURL=mapNotificationResponse.js.map

package/build/utils/mapNotificationResponse.js.map

@@ -1 +1 @@
-{"version":3,"file":"mapNotificationResponse.js","sourceRoot":"","sources":["../../src/utils/mapNotificationResponse.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,QAA8B,EAAE,EAAE;IACxE,MAAM,cAAc,GAEhB,EAAE,GAAG,QAAQ,EAAE,CAAC;IACpB,IAAI;QACF,MAAM,UAAU,GAAG,cAAc,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;QAChF,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;YAClC,cAAc,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YAC1E,OAAO,cAAc,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;SAC/D;KACF;IAAC,OAAO,CAAM,EAAE;QACf,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,EAAE,CAAC,CAAC;KACxC;IACD,OAAO,cAAc,CAAC;AACxB,CAAC,CAAC","sourcesContent":["import { NotificationResponse } from '../Notifications.types';\n\n/**\n * @hidden\n *\n * Does any required processing of a notification response from native code\n * before it is passed to a notification response listener, or to the\n * last notification response hook.\n *\n * @param response The raw response passed in from native code\n * @returns the mapped response.\n */\nexport const mapNotificationResponse = (response: NotificationResponse) => {\n  const mappedResponse: NotificationResponse & {\n    notification: { request: { content: { dataString?: string } } };\n  } = { ...response };\n  try {\n    const dataString = mappedResponse?.notification?.request?.content['dataString'];\n    if (typeof dataString === 'string') {\n      mappedResponse.notification.request.content.data = JSON.parse(dataString);\n      delete mappedResponse.notification.request.content.dataString;\n    }\n  } catch (e: any) {\n    console.log(`Error in response: ${e}`);\n  }\n  return mappedResponse;\n};\n"]}
+{"version":3,"file":"mapNotificationResponse.js","sourceRoot":"","sources":["../../src/utils/mapNotificationResponse.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,QAA8B,EAAE,EAAE;IACxE,OAAO;QACL,GAAG,QAAQ;QACX,YAAY,EAAE,eAAe,CAAC,QAAQ,CAAC,YAAY,CAAC;KACrD,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,YAA0B,EAAE,EAAE;IAC5D,MAAM,kBAAkB,GAEpB,EAAE,GAAG,YAAY,EAAE,CAAC;IACxB,IAAI;QACF,MAAM,UAAU,GAAG,kBAAkB,EAAE,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;QACtE,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;YAClC,kBAAkB,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YACjE,OAAO,kBAAkB,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;SACtD;KACF;IAAC,OAAO,CAAM,EAAE;QACf,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAC;KAC5C;IACD,OAAO,kBAAkB,CAAC;AAC5B,CAAC,CAAC","sourcesContent":["import { Notification, NotificationResponse } from '../Notifications.types';\n\n/**\n * @hidden\n *\n * Does any required processing of a notification response from native code\n * before it is passed to a notification response listener, or to the\n * last notification response hook.\n *\n * @param response The raw response passed in from native code\n * @returns the mapped response.\n */\nexport const mapNotificationResponse = (response: NotificationResponse) => {\n  return {\n    ...response,\n    notification: mapNotification(response.notification),\n  };\n};\n\n/**\n * @hidden\n *\n * Does any required processing of a notification from native code\n * before it is passed to a notification listener.\n *\n * @param notification The raw notification passed in from native code\n * @returns the mapped notification.\n */\nexport const mapNotification = (notification: Notification) => {\n  const mappedNotification: Notification & {\n    request: { content: { dataString?: string } };\n  } = { ...notification };\n  try {\n    const dataString = mappedNotification?.request?.content['dataString'];\n    if (typeof dataString === 'string') {\n      mappedNotification.request.content.data = JSON.parse(dataString);\n      delete mappedNotification.request.content.dataString;\n    }\n  } catch (e: any) {\n    console.log(`Error in notification: ${e}`);\n  }\n  return mappedNotification;\n};\n"]}

package/ios/EXNotifications/Notifications/EXNotificationCenterDelegate.h

@@ -12,6 +12,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)addDelegate:(id<EXNotificationsDelegate>)delegate;
 - (void)removeDelegate:(id<EXNotificationsDelegate>)delegate;
+- (nullable UNNotificationResponse *)lastNotificationResponse;
+- (void)setLastNotificationResponse:(nullable UNNotificationResponse *)response;
 
 @end
 
@@ -24,6 +26,8 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler;
 - (void)userNotificationCenter:(UNUserNotificationCenter *)center openSettingsForNotification:(nullable UNNotification *)notification;
 
+@property (nonatomic, strong, nullable) UNNotificationResponse *lastNotificationResponse;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/EXNotifications/Notifications/EXNotificationCenterDelegate.m

@@ -123,6 +123,8 @@ EX_REGISTER_SINGLETON_MODULE(NotificationCenterDelegate);
 
 - (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler
 {
+  // Save last response here for use by EXNotificationsEmitter
+  self.lastNotificationResponse = response;
   // Save response to pending responses array if none of the handlers will handle it.
   BOOL responseWillBeHandledByAppropriateDelegate = NO;
   for (int i = 0; i < _delegates.count; i++) {

package/ios/EXNotifications/Notifications/Emitter/EXNotificationsEmitter.m

@@ -15,8 +15,6 @@
 
 @property (nonatomic, weak) id<EXEventEmitterService> eventEmitter;
 
-@property (nonatomic, strong) UNNotificationResponse *lastNotificationResponse;
-
 @end
 
 @implementation EXNotificationsEmitter
@@ -26,7 +24,8 @@ EX_EXPORT_MODULE(ExpoNotificationsEmitter);
 EX_EXPORT_METHOD_AS(getLastNotificationResponseAsync,
                     getLastNotificationResponseAsyncWithResolver:(EXPromiseResolveBlock)resolve reject:(EXPromiseRejectBlock)reject)
 {
-  resolve(_lastNotificationResponse ? [self serializedNotificationResponse:_lastNotificationResponse] : [NSNull null]);
+  UNNotificationResponse* lastResponse = _notificationCenterDelegate.lastNotificationResponse;
+  resolve(lastResponse ? [self serializedNotificationResponse:lastResponse] : [NSNull null]);
 }
 
 # pragma mark - EXModuleRegistryConsumer
@@ -77,7 +76,7 @@ EX_EXPORT_METHOD_AS(getLastNotificationResponseAsync,
 
 - (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler
 {
-  _lastNotificationResponse = response;
+  _notificationCenterDelegate.lastNotificationResponse = response;
   [self sendEventWithName:onDidReceiveNotificationResponse body:[self serializedNotificationResponse:response]];
   completionHandler();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-notifications",
-  "version": "0.28.12",
+  "version": "0.28.14",
   "description": "Notifications module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -55,5 +55,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "e4d9b651e6693856e4ffe674490f6463e34f3ecc"
+  "gitHead": "10eaf729822bf46ab821a000eb961cf8df40b35b"
 }

package/src/NotificationsEmitter.ts

@@ -2,7 +2,7 @@ import { EventEmitter, Subscription, UnavailabilityError } from 'expo-modules-co
 
 import { Notification, NotificationResponse } from './Notifications.types';
 import NotificationsEmitterModule from './NotificationsEmitterModule';
-import { mapNotificationResponse } from './utils/mapNotificationResponse';
+import { mapNotification, mapNotificationResponse } from './utils/mapNotificationResponse';
 
 // Web uses SyntheticEventEmitter
 const emitter = new EventEmitter(NotificationsEmitterModule);
@@ -41,7 +41,13 @@ export const DEFAULT_ACTION_IDENTIFIER = 'expo.modules.notifications.actions.DEF
 export function addNotificationReceivedListener(
   listener: (event: Notification) => void
 ): Subscription {
-  return emitter.addListener<Notification>(didReceiveNotificationEventName, listener);
+  return emitter.addListener<Notification>(
+    didReceiveNotificationEventName,
+    (notification: Notification) => {
+      const mappedNotification = mapNotification(notification);
+      listener(mappedNotification);
+    }
+  );
 }
 
 /**

package/src/useLastNotificationResponse.ts

@@ -1,9 +1,12 @@
-import { useEffect, useLayoutEffect, useState } from 'react';
+import { useLayoutEffect, useState } from 'react';
 
 import { NotificationResponse } from './Notifications.types';
-import { addNotificationResponseReceivedListener } from './NotificationsEmitter';
-import NotificationsEmitterModule from './NotificationsEmitterModule';
-import { mapNotificationResponse } from './utils/mapNotificationResponse';
+import {
+  addNotificationResponseReceivedListener,
+  getLastNotificationResponseAsync,
+} from './NotificationsEmitter';
+
+type MaybeNotificationResponse = NotificationResponse | null | undefined;
 
 /**
  * A React hook always returns the notification response that was received most recently
@@ -42,29 +45,45 @@ import { mapNotificationResponse } from './utils/mapNotificationResponse';
  * @header listen
  */
 export default function useLastNotificationResponse() {
-  const [lastNotificationResponse, setLastNotificationResponse] = useState<
-    NotificationResponse | null | undefined
-  >(undefined);
+  const [lastNotificationResponse, setLastNotificationResponse] =
+    useState<MaybeNotificationResponse>(undefined);
+
+  // Pure function that returns the new response if it is different from the previous,
+  // otherwise return the previous response
+  const newResponseIfNeeded = (
+    prevResponse: MaybeNotificationResponse,
+    newResponse: MaybeNotificationResponse
+  ) => {
+    // If the new response is undefined or null, no need for update
+    if (!newResponse) {
+      return prevResponse;
+    }
+    // If the previous response is undefined or null and the new response is not, we should update
+    if (!prevResponse) {
+      return newResponse;
+    }
+    return prevResponse.notification.request.identifier !==
+      newResponse.notification.request.identifier
+      ? newResponse
+      : prevResponse;
+  };
 
   // useLayoutEffect ensures the listener is registered as soon as possible
   useLayoutEffect(() => {
-    const subscription = addNotificationResponseReceivedListener((response) => {
-      const mappedResponse = mapNotificationResponse(response);
-      setLastNotificationResponse(mappedResponse);
-    });
+    // Get the last response first, in case it was set earlier (even in native code on startup)
+    // before this renders
+    getLastNotificationResponseAsync?.().then((response) =>
+      setLastNotificationResponse((prevResponse) => newResponseIfNeeded(prevResponse, response))
+    );
+
+    // Set up listener for responses that come in, and set the last response if needed
+    const subscription = addNotificationResponseReceivedListener((response) =>
+      setLastNotificationResponse((prevResponse) => newResponseIfNeeded(prevResponse, response))
+    );
     return () => {
       subscription.remove();
     };
   }, []);
 
-  // On each mount of this hook we fetch last notification response
-  // from the native module which is an "always active listener"
-  // and always returns the most recent response.
-  useEffect(() => {
-    NotificationsEmitterModule.getLastNotificationResponseAsync?.().then((response) => {
-      setLastNotificationResponse(response);
-    });
-  }, []);
-
   return lastNotificationResponse;
 }

package/src/utils/mapNotificationResponse.ts

@@ -1,4 +1,4 @@
-import { NotificationResponse } from '../Notifications.types';
+import { Notification, NotificationResponse } from '../Notifications.types';
 
 /**
  * @hidden
@@ -11,17 +11,33 @@ import { NotificationResponse } from '../Notifications.types';
  * @returns the mapped response.
  */
 export const mapNotificationResponse = (response: NotificationResponse) => {
-  const mappedResponse: NotificationResponse & {
-    notification: { request: { content: { dataString?: string } } };
-  } = { ...response };
+  return {
+    ...response,
+    notification: mapNotification(response.notification),
+  };
+};
+
+/**
+ * @hidden
+ *
+ * Does any required processing of a notification from native code
+ * before it is passed to a notification listener.
+ *
+ * @param notification The raw notification passed in from native code
+ * @returns the mapped notification.
+ */
+export const mapNotification = (notification: Notification) => {
+  const mappedNotification: Notification & {
+    request: { content: { dataString?: string } };
+  } = { ...notification };
   try {
-    const dataString = mappedResponse?.notification?.request?.content['dataString'];
+    const dataString = mappedNotification?.request?.content['dataString'];
     if (typeof dataString === 'string') {
-      mappedResponse.notification.request.content.data = JSON.parse(dataString);
-      delete mappedResponse.notification.request.content.dataString;
+      mappedNotification.request.content.data = JSON.parse(dataString);
+      delete mappedNotification.request.content.dataString;
     }
   } catch (e: any) {
-    console.log(`Error in response: ${e}`);
+    console.log(`Error in notification: ${e}`);
   }
-  return mappedResponse;
+  return mappedNotification;
 };