chore: app start time improvement (#WPB-14874)

app/src/main/kotlin/com/wire/android/navigation/LoginTypeSelector.kt

@@ -22,6 +22,7 @@ import com.wire.android.di.KaliumCoreLogic
 import com.wire.kalium.logic.CoreLogic
 import com.wire.kalium.logic.configuration.server.ServerConfig
 import com.wire.kalium.logic.feature.auth.LoginContext
+import dagger.Lazy
 import kotlinx.coroutines.flow.first
 import javax.inject.Inject
 import javax.inject.Named
@@ -33,14 +34,15 @@ import javax.inject.Singleton
  */
 @Singleton
 class LoginTypeSelector @Inject constructor(
-    @KaliumCoreLogic private val coreLogic: CoreLogic,
+    @KaliumCoreLogic private val coreLogic: Lazy<CoreLogic>,
     @Named("useNewLoginForDefaultBackend") private val useNewLoginForDefaultBackend: Boolean,
 ) {
 
     /**
      * Observe the [LoginContext] for the given [ServerConfig.Links].
      */
-    private suspend fun loginContextFlow(serverLinks: ServerConfig.Links) = coreLogic.getGlobalScope().observeLoginContext(serverLinks)
+    private suspend fun loginContextFlow(serverLinks: ServerConfig.Links) =
+        coreLogic.get().getGlobalScope().observeLoginContext(serverLinks)
 
     /**
      *  Determine if the new login flow can be used for the given [ServerConfig.Links].

app/src/main/kotlin/com/wire/android/ui/CallFeedbackViewModel.kt

@@ -32,6 +32,7 @@ import com.wire.kalium.logic.data.user.UserId
 import com.wire.kalium.logic.feature.session.CurrentSessionFlowUseCase
 import com.wire.kalium.logic.feature.session.CurrentSessionResult
 import com.wire.kalium.logic.feature.user.ShouldAskCallFeedbackUseCaseResult
+import dagger.Lazy
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.collectLatest
@@ -45,10 +46,10 @@ import javax.inject.Inject
 
 @HiltViewModel
 class CallFeedbackViewModel @Inject constructor(
-    @KaliumCoreLogic private val coreLogic: CoreLogic,
-    private val currentSessionFlow: CurrentSessionFlowUseCase,
-    private val isAnalyticsAvailable: IsAnalyticsAvailableUseCase,
-    private val analyticsManager: AnonymousAnalyticsManager,
+    @KaliumCoreLogic private val coreLogic: Lazy<CoreLogic>,
+    private val currentSessionFlow: Lazy<CurrentSessionFlowUseCase>,
+    private val isAnalyticsAvailable: Lazy<IsAnalyticsAvailableUseCase>,
+    private val analyticsManager: Lazy<AnonymousAnalyticsManager>,
 ) : ViewModel() {
 
     val showCallFeedbackFlow = MutableSharedFlow<Unit>()
@@ -62,32 +63,32 @@ class CallFeedbackViewModel @Inject constructor(
     }
 
     private suspend fun observeAskCallFeedback() {
-        currentSessionFlow()
+        currentSessionFlow.get().invoke()
             .distinctUntilChanged()
             .flatMapLatest { session ->
                 if (session is CurrentSessionResult.Success && session.accountInfo.isValid()) {
                     currentUserId = session.accountInfo.userId
-                    coreLogic.getSessionScope(currentUserId!!).observeSyncState()
+                    coreLogic.get().getSessionScope(currentUserId!!).observeSyncState()
                 } else {
                     currentUserId = null
                     emptyFlow()
                 }
             }
             .filter { it == SyncState.Live }
             .flatMapLatest {
-                coreLogic.getSessionScope(currentUserId!!).calls.observeAskCallFeedbackUseCase()
+                coreLogic.get().getSessionScope(currentUserId!!).calls.observeAskCallFeedbackUseCase()
             }
             .collectLatest { shouldAskFeedback ->
-                if (isAnalyticsAvailable(currentUserId!!)) {
+                if (isAnalyticsAvailable.get().invoke(currentUserId!!)) {
                     when (shouldAskFeedback) {
                         is ShouldAskCallFeedbackUseCaseResult.ShouldAskCallFeedback -> {
                             showCallFeedbackFlow.emit(Unit)
                         }
 
                         is ShouldAskCallFeedbackUseCaseResult.ShouldNotAskCallFeedback.CallDurationIsLessThanOneMinute -> {
                             val recentlyEndedCallMetadata =
-                                coreLogic.getSessionScope(currentUserId!!).calls.observeRecentlyEndedCallMetadata().first()
-                            analyticsManager.sendEvent(
+                                coreLogic.get().getSessionScope(currentUserId!!).calls.observeRecentlyEndedCallMetadata().first()
+                            analyticsManager.get().sendEvent(
                                 with(recentlyEndedCallMetadata) {
                                     AnalyticsEvent.CallQualityFeedback.TooShort(
                                         callDuration = shouldAskFeedback.callDurationInSeconds.toInt(),
@@ -102,8 +103,8 @@ class CallFeedbackViewModel @Inject constructor(
 
                         is ShouldAskCallFeedbackUseCaseResult.ShouldNotAskCallFeedback.NextTimeForCallFeedbackIsNotReached -> {
                             val recentlyEndedCallMetadata =
-                                coreLogic.getSessionScope(currentUserId!!).calls.observeRecentlyEndedCallMetadata().first()
-                            analyticsManager.sendEvent(
+                                coreLogic.get().getSessionScope(currentUserId!!).calls.observeRecentlyEndedCallMetadata().first()
+                            analyticsManager.get().sendEvent(
                                 with(recentlyEndedCallMetadata) {
                                     AnalyticsEvent.CallQualityFeedback.Muted(
                                         callDuration = shouldAskFeedback.callDurationInSeconds.toInt(),
@@ -123,8 +124,8 @@ class CallFeedbackViewModel @Inject constructor(
     fun rateCall(rate: Int, doNotAsk: Boolean) {
         currentUserId?.let {
             viewModelScope.launch {
-                val recentlyEndedCallMetadata = coreLogic.getSessionScope(it).calls.observeRecentlyEndedCallMetadata().first()
-                analyticsManager.sendEvent(
+                val recentlyEndedCallMetadata = coreLogic.get().getSessionScope(it).calls.observeRecentlyEndedCallMetadata().first()
+                analyticsManager.get().sendEvent(
                     with(recentlyEndedCallMetadata) {
                         AnalyticsEvent.CallQualityFeedback.Answered(
                             score = rate,
@@ -136,17 +137,17 @@ class CallFeedbackViewModel @Inject constructor(
                         )
                     }
                 )
-                coreLogic.getSessionScope(it).calls.updateNextTimeCallFeedback(doNotAsk)
+                coreLogic.get().getSessionScope(it).calls.updateNextTimeCallFeedback(doNotAsk)
             }
         }
     }
 
     fun skipCallFeedback(doNotAsk: Boolean) {
         currentUserId?.let {
             viewModelScope.launch {
-                val recentlyEndedCallMetadata = coreLogic.getSessionScope(it).calls.observeRecentlyEndedCallMetadata().first()
-                coreLogic.getSessionScope(it).calls.updateNextTimeCallFeedback(doNotAsk)
-                analyticsManager.sendEvent(
+                val recentlyEndedCallMetadata = coreLogic.get().getSessionScope(it).calls.observeRecentlyEndedCallMetadata().first()
+                coreLogic.get().getSessionScope(it).calls.updateNextTimeCallFeedback(doNotAsk)
+                analyticsManager.get().sendEvent(
                     with(recentlyEndedCallMetadata) {
                         AnalyticsEvent.CallQualityFeedback.Dismissed(
                             callDuration = callDetails.callDurationInSeconds.toInt(),

app/src/main/kotlin/com/wire/android/ui/WireActivityViewModel.kt

@@ -104,7 +104,7 @@
 @OptIn(ExperimentalCoroutinesApi::class)
 @HiltViewModel
 class WireActivityViewModel @Inject constructor(
-    @KaliumCoreLogic private val coreLogic: CoreLogic,
+    @KaliumCoreLogic private val coreLogic: Lazy<CoreLogic>,
     private val dispatchers: DispatcherProvider,
     currentSessionFlow: Lazy<CurrentSessionFlowUseCase>,
     private val doesValidSessionExist: Lazy<DoesValidSessionExistUseCase>,
@@ -288,11 +288,11 @@
         data: InputStream
     ) {
         viewModelScope.launch(dispatchers.io()) {
-            when (val currentSession = coreLogic.getGlobalScope().session.currentSession()) {
+            when (val currentSession = coreLogic.get().getGlobalScope().session.currentSession()) {
                 is CurrentSessionResult.Failure.Generic -> null
                 CurrentSessionResult.Failure.SessionNotFound -> null
                 is CurrentSessionResult.Success -> {
-                    coreLogic.sessionScope(currentSession.accountInfo.userId) {
+                    coreLogic.get().sessionScope(currentSession.accountInfo.userId) {
                         when (val result = debug.synchronizeExternalData(InputStreamReader(data).readText())) {
                             is SynchronizeExternalDataResult.Success -> {
                                 appLogger.d("Synchronized external data")
@@ -358,11 +358,11 @@
         switchAccountActions: SwitchAccountActions
     ) {
         viewModelScope.launch {
-            coreLogic.getGlobalScope().session.currentSession().takeIf {
+            coreLogic.get().getGlobalScope().session.currentSession().takeIf {
                 it is CurrentSessionResult.Success
             }?.let {
                 val currentUserId = (it as CurrentSessionResult.Success).accountInfo.userId
-                coreLogic.getSessionScope(currentUserId).logout(LogoutReason.SELF_HARD_LOGOUT)
+                coreLogic.get().getSessionScope(currentUserId).logout(LogoutReason.SELF_HARD_LOGOUT)
                 clearUserData(currentUserId)
             }
             accountSwitch.get().invoke(SwitchAccountParam.TryToSwitchToNextAccount).also {
@@ -439,11 +439,11 @@
         key: String,
         domain: String?,
         onSuccess: (ConversationId) -> Unit
-    ) = when (val currentSession = coreLogic.getGlobalScope().session.currentSession()) {
+    ) = when (val currentSession = coreLogic.get().getGlobalScope().session.currentSession()) {
         is CurrentSessionResult.Failure.Generic -> null
         CurrentSessionResult.Failure.SessionNotFound -> null
         is CurrentSessionResult.Success -> {
-            coreLogic.sessionScope(currentSession.accountInfo.userId) {
+            coreLogic.get().sessionScope(currentSession.accountInfo.userId) {
                 when (val result = conversations.checkIConversationInviteCode(code, key, domain)) {
                     is CheckConversationInviteCodeUseCase.Result.Success -> {
                         if (result.isSelfMember) {
@@ -485,7 +485,7 @@
 
     fun observePersistentConnectionStatus() {
         viewModelScope.launch {
-            coreLogic.getGlobalScope().observePersistentWebSocketConnectionStatus()
+            coreLogic.get().getGlobalScope().observePersistentWebSocketConnectionStatus()
                 .let { result ->
                     when (result) {
                         is ObservePersistentWebSocketConnectionStatusUseCase.Result.Failure -> {

app/src/main/kotlin/com/wire/android/ui/analytics/AnalyticsUsageViewModel.kt

@@ -25,6 +25,7 @@ import androidx.lifecycle.viewModelScope
 import com.wire.android.datastore.UserDataStore
 import com.wire.kalium.logic.configuration.server.ServerConfig
 import com.wire.kalium.logic.feature.user.SelfServerConfigUseCase
+import dagger.Lazy
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
@@ -33,18 +34,18 @@ import javax.inject.Inject
 @HiltViewModel
 class AnalyticsUsageViewModel @Inject constructor(
     private val analyticsEnabled: AnalyticsConfiguration,
-    private val dataStore: UserDataStore,
-    private val selfServerConfig: SelfServerConfigUseCase
+    private val dataStore: Lazy<UserDataStore>,
+    private val selfServerConfig: Lazy<SelfServerConfigUseCase>,
 ) : ViewModel() {
 
     var state by mutableStateOf(AnalyticsUsageState())
 
     init {
         viewModelScope.launch {
-            val isDialogSeen = dataStore.isAnalyticsDialogSeen().first()
-            val isAnalyticsUsageEnabled = dataStore.isAnonymousUsageDataEnabled().first()
+            val isDialogSeen = dataStore.get().isAnalyticsDialogSeen().first()
+            val isAnalyticsUsageEnabled = dataStore.get().isAnonymousUsageDataEnabled().first()
             val isAnalyticsConfigurationEnabled = analyticsEnabled is AnalyticsConfiguration.Enabled
-            val isValidBackend = when (val serverConfig = selfServerConfig()) {
+            val isValidBackend = when (val serverConfig = selfServerConfig.get().invoke()) {
                 is SelfServerConfigUseCase.Result.Success ->
                     serverConfig.serverLinks.links.api == ServerConfig.PRODUCTION.api
                             || serverConfig.serverLinks.links.api == ServerConfig.STAGING.api
@@ -61,17 +62,17 @@ class AnalyticsUsageViewModel @Inject constructor(
 
     fun agreeAnalyticsUsage() {
         viewModelScope.launch {
-            dataStore.setIsAnonymousAnalyticsEnabled(enabled = true)
-            dataStore.setIsAnalyticsDialogSeen()
+            dataStore.get().setIsAnonymousAnalyticsEnabled(enabled = true)
+            dataStore.get().setIsAnalyticsDialogSeen()
 
             hideDialog()
         }
     }
 
     fun declineAnalyticsUsage() {
         viewModelScope.launch {
-            dataStore.setIsAnonymousAnalyticsEnabled(enabled = false)
-            dataStore.setIsAnalyticsDialogSeen()
+            dataStore.get().setIsAnonymousAnalyticsEnabled(enabled = false)
+            dataStore.get().setIsAnalyticsDialogSeen()
 
             hideDialog()
         }

app/src/main/kotlin/com/wire/android/ui/common/topappbar/CommonTopAppBarViewModel.kt

@@ -37,6 +37,7 @@ import com.wire.kalium.logic.data.sync.SyncState.Waiting
 import com.wire.kalium.logic.data.user.UserId
 import com.wire.kalium.logic.feature.session.CurrentSessionResult
 import com.wire.kalium.network.NetworkState
+import dagger.Lazy
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.collectLatest
@@ -52,7 +53,7 @@ import javax.inject.Inject
 @HiltViewModel
 class CommonTopAppBarViewModel @Inject constructor(
     private val currentScreenManager: CurrentScreenManager,
-    @KaliumCoreLogic private val coreLogic: CoreLogic
+    @KaliumCoreLogic private val coreLogic: Lazy<CoreLogic>,
 ) : ViewModel() {
 
     var state by mutableStateOf(CommonTopAppBarState())
@@ -62,8 +63,8 @@ class CommonTopAppBarViewModel @Inject constructor(
         currentScreenManager.observeCurrentScreen(viewModelScope)
 
     private fun connectivityFlow(userId: UserId): Flow<Connectivity> =
-        coreLogic.sessionScope(userId) {
-            combine(observeSyncState(), coreLogic.networkStateObserver.observeNetworkState()) { syncState, networkState ->
+        coreLogic.get().sessionScope(userId) {
+            combine(observeSyncState(), coreLogic.get().networkStateObserver.observeNetworkState()) { syncState, networkState ->
                 when (syncState) {
                     is Waiting -> Connectivity.WaitingConnection(null, null)
                     is Failed -> Connectivity.WaitingConnection(syncState.cause, syncState.retryDelay)
@@ -82,7 +83,7 @@ class CommonTopAppBarViewModel @Inject constructor(
 
     @VisibleForTesting
     internal suspend fun activeCallsFlow(userId: UserId): Flow<List<Call>> =
-        coreLogic.sessionScope(userId) {
+        coreLogic.get().sessionScope(userId) {
             combine(
                 calls.establishedCall(),
                 calls.getIncomingCalls(),
@@ -94,7 +95,7 @@ class CommonTopAppBarViewModel @Inject constructor(
 
     init {
         viewModelScope.launch {
-            coreLogic.globalScope {
+            coreLogic.get().globalScope {
                 session.currentSessionFlow()
                     .flatMapLatest {
                         when (it) {
@@ -134,7 +135,7 @@ class CommonTopAppBarViewModel @Inject constructor(
                         state = state.copy(connectivityState = connectivityUIState)
                     }
             }
-            coreLogic.networkStateObserver.observeNetworkState().collectLatest {
+            coreLogic.get().networkStateObserver.observeNetworkState().collectLatest {
                 state = state.copy(networkState = it)
             }
         }

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

@@ -31,6 +31,7 @@ import com.wire.kalium.logic.data.user.type.UserType
 import com.wire.kalium.logic.feature.conversation.ObserveArchivedUnreadConversationsCountUseCase
 import com.wire.kalium.logic.feature.server.GetTeamUrlUseCase
 import com.wire.kalium.logic.feature.user.ObserveSelfUserUseCase
+import dagger.Lazy
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
@@ -42,10 +43,10 @@ import javax.inject.Inject
 @HiltViewModel
 class HomeDrawerViewModel @Inject constructor(
     val savedStateHandle: SavedStateHandle,
-    private val observeArchivedUnreadConversationsCount: ObserveArchivedUnreadConversationsCountUseCase,
+    private val observeArchivedUnreadConversationsCount: Lazy<ObserveArchivedUnreadConversationsCountUseCase>,
     private val observeSelfUser: ObserveSelfUserUseCase,
     private val getTeamUrl: GetTeamUrlUseCase,
-    private val globalDataStore: GlobalDataStore,
+    private val globalDataStore: Lazy<GlobalDataStore>,
 ) : ViewModel() {
 
     var drawerState by mutableStateOf(HomeDrawerState())
@@ -78,8 +79,8 @@ class HomeDrawerViewModel @Inject constructor(
     private fun buildDrawerItems() {
         viewModelScope.launch {
             combine(
-                globalDataStore.wireCellsEnabled(),
-                observeArchivedUnreadConversationsCount(),
+                globalDataStore.get().wireCellsEnabled(),
+                observeArchivedUnreadConversationsCount.get().invoke(),
                 observeTeamManagementUrlForUser()
             ) { wireCellsEnabled, unreadArchiveConversationsCount, teamManagementUrl ->
                 buildList {