expo-notifications 0.28.13 → 0.28.15

package/CHANGELOG.md

@@ -10,6 +10,18 @@
 
 ### 💡 Others
 
+## 0.28.15 — 2024-08-05
+
+### 🐛 Bug fixes
+
+- [Android] Eliminate unsupported types when processing notification intents from onCreate/onNewIntent. ([#30750](https://github.com/expo/expo/pull/30750) by [@douglowder](https://github.com/douglowder))
+
+## 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

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '0.28.13'
+version = '0.28.15'
 
 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.13'
+    versionName '0.28.15'
   }
 
   buildFeatures {

package/android/src/main/java/expo/modules/notifications/Utils.kt

@@ -3,8 +3,13 @@ package expo.modules.notifications
 import android.os.Bundle
 import android.os.Handler
 import android.os.ResultReceiver
+import expo.modules.kotlin.types.JSTypeConverter
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
 
 typealias ResultReceiverBody = (resultCode: Int, resultData: Bundle?) -> Unit
+typealias BundleConversionTester = (bundle: Bundle) -> Boolean
 
 internal fun createDefaultResultReceiver(
   handler: Handler?,
@@ -17,3 +22,87 @@ internal fun createDefaultResultReceiver(
     }
   }
 }
+
+/**
+ * Given an input bundle, creates a new bundle with non-convertible objects removed
+ */
+internal fun filteredBundleForJSTypeConverter(bundle: Bundle): Bundle {
+  return filteredBundleForJSTypeConverter(bundle, isBundleConvertibleToJSValue)
+}
+
+internal fun filteredBundleForJSTypeConverter(bundle: Bundle, testBundle: BundleConversionTester): Bundle {
+  return when (testBundle(bundle)) {
+    true -> bundle
+    else -> {
+      // Store keys whose values are convertible
+      val goodKeys: MutableSet<String> = mutableSetOf()
+      // Do first pass to filter any values that are bundles
+      bundle.keySet().forEach { key: String ->
+        val value = bundle[key]
+        if (value is Bundle) {
+          bundle.putBundle(key, filteredBundleForJSTypeConverter(value, testBundle))
+          goodKeys.add(key)
+        }
+      }
+      // Second pass: create a bundle with just the value for that key, and see if it converts
+      // There is no generic put() method for bundles, so we putAll() and then remove values
+      // other than the one we are testing
+      bundle.keySet().forEach { key: String ->
+        if (!goodKeys.contains(key)) {
+          val test = Bundle()
+          test.putAll(bundle)
+          bundle.keySet().forEach { otherKey: String ->
+            if (!otherKey.equals(key)) {
+              test.remove(otherKey)
+            }
+          }
+          if (testBundle(test)) {
+            goodKeys.add(key)
+          }
+        }
+      }
+      // Now create a new bundle, remove keys that are not good, and return
+      val result = Bundle()
+      result.putAll(bundle)
+      bundle.keySet().forEach { key: String ->
+        if (!goodKeys.contains(key)) {
+          result.remove(key)
+        }
+      }
+      result
+    }
+  }
+}
+
+internal val isBundleConvertibleToJSValue: BundleConversionTester = { bundle: Bundle ->
+  try {
+    JSTypeConverter.convertToJSValue(bundle)
+    true
+  } catch (e: Throwable) {
+    false
+  }
+}
+
+/**
+ * Returns true if the argument is a valid JSON string, false otherwise
+ */
+internal fun isValidJSONString(test: Any?): Boolean {
+  when (test is String) {
+    true -> {
+      try {
+        JSONObject(test as String)
+        return true
+      } catch (objectEx: JSONException) {
+        try {
+          JSONArray(test as String)
+          return true
+        } catch (arrayEx: JSONException) {
+          return false
+        }
+      }
+    }
+    else -> {
+      return false
+    }
+  }
+}

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

@@ -1,5 +1,8 @@
 package expo.modules.notifications.notifications;
 
+import static expo.modules.notifications.UtilsKt.filteredBundleForJSTypeConverter;
+import static expo.modules.notifications.UtilsKt.isValidJSONString;
+
 import android.os.Build;
 import android.os.Bundle;
 
@@ -9,7 +12,6 @@ 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;
 
@@ -58,8 +60,7 @@ public class NotificationSerializer {
     serializedRequest.putBundle("trigger", toBundle(request.getTrigger()));
     Bundle content = toBundle(request.getContent());
     Bundle existingContentData = content.getBundle("data");
-    if (existingContentData == null) {
-      FirebaseNotificationTrigger trigger = (FirebaseNotificationTrigger) request.getTrigger();
+    if (existingContentData == null && request.getTrigger() instanceof FirebaseNotificationTrigger trigger) {
       RemoteMessage message = trigger.getRemoteMessage();
       RemoteMessage.Notification notification = message.getNotification();
       Map<String, String> data = message.getData();
@@ -226,17 +227,17 @@ public class NotificationSerializer {
     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,
+    if (isValidJSONString(body) ) {
+      // If 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"));
     } 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);
+      // so we copy the data as is from the extras bundle, after
+      // ensuring it can be converted for emitting to JS
+      serializedContent.putBundle("data", filteredBundleForJSTypeConverter(extras));
     }
 
     Bundle serializedTrigger = new Bundle();
@@ -259,17 +260,4 @@ public class NotificationSerializer {
     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/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/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.13",
+  "version": "0.28.15",
   "description": "Notifications module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -55,5 +55,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "89cb316cd1f16193ae9841d2aec2ae39e0ee00bb"
+  "gitHead": "760c0c1a3bebcedc19836db8bc98c737f0db8c8d"
 }

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;
 }