notif ios: Navigate when app running but in background

Author: rajveermalviya

ios/Runner/AppDelegate.swift

@@ -3,6 +3,8 @@ import Flutter
 
 @main
 @objc class AppDelegate: FlutterAppDelegate {
+  private var notificationTapEventListener: NotificationTapEventListener?
+
   override func application(
     _ application: UIApplication,
     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
@@ -18,8 +20,26 @@ import Flutter
     let api = NotificationHostApiImpl(notificationData.map { NotificationPayloadForOpen(payload: $0) })
     NotificationHostApiSetup.setUp(binaryMessenger: controller.binaryMessenger, api: api)
 
+    notificationTapEventListener = NotificationTapEventListener()
+    NotificationTapEventsStreamHandler.register(with: controller.binaryMessenger, streamHandler: notificationTapEventListener!)
+
+    // Setup handler for notification tap while the app is running.
+    UNUserNotificationCenter.current().delegate = self
+
     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
   }
+
+  override func userNotificationCenter(
+    _ center: UNUserNotificationCenter,
+    didReceive response: UNNotificationResponse,
+    withCompletionHandler completionHandler: @escaping () -> Void
+  ) {
+    if let listener = notificationTapEventListener {
+      let userInfo = response.notification.request.content.userInfo
+      listener.onNotificationTapEvent(data: NotificationPayloadForOpen(payload: userInfo))
+      completionHandler()
+    }
+  }
 }
 
 private class NotificationHostApiImpl: NotificationHostApi {
@@ -33,3 +53,22 @@ private class NotificationHostApiImpl: NotificationHostApi {
     maybeNotifPayload
   }
 }
+
+class NotificationTapEventListener: NotificationTapEventsStreamHandler {
+  var eventSink: PigeonEventSink<NotificationPayloadForOpen>?
+
+  override func onListen(withArguments arguments: Any?, sink: PigeonEventSink<NotificationPayloadForOpen>) {
+    eventSink = sink
+  }
+
+  func onNotificationTapEvent(data: NotificationPayloadForOpen) {
+    if let eventSink = eventSink {
+      eventSink.success(data)
+    }
+  }
+
+  func onEventsDone() {
+    eventSink?.endOfStream()
+    eventSink = nil
+  }
+}

ios/Runner/Notifications.g.swift

@@ -123,6 +123,8 @@ class NotificationsPigeonCodec: FlutterStandardMessageCodec, @unchecked Sendable
   static let shared = NotificationsPigeonCodec(readerWriter: NotificationsPigeonCodecReaderWriter())
 }
 
+var notificationsPigeonMethodCodec = FlutterStandardMethodCodec(readerWriter: NotificationsPigeonCodecReaderWriter());
+
 /// Generated protocol from Pigeon that represents a handler of messages from Flutter.
 protocol NotificationHostApi {
   /// Retrieves notification data if the app was launched by tapping on a notification.
@@ -165,3 +167,67 @@ class NotificationHostApiSetup {
     }
   }
 }
+
+private class PigeonStreamHandler<ReturnType>: NSObject, FlutterStreamHandler {
+  private let wrapper: PigeonEventChannelWrapper<ReturnType>
+  private var pigeonSink: PigeonEventSink<ReturnType>? = nil
+
+  init(wrapper: PigeonEventChannelWrapper<ReturnType>) {
+    self.wrapper = wrapper
+  }
+
+  func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink)
+    -> FlutterError?
+  {
+    pigeonSink = PigeonEventSink<ReturnType>(events)
+    wrapper.onListen(withArguments: arguments, sink: pigeonSink!)
+    return nil
+  }
+
+  func onCancel(withArguments arguments: Any?) -> FlutterError? {
+    pigeonSink = nil
+    wrapper.onCancel(withArguments: arguments)
+    return nil
+  }
+}
+
+class PigeonEventChannelWrapper<ReturnType> {
+  func onListen(withArguments arguments: Any?, sink: PigeonEventSink<ReturnType>) {}
+  func onCancel(withArguments arguments: Any?) {}
+}
+
+class PigeonEventSink<ReturnType> {
+  private let sink: FlutterEventSink
+
+  init(_ sink: @escaping FlutterEventSink) {
+    self.sink = sink
+  }
+
+  func success(_ value: ReturnType) {
+    sink(value)
+  }
+
+  func error(code: String, message: String?, details: Any?) {
+    sink(FlutterError(code: code, message: message, details: details))
+  }
+
+  func endOfStream() {
+    sink(FlutterEndOfEventStream)
+  }
+
+}
+
+class NotificationTapEventsStreamHandler: PigeonEventChannelWrapper<NotificationPayloadForOpen> {
+  static func register(with messenger: FlutterBinaryMessenger,
+                      instanceName: String = "",
+                      streamHandler: NotificationTapEventsStreamHandler) {
+    var channelName = "dev.flutter.pigeon.zulip.NotificationHostEvents.notificationTapEvents"
+    if !instanceName.isEmpty {
+      channelName += ".\(instanceName)"
+    }
+    let internalStreamHandler = PigeonStreamHandler<NotificationPayloadForOpen>(wrapper: streamHandler)
+    let channel = FlutterEventChannel(name: channelName, binaryMessenger: messenger, codec: notificationsPigeonMethodCodec)
+    channel.setStreamHandler(internalStreamHandler)
+  }
+}
+      

lib/host/notifications.g.dart

@@ -65,6 +65,8 @@ class _PigeonCodec extends StandardMessageCodec {
   }
 }
 
+const StandardMethodCodec pigeonMethodCodec = StandardMethodCodec(_PigeonCodec());
+
 class NotificationHostApi {
   /// Constructor for [NotificationHostApi].  The [binaryMessenger] named argument is
   /// available for dependency injection.  If it is left null, the default
@@ -109,3 +111,15 @@ class NotificationHostApi {
     }
   }
 }
+
+Stream<NotificationPayloadForOpen> notificationTapEvents( {String instanceName = ''}) {
+  if (instanceName.isNotEmpty) {
+    instanceName = '.$instanceName';
+  }
+  final EventChannel notificationTapEventsChannel =
+      EventChannel('dev.flutter.pigeon.zulip.NotificationHostEvents.notificationTapEvents$instanceName', pigeonMethodCodec);
+  return notificationTapEventsChannel.receiveBroadcastStream().map((dynamic event) {
+    return event as NotificationPayloadForOpen;
+  });
+}
+    

lib/model/binding.dart

@@ -314,11 +314,17 @@ class PackageInfo {
   });
 }
 
+// Pigeon generates methods under `@EventChannelApi` annotated classes
+// in global scope of the generated file. This is a helper class to
+// namespace the notification related Pigeon API under a single class.
 class NotificationPigeonApi {
   final _notifInteractionHost = notif_pigeon.NotificationHostApi();
 
   Future<notif_pigeon.NotificationPayloadForOpen?> getNotificationDataFromLaunch() =>
     _notifInteractionHost.getNotificationDataFromLaunch();
+
+  Stream<notif_pigeon.NotificationPayloadForOpen> notificationTapEventsStream() =>
+    notif_pigeon.notificationTapEvents();
 }
 
 /// A concrete binding for use in the live application.

lib/notifications/open.dart

@@ -12,6 +12,7 @@ import '../host/notifications.dart';
 import '../log.dart';
 import '../model/binding.dart';
 import '../model/narrow.dart';
+import '../widgets/app.dart';
 import '../widgets/dialog.dart';
 import '../widgets/message_list.dart';
 import '../widgets/page.dart';
@@ -40,6 +41,8 @@ class NotificationOpenManager {
       switch (defaultTargetPlatform) {
         case TargetPlatform.iOS:
           _notifLaunchData = await _notifPigeonApi.getNotificationDataFromLaunch();
+          _notifPigeonApi.notificationTapEventsStream()
+            .listen(_navigateForNotification);
 
         case TargetPlatform.android:
           // Do nothing; we do notification routing differently on Android.
@@ -95,6 +98,24 @@ class NotificationOpenManager {
       // TODO(#82): Open at specific message, not just conversation
       narrow: openData.narrow);
   }
+
+  /// Navigates to the [MessageListPage] of the specific conversation
+  /// for the provided payload that was attached while creating the
+  /// notification.
+  Future<void> _navigateForNotification(NotificationPayloadForOpen payload) async {
+    assert(debugLog('opened notif: ${jsonEncode(payload.payload)}'));
+
+    NavigatorState navigator = await ZulipApp.navigator;
+    final context = navigator.context;
+    assert(context.mounted);
+    if (!context.mounted) return; // TODO(linter): this is impossible as there's no actual async gap, but the use_build_context_synchronously lint doesn't see that
+
+    final route = _routeForNotification(context, payload);
+    if (route == null) return; // TODO(log)
+
+    // TODO(nav): Better interact with existing nav stack on notif open
+    unawaited(navigator.push(route));
+  }
 }
 
 class NotificationDataForOpen {

pigeon/notifications.dart

@@ -26,3 +26,16 @@ abstract class NotificationHostApi {
   /// See: https://developer.apple.com/documentation/uikit/uiapplication/launchoptionskey/remotenotification
   NotificationPayloadForOpen? getNotificationDataFromLaunch();
 }
+
+@EventChannelApi()
+abstract class NotificationHostEvents {
+  /// An event stream that emits a notification payload when the app
+  /// encounters a notification tap, while the app is running.
+  ///
+  /// On iOS, this emits an event when
+  /// `userNotificationCenter(_:didReceive:withCompletionHandler:)` gets
+  /// called, indicating that the user has tapped on a notification. The
+  /// emitted payload will be the raw APNs data from the
+  /// `UNNotificationResponse` passed to the method.
+  NotificationPayloadForOpen notificationTapEvents();
+}

test/model/binding.dart

@@ -745,6 +745,18 @@ class FakeNotificationPigeonApi implements NotificationPigeonApi {
   @override
   Future<NotificationPayloadForOpen?> getNotificationDataFromLaunch() async =>
     _notificationDataFromLaunch;
+
+  StreamController<NotificationPayloadForOpen>? _notificationTapEventsStreamController;
+
+  void addNotificationTapEvent(NotificationPayloadForOpen data) {
+    _notificationTapEventsStreamController!.add(data);
+  }
+
+  @override
+  Stream<NotificationPayloadForOpen> notificationTapEventsStream() {
+    _notificationTapEventsStreamController ??= StreamController();
+    return _notificationTapEventsStreamController!.stream;
+  }
 }
 
 typedef AndroidNotificationHostApiNotifyCall = ({