Merge branch 'develop' into mo/chore/set-compile-sdk-to-35

# Conflicts:
#	kalium

Author: MohamadJaara

.github/actions/deploy-to-s3/action.yml

@@ -55,15 +55,15 @@ runs:
         file-path: ${{ steps.path.outputs.apk_full_path }}
         output-file-url: 'false'
         public: false
-    - name: Show URL
-      if: github.event.pull_request.number != ''
-      shell: bash
-      env:
-        EVENT_FILE_PATH: artifacts/Event File/event.json
-        GITHUB_USER: ${{ github.actor }}
-        GITHUB_TOKEN: ${{ inputs.github-token }}
-      run: |
-        gh pr comment "${{ github.event.pull_request.number }}" --body "Built [wire-android-${{ inputs.build-flavour }}-${{ inputs.build-variant }}-pr-${{ github.event.pull_request.number }}.apk](${{ steps.upload.outputs.file-url }}) is available for download"
+#    - name: Show URL
+#      if: github.event.pull_request.number != ''
+#      shell: bash
+#      env:
+#        EVENT_FILE_PATH: artifacts/Event File/event.json
+#        GITHUB_USER: ${{ github.actor }}
+#        GITHUB_TOKEN: ${{ inputs.github-token }}
+#      run: |
+#        gh pr comment "${{ github.event.pull_request.number }}" --body "Built [wire-android-${{ inputs.build-flavour }}-${{ inputs.build-variant }}-pr-${{ github.event.pull_request.number }}.apk](${{ steps.upload.outputs.file-url }}) is available for download"
     - name: Extract version and version code from APK filename
       shell: bash
       run: |

.github/dependabot.yml

@@ -10,8 +10,6 @@ updates:
     directory: "/"
     schedule:
       interval: "daily"
-    reviewers:
-      - "wireapp/android"
     commit-message:
       prefix: "chore(deps): [WPB-9777] "
 
@@ -20,7 +18,5 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
-    reviewers:
-      - "wireapp/android"
     commit-message:
       prefix: "chore(deps): [WPB-9777] "

CODEOWNERS

@@ -0,0 +1 @@
+@wireapp/android

app/src/main/kotlin/com/wire/android/di/KaliumConfigsModule.kt

@@ -60,8 +60,7 @@ class KaliumConfigsModule {
             isWebSocketEnabledByDefault = isWebsocketEnabledByDefault(context),
             certPinningConfig = BuildConfig.CERTIFICATE_PINNING_CONFIG,
             maxRemoteSearchResultCount = BuildConfig.MAX_REMOTE_SEARCH_RESULT_COUNT,
-            limitTeamMembersFetchDuringSlowSync = BuildConfig.LIMIT_TEAM_MEMBERS_FETCH_DURING_SLOW_SYNC,
-            enableAsyncNotifications = BuildConfig.ENABLE_ASYNC_NOTIFICATIONS
+            limitTeamMembersFetchDuringSlowSync = BuildConfig.LIMIT_TEAM_MEMBERS_FETCH_DURING_SLOW_SYNC
         )
     }
 }

app/src/main/kotlin/com/wire/android/di/accountScoped/ConversationModule.kt

@@ -20,6 +20,8 @@ package com.wire.android.di.accountScoped
 import com.wire.android.di.CurrentAccount
 import com.wire.android.di.KaliumCoreLogic
 import com.wire.kalium.logic.CoreLogic
+import com.wire.kalium.logic.data.conversation.FetchConversationUseCase
+import com.wire.kalium.logic.data.conversation.ResetMLSConversationUseCase
 import com.wire.kalium.logic.data.user.UserId
 import com.wire.kalium.logic.feature.conversation.AddMemberToConversationUseCase
 import com.wire.kalium.logic.feature.conversation.AddServiceToConversationUseCase
@@ -59,6 +61,7 @@ import com.wire.kalium.logic.feature.conversation.UpdateConversationReadDateUseC
 import com.wire.kalium.logic.feature.conversation.UpdateConversationReceiptModeUseCase
 import com.wire.kalium.logic.feature.conversation.createconversation.CreateChannelUseCase
 import com.wire.kalium.logic.feature.conversation.createconversation.CreateRegularGroupUseCase
+import com.wire.kalium.logic.feature.conversation.delete.MarkConversationAsDeletedLocallyUseCase
 import com.wire.kalium.logic.feature.conversation.getPaginatedFlowOfConversationDetailsWithEventsBySearchQuery
 import com.wire.kalium.logic.feature.conversation.guestroomlink.CanCreatePasswordProtectedLinksUseCase
 import com.wire.kalium.logic.feature.conversation.guestroomlink.GenerateGuestRoomLinkUseCase
@@ -114,6 +117,11 @@ class ConversationModule {
     fun provideDeleteTeamConversationUseCase(conversationScope: ConversationScope): DeleteTeamConversationUseCase =
         conversationScope.deleteTeamConversation
 
+    @ViewModelScoped
+    @Provides
+    fun provideMarkConversationAsDeletedLocallyUseCase(conversationScope: ConversationScope): MarkConversationAsDeletedLocallyUseCase =
+        conversationScope.markConversationAsDeletedLocallyUseCase
+
     @ViewModelScoped
     @Provides
     fun provideObserveIsSelfConversationMemberUseCase(conversationScope: ConversationScope): ObserveIsSelfUserMemberUseCase =
@@ -363,4 +371,18 @@ class ConversationModule {
     @Provides
     fun provideCreateConversationFolderUseCase(conversationScope: ConversationScope) =
         conversationScope.createConversationFolder
+
+    @ViewModelScoped
+    @Provides
+    fun provideResetMlsConversationUseCase(
+        @KaliumCoreLogic coreLogic: CoreLogic,
+        @CurrentAccount currentAccount: UserId
+    ): ResetMLSConversationUseCase = coreLogic.getSessionScope(currentAccount).resetMlsConversation
+
+    @ViewModelScoped
+    @Provides
+    fun provideFetchConversationUseCase(
+        @KaliumCoreLogic coreLogic: CoreLogic,
+        @CurrentAccount currentAccount: UserId
+    ): FetchConversationUseCase = coreLogic.getSessionScope(currentAccount).fetchConversationUseCase
 }

app/src/main/kotlin/com/wire/android/notification/WireNotificationManager.kt

@@ -52,11 +52,11 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.cancellable
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
@@ -419,8 +419,9 @@ class WireNotificationManager @Inject constructor(
     }
 
     /**
-     * Infinitely listen for outgoing and established calls of a current user and run the call on foreground Service
-     * to show corresponding notification and do not lose a call.
+     * Infinitely listen for outgoing and established calls of a current user and run the call on foreground Service to show corresponding
+     * notification and do not lose a call. The call service handles stopping itself when there are no calls so here only care about
+     * starting the service when there are calls.
      */
     private suspend fun observeOutgoingOngoingCalls() {
         coreLogic.getGlobalScope().session.currentSessionFlow()
@@ -429,29 +430,15 @@ class WireNotificationManager @Inject constructor(
                     combine(
                         coreLogic.getSessionScope(it.accountInfo.userId).calls.establishedCall(),
                         coreLogic.getSessionScope(it.accountInfo.userId).calls.observeOutgoingCall()
-                    ) { establishedCalls, outgoingCalls ->
-                        if (establishedCalls.isNotEmpty()) {
-                            return@combine true
-                        }
-                        if (outgoingCalls.isNotEmpty()) {
-                            return@combine true
-                        }
-                        return@combine false
-                    }
+                    ) { establishedCalls, outgoingCalls -> (establishedCalls + outgoingCalls).isNotEmpty() }
                 } else {
-                    flowOf(false)
+                    flowOf(null)
                 }
             }
             .distinctUntilChanged()
-            .onCompletion {
-                servicesManager.stopCallService()
-            }
-            .collect { isOnCall ->
-                if (isOnCall) {
-                    servicesManager.startCallService()
-                } else {
-                    servicesManager.stopCallService()
-                }
+            .filter { it == true }
+            .collect {
+                servicesManager.startCallService()
             }
     }
 

app/src/main/kotlin/com/wire/android/services/CallService.kt

@@ -26,39 +26,25 @@ import android.content.pm.ServiceInfo
 import android.os.IBinder
 import androidx.core.app.ServiceCompat
 import com.wire.android.appLogger
-import com.wire.android.di.KaliumCoreLogic
-import com.wire.android.di.NoSession
 import com.wire.android.notification.CallNotificationData
 import com.wire.android.notification.CallNotificationManager
 import com.wire.android.notification.NotificationIds
 import com.wire.android.services.CallService.Action
 import com.wire.android.util.dispatchers.DispatcherProvider
-import com.wire.android.util.logIfEmptyUserName
-import com.wire.kalium.common.functional.Either
 import com.wire.kalium.common.functional.fold
-import com.wire.kalium.logic.CoreLogic
 import com.wire.kalium.logic.data.call.CallStatus
 import com.wire.kalium.logic.data.id.ConversationId
-import com.wire.kalium.logic.data.id.QualifiedIdMapper
 import com.wire.kalium.logic.data.user.UserId
-import com.wire.kalium.logic.feature.call.CallsScope
-import com.wire.kalium.logic.feature.session.CurrentSessionResult
 import dagger.hilt.android.AndroidEntryPoint
 import dev.ahmedmourad.bundlizer.Bundlizer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import kotlinx.serialization.Serializable
-import java.util.concurrent.atomic.AtomicReference
 import javax.inject.Inject
 
 /**
@@ -68,27 +54,23 @@ import javax.inject.Inject
 class CallService : Service() {
 
     @Inject
-    @KaliumCoreLogic
-    lateinit var coreLogic: CoreLogic
+    lateinit var lifecycleManager: CallServiceManager
 
     @Inject
     lateinit var callNotificationManager: CallNotificationManager
 
     @Inject
     lateinit var dispatcherProvider: DispatcherProvider
 
-    @Inject
-    @NoSession
-    lateinit var qualifiedIdMapper: QualifiedIdMapper
-
     private val scope by lazy {
         // There's no UI, no need to run anything using the Main/UI Dispatcher
         CoroutineScope(SupervisorJob() + dispatcherProvider.default())
     }
 
     override fun onCreate() {
-        serviceState.set(ServiceState.STARTED)
+        _serviceState.value = ServiceState.STARTED
         super.onCreate()
+        handleActions()
     }
 
     override fun onBind(intent: Intent?): IBinder? {
@@ -97,70 +79,35 @@ class CallService : Service() {
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         appLogger.i("$TAG: onStartCommand")
-        val action = intent?.getActionTypeExtra(EXTRA_ACTION_TYPE)
+        val action = intent?.getActionTypeExtra(EXTRA_ACTION_TYPE) ?: Action.Start.Default
         generatePlaceholderForegroundNotification()
-        serviceState.set(ServiceState.FOREGROUND)
-        if (action is Action.Stop) {
-            appLogger.i("$TAG: stopSelf. Reason: stopService was called")
-            stopSelf()
-        } else {
-            scope.launch {
-                if (action is Action.AnswerCall) {
-                    coreLogic.getSessionScope(action.userId).calls.answerCall(action.conversationId)
-                }
-                coreLogic.getGlobalScope().session.currentSessionFlow()
-                    .flatMapLatest {
-                        if (it is CurrentSessionResult.Success && it.accountInfo.isValid()) {
-                            val userId = it.accountInfo.userId
-                            val userSessionScope = coreLogic.getSessionScope(userId)
-                            val outgoingCallsFlow = userSessionScope.calls.observeOutgoingCall()
-                            val establishedCallsFlow = userSessionScope.calls.establishedCall()
-                            val callCurrentlyBeingAnsweredFlow = userSessionScope.calls.observeCallCurrentlyBeingAnswered(action)
-
-                            combine(
-                                outgoingCallsFlow,
-                                establishedCallsFlow,
-                                callCurrentlyBeingAnsweredFlow
-                            ) { outgoingCalls, establishedCalls, answeringCall ->
-                                val calls = outgoingCalls + establishedCalls + answeringCall
-                                calls.firstOrNull()?.let { call ->
-                                    val userName = userSessionScope.users.observeSelfUser().first()
-                                        .also { it.logIfEmptyUserName() }
-                                        .let { it.handle ?: it.name ?: "" }
-                                    Either.Right(CallNotificationData(userId, call, userName))
-                                } ?: Either.Left("no calls")
-                            }
-                        } else {
-                            flowOf(Either.Left("no valid current session"))
-                        }
-                    }
-                    .distinctUntilChanged()
-                    .debounce {
-                        if (it is Either.Left) ServicesManager.DEBOUNCE_TIME else 0L
-                    }
-                    .collectLatest {
-                        it.fold(
-                            { reason ->
-                                appLogger.i("$TAG: stopSelf. Reason: $reason")
-                                stopSelf()
-                            },
-                            { data ->
-                                updateForegroundNotification(data)
-                            }
-                        )
-                    }
-            }
+        _serviceState.value = ServiceState.FOREGROUND
+        scope.launch {
+            lifecycleManager.handleAction(action)
         }
         return START_STICKY
     }
 
     override fun onDestroy() {
         appLogger.i("$TAG: onDestroy")
-        serviceState.set(ServiceState.NOT_STARTED)
+        _serviceState.value = ServiceState.NOT_STARTED
         super.onDestroy()
         scope.cancel()
     }
 
+    private fun handleActions() {
+        scope.launch {
+            lifecycleManager.handleActionsFlow().collectLatest {
+                it.fold({ reason ->
+                    appLogger.i("$TAG: stopSelf. Reason: ${reason.message}")
+                    stopSelf()
+                }, { data ->
+                    updateForegroundNotification(data)
+                })
+            }
+        }
+    }
+
     private fun updateForegroundNotification(data: CallNotificationData) {
         // Updating service notification when notifications are disabled (or background work restricted)
         // causes app crash when putting app in background
@@ -190,40 +137,40 @@ class CallService : Service() {
         appLogger.i("$TAG: started foreground with placeholder notification")
     }
 
-    private suspend fun CallsScope.observeCallCurrentlyBeingAnswered(action: Action?) = when (action) {
-        is Action.AnswerCall -> getIncomingCalls().map { it.filter { it.conversationId == action.conversationId } }
-        else -> flowOf(emptyList())
-    }
-
     companion object {
         private const val TAG = "CallService"
         private const val EXTRA_ACTION_TYPE = "action_type"
 
-        fun newIntent(context: Context, actionType: Action = Action.Default): Intent = Intent(context, CallService::class.java)
+        fun newIntent(context: Context, actionType: Action = Action.Start.Default): Intent = Intent(context, CallService::class.java)
             .putExtra(EXTRA_ACTION_TYPE, actionType)
 
-        val serviceState: AtomicReference<ServiceState> = AtomicReference(ServiceState.NOT_STARTED)
+        private val _serviceState: MutableStateFlow<ServiceState> = MutableStateFlow(ServiceState.NOT_STARTED)
+        val serviceState: StateFlow<ServiceState> = _serviceState
     }
 
     enum class ServiceState {
         NOT_STARTED, STARTED, FOREGROUND
     }
 
     @Serializable
-    sealed class Action {
+    sealed interface Action {
         @Serializable
-        data object Default : Action()
+        sealed interface Start : Action {
 
-        @Serializable
-        data class AnswerCall(val userId: UserId, val conversationId: ConversationId) : Action()
+            @Serializable
+            data object Default : Start
+
+            @Serializable
+            data class AnswerCall(val userId: UserId, val conversationId: ConversationId) : Start
+        }
 
         @Serializable
-        data object Stop : Action()
+        data object Stop : Action
     }
 }
 
 private fun Intent.putExtra(name: String, actionType: Action): Intent = putExtra(name, Bundlizer.bundle(Action.serializer(), actionType))
 
 private fun Intent.getActionTypeExtra(name: String): Action? = getBundleExtra(name)?.let {
-        Bundlizer.unbundle(Action.serializer(), it)
-    }
+    Bundlizer.unbundle(Action.serializer(), it)
+}