ios: Fix bug where tapping a notification didn't navigate to conversation

For no apparent reason, the library we've been using for iOS
notifications (@react-native-community/push-notification-ios) sends
remote notification response events, including the simple response
of tapping on a remote notification, with the name
'localNotification' instead of the name they document, which is
'notification':
  https://github.com/react-native-push-notification/ios/blob/v1.10.1/README.md#how-to-determine-push-notification-user-click

(For what their 'notificaton' event actually means, see a recent
commit where we removed our handler for it.)

Rather than giving in and just listening for 'localNotification',
set up our own native module to forward the event that iOS sends to
the app. This took some time, but it makes the logic more
transparent and removes some dependence on that library, which are
nice outcomes.

There was some custom `RCTConvert` and JavaScript munging to read
through in the library's codepath, but thankfully the part that
affects what we actually use is small: just a call to
`RCTJSONClean`.

Fixes: zulip#5679

Author: chrisbobbe

ios/ZulipMobile/AppDelegate.mm

@@ -11,6 +11,9 @@
 
 #import <React/RCTAppSetupUtils.h>
 
+#import "ExpoModulesCore-Swift.h"
+#import "ZulipMobile-Swift.h"
+
 #if RCT_NEW_ARCH_ENABLED
 #import <React/CoreModulesPlugins.h>
 #import <React/RCTCxxBridgeDelegate.h>
@@ -119,8 +122,9 @@ - (void)userNotificationCenter:(UNUserNotificationCenter *)center
 didReceiveNotificationResponse:(UNNotificationResponse *)response
          withCompletionHandler:(void (^)(void))completionHandler
 {
-  [RNCPushNotificationIOS didReceiveNotificationResponse:response];
-  completionHandler();
+  [ZLPNotificationsEvents userNotificationCenter:center
+                                      didReceive:response
+                           withCompletionHandler:completionHandler];
 }
 
 // Called when a notification is delivered to a foreground app.

ios/ZulipMobile/ZLPNotifications.swift

@@ -1,6 +1,47 @@
 import Foundation
 import UIKit
 import React.RCTBridgeModule
+import React.RCTConvert
+import React.RCTEventEmitter
+
+@objc(ZLPNotificationsEvents)
+class ZLPNotificationsEvents: RCTEventEmitter {
+  static var currentInstance: ZLPNotificationsEvents? = nil
+
+  override func startObserving() -> Void {
+    super.startObserving()
+    ZLPNotificationsEvents.currentInstance = self
+  }
+
+  override func stopObserving() -> Void {
+    ZLPNotificationsEvents.currentInstance = nil
+    super.stopObserving()
+  }
+
+  @objc
+  override func supportedEvents() -> [String] {
+    return ["response"]
+  }
+
+  @objc
+  class func userNotificationCenter(
+    _ center: UNUserNotificationCenter,
+    didReceive response: UNNotificationResponse,
+    withCompletionHandler completionHandler: () -> Void
+  ) {
+    currentInstance?.sendEvent(
+      withName: "response",
+
+      // The RCTJSONClean was copied over from
+      // @react-native-community/push-notification-ios; possibly we don't
+      // need it.
+      body: RCTJSONClean(
+        response.notification.request.content.userInfo
+      )
+    )
+    completionHandler()
+  }
+}
 
 @objc(ZLPNotificationsStatus)
 class ZLPNotificationsStatus: NSObject {

ios/ZulipMobile/ZLPNotificationsBridge.m

@@ -1,8 +1,12 @@
 #import "React/RCTBridgeModule.h"
+#import "React/RCTEventEmitter.h"
 
-// Register the ZLPNotificationsStatus implementation with React Native
-// needed because ZLPNotificationsStatus is in Swift:
+// Register our Swift modules with React Native:
 //   https://reactnative.dev/docs/0.68/native-modules-ios#exporting-swift
+
+@interface RCT_EXTERN_MODULE(ZLPNotificationsEvents, RCTEventEmitter)
+@end
+
 @interface RCT_EXTERN_MODULE(ZLPNotificationsStatus, NSObject)
 
     RCT_EXTERN_METHOD(areNotificationsAuthorized:

src/notification/NotificationListener.js

@@ -1,15 +1,23 @@
 /* @flow strict-local */
-import { DeviceEventEmitter, Platform } from 'react-native';
+import { DeviceEventEmitter, Platform, NativeModules, NativeEventEmitter } from 'react-native';
 import type { PushNotificationEventName } from '@react-native-community/push-notification-ios';
 import PushNotificationIOS from '@react-native-community/push-notification-ios';
+import invariant from 'invariant';
 
 import type { JSONableDict } from '../utils/jsonable';
 import type { GlobalDispatch } from '../types';
 import { androidGetToken, handleDeviceToken } from './notifTokens';
 import type { Notification } from './types';
 import * as logging from '../utils/logging';
+import { fromAPNs } from './extract';
 import { narrowToNotification } from './notifOpen';
 
+// TODO: Could go in a separate file, with some thin wrapper perhaps.
+const iosNativeEventEmitter =
+  Platform.OS === 'ios'
+    ? new NativeEventEmitter<{| +response: [JSONableDict] |}>(NativeModules.ZLPNotificationsEvents)
+    : null;
+
 /**
  * From ios/RNCPushNotificationIOS.m in @rnc/push-notification-ios at 1.2.2.
  */
@@ -42,11 +50,26 @@ export default class NotificationListener {
   }
 
   /** Private. */
-  // prettier-ignore
   listenIOS(
     args:
-      {| +name: PushNotificationEventName, +handler: (...empty) => void | Promise<void> |}
+      | {| +name: PushNotificationEventName, +handler: (...empty) => void | Promise<void> |}
+      | {| +name: 'response', +handler: JSONableDict => void |},
   ) {
+    invariant(
+      iosNativeEventEmitter != null,
+      'NotificationListener: expected `iosNativeEventEmitter` in listenIOS',
+    );
+
+    if (args.name === 'response') {
+      const { name, handler } = args;
+      const sub = iosNativeEventEmitter.addListener(name, handler);
+      this.unsubs.push(() => sub.remove());
+      return;
+    }
+
+    // TODO: Use iosNativeEventEmitter (as above) instead of
+    //   PushNotificationIOS (as below) for all iOS events
+
     // In the native code, the PushNotificationEventName we pass here
     // is mapped to something else (see implementation):
     //
@@ -96,6 +119,16 @@ export default class NotificationListener {
       this.listenAndroid('notificationOpened', this.handleNotificationOpen);
       this.listenAndroid('remoteNotificationsRegistered', this.handleDeviceToken);
     } else {
+      this.listenIOS({
+        name: 'response',
+        handler: payload => {
+          const dataFromAPNs = fromAPNs(payload);
+          if (!dataFromAPNs) {
+            return;
+          }
+          this.handleNotificationOpen(dataFromAPNs);
+        },
+      });
       this.listenIOS({ name: 'register', handler: this.handleDeviceToken });
       this.listenIOS({ name: 'registrationError', handler: this.handleIOSRegistrationFailure });
     }

src/notification/extract.js

@@ -38,11 +38,12 @@ export const fromAPNsImpl = (data: ?JSONableDict): Notification | void => {
   //
   // For the format this parses, see `ApnsPayload` in src/api/notificationTypes.js .
   //
-  // Though what it actually receives is more like this:
+  // Though in one case what it actually receives is more like this:
   //   $Rest<ApnsPayload, {| aps: mixed |}>
-  // because the `ApnsPayload` gets parsed by the `PushNotificationIOS`
-  // library, and what it gives us through `getData` is everything but the
-  // `aps` property.
+  // That case is the "initial notification", a notification that launched
+  // the app by being tapped, because the `PushNotificationIOS` library
+  // parses the `ApnsPayload` and gives us (through `getData`) everything
+  // but the `aps` property.
 
   /** Helper function: fail. */
   const err = (style: string) =>
@@ -160,7 +161,7 @@ export const fromAPNsImpl = (data: ?JSONableDict): Notification | void => {
  *
  * @returns A `Notification` on success; `undefined` on failure.
  */
-const fromAPNs = (data: ?JSONableDict): Notification | void => {
+export const fromAPNs = (data: ?JSONableDict): Notification | void => {
   try {
     return fromAPNsImpl(data);
   } catch (errorIllTyped) {