perf: switch every channel alert in one request when supported

Author: Priveetee

core/data/src/main/java/dev/typetype/android/data/network/TypeTypeNotificationsApi.kt

@@ -4,6 +4,7 @@ import dev.typetype.android.data.network.dto.MarkNotificationsReadResponseDto
 import dev.typetype.android.data.network.dto.NotificationsResponseDto
 import dev.typetype.android.data.network.dto.ChannelNotificationPreferenceDto
 import dev.typetype.android.data.network.dto.ChannelNotificationPreferenceRequestDto
+import dev.typetype.android.data.network.dto.ChannelNotificationPreferencesBulkRequestDto
 import dev.typetype.android.data.network.dto.PushDeviceRegistrationRequestDto
 import dev.typetype.android.data.network.dto.PushDeviceRegistrationResponseDto
 import dev.typetype.android.data.network.dto.PushDeliveryAcknowledgementRequestDto
@@ -55,4 +56,9 @@ interface TypeTypeNotificationsApi {
     suspend fun setChannelNotificationPreference(
         @Body request: ChannelNotificationPreferenceRequestDto,
     ): Response<ChannelNotificationPreferenceDto>
+
+    @PUT("notifications/channel-preferences/bulk")
+    suspend fun setChannelNotificationPreferences(
+        @Body request: ChannelNotificationPreferencesBulkRequestDto,
+    ): Response<List<ChannelNotificationPreferenceDto>>
 }

core/data/src/main/java/dev/typetype/android/data/network/dto/PushDto.kt

@@ -37,6 +37,12 @@ data class ChannelNotificationPreferenceRequestDto(
     val enabled: Boolean,
 )
 
+@Serializable
+data class ChannelNotificationPreferencesBulkRequestDto(
+    val enabled: Boolean,
+    val channelUrls: List<String>,
+)
+
 @Serializable
 data class ChannelNotificationPreferenceDto(
     val channelUrl: String,

core/data/src/main/java/dev/typetype/android/data/push/RemotePushRepository.kt

@@ -6,6 +6,7 @@ import dev.typetype.android.data.account.AccountScope
 import dev.typetype.android.data.account.ActiveAccountScope
 import dev.typetype.android.data.network.TypeTypeApiHolder
 import dev.typetype.android.data.network.dto.ChannelNotificationPreferenceRequestDto
+import dev.typetype.android.data.network.dto.ChannelNotificationPreferencesBulkRequestDto
 import dev.typetype.android.data.network.dto.PushDeviceRegistrationRequestDto
 import dev.typetype.android.data.network.dto.toDomain
 import dev.typetype.android.data.network.requireSuccessfulResponse
@@ -84,6 +85,16 @@ class RemotePushRepository @Inject constructor(
         response.requireSuccessfulResponse()
     }
 
+    override suspend fun setChannelPreferences(channelUrls: List<String>, enabled: Boolean): Result<Unit> = guarded {
+        val api = apiHolder.require(requireEligibleScope())
+        val response = withContext(Dispatchers.IO) {
+            api.setChannelNotificationPreferences(
+                ChannelNotificationPreferencesBulkRequestDto(enabled = enabled, channelUrls = channelUrls),
+            )
+        }
+        response.requireSuccessfulResponse()
+    }
+
     private suspend fun requireEligibleScope(): AccountScope {
         val scope = activeAccountScope.require()
         val account = accountDao.get(scope.serverId, scope.accountId)

core/model/src/main/java/dev/typetype/android/domain/push/PushRepository.kt

@@ -14,4 +14,6 @@ interface PushRepository {
     suspend fun channelPreferences(): Result<List<ChannelNotificationsPreference>>
 
     suspend fun setChannelPreference(channelUrl: String, enabled: Boolean): Result<Unit>
+
+    suspend fun setChannelPreferences(channelUrls: List<String>, enabled: Boolean): Result<Unit>
 }

feature/settings/src/main/java/dev/typetype/android/feature/settings/notifications/ChannelNotificationsViewModel.kt

@@ -112,17 +112,51 @@ class ChannelNotificationsViewModel @Inject constructor(
         if (targets.isEmpty()) return
         viewModelScope.launch {
             _state.update { it.copy(bulkInFlight = true, bulkDone = 0, bulkTotal = targets.size, showError = false) }
-            val gate = Semaphore(BULK_PARALLELISM)
-            val results = coroutineScope {
-                targets.map { channel ->
-                    async {
-                        gate.withPermit { save(channel, enabled) }
-                            .also { _state.update { it.copy(bulkDone = it.bulkDone + 1) } }
-                    }
-                }.awaitAll()
+            val saved = when (saveAllAtOnce(targets, enabled)) {
+                BulkSave.Saved -> true
+                BulkSave.Failed -> false
+                BulkSave.Unsupported -> saveOneByOne(targets, enabled)
             }
-            _state.update { it.copy(bulkInFlight = false, showError = results.any { saved -> !saved }) }
+            _state.update { it.copy(bulkInFlight = false, showError = !saved) }
+        }
+    }
+
+    private suspend fun saveAllAtOnce(targets: List<ChannelBell>, enabled: Boolean): BulkSave {
+        val urls = targets.mapTo(hashSetOf(), ChannelBell::channelUrl)
+        _state.update { state ->
+            state.copy(channels = state.channels.map { if (it.channelUrl in urls) it.copy(pending = true) else it })
+        }
+        val failure = suspendRunCatching {
+            pushRepository.setChannelPreferences(urls.toList(), enabled).getOrThrow()
+        }.exceptionOrNull()
+        val result = when {
+            failure == null -> BulkSave.Saved
+            (failure as? CodedFailure)?.statusCode in BULK_UNSUPPORTED_STATUSES -> BulkSave.Unsupported
+            else -> BulkSave.Failed
+        }
+        _state.update { state ->
+            state.copy(
+                bulkDone = if (result == BulkSave.Saved) state.bulkTotal else state.bulkDone,
+                channels = state.channels.map { channel ->
+                    if (channel.channelUrl !in urls) return@map channel
+                    channel.copy(enabled = if (result == BulkSave.Saved) enabled else channel.enabled, pending = false)
+                },
+            )
         }
+        return result
+    }
+
+    private suspend fun saveOneByOne(targets: List<ChannelBell>, enabled: Boolean): Boolean {
+        val gate = Semaphore(BULK_PARALLELISM)
+        val results = coroutineScope {
+            targets.map { channel ->
+                async {
+                    gate.withPermit { save(channel, enabled) }
+                        .also { _state.update { it.copy(bulkDone = it.bulkDone + 1) } }
+                }
+            }.awaitAll()
+        }
+        return results.all { it }
     }
 
     private suspend fun save(channel: ChannelBell, enabled: Boolean): Boolean {
@@ -154,7 +188,10 @@ class ChannelNotificationsViewModel @Inject constructor(
         }
     }
 
+    private enum class BulkSave { Saved, Failed, Unsupported }
+
     private companion object {
+        val BULK_UNSUPPORTED_STATUSES = setOf(404, 405)
         const val BULK_PARALLELISM = 4
         const val MAX_ATTEMPTS = 5
         const val HTTP_TOO_MANY_REQUESTS = 429