add support for mark-read-generic and mark-read-messages

modules/BlueskyNSE/NotificationService.swift

@@ -4,6 +4,30 @@ import UIKit
 let APP_GROUP = "group.app.bsky"
 typealias ContentHandler = (UNNotificationContent) -> Void
 
+enum NotificationType: String, CaseIterable  {
+  case like
+  case repost
+  case follow
+  case reply
+  case quote
+  case chatMessage = "chat-message"
+  case markReadGeneric = "mark-read-generic"
+  case markReadMessages = "mark-read-messages"
+  case starterPackJoined = "starterpack-joined"
+}
+
+enum BadgeType: String, CaseIterable {
+  case generic
+  case messages
+}
+
+enum BadgeOperation {
+  case increment
+  case decrement
+}
+
+let INCREMENTED_FOR_KEY = "incremented-for-convos"
+
 // This extension allows us to do some processing of the received notification
 // data before displaying the notification to the user. In our use case, there
 // are a few particular things that we want to do:
@@ -30,27 +54,32 @@ class NotificationService: UNNotificationServiceExtension {
   private var bestAttempt: UNMutableNotificationContent?
 
   override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
-    self.contentHandler = contentHandler
 
     guard let bestAttempt = NSEUtil.createCopy(request.content),
-          let reason = request.content.userInfo["reason"] as? String
+          let reasonString = request.content.userInfo["reason"] as? String,
+          let reason = NotificationType(rawValue: reasonString)
     else {
       contentHandler(request.content)
       return
     }
-
+
+    self.contentHandler = contentHandler
     self.bestAttempt = bestAttempt
-    if reason == "chat-message" {
-      mutateWithChatMessage(bestAttempt)
-    } else {
-      mutateWithBadge(bestAttempt)
+
+    NSEUtil.shared.prefsQueue.sync {
+      switch reason {
+      case .like, .repost, .follow, .reply, .quote, .starterPackJoined:
+        NSEUtil.mutateWithBadge(bestAttempt, badgeType: .generic, operation: .increment)
+      case .chatMessage:
+        NSEUtil.mutateWithChatMessage(bestAttempt)
+        NSEUtil.mutateWithBadge(bestAttempt, badgeType: .messages, operation: .increment)
+      case .markReadGeneric:
+        NSEUtil.mutateWithBadge(bestAttempt, badgeType: .generic, operation: .decrement)
+      case .markReadMessages:
+        NSEUtil.mutateWithBadge(bestAttempt, badgeType: .messages, operation: .decrement)
+      }
+      contentHandler(bestAttempt)
     }
-
-    // Any image downloading (or other network tasks) should be handled at the end
-    // of this block. Otherwise, if there is a timeout and serviceExtensionTimeWillExpire
-    // gets called, we might not have all the needed mutations completed in time.
-
-    contentHandler(bestAttempt)
   }
 
   override func serviceExtensionTimeWillExpire() {
@@ -60,46 +89,106 @@ class NotificationService: UNNotificationServiceExtension {
     }
     contentHandler(bestAttempt)
   }
-
-  // MARK: Mutations
-
-  func mutateWithBadge(_ content: UNMutableNotificationContent) {
-    NSEUtil.shared.prefsQueue.sync {
-      var count = NSEUtil.shared.prefs?.integer(forKey: "badgeCount") ?? 0
-      count += 1
-
-      // Set the new badge number for the notification, then store that value for using later
-      content.badge = NSNumber(value: count)
-      NSEUtil.shared.prefs?.setValue(count, forKey: "badgeCount")
-    }
-  }
-
-  func mutateWithChatMessage(_ content: UNMutableNotificationContent) {
-    if NSEUtil.shared.prefs?.bool(forKey: "playSoundChat") == true {
-      mutateWithDmSound(content)
-    }
-  }
-
-  func mutateWithDefaultSound(_ content: UNMutableNotificationContent) {
-    content.sound = UNNotificationSound.default
-  }
-
-  func mutateWithDmSound(_ content: UNMutableNotificationContent) {
-    content.sound = UNNotificationSound(named: UNNotificationSoundName(rawValue: "dm.aiff"))
-  }
 }
 
 // NSEUtil's purpose is to create a shared instance of `UserDefaults` across
 // `NotificationService` instances. It also includes a queue so that we can process
 // updates to `UserDefaults` in parallel.
+//
+// Any time that you increment or decrement counts for notifications, you should use
+// the prefsQueue so that things remain in sync.
 
 private class NSEUtil {
   static let shared = NSEUtil()
 
   var prefs = UserDefaults(suiteName: APP_GROUP)
   var prefsQueue = DispatchQueue(label: "NSEPrefsQueue")
 
+  // MARK: - Utils
+
   static func createCopy(_ content: UNNotificationContent) -> UNMutableNotificationContent? {
     return content.mutableCopy() as? UNMutableNotificationContent
   }
+
+  static func getDecrementedBadgeCount(current: Int, decrementBy by: Int) -> Int {
+    let new = current - by
+    if new < 0 {
+      return 0
+    }
+    return new
+  }
+
+  // MARK: - Mutations
+
+  static func mutateWithBadge(_ content: UNMutableNotificationContent,
+                       badgeType type: BadgeType,
+                       operation: BadgeOperation) {
+    var genericCount = Self.shared.prefs?.integer(forKey: BadgeType.generic.rawValue) ?? 0
+    var messagesCount = Self.shared.prefs?.integer(forKey: BadgeType.messages.rawValue) ?? 0
+
+    if type == .generic {
+      if operation == .decrement {
+        genericCount = 0
+      } else {
+        genericCount += 1
+      }
+      Self.shared.prefs?.setValue(genericCount, forKey: BadgeType.generic.rawValue)
+      // TEMPORARY - since we have not implemented message count clearing on the server, we'll clear
+      // those here as well.
+      Self.shared.prefs?.setValue(messagesCount, forKey: BadgeType.messages.rawValue)
+    } else if type == .messages {
+      // Not yet implemented, but here's the logic
+      if operation == .decrement,
+         Self.shouldDecrementForConvo(content) {
+        messagesCount = Self.getDecrementedBadgeCount(current: messagesCount, decrementBy: 1)
+      } else if operation == .increment,
+                shouldIncrementForConvo(content) {
+        messagesCount += 1
+      }
+    }
+  }
+
+  static func mutateWithChatMessage(_ content: UNMutableNotificationContent) {
+    if Self.shared.prefs?.bool(forKey: "playSoundChat") == true {
+      Self.mutateWithDmSound(content)
+    }
+  }
+
+  static func mutateWithDefaultSound(_ content: UNMutableNotificationContent) {
+    content.sound = UNNotificationSound.default
+  }
+
+  static func mutateWithDmSound(_ content: UNMutableNotificationContent) {
+    content.sound = UNNotificationSound(named: UNNotificationSoundName(rawValue: "dm.aiff"))
+  }
+
+  static func shouldIncrementForConvo(_ content: UNMutableNotificationContent) -> Bool {
+    guard let convoId = content.userInfo["convoId"] as? String,
+          var dict = Self.shared.prefs?.dictionary(forKey: INCREMENTED_FOR_KEY) as? [String: Bool] else {
+      return false
+    }
+
+    if dict["convoId"] == true {
+      return false
+    }
+
+    dict[convoId] = true
+    Self.shared.prefs?.set(dict, forKey: INCREMENTED_FOR_KEY)
+    return true
+  }
+
+  static func shouldDecrementForConvo(_ content: UNMutableNotificationContent) -> Bool {
+    guard let convoId = content.userInfo["convoId"] as? String,
+          var dict = Self.shared.prefs?.dictionary(forKey: INCREMENTED_FOR_KEY) as? [String: Bool] else {
+      return false
+    }
+
+    if dict["convoId"] != true {
+      return false
+    }
+
+    dict.removeValue(forKey: convoId)
+    Self.shared.prefs?.set(dict, forKey: INCREMENTED_FOR_KEY)
+    return true
+  }
 }

modules/expo-background-notification-handler/android/build.gradle

@@ -6,88 +6,89 @@ group = 'expo.modules.backgroundnotificationhandler'
 version = '0.5.0'
 
 buildscript {
-  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-  if (expoModulesCorePlugin.exists()) {
-    apply from: expoModulesCorePlugin
-    applyKotlinExpoModulesCorePlugin()
-  }
+    def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+    if (expoModulesCorePlugin.exists()) {
+        apply from: expoModulesCorePlugin
+        applyKotlinExpoModulesCorePlugin()
+    }
 
-  // Simple helper that allows the root project to override versions declared by this library.
-  ext.safeExtGet = { prop, fallback ->
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-  }
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
 
-  // Ensures backward compatibility
-  ext.getKotlinVersion = {
-    if (ext.has("kotlinVersion")) {
-      ext.kotlinVersion()
-    } else {
-      ext.safeExtGet("kotlinVersion", "1.8.10")
+    // Ensures backward compatibility
+    ext.getKotlinVersion = {
+        if (ext.has("kotlinVersion")) {
+            ext.kotlinVersion()
+        } else {
+            ext.safeExtGet("kotlinVersion", "1.8.10")
+        }
     }
-  }
 
-  repositories {
-    mavenCentral()
-  }
+    repositories {
+        mavenCentral()
+    }
 
-  dependencies {
-    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
-  }
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
+    }
 }
 
 afterEvaluate {
-  publishing {
-    publications {
-      release(MavenPublication) {
-        from components.release
-      }
+    publishing {
+        publications {
+            release(MavenPublication) {
+                from components.release
+            }
+        }
+        repositories {
+            maven {
+                url = mavenLocal().url
+            }
+        }
     }
-    repositories {
-      maven {
-        url = mavenLocal().url
-      }
-    }
-  }
 }
 
 android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 33)
+    compileSdkVersion safeExtGet("compileSdkVersion", 33)
 
-  def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
-  if (agpVersion.tokenize('.')[0].toInteger() < 8) {
-    compileOptions {
-      sourceCompatibility JavaVersion.VERSION_11
-      targetCompatibility JavaVersion.VERSION_11
-    }
+    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+    if (agpVersion.tokenize('.')[0].toInteger() < 8) {
+        compileOptions {
+            sourceCompatibility JavaVersion.VERSION_11
+            targetCompatibility JavaVersion.VERSION_11
+        }
 
-    kotlinOptions {
-      jvmTarget = JavaVersion.VERSION_11.majorVersion
+        kotlinOptions {
+            jvmTarget = JavaVersion.VERSION_11.majorVersion
+        }
     }
-  }
 
-  namespace "expo.modules.backgroundnotificationhandler"
-  defaultConfig {
-    minSdkVersion safeExtGet("minSdkVersion", 21)
-    targetSdkVersion safeExtGet("targetSdkVersion", 34)
-    versionCode 1
-    versionName "0.5.0"
-  }
-  lintOptions {
-    abortOnError false
-  }
-  publishing {
-    singleVariant("release") {
-      withSourcesJar()
+    namespace "expo.modules.backgroundnotificationhandler"
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 21)
+        targetSdkVersion safeExtGet("targetSdkVersion", 34)
+        versionCode 1
+        versionName "0.5.0"
+    }
+    lintOptions {
+        abortOnError false
+    }
+    publishing {
+        singleVariant("release") {
+            withSourcesJar()
+        }
     }
-  }
 }
 
 repositories {
-  mavenCentral()
+    mavenCentral()
 }
 
 dependencies {
-  implementation project(':expo-modules-core')
-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
-  implementation 'com.google.firebase:firebase-messaging-ktx:24.0.0'
+    implementation project(':expo-bluesky-swiss-army')
+    implementation project(':expo-modules-core')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+    implementation 'com.google.firebase:firebase-messaging-ktx:24.0.0'
 }