notif: Add messaging-style notifications support to Pigeon bindings

Add methods and types for creating messaging style notifications:
 https://developer.android.com/develop/ui/views/notifications/build-notification#messaging-style

Author: rajveermalviya

android/app/src/main/kotlin/com/zulip/flutter/Notifications.g.kt

@@ -107,6 +107,117 @@ data class InboxStyle (
     )
   }
 }
+
+/**
+ * Corresponds to `androidx.core.app.Person`
+ *
+ * See: https://developer.android.com/reference/androidx/core/app/Person
+ *
+ * Generated class from Pigeon that represents data sent in messages.
+ */
+data class Person (
+  /**
+   * An icon for this person.
+   *
+   * Wraps `androidx.core.graphics.drawable.IconCompat.createWithData`
+   * which generates an `IconCompat` from compressed image data.
+   *
+   * It uses `android.graphics.BitmapFactory` to decode the image data,
+   * and the `android.graphics.Bitmap.CompressFormat` enum lists the
+   * supported image compression formats (JPEG, PNG, WEBP).
+   *
+   * See:
+   *  https://developer.android.com/reference/androidx/core/graphics/drawable/IconCompat#createWithData(byte[],int,int)
+   *  https://developer.android.com/reference/android/graphics/BitmapFactory.html
+   *  https://developer.android.com/reference/android/graphics/Bitmap.CompressFormat.html
+   */
+  val iconBitmap: ByteArray? = null,
+  val key: String,
+  val name: String
+
+) {
+  companion object {
+    @Suppress("LocalVariableName")
+    fun fromList(__pigeon_list: List<Any?>): Person {
+      val iconBitmap = __pigeon_list[0] as ByteArray?
+      val key = __pigeon_list[1] as String
+      val name = __pigeon_list[2] as String
+      return Person(iconBitmap, key, name)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      iconBitmap,
+      key,
+      name,
+    )
+  }
+}
+
+/**
+ * Corresponds to `androidx.core.app.NotificationCompat.MessagingStyle.Message`
+ *
+ * See: https://developer.android.com/reference/androidx/core/app/NotificationCompat.MessagingStyle.Message
+ *
+ * Generated class from Pigeon that represents data sent in messages.
+ */
+data class MessagingStyleMessage (
+  val text: String,
+  val timestampMs: Long,
+  val person: Person
+
+) {
+  companion object {
+    @Suppress("LocalVariableName")
+    fun fromList(__pigeon_list: List<Any?>): MessagingStyleMessage {
+      val text = __pigeon_list[0] as String
+      val timestampMs = __pigeon_list[1].let { num -> if (num is Int) num.toLong() else num as Long }
+      val person = __pigeon_list[2] as Person
+      return MessagingStyleMessage(text, timestampMs, person)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      text,
+      timestampMs,
+      person,
+    )
+  }
+}
+
+/**
+ * Corresponds to `androidx.core.app.NotificationCompat.MessagingStyle`
+ *
+ * See: https://developer.android.com/reference/androidx/core/app/NotificationCompat.MessagingStyle
+ *
+ * Generated class from Pigeon that represents data sent in messages.
+ */
+data class MessagingStyle (
+  val user: Person,
+  val conversationTitle: String? = null,
+  val messages: List<MessagingStyleMessage?>,
+  val isGroupConversation: Boolean
+
+) {
+  companion object {
+    @Suppress("LocalVariableName")
+    fun fromList(__pigeon_list: List<Any?>): MessagingStyle {
+      val user = __pigeon_list[0] as Person
+      val conversationTitle = __pigeon_list[1] as String?
+      val messages = __pigeon_list[2] as List<MessagingStyleMessage?>
+      val isGroupConversation = __pigeon_list[3] as Boolean
+      return MessagingStyle(user, conversationTitle, messages, isGroupConversation)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      user,
+      conversationTitle,
+      messages,
+      isGroupConversation,
+    )
+  }
+}
 private object NotificationsPigeonCodec : StandardMessageCodec() {
   override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
     return when (type) {
@@ -120,6 +231,21 @@ private object NotificationsPigeonCodec : StandardMessageCodec() {
           InboxStyle.fromList(it)
         }
       }
+      131.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          Person.fromList(it)
+        }
+      }
+      132.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          MessagingStyleMessage.fromList(it)
+        }
+      }
+      133.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          MessagingStyle.fromList(it)
+        }
+      }
       else -> super.readValueOfType(type, buffer)
     }
   }
@@ -133,6 +259,18 @@ private object NotificationsPigeonCodec : StandardMessageCodec() {
         stream.write(130)
         writeValue(stream, value.toList())
       }
+      is Person -> {
+        stream.write(131)
+        writeValue(stream, value.toList())
+      }
+      is MessagingStyleMessage -> {
+        stream.write(132)
+        writeValue(stream, value.toList())
+      }
+      is MessagingStyle -> {
+        stream.write(133)
+        writeValue(stream, value.toList())
+      }
       else -> super.writeValue(stream, value)
     }
   }
@@ -159,7 +297,23 @@ interface AndroidNotificationHostApi {
    *   https://developer.android.com/reference/kotlin/android/app/NotificationManager.html#notify
    *   https://developer.android.com/reference/androidx/core/app/NotificationCompat.Builder
    */
-  fun notify(tag: String?, id: Long, autoCancel: Boolean?, channelId: String, color: Long?, contentIntent: PendingIntent?, contentText: String?, contentTitle: String?, extras: Map<String?, String?>?, groupKey: String?, inboxStyle: InboxStyle?, isGroupSummary: Boolean?, smallIconResourceName: String?)
+  fun notify(tag: String?, id: Long, autoCancel: Boolean?, channelId: String, color: Long?, contentIntent: PendingIntent?, contentText: String?, contentTitle: String?, extras: Map<String?, String?>?, groupKey: String?, inboxStyle: InboxStyle?, isGroupSummary: Boolean?, messagingStyle: MessagingStyle?, number: Long?, smallIconResourceName: String?)
+  /**
+   * Wraps `androidx.core.app.NotificationManagerCompat.getActiveNotifications`,
+   * combined with `androidx.core.app.NotificationCompat.MessagingStyle.extractMessagingStyleFromNotification`.
+   *
+   * The `tag` is used to find a notification that matches the
+   * same tag from the active notifications list.
+   *
+   * Returns null if active notifications list is empty or none
+   * of the notification matches the `tag`, else returns messaging
+   * style information of the matching active notification.
+   *
+   * See:
+   *   https://developer.android.com/reference/kotlin/androidx/core/app/NotificationManagerCompat#getActiveNotifications()
+   *   https://developer.android.com/reference/kotlin/androidx/core/app/NotificationCompat.MessagingStyle#extractMessagingStyleFromNotification(android.app.Notification)
+   */
+  fun getActiveNotificationMessagingStyleByTag(tag: String): MessagingStyle?
 
   companion object {
     /** The codec used by AndroidNotificationHostApi. */
@@ -187,9 +341,11 @@ interface AndroidNotificationHostApi {
             val groupKeyArg = args[9] as String?
             val inboxStyleArg = args[10] as InboxStyle?
             val isGroupSummaryArg = args[11] as Boolean?
-            val smallIconResourceNameArg = args[12] as String?
+            val messagingStyleArg = args[12] as MessagingStyle?
+            val numberArg = args[13].let { num -> if (num is Int) num.toLong() else num as Long? }
+            val smallIconResourceNameArg = args[14] as String?
             val wrapped: List<Any?> = try {
-              api.notify(tagArg, idArg, autoCancelArg, channelIdArg, colorArg, contentIntentArg, contentTextArg, contentTitleArg, extrasArg, groupKeyArg, inboxStyleArg, isGroupSummaryArg, smallIconResourceNameArg)
+              api.notify(tagArg, idArg, autoCancelArg, channelIdArg, colorArg, contentIntentArg, contentTextArg, contentTitleArg, extrasArg, groupKeyArg, inboxStyleArg, isGroupSummaryArg, messagingStyleArg, numberArg, smallIconResourceNameArg)
               listOf(null)
             } catch (exception: Throwable) {
               wrapError(exception)
@@ -200,6 +356,23 @@ interface AndroidNotificationHostApi {
           channel.setMessageHandler(null)
         }
       }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.zulip.AndroidNotificationHostApi.getActiveNotificationMessagingStyleByTag$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val tagArg = args[0] as String
+            val wrapped: List<Any?> = try {
+              listOf(api.getActiveNotificationMessagingStyleByTag(tagArg))
+            } catch (exception: Throwable) {
+              wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
     }
   }
 }

android/app/src/main/kotlin/com/zulip/flutter/ZulipPlugin.kt

@@ -8,10 +8,38 @@ import android.util.Log
 import androidx.annotation.Keep
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.graphics.drawable.IconCompat
 import io.flutter.embedding.engine.plugins.FlutterPlugin
 
 private const val TAG = "ZulipPlugin"
 
+fun toAndroidPerson(person: Person): androidx.core.app.Person {
+    return androidx.core.app.Person.Builder().apply {
+        person.iconBitmap?.let { setIcon(IconCompat.createWithData(it, 0, it.size)) }
+        setKey(person.key)
+        setName(person.name)
+    }.build()
+}
+
+fun toPigeonPerson(person: androidx.core.app.Person): Person {
+    return Person(
+        // The API doesn't provide a way to retrieve the icon data,
+        // so we set this to null.
+        //
+        // Notably, Android retains a limited number [1] of messages
+        // in the messaging style, and it also retains the icon data
+        // for persons within those messages. Therefore, there's no
+        // need to include the person's icon data in each message.
+        // Only one icon data instance is needed for each unique
+        // person's key in the retained messages.
+        //
+        // [1]: https://developer.android.com/reference/androidx/core/app/NotificationCompat.MessagingStyle#MAXIMUM_RETAINED_MESSAGES()
+        null,
+        person.key!!,
+        person.name!!.toString(),
+    )
+}
+
 private class AndroidNotificationHost(val context: Context)
         : AndroidNotificationHostApi {
     @SuppressLint(
@@ -33,6 +61,8 @@ private class AndroidNotificationHost(val context: Context)
         groupKey: String?,
         inboxStyle: InboxStyle?,
         isGroupSummary: Boolean?,
+        messagingStyle: MessagingStyle?,
+        number: Long?,
         smallIconResourceName: String?
     ) {
         val notification = NotificationCompat.Builder(context, channelId).apply {
@@ -60,11 +90,48 @@ private class AndroidNotificationHost(val context: Context)
                     .setSummaryText(it.summaryText)
             ) }
             isGroupSummary?.let { setGroupSummary(it) }
+            messagingStyle?.let { messagingStyle ->
+                val style = NotificationCompat.MessagingStyle(toAndroidPerson(messagingStyle.user))
+                    .setConversationTitle(messagingStyle.conversationTitle)
+                    .setGroupConversation(messagingStyle.isGroupConversation)
+                messagingStyle.messages?.forEach { it?.let {
+                    style.addMessage(NotificationCompat.MessagingStyle.Message(
+                        it.text,
+                        it.timestampMs,
+                        toAndroidPerson(it.person),
+                    ))
+                } }
+                setStyle(style)
+            }
+            number?.let { setNumber(it.toInt()) }
             smallIconResourceName?.let { setSmallIcon(context.resources.getIdentifier(
                 it, "drawable", context.packageName)) }
         }.build()
         NotificationManagerCompat.from(context).notify(tag, id.toInt(), notification)
     }
+
+    override fun getActiveNotificationMessagingStyleByTag(tag: String): MessagingStyle? {
+        val activeNotification = NotificationManagerCompat.from(context)
+            .activeNotifications
+            .find { it.tag == tag }
+        activeNotification?.notification?.let { notification ->
+            NotificationCompat.MessagingStyle
+                .extractMessagingStyleFromNotification(notification)
+                ?.let { style ->
+                    return MessagingStyle(
+                        toPigeonPerson(style.user),
+                        style.conversationTitle!!.toString(),
+                        style.messages.map { MessagingStyleMessage(
+                            it.text!!.toString(),
+                            it.timestamp,
+                            toPigeonPerson(it.person!!)
+                        ) },
+                        style.isGroupConversation,
+                    )
+                }
+        }
+        return null
+    }
 }
 
 /** A Flutter plugin for the Zulip app's ad-hoc needs. */