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(notificationPayload.map { NotificationDataFromLaunch(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: NotificationTapEvent(payload: userInfo))
+      completionHandler()
+    }
+  }
 }
 
 private class NotificationHostApiImpl: NotificationHostApi {
@@ -33,3 +53,22 @@ private class NotificationHostApiImpl: NotificationHostApi {
     maybeDataFromLaunch
   }
 }
+
+class NotificationTapEventListener: NotificationTapEventsStreamHandler {
+  var eventSink: PigeonEventSink<NotificationTapEvent>?
+
+  override func onListen(withArguments arguments: Any?, sink: PigeonEventSink<NotificationTapEvent>) {
+    eventSink = sink
+  }
+
+  func onNotificationTapEvent(data: NotificationTapEvent) {
+    if let eventSink = eventSink {
+      eventSink.success(data)
+    }
+  }
+
+  func onEventsDone() {
+    eventSink?.endOfStream()
+    eventSink = nil
+  }
+}

ios/Runner/Notifications.g.swift

@@ -86,11 +86,35 @@ struct NotificationDataFromLaunch {
   }
 }
 
+/// Generated class from Pigeon that represents data sent in messages.
+struct NotificationTapEvent {
+  /// The raw payload that is attached to the notification,
+  /// holding the information required to carry out the navigation.
+  var payload: [AnyHashable?: Any?]
+
+
+  // swift-format-ignore: AlwaysUseLowerCamelCase
+  static func fromList(_ pigeonVar_list: [Any?]) -> NotificationTapEvent? {
+    let payload = pigeonVar_list[0] as! [AnyHashable?: Any?]
+
+    return NotificationTapEvent(
+      payload: payload
+    )
+  }
+  func toList() -> [Any?] {
+    return [
+      payload
+    ]
+  }
+}
+
 private class NotificationsPigeonCodecReader: FlutterStandardReader {
   override func readValue(ofType type: UInt8) -> Any? {
     switch type {
     case 129:
       return NotificationDataFromLaunch.fromList(self.readValue() as! [Any?])
+    case 130:
+      return NotificationTapEvent.fromList(self.readValue() as! [Any?])
     default:
       return super.readValue(ofType: type)
     }
@@ -102,6 +126,9 @@ private class NotificationsPigeonCodecWriter: FlutterStandardWriter {
     if let value = value as? NotificationDataFromLaunch {
       super.writeByte(129)
       super.writeValue(value.toList())
+    } else if let value = value as? NotificationTapEvent {
+      super.writeByte(130)
+      super.writeValue(value.toList())
     } else {
       super.writeValue(value)
     }
@@ -122,6 +149,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.
@@ -162,3 +191,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<NotificationTapEvent> {
+  static func register(with messenger: FlutterBinaryMessenger,
+                      instanceName: String = "",
+                      streamHandler: NotificationTapEventsStreamHandler) {
+    var channelName = "dev.flutter.pigeon.zulip.NotificationEventChannelApi.notificationTapEvents"
+    if !instanceName.isEmpty {
+      channelName += ".\(instanceName)"
+    }
+    let internalStreamHandler = PigeonStreamHandler<NotificationTapEvent>(wrapper: streamHandler)
+    let channel = FlutterEventChannel(name: channelName, binaryMessenger: messenger, codec: notificationsPigeonMethodCodec)
+    channel.setStreamHandler(internalStreamHandler)
+  }
+}
+      

lib/host/notifications.g.dart

@@ -38,6 +38,29 @@ class NotificationDataFromLaunch {
   }
 }
 
+class NotificationTapEvent {
+  NotificationTapEvent({
+    required this.payload,
+  });
+
+  /// The raw payload that is attached to the notification,
+  /// holding the information required to carry out the navigation.
+  Map<Object?, Object?> payload;
+
+  Object encode() {
+    return <Object?>[
+      payload,
+    ];
+  }
+
+  static NotificationTapEvent decode(Object result) {
+    result as List<Object?>;
+    return NotificationTapEvent(
+      payload: (result[0] as Map<Object?, Object?>?)!.cast<Object?, Object?>(),
+    );
+  }
+}
+
 
 class _PigeonCodec extends StandardMessageCodec {
   const _PigeonCodec();
@@ -49,6 +72,9 @@ class _PigeonCodec extends StandardMessageCodec {
     }    else if (value is NotificationDataFromLaunch) {
       buffer.putUint8(129);
       writeValue(buffer, value.encode());
+    }    else if (value is NotificationTapEvent) {
+      buffer.putUint8(130);
+      writeValue(buffer, value.encode());
     } else {
       super.writeValue(buffer, value);
     }
@@ -59,12 +85,16 @@ class _PigeonCodec extends StandardMessageCodec {
     switch (type) {
       case 129: 
         return NotificationDataFromLaunch.decode(readValue(buffer)!);
+      case 130: 
+        return NotificationTapEvent.decode(readValue(buffer)!);
       default:
         return super.readValueOfType(type, buffer);
     }
   }
 }
 
+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
@@ -108,3 +138,15 @@ class NotificationHostApi {
     }
   }
 }
+
+Stream<NotificationTapEvent> notificationTapEvents( {String instanceName = ''}) {
+  if (instanceName.isNotEmpty) {
+    instanceName = '.$instanceName';
+  }
+  final EventChannel notificationTapEventsChannel =
+      EventChannel('dev.flutter.pigeon.zulip.NotificationEventChannelApi.notificationTapEvents$instanceName', pigeonMethodCodec);
+  return notificationTapEventsChannel.receiveBroadcastStream().map((dynamic event) {
+    return event as NotificationTapEvent;
+  });
+}
+    

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 _hostApi = notif_pigeon.NotificationHostApi();
 
   Future<notif_pigeon.NotificationDataFromLaunch?> getNotificationDataFromLaunch() =>
     _hostApi.getNotificationDataFromLaunch();
+
+  Stream<notif_pigeon.NotificationTapEvent> notificationTapEventsStream() =>
+    notif_pigeon.notificationTapEvents();
 }
 
 /// A concrete binding for use in the live application.

lib/notifications/open.dart

@@ -11,6 +11,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';
@@ -46,6 +47,8 @@ class NotificationOpenManager {
       switch (defaultTargetPlatform) {
         case TargetPlatform.iOS:
           _notifDataFromLaunch = await _notifPigeonApi.getNotificationDataFromLaunch();
+          _notifPigeonApi.notificationTapEventsStream()
+            .listen(_navigateForNotification);
 
         case TargetPlatform.android:
           // Do nothing; we do notification routing differently on Android.
@@ -79,17 +82,8 @@ class NotificationOpenManager {
     if (data == null) return null;
     assert(debugLog('opened notif: ${jsonEncode(data.payload)}'));
 
-    final NotificationNavigationData notifNavData;
-    try {
-      notifNavData = NotificationNavigationData.fromIosApnsPayload(data.payload);
-    } on FormatException catch (e, st) {
-      assert(debugLog('$e\n$st'));
-      final zulipLocalizations = ZulipLocalizations.of(context);
-      showErrorDialog(context: context,
-        title: zulipLocalizations.errorNotificationOpenTitle);
-      return null;
-    }
-
+    final notifNavData = _tryParsePayload(context, data.payload);
+    if (notifNavData == null) return null; // TODO(log)
     return _routeForNotification(context, notifNavData);
   }
 
@@ -116,6 +110,41 @@ class NotificationOpenManager {
       // TODO(#82): Open at specific message, not just conversation
       narrow: data.narrow);
   }
+
+  /// Navigates to the [MessageListPage] of the specific conversation
+  /// for the provided payload that was attached while creating the
+  /// notification.
+  Future<void> _navigateForNotification(NotificationTapEvent event) async {
+    assert(debugLog('opened notif: ${jsonEncode(event.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 notifNavData = _tryParsePayload(context, event.payload);
+    if (notifNavData == null) return; // TODO(log)
+    final route = _routeForNotification(context, notifNavData);
+    if (route == null) return; // TODO(log)
+
+    // TODO(nav): Better interact with existing nav stack on notif open
+    unawaited(navigator.push(route));
+  }
+
+  NotificationNavigationData? _tryParsePayload(
+    BuildContext context,
+    Map<Object?, Object?> payload,
+  ) {
+    try {
+      return NotificationNavigationData.fromIosApnsPayload(payload);
+    } on FormatException catch (e, st) {
+      assert(debugLog('$e\n$st'));
+      final zulipLocalizations = ZulipLocalizations.of(context);
+      showErrorDialog(context: context,
+        title: zulipLocalizations.errorNotificationOpenTitle);
+      return null;
+    }
+  }
 }
 
 class NotificationNavigationData {

pigeon/notifications.dart

@@ -12,6 +12,18 @@ class NotificationDataFromLaunch {
 
   /// The raw payload that is attached to the notification,
   /// holding the information required to carry out the navigation.
+  ///
+  /// See [NotificationHostApi.getNotificationDataFromLaunch].
+  final Map<Object?, Object?> payload;
+}
+
+class NotificationTapEvent {
+  const NotificationTapEvent({required this.payload});
+
+  /// The raw payload that is attached to the notification,
+  /// holding the information required to carry out the navigation.
+  ///
+  /// See [NotificationEventChannelApi.notificationTapEvents].
   final Map<Object?, Object?> payload;
 }
 
@@ -26,3 +38,16 @@ abstract class NotificationHostApi {
   ///   https://developer.apple.com/documentation/uikit/uiapplication/launchoptionskey/remotenotification
   NotificationDataFromLaunch? getNotificationDataFromLaunch();
 }
+
+@EventChannelApi()
+abstract class NotificationEventChannelApi {
+  /// An event stream that emits a notification payload when the app
+  /// encounters a notification tap, while the app is running.
+  ///
+  /// 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 dictionary from the
+  /// `UNNotificationResponse` passed to that method.
+  NotificationTapEvent notificationTapEvents();
+}