refactor: remove not needed usage of observe self user [WPB-15414]

app/src/main/kotlin/com/wire/android/ui/home/HomeViewModel.kt

@@ -37,10 +37,10 @@ import com.wire.kalium.logic.feature.client.NeedsToRegisterClientUseCase
 import com.wire.kalium.logic.feature.legalhold.LegalHoldStateForSelfUser
 import com.wire.kalium.logic.feature.legalhold.ObserveLegalHoldStateForSelfUserUseCase
 import com.wire.kalium.logic.feature.personaltoteamaccount.CanMigrateFromPersonalToTeamUseCase
+import com.wire.kalium.logic.feature.user.GetSelfUserUseCase
 import com.wire.kalium.logic.feature.user.ObserveSelfUserUseCase
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
@@ -50,12 +50,13 @@ class HomeViewModel @Inject constructor(
     override val savedStateHandle: SavedStateHandle,
     private val globalDataStore: GlobalDataStore,
     private val dataStore: UserDataStore,
+    private val getSelfUser: GetSelfUserUseCase,
     private val observeSelf: ObserveSelfUserUseCase,
     private val needsToRegisterClient: NeedsToRegisterClientUseCase,
     private val canMigrateFromPersonalToTeam: CanMigrateFromPersonalToTeamUseCase,
     private val observeLegalHoldStatusForSelfUser: ObserveLegalHoldStateForSelfUserUseCase,
     private val shouldTriggerMigrationForUser: ShouldTriggerMigrationForUserUserCase,
-    private val analyticsManager: AnonymousAnalyticsManager
+    private val analyticsManager: AnonymousAnalyticsManager,
 ) : SavedStateViewModel(savedStateHandle) {
 
     @VisibleForTesting
@@ -97,7 +98,7 @@ class HomeViewModel @Inject constructor(
 
     fun checkRequirements(onRequirement: (HomeRequirement) -> Unit) {
         viewModelScope.launch {
-            val selfUser = observeSelf().first()
+            val selfUser = getSelfUser() ?: return@launch
             when {
                 shouldTriggerMigrationForUser(selfUser.id) ->
                     onRequirement(HomeRequirement.Migration(selfUser.id))

app/src/main/kotlin/com/wire/android/ui/home/newconversation/NewConversationViewModel.kt

@@ -39,20 +39,19 @@ import com.wire.kalium.logic.data.user.UserId
 import com.wire.kalium.logic.data.user.type.UserType
 import com.wire.kalium.logic.feature.conversation.CreateGroupConversationUseCase
 import com.wire.kalium.logic.feature.user.GetDefaultProtocolUseCase
-import com.wire.kalium.logic.feature.user.ObserveSelfUserUseCase
+import com.wire.kalium.logic.feature.user.GetSelfUserUseCase
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.collections.immutable.toImmutableSet
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.dropWhile
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @Suppress("LongParameterList", "TooManyFunctions")
 @HiltViewModel
 class NewConversationViewModel @Inject constructor(
     private val createGroupConversation: CreateGroupConversationUseCase,
-    private val observeSelfUser: ObserveSelfUserUseCase,
+    private val getSelfUser: GetSelfUserUseCase,
     getDefaultProtocol: GetDefaultProtocolUseCase
 ) : ViewModel() {
 
@@ -78,16 +77,20 @@ class NewConversationViewModel @Inject constructor(
     var createGroupState: CreateGroupState by mutableStateOf(CreateGroupState())
 
     init {
+        setConversationCreationParam()
+        observeGroupNameChanges()
+    }
+
+    private fun setConversationCreationParam() {
         viewModelScope.launch {
-            val selfUser = observeSelfUser().first()
-            val isSelfTeamMember = selfUser.teamId != null
-            val isSelfExternalTeamMember = selfUser.userType == UserType.EXTERNAL
+            val selfUser = getSelfUser()
+            val isSelfTeamMember = selfUser?.teamId != null
+            val isSelfExternalTeamMember = selfUser?.userType == UserType.EXTERNAL
             newGroupState = newGroupState.copy(
                 isSelfTeamMember = isSelfTeamMember,
                 isGroupCreatingAllowed = !isSelfExternalTeamMember
             )
         }
-        observeGroupNameChanges()
     }
 
     private fun observeGroupNameChanges() {

app/src/main/kotlin/com/wire/android/ui/settings/devices/e2ei/E2eiCertificateDetailsViewModel.kt

@@ -22,30 +22,29 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.wire.android.ui.navArgs
 import com.wire.android.util.fileDateTime
-import com.wire.kalium.logic.feature.user.ObserveSelfUserUseCase
+import com.wire.kalium.logic.feature.user.GetSelfUserUseCase
 import com.wire.kalium.util.DateTimeUtil
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltViewModel
 class E2eiCertificateDetailsViewModel @Inject constructor(
     savedStateHandle: SavedStateHandle,
-    private val observerSelfUser: ObserveSelfUserUseCase,
+    private val getSelfUser: GetSelfUserUseCase,
 ) : ViewModel() {
     private val navArgs: E2eiCertificateDetailsScreenNavArgs =
         savedStateHandle.navArgs()
 
     private var selfUserHandle: String? = null
 
     init {
-        getSelfUserId()
+        getSelfUserHandle()
     }
 
-    private fun getSelfUserId() {
+    private fun getSelfUserHandle() {
         viewModelScope.launch {
-            selfUserHandle = observerSelfUser().first().handle
+            selfUserHandle = getSelfUser()?.handle
         }
     }
 

app/src/main/kotlin/com/wire/android/ui/sharing/ImportMediaAuthenticatedViewModel.kt

@@ -115,12 +115,10 @@ class ImportMediaAuthenticatedViewModel @Inject constructor(
         importMediaState = importMediaState.copy(importedAssets = importMediaState.importedAssets.removeAt(index))
     }
 
-    private fun loadUserAvatar() = viewModelScope.launch(dispatchers.io()) {
+    private fun loadUserAvatar() = viewModelScope.launch {
         getSelf().collect { selfUser ->
-            withContext(dispatchers.main()) {
-                avatarAsset = selfUser.previewPicture?.let {
-                    ImageAsset.UserAvatarAsset(it)
-                }
+            avatarAsset = selfUser.previewPicture?.let {
+                ImageAsset.UserAvatarAsset(it)
             }
         }
     }
@@ -225,6 +223,7 @@ class ImportMediaAuthenticatedViewModel @Inject constructor(
                 appLogger.e("$TAG: Failed to import asset message: Unknown error")
                 null
             }
+
             is HandleUriAssetUseCase.Result.Success -> ImportedMediaAsset(result.assetBundle, null)
         }
     }

app/src/main/kotlin/com/wire/android/ui/userprofile/service/ServiceDetailsViewModel.kt

@@ -23,6 +23,7 @@ import androidx.compose.runtime.setValue
 import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.wire.android.di.CurrentAccount
 import com.wire.android.model.ImageAsset
 import com.wire.android.ui.home.conversations.details.participants.usecase.ObserveConversationRoleForUserUseCase
 import com.wire.android.ui.navArgs
@@ -38,15 +39,13 @@ import com.wire.kalium.logic.feature.conversation.AddServiceToConversationUseCas
 import com.wire.kalium.logic.feature.conversation.RemoveMemberFromConversationUseCase
 import com.wire.kalium.logic.feature.service.GetServiceByIdUseCase
 import com.wire.kalium.logic.feature.service.ObserveIsServiceMemberUseCase
-import com.wire.kalium.logic.feature.user.ObserveSelfUserUseCase
 import com.wire.kalium.logic.functional.Either
 import com.wire.kalium.logic.functional.nullableFold
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
@@ -57,22 +56,20 @@ import javax.inject.Inject
 @HiltViewModel
 class ServiceDetailsViewModel @Inject constructor(
     private val dispatchers: DispatcherProvider,
-    private val observeSelfUser: ObserveSelfUserUseCase,
+    @CurrentAccount private val selfUserId: UserId,
     private val getServiceById: GetServiceByIdUseCase,
     private val observeIsServiceMember: ObserveIsServiceMemberUseCase,
     private val observeConversationRoleForUser: ObserveConversationRoleForUserUseCase,
     private val removeMemberFromConversation: RemoveMemberFromConversationUseCase,
     private val addServiceToConversation: AddServiceToConversationUseCase,
-    private val serviceDetailsMapper: ServiceDetailsMapper,
+    serviceDetailsMapper: ServiceDetailsMapper,
     savedStateHandle: SavedStateHandle
 ) : ViewModel() {
 
     private val serviceDetailsNavArgs: ServiceDetailsNavArgs = savedStateHandle.navArgs()
     private val serviceId: ServiceId = serviceDetailsMapper.fromBotServiceToServiceId(serviceDetailsNavArgs.botService)
     private val conversationId: QualifiedID = serviceDetailsNavArgs.conversationId
 
-    private lateinit var selfUserId: UserId
-
     var serviceDetailsState by mutableStateOf(ServiceDetailsState())
     private val _infoMessage = MutableSharedFlow<UIText>()
     val infoMessage = _infoMessage.asSharedFlow()
@@ -86,7 +83,6 @@ class ServiceDetailsViewModel @Inject constructor(
                 isAvatarLoading = true
             )
 
-            selfUserId = observeSelfUser().first().id
             getServiceDetailsAndUpdateViewState()?.let {
                 observeIsServiceConversationMember()
             }

app/src/test/kotlin/com/wire/android/ui/home/HomeViewModelTest.kt

@@ -31,6 +31,7 @@ import com.wire.kalium.logic.feature.client.NeedsToRegisterClientUseCase
 import com.wire.kalium.logic.feature.legalhold.LegalHoldStateForSelfUser
 import com.wire.kalium.logic.feature.legalhold.ObserveLegalHoldStateForSelfUserUseCase
 import com.wire.kalium.logic.feature.personaltoteamaccount.CanMigrateFromPersonalToTeamUseCase
+import com.wire.kalium.logic.feature.user.GetSelfUserUseCase
 import com.wire.kalium.logic.feature.user.ObserveSelfUserUseCase
 import io.mockk.MockKAnnotations
 import io.mockk.coEvery
@@ -126,7 +127,10 @@ class HomeViewModelTest {
         lateinit var dataStore: UserDataStore
 
         @MockK
-        lateinit var getSelf: ObserveSelfUserUseCase
+        lateinit var observeSelfUser: ObserveSelfUserUseCase
+
+        @MockK
+        lateinit var getSelf: GetSelfUserUseCase
 
         @MockK
         lateinit var needsToRegisterClient: NeedsToRegisterClientUseCase
@@ -148,12 +152,13 @@ class HomeViewModelTest {
                 savedStateHandle = savedStateHandle,
                 globalDataStore = globalDataStore,
                 dataStore = dataStore,
-                observeSelf = getSelf,
+                observeSelf = observeSelfUser,
                 needsToRegisterClient = needsToRegisterClient,
                 observeLegalHoldStatusForSelfUser = observeLegalHoldStatusForSelfUser,
                 shouldTriggerMigrationForUser = shouldTriggerMigrationForUser,
                 analyticsManager = analyticsManager,
-                canMigrateFromPersonalToTeam = canMigrateFromPersonalToTeam
+                canMigrateFromPersonalToTeam = canMigrateFromPersonalToTeam,
+                getSelfUser = getSelf,
             )
         }
 
@@ -164,7 +169,7 @@ class HomeViewModelTest {
         }
 
         fun withGetSelf(result: Flow<SelfUser>) = apply {
-            coEvery { getSelf.invoke() } returns result
+            coEvery { observeSelfUser.invoke() } returns result
         }
 
         private fun withCanMigrateFromPersonalToTeamReturning(result: Boolean) = apply {

app/src/test/kotlin/com/wire/android/ui/home/newconversation/NewConversationViewModelArrangement.kt

@@ -35,13 +35,12 @@ import com.wire.kalium.logic.data.user.UserAvailabilityStatus
 import com.wire.kalium.logic.data.user.type.UserType
 import com.wire.kalium.logic.feature.conversation.CreateGroupConversationUseCase
 import com.wire.kalium.logic.feature.user.GetDefaultProtocolUseCase
-import com.wire.kalium.logic.feature.user.ObserveSelfUserUseCase
+import com.wire.kalium.logic.feature.user.GetSelfUserUseCase
 import com.wire.kalium.logic.feature.user.IsMLSEnabledUseCase
 import io.mockk.MockKAnnotations
 import io.mockk.coEvery
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.flow.flowOf
 import kotlinx.datetime.Instant
 
 internal class NewConversationViewModelArrangement {
@@ -62,7 +61,7 @@ internal class NewConversationViewModelArrangement {
     lateinit var isMLSEnabledUseCase: IsMLSEnabledUseCase
 
     @MockK
-    lateinit var observeSelfUserUseCase: ObserveSelfUserUseCase
+    lateinit var getSelf: GetSelfUserUseCase
 
     @MockK(relaxed = true)
     lateinit var onGroupCreated: (ConversationId) -> Unit
@@ -172,10 +171,10 @@ internal class NewConversationViewModelArrangement {
     }
 
     fun withGetSelfUser(isTeamMember: Boolean, userType: UserType = UserType.INTERNAL) = apply {
-        coEvery { observeSelfUserUseCase() } returns flowOf(SELF_USER.copy(
+        coEvery { getSelf() } returns SELF_USER.copy(
             teamId = if (isTeamMember) TeamId("teamId") else null,
             userType = userType,
-        ))
+        )
     }
 
     fun withDefaultProtocol(supportedProtocol: SupportedProtocol) = apply {
@@ -184,7 +183,7 @@ internal class NewConversationViewModelArrangement {
 
     fun arrange() = this to NewConversationViewModel(
         createGroupConversation = createGroupConversation,
-        observeSelfUser = observeSelfUserUseCase,
+        getSelfUser = getSelf,
         getDefaultProtocol = getDefaultProtocol
     ).also {
         it.createGroupState = createGroupState

app/src/test/kotlin/com/wire/android/ui/userprofile/service/ServiceDetailsViewModelTest.kt

@@ -41,7 +41,6 @@ import com.wire.kalium.logic.feature.conversation.AddServiceToConversationUseCas
 import com.wire.kalium.logic.feature.conversation.RemoveMemberFromConversationUseCase
 import com.wire.kalium.logic.feature.service.GetServiceByIdUseCase
 import com.wire.kalium.logic.feature.service.ObserveIsServiceMemberUseCase
-import com.wire.kalium.logic.feature.user.ObserveSelfUserUseCase
 import com.wire.kalium.logic.functional.Either
 import io.mockk.MockKAnnotations
 import io.mockk.coEvery
@@ -282,9 +281,6 @@ class ServiceDetailsViewModelTest {
 
     private class Arrangement {
 
-        @MockK
-        lateinit var observeSelfUser: ObserveSelfUserUseCase
-
         @MockK
         lateinit var getServiceById: GetServiceByIdUseCase
 
@@ -305,10 +301,12 @@ class ServiceDetailsViewModelTest {
         @MockK
         lateinit var savedStateHandle: SavedStateHandle
 
+        private val selfUser = TestUser.SELF_USER
+
         private val viewModel by lazy {
             ServiceDetailsViewModel(
                 TestDispatcherProvider(),
-                observeSelfUser,
+                selfUserId = selfUser.id,
                 getServiceById,
                 observeIsServiceMember,
                 observeConversationRoleForUser,
@@ -322,32 +320,31 @@ class ServiceDetailsViewModelTest {
         init {
             MockKAnnotations.init(this, relaxUnitFun = true)
             mockUri()
-            coEvery { observeSelfUser() } returns flowOf(TestUser.SELF_USER)
         }
 
         fun withService(service: BotService) = apply {
             every { savedStateHandle.navArgs<ServiceDetailsNavArgs>() } returns ServiceDetailsNavArgs(service, CONVERSATION_ID)
         }
 
-        suspend fun withConversationRoleForUser(roleData: ConversationRoleData) = apply {
+        fun withConversationRoleForUser(roleData: ConversationRoleData) = apply {
             coEvery {
                 observeConversationRoleForUser.invoke(any(), any())
             } returns flowOf(roleData)
         }
 
-        suspend fun withServiceDetails(serviceDetails: ServiceDetails?) = apply {
+        fun withServiceDetails(serviceDetails: ServiceDetails?) = apply {
             coEvery { getServiceById(any()) } returns serviceDetails
         }
 
-        suspend fun withIsServiceMember(eitherMember: Either<StorageFailure, UserId?>) = apply {
+        fun withIsServiceMember(eitherMember: Either<StorageFailure, UserId?>) = apply {
             coEvery { observeIsServiceMember(any(), any()) } returns flowOf(eitherMember)
         }
 
-        suspend fun withRemoveService(result: RemoveMemberFromConversationUseCase.Result) = apply {
+        fun withRemoveService(result: RemoveMemberFromConversationUseCase.Result) = apply {
             coEvery { removeMemberFromConversation(any(), any()) } returns result
         }
 
-        suspend fun withAddService(result: AddServiceToConversationUseCase.Result) = apply {
+        fun withAddService(result: AddServiceToConversationUseCase.Result) = apply {
             coEvery { addServiceToConversation(any(), any()) } returns result
         }