refactor(logging): introduce custom FastLogger and replace direct Android logging

app/src/main/AndroidManifest.xml

@@ -3,7 +3,6 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />

app/src/main/kotlin/dev/meloda/fast/MainViewModel.kt

@@ -29,30 +29,61 @@ import dev.meloda.fast.navigation.Main
 import dev.meloda.fast.settings.navigation.Settings
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 
-class MainViewModel(
+interface MainViewModel {
+
+    val startDestination: StateFlow<Any?>
+    val isNeedToReplaceWithAuth: StateFlow<Boolean>
+    val currentUser: StateFlow<VkUser?>
+
+    val isNeedToShowNotificationsDeniedDialog: StateFlow<Boolean>
+    val isNeedToShowNotificationsRationaleDialog: StateFlow<Boolean>
+    val isNeedToCheckNotificationsPermission: StateFlow<Boolean>
+    val isNeedToRequestNotifications: StateFlow<Boolean>
+
+    fun onError(error: BaseError)
+
+    fun onNavigatedToAuth()
+
+    fun onAppResumed(intent: Intent)
+
+    @OptIn(ExperimentalPermissionsApi::class)
+    fun onPermissionCheckStatus(status: PermissionStatus)
+    fun onPermissionsRequested()
+
+    fun onNotificationsDeniedDialogConfirmClicked()
+    fun onNotificationsDeniedDialogCancelClicked()
+    fun onNotificationsDeniedDialogDismissed()
+    fun onNotificationsRationaleDialogDismissed()
+    fun onNotificationsRationaleDialogCancelClicked()
+
+    fun onUserAuthenticated()
+}
+
+class MainViewModelImpl(
     private val getCurrentAccountUseCase: GetCurrentAccountUseCase,
     private val loadUserByIdUseCase: LoadUserByIdUseCase,
     private val userSettings: UserSettings,
     private val longPollController: LongPollController,
     private val logger: FastLogger
-) : ViewModel() {
+) : MainViewModel, ViewModel() {
 
-    val startDestination = MutableStateFlow<Any?>(null)
-    val isNeedToReplaceWithAuth = MutableStateFlow(false)
-    val currentUser = MutableStateFlow<VkUser?>(null)
+    override val startDestination = MutableStateFlow<Any?>(null)
+    override val isNeedToReplaceWithAuth = MutableStateFlow(false)
+    override val currentUser = MutableStateFlow<VkUser?>(null)
 
-    val isNeedToShowNotificationsDeniedDialog = MutableStateFlow(false)
-    val isNeedToShowNotificationsRationaleDialog = MutableStateFlow(false)
-    val isNeedToCheckNotificationsPermission = MutableStateFlow(false)
-    val isNeedToRequestNotifications = MutableStateFlow(false)
+    override val isNeedToShowNotificationsDeniedDialog = MutableStateFlow(false)
+    override val isNeedToShowNotificationsRationaleDialog = MutableStateFlow(false)
+    override val isNeedToCheckNotificationsPermission = MutableStateFlow(false)
+    override val isNeedToRequestNotifications = MutableStateFlow(false)
 
     private var openNotificationsSettings = false
     private var openAppSettings = false
 
-    fun onError(error: BaseError) {
+    override fun onError(error: BaseError) {
         when (error) {
             BaseError.SessionExpired,
             BaseError.AccountBlocked -> {
@@ -63,11 +94,11 @@ class MainViewModel(
         }
     }
 
-    fun onNavigatedToAuth() {
+    override fun onNavigatedToAuth() {
         isNeedToReplaceWithAuth.update { false }
     }
 
-    fun onAppResumed(intent: Intent) {
+    override fun onAppResumed(intent: Intent) {
         openNotificationsSettings =
             intent.hasCategory(NotificationCompat.INTENT_CATEGORY_NOTIFICATION_PREFERENCES)
         openAppSettings =
@@ -94,7 +125,7 @@ class MainViewModel(
     }
 
     @ExperimentalPermissionsApi
-    fun onPermissionCheckStatus(status: PermissionStatus) {
+    override fun onPermissionCheckStatus(status: PermissionStatus) {
         isNeedToCheckNotificationsPermission.update { false }
 
         when (status) {
@@ -116,33 +147,33 @@ class MainViewModel(
         }
     }
 
-    fun onPermissionsRequested() {
+    override fun onPermissionsRequested() {
         isNeedToRequestNotifications.update { false }
     }
 
-    fun onNotificationsDeniedDialogConfirmClicked() {
+    override fun onNotificationsDeniedDialogConfirmClicked() {
         isNeedToRequestNotifications.update { true }
     }
 
-    fun onNotificationsDeniedDialogCancelClicked() {
+    override fun onNotificationsDeniedDialogCancelClicked() {
         isNeedToShowNotificationsDeniedDialog.update { false }
         disableBackgroundLongPoll()
     }
 
-    fun onNotificationsDeniedDialogDismissed() {
+    override fun onNotificationsDeniedDialogDismissed() {
         isNeedToShowNotificationsDeniedDialog.update { false }
     }
 
-    fun onNotificationsRationaleDialogDismissed() {
+    override fun onNotificationsRationaleDialogDismissed() {
         isNeedToShowNotificationsRationaleDialog.update { false }
     }
 
-    fun onNotificationsRationaleDialogCancelClicked() {
+    override fun onNotificationsRationaleDialogCancelClicked() {
         isNeedToShowNotificationsRationaleDialog.update { false }
         disableBackgroundLongPoll()
     }
 
-    fun onUserAuthenticated() {
+    override fun onUserAuthenticated() {
         loadProfile()
     }
 
@@ -171,17 +202,11 @@ class MainViewModel(
 
     private fun loadAccounts() {
         viewModelScope.launch(Dispatchers.IO) {
-            val currentAccount = getCurrentAccountUseCase()?.mapToDto()
+            val currentAccount = getCurrentAccountUseCase()
 
             logger.debug(
-                this@MainViewModel::class,
-                "loadAccounts(): currentAccount: %s"
-                    .format(
-                        currentAccount?.copy(
-                            accessToken = if (currentAccount.accessToken.isNotEmpty()) "<redacted>"
-                            else "null"
-                        )
-                    )
+                this@MainViewModelImpl::class,
+                "loadAccounts(): currentAccount: $currentAccount"
             )
 
             listenLongPollState()

app/src/main/kotlin/dev/meloda/fast/common/di/AndroidModule.kt

@@ -1,18 +0,0 @@
-package dev.meloda.fast.common.di
-
-import android.content.Context
-import android.content.res.Resources
-import android.net.ConnectivityManager
-import android.os.PowerManager
-import androidx.preference.PreferenceManager
-import org.koin.android.ext.koin.androidContext
-import org.koin.core.module.dsl.factoryOf
-import org.koin.dsl.module
-
-val androidModule = module {
-    // TODO: 14/05/2024, Danil Nikolaev: extract all operations with preferences to standalone class
-    factoryOf(PreferenceManager::getDefaultSharedPreferences)
-    factory<Resources> { androidContext().resources }
-    factory<PowerManager> { androidContext().getSystemService(Context.POWER_SERVICE) as PowerManager }
-    factory<ConnectivityManager> { androidContext().getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager }
-}

app/src/main/kotlin/dev/meloda/fast/common/di/ApplicationModule.kt

@@ -1,13 +1,16 @@
 package dev.meloda.fast.common.di
 
+import android.content.Context
+import android.content.res.Resources
+import android.os.PowerManager
+import androidx.preference.PreferenceManager
 import coil.ImageLoader
 import coil.annotation.ExperimentalCoilApi
-import dev.meloda.fast.MainViewModel
+import dev.meloda.fast.MainViewModelImpl
 import dev.meloda.fast.auth.authModule
 import dev.meloda.fast.chatmaterials.di.chatMaterialsModule
 import dev.meloda.fast.common.LongPollController
 import dev.meloda.fast.common.LongPollControllerImpl
-import dev.meloda.fast.common.NetworkStateListener
 import dev.meloda.fast.common.provider.Provider
 import dev.meloda.fast.common.provider.ResourceProvider
 import dev.meloda.fast.common.provider.ResourceProviderImpl
@@ -19,12 +22,11 @@ import dev.meloda.fast.languagepicker.di.languagePickerModule
 import dev.meloda.fast.logger.loggerModule
 import dev.meloda.fast.messageshistory.di.messagesHistoryModule
 import dev.meloda.fast.photoviewer.di.photoViewModule
-import dev.meloda.fast.presentation.NetworkObserver
 import dev.meloda.fast.profile.di.profileModule
 import dev.meloda.fast.provider.ApiLanguageProvider
 import dev.meloda.fast.service.longpolling.di.longPollModule
 import dev.meloda.fast.settings.di.settingsModule
-import org.koin.core.module.dsl.factoryOf
+import org.koin.android.ext.koin.androidContext
 import org.koin.core.module.dsl.singleOf
 import org.koin.core.module.dsl.viewModelOf
 import org.koin.core.qualifier.qualifier
@@ -49,24 +51,25 @@ val applicationModule = module {
     )
 
     includes(loggerModule)
-    includes(androidModule)
 
-    factoryOf(::ApiLanguageProvider) bind Provider::class
+    // TODO: 14/05/2024, Danil Nikolaev: extract all operations with preferences to standalone class
+    singleOf(PreferenceManager::getDefaultSharedPreferences)
+    single<Resources> { androidContext().resources }
+    factory<PowerManager> { androidContext().getSystemService(Context.POWER_SERVICE) as PowerManager }
 
-    viewModelOf(::MainViewModel) { qualifier = qualifier("main") }
+    singleOf(::ApiLanguageProvider) bind Provider::class
+
+    viewModelOf(::MainViewModelImpl) {
+        qualifier = qualifier("main")
+    }
 
     single<ImageLoader> {
         ImageLoader.Builder(get())
             .crossfade(true)
             .build()
-            .also {
-                it.diskCache?.directory?.toFile()?.listFiles()
-            }
+            .also { it.diskCache?.directory?.toFile()?.listFiles() }
     }
 
     singleOf(::LongPollControllerImpl) bind LongPollController::class
     singleOf(::ResourceProviderImpl) bind ResourceProvider::class
-
-    singleOf(::NetworkStateListener)
-    singleOf(::NetworkObserver) { qualifier = qualifier("main") }
 }

app/src/main/kotlin/dev/meloda/fast/presentation/MainActivity.kt

@@ -20,15 +20,14 @@ import androidx.core.content.ContextCompat
 import androidx.lifecycle.compose.LifecycleResumeEffect
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import dev.meloda.fast.MainViewModel
+import dev.meloda.fast.MainViewModelImpl
 import dev.meloda.fast.common.AppConstants
 import dev.meloda.fast.datastore.AppSettings
-import dev.meloda.fast.domain.LongPollEventsHandler
 import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.service.OnlineService
 import dev.meloda.fast.service.longpolling.LongPollingService
 import dev.meloda.fast.ui.R
 import dev.meloda.fast.ui.common.LocalLogger
-import org.koin.android.ext.android.get
 import org.koin.androidx.compose.koinViewModel
 import org.koin.compose.koinInject
 
@@ -69,7 +68,7 @@ class MainActivity : AppCompatActivity() {
         setContent {
             val logger: FastLogger = koinInject()
 
-            val viewModel: MainViewModel = koinViewModel()
+            val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
             LifecycleResumeEffect(true) {
                 viewModel.onAppResumed(intent)
                 onPauseOrDispose {}
@@ -182,7 +181,6 @@ class MainActivity : AppCompatActivity() {
     override fun onDestroy() {
         super.onDestroy()
         stopServices()
-        get<LongPollEventsHandler>().onDestroy()
     }
 
     companion object {

app/src/main/kotlin/dev/meloda/fast/presentation/NetworkObserver.kt

@@ -1,238 +0,0 @@
-package dev.meloda.fast.presentation
-
-import android.net.ConnectivityManager
-import android.net.LinkProperties
-import android.net.Network
-import android.net.NetworkCapabilities
-import android.net.NetworkRequest
-import android.os.Build
-import dev.meloda.fast.common.NetworkStateListener
-import dev.meloda.fast.common.model.NetworkState
-import dev.meloda.fast.common.model.NetworkStatus
-import dev.meloda.fast.common.model.NetworkType
-import dev.meloda.fast.logger.FastLogger
-import java.util.concurrent.ConcurrentHashMap
-
-internal class NetworkObserver(
-    private val connectivityManager: ConnectivityManager,
-    private val logger: FastLogger,
-    private val networkStateListener: NetworkStateListener
-) {
-
-    private val networks = ConcurrentHashMap<Network, NetworkModel>()
-
-    private var clearCallbacks: (() -> Unit)? = null
-
-    init {
-        startListener()
-    }
-
-    private fun syncNetworkState() {
-        val state = if (networks.values.any { it.isInternetAvailable() }) {
-            NetworkState.CONNECTED
-        } else {
-            NetworkState.DISCONNECTED
-        }
-
-        networkStateListener.updateNetworkState(state)
-        log("STATE: $state")
-    }
-
-    private fun startListener() {
-        val callback = object : ConnectivityManager.NetworkCallback() {
-            override fun onAvailable(network: Network) {
-                log("onAvailable(): network: $network")
-
-                networks[network] = mapNetworkModel(
-                    network = network,
-                    capabilities = connectivityManager.getNetworkCapabilities(network),
-                    properties = connectivityManager.getLinkProperties(network),
-                    status = NetworkStatus.AVAILABLE,
-                    assumeInternet = true
-                )
-
-                syncNetworkState()
-            }
-
-            override fun onUnavailable() {
-                log("onUnavailable()")
-
-                networks.clear()
-                syncNetworkState()
-            }
-
-            override fun onLost(network: Network) {
-                log("onLost() network: $network")
-
-                networks.remove(network)
-                syncNetworkState()
-            }
-
-            override fun onCapabilitiesChanged(
-                network: Network,
-                networkCapabilities: NetworkCapabilities
-            ) {
-                log("onCapabilitiesChanged(): network: $network; caps: $networkCapabilities")
-
-                val current = networks[network]
-                networks[network] = mapNetworkModel(
-                    network = network,
-                    capabilities = networkCapabilities,
-                    from = current,
-                    status = current?.status ?: NetworkStatus.AVAILABLE
-                )
-
-                syncNetworkState()
-            }
-
-            override fun onBlockedStatusChanged(
-                network: Network,
-                blocked: Boolean
-            ) {
-                log("onBlockedStatusChanged(): network: $network; blocked: $blocked")
-
-                networks[network] = mapNetworkModel(
-                    network = network,
-                    from = networks[network],
-                    status = if (blocked) NetworkStatus.BLOCKED else NetworkStatus.UNBLOCKED
-                )
-
-                syncNetworkState()
-            }
-
-            override fun onLinkPropertiesChanged(
-                network: Network,
-                linkProperties: LinkProperties
-            ) {
-                log("onLinkPropertiesChanged(): network: $network; props: $linkProperties")
-
-                val current = networks[network]
-                networks[network] = mapNetworkModel(
-                    network = network,
-                    properties = linkProperties,
-                    from = current,
-                    status = current?.status ?: NetworkStatus.AVAILABLE
-                )
-
-                syncNetworkState()
-            }
-
-            override fun onLosing(network: Network, maxMsToLive: Int) {
-                log("onLosing(): network: $network; maxMsToLive: $maxMsToLive")
-
-                val current = networks[network]
-                networks[network] = mapNetworkModel(
-                    network = network,
-                    maxMsToLive = maxMsToLive.toLong(),
-                    from = current,
-                    status = current?.status ?: NetworkStatus.AVAILABLE
-                )
-
-                syncNetworkState()
-            }
-
-            override fun onReserved(networkCapabilities: NetworkCapabilities) {
-                log("onReserved(): caps: $networkCapabilities")
-            }
-        }
-
-        val request = NetworkRequest.Builder()
-            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
-            .build()
-
-        connectivityManager.registerNetworkCallback(request, callback)
-        clearCallbacks = { connectivityManager.unregisterNetworkCallback(callback) }
-
-        refreshActiveNetwork()
-    }
-
-    private fun log(text: String) {
-        logger.debug(this::class, text)
-    }
-
-    private fun refreshActiveNetwork() {
-        val network = connectivityManager.activeNetwork
-        if (network == null) {
-            networks.clear()
-            syncNetworkState()
-            return
-        }
-
-        val capabilities = connectivityManager.getNetworkCapabilities(network)
-        if (capabilities?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true) {
-            networks[network] = mapNetworkModel(
-                network = network,
-                capabilities = capabilities,
-                properties = connectivityManager.getLinkProperties(network),
-                status = NetworkStatus.AVAILABLE
-            )
-        }
-
-        syncNetworkState()
-    }
-
-    private fun mapNetworkModel(
-        network: Network,
-        capabilities: NetworkCapabilities? = null,
-        properties: LinkProperties? = null,
-        status: NetworkStatus? = null,
-        maxMsToLive: Long? = null,
-        from: NetworkModel? = null,
-        assumeInternet: Boolean = false
-    ): NetworkModel {
-        val caps = capabilities
-            ?: from?.networkCapabilities
-            ?: connectivityManager.getNetworkCapabilities(network)
-
-        val networkType = when {
-            caps?.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) == true -> NetworkType.CELLULAR
-            caps?.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) == true -> NetworkType.WIFI
-            else -> from?.type ?: NetworkType.UNKNOWN
-        }
-
-        val hasInternet = if (caps != null) {
-            caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) ||
-                    caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
-        } else {
-            from?.hasInternet ?: assumeInternet
-        }
-
-        val signalStrength =
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                caps?.signalStrength
-            } else {
-                null
-            } ?: from?.signalStrength ?: Int.MAX_VALUE
-
-        return NetworkModel(
-            id = network.hashCode(),
-            type = networkType,
-            original = network,
-            hasInternet = hasInternet,
-            signalStrength = signalStrength,
-            status = status ?: from?.status ?: NetworkStatus.UNAVAILABLE,
-            maxMsToLive = maxMsToLive ?: from?.maxMsToLive,
-            networkCapabilities = caps,
-            linkProperties = properties
-                ?: from?.linkProperties
-                ?: connectivityManager.getLinkProperties(network)
-        )
-    }
-}
-
-
-data class NetworkModel(
-    val id: Int,
-    val type: NetworkType,
-    val original: Network,
-    val hasInternet: Boolean,
-    val signalStrength: Int,
-    val status: NetworkStatus,
-    val maxMsToLive: Long?,
-    val networkCapabilities: NetworkCapabilities?,
-    val linkProperties: LinkProperties?
-) {
-    fun isStatusOk(): Boolean = status.isOk()
-
-    fun isInternetAvailable(): Boolean = hasInternet && isStatusOk()
-}

app/src/main/kotlin/dev/meloda/fast/presentation/RootScreen.kt

@@ -38,13 +38,13 @@ import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
 import dev.meloda.fast.MainViewModel
+import dev.meloda.fast.MainViewModelImpl
 import dev.meloda.fast.auth.authNavGraph
 import dev.meloda.fast.auth.captcha.presentation.CaptchaScreen
 import dev.meloda.fast.auth.navigateToAuth
 import dev.meloda.fast.chatmaterials.navigation.chatMaterialsScreen
 import dev.meloda.fast.chatmaterials.navigation.navigateToChatMaterials
 import dev.meloda.fast.common.LongPollController
-import dev.meloda.fast.common.NetworkStateListener
 import dev.meloda.fast.common.model.LongPollState
 import dev.meloda.fast.convos.navigation.createChatScreen
 import dev.meloda.fast.convos.navigation.navigateToCreateChat
@@ -59,12 +59,10 @@ import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.navigation.Main
 import dev.meloda.fast.navigation.mainScreen
 import dev.meloda.fast.photoviewer.presentation.PhotoViewDialog
-import dev.meloda.fast.settings.model.SettingsNavigationIntent
 import dev.meloda.fast.settings.navigation.navigateToSettings
 import dev.meloda.fast.settings.navigation.settingsScreen
 import dev.meloda.fast.ui.R
 import dev.meloda.fast.ui.common.LocalLogger
-import dev.meloda.fast.ui.common.LocalNetworkState
 import dev.meloda.fast.ui.common.LocalSizeConfig
 import dev.meloda.fast.ui.model.DeviceSize
 import dev.meloda.fast.ui.model.SizeConfig
@@ -94,7 +92,7 @@ fun RootScreen(
     val longPollCurrentState by longPollController.currentState.collectAsStateWithLifecycle()
     val longPollStateToApply by longPollController.stateToApply.collectAsStateWithLifecycle()
 
-    val viewModel: MainViewModel = koinViewModel()
+    val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
     val currentUser: VkUser? by viewModel.currentUser.collectAsStateWithLifecycle()
 
     val permissionState =
@@ -222,17 +220,10 @@ fun RootScreen(
         }
     }
 
-    val networkStateListener: NetworkStateListener = koinInject()
-    val networkState by networkStateListener.networkStateFlow.collectAsStateWithLifecycle()
-    LaunchedEffect(networkState) {
-        logger.debug("RootScreen", "NetworkState: $networkState")
-    }
-
     CompositionLocalProvider(
         LocalThemeConfig provides themeConfig,
         LocalSizeConfig provides sizeConfig,
-        LocalUser provides currentUser,
-        LocalNetworkState provides networkState
+        LocalUser provides currentUser
     ) {
         AppTheme(
             useDarkTheme = themeConfig.darkMode,
@@ -371,31 +362,18 @@ fun RootScreen(
                             )
 
                             settingsScreen(
-                                handleNavigationIntent = { intent ->
-                                    when (intent) {
-                                        SettingsNavigationIntent.Back -> navController.navigateUp()
-                                        SettingsNavigationIntent.Language -> navController.navigateToLanguagePicker()
-                                        SettingsNavigationIntent.Restart -> {
-                                            activity?.let {
-                                                val intent =
-                                                    Intent(activity, MainActivity::class.java)
-                                                intent.setFlags(
-                                                    Intent.FLAG_ACTIVITY_NEW_TASK or
-                                                            Intent.FLAG_ACTIVITY_CLEAR_TASK or
-                                                            Intent.FLAG_ACTIVITY_CLEAR_TOP
-                                                )
-                                                activity.finish()
-                                                activity.startActivity(intent)
-                                            }
-                                        }
-
-                                        SettingsNavigationIntent.LogOut -> {
-                                            navController.navigateToAuth(true)
-                                        }
+                                onBack = navController::navigateUp,
+                                onLogOutButtonClicked = { navController.navigateToAuth(true) },
+                                onLanguageItemClicked = navController::navigateToLanguagePicker,
+                                onRestartRequired = {
+                                    activity?.let {
+                                        val intent = Intent(activity, MainActivity::class.java)
+                                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                                        activity.startActivity(intent)
+                                        activity.finish()
                                     }
                                 }
                             )
-
                             languagePickerScreen(onBack = navController::navigateUp)
                         }
 

core/common/src/main/kotlin/dev/meloda/fast/common/NetworkStateListener.kt

@@ -1,23 +0,0 @@
-package dev.meloda.fast.common
-
-import dev.meloda.fast.common.model.NetworkState
-import dev.meloda.fast.common.model.NetworkStatus
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-
-class NetworkStateListener {
-
-    private val networkStatus = MutableStateFlow(NetworkStatus.UNAVAILABLE)
-    val networkStatusFlow = networkStatus.asStateFlow()
-
-    private val networkState = MutableStateFlow(NetworkState.DISCONNECTED)
-    val networkStateFlow = networkState.asStateFlow()
-
-    fun updateNetworkState(state: NetworkState) {
-        networkState.value = state
-        networkStatus.value = when (state) {
-            NetworkState.CONNECTED -> NetworkStatus.AVAILABLE
-            NetworkState.DISCONNECTED -> NetworkStatus.UNAVAILABLE
-        }
-    }
-}

core/common/src/main/kotlin/dev/meloda/fast/common/extensions/Extensions.kt

@@ -2,13 +2,10 @@ package dev.meloda.fast.common.extensions
 
 import android.os.Build
 import android.os.Bundle
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.flow
@@ -16,7 +13,6 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
 import kotlin.reflect.KClass
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
@@ -44,16 +40,6 @@ fun <T> MutableList<T>.removeIfCompat(condition: (T) -> Boolean): Boolean {
     return removed
 }
 
-context(viewModel: ViewModel)
-fun <T> Flow<T>.listenValue(action: suspend (T) -> Unit): Job =
-    listenValue(viewModel.viewModelScope, action)
-
-context(viewModel: ViewModel)
-fun <T> MutableSharedFlow<T>.emitOnMain(value: T) {
-    val flow = this
-    viewModel.viewModelScope.launch { flow.emit(value) }
-}
-
 fun <T> Flow<T>.listenValue(
     coroutineScope: CoroutineScope,
     action: suspend (T) -> Unit

core/common/src/main/kotlin/dev/meloda/fast/common/model/NetworkState.kt

@@ -1,3 +0,0 @@
-package dev.meloda.fast.common.model
-
-enum class NetworkState { CONNECTED, DISCONNECTED }

core/common/src/main/kotlin/dev/meloda/fast/common/model/NetworkStatus.kt

@@ -1,10 +0,0 @@
-package dev.meloda.fast.common.model
-
-enum class NetworkStatus {
-    AVAILABLE, UNAVAILABLE, LOST, BLOCKED, UNBLOCKED;
-
-    fun isOk(): Boolean = when (this) {
-        AVAILABLE, UNBLOCKED -> true
-        UNAVAILABLE, LOST, BLOCKED -> false
-    }
-}

core/common/src/main/kotlin/dev/meloda/fast/common/model/NetworkType.kt

@@ -1,5 +0,0 @@
-package dev.meloda.fast.common.model
-
-enum class NetworkType {
-    CELLULAR, WIFI, UNKNOWN
-}

core/common/src/main/kotlin/dev/meloda/fast/common/provider/ResourceProvider.kt

@@ -3,7 +3,9 @@ package dev.meloda.fast.common.provider
 import android.content.res.Resources
 
 interface ResourceProvider {
+
     val resources: Resources
+
     fun getString(resId: Int): String
 }
 

core/data/src/main/kotlin/dev/meloda/fast/data/VkMemoryCache.kt

@@ -35,7 +35,7 @@ object VkMemoryCache {
     }
 
     fun appendContacts(contacts: List<VkContactDomain>) {
-        contacts.forEach { contact -> VkMemoryCache[contact.userId] = contact }
+        contacts.forEach { contact -> VkMemoryCache.contacts[contact.userId] = contact }
     }
 
     operator fun set(userid: Long, user: VkUser) {

core/data/src/main/kotlin/dev/meloda/fast/data/api/convos/ConvosRepositoryImpl.kt

@@ -129,10 +129,6 @@ class ConvosRepositoryImpl(
                 val groupsList = response.groups.orEmpty().map(VkGroupData::mapToDomain)
                 val contactsList = response.contacts.orEmpty().map(VkContactData::mapToDomain)
 
-                VkMemoryCache.appendUsers(profilesList)
-                VkMemoryCache.appendGroups(groupsList)
-                VkMemoryCache.appendContacts(contactsList)
-
                 val usersMap = VkUsersMap.forUsers(profilesList)
                 val groupsMap = VkGroupsMap.forGroups(groupsList)
 
@@ -151,6 +147,10 @@ class ConvosRepositoryImpl(
                     groupDao.insertAll(groupsList.map(VkGroupDomain::asEntity))
                 }
 
+                VkMemoryCache.appendUsers(profilesList)
+                VkMemoryCache.appendGroups(groupsList)
+                VkMemoryCache.appendContacts(contactsList)
+
                 convos
             },
             errorMapper = { error ->

core/data/src/main/kotlin/dev/meloda/fast/data/api/friends/FriendsRepositoryImpl.kt

@@ -1,12 +1,9 @@
 package dev.meloda.fast.data.api.friends
 
-import com.slack.eithernet.ApiResult
-import com.slack.eithernet.successOrElse
 import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.database.dao.UserDao
 import dev.meloda.fast.model.FriendsInfo
-import dev.meloda.fast.model.api.data.VkContactData
 import dev.meloda.fast.model.api.data.VkUserData
 import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.model.api.domain.asEntity
@@ -16,6 +13,8 @@ import dev.meloda.fast.network.RestApiErrorDomain
 import dev.meloda.fast.network.mapApiDefault
 import dev.meloda.fast.network.mapApiResult
 import dev.meloda.fast.network.service.friends.FriendsService
+import com.slack.eithernet.ApiResult
+import com.slack.eithernet.successOrElse
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.withContext
@@ -52,18 +51,14 @@ class FriendsRepositoryImpl(
             order = order,
             count = count,
             offset = offset,
-            fields = VkConstants.USER_FIELDS,
-            extended = true
+            fields = VkConstants.USER_FIELDS
         )
         service.getFriends(requestModel.map).mapApiResult(
             successMapper = { apiResponse ->
                 val response = apiResponse.requireResponse()
-
                 val users = response.items.map(VkUserData::mapToDomain)
-                val contactsList = response.contacts.orEmpty().map(VkContactData::mapToDomain)
 
                 VkMemoryCache.appendUsers(users)
-                VkMemoryCache.appendContacts(contactsList)
 
                 users
             },

core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollEventsHandler.kt

@@ -3,20 +3,13 @@ package dev.meloda.fast.domain
 import dev.meloda.fast.database.dao.ConvoDao
 import dev.meloda.fast.database.dao.MessageDao
 import dev.meloda.fast.logger.FastLogger
-import dev.meloda.fast.model.InteractionType
-import dev.meloda.fast.model.LongPollEvent
 import dev.meloda.fast.model.LongPollParsedEvent
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import kotlin.coroutines.CoroutineContext
 
-typealias EventListener = (event: LongPollParsedEvent) -> Unit
-typealias EventListenerMap = MutableMap<LongPollEvent, MutableList<EventListener>>
-
 class LongPollEventsHandler(
     private val logger: FastLogger,
     private val convoUseCase: ConvoUseCase,
@@ -36,15 +29,8 @@ class LongPollEventsHandler(
 
     private val coroutineScope = CoroutineScope(coroutineContext)
 
-    private val listenersMap: EventListenerMap = mutableMapOf()
-
-    fun handleEvents(events: List<LongPollParsedEvent>) {
-        coroutineScope.launch {
-            // TODO: 30.05.2026, Danil Nikolaev: switch to interactors or something else
-            withContext(Dispatchers.IO) {
-                events.forEach { handleNextEvent(it) }
-            }
-        }
+    suspend fun handleEvents(events: List<LongPollParsedEvent>) {
+        events.forEach { handleNextEvent(it) }
     }
 
     private suspend fun handleNextEvent(event: LongPollParsedEvent) {
@@ -102,21 +88,11 @@ class LongPollEventsHandler(
             }
 
             is LongPollParsedEvent.Interaction -> {
-                val eventType = when (event.interactionType) {
-                    InteractionType.Typing -> LongPollEvent.TYPING
-                    InteractionType.VoiceMessage -> LongPollEvent.AUDIO_MESSAGE_RECORDING
-                    InteractionType.Photo -> LongPollEvent.PHOTO_UPLOADING
-                    InteractionType.Video -> LongPollEvent.VIDEO_UPLOADING
-                    InteractionType.File -> LongPollEvent.FILE_UPLOADING
-                }
 
-                emitEvent(eventType, event)
             }
 
             is LongPollParsedEvent.MessageCacheClear -> {
                 messagesUseCase.storeMessage(event.message)
-
-                emitEvent(LongPollEvent.MESSAGE_CACHE_CLEAR, event)
             }
 
             is LongPollParsedEvent.MessageDeleted -> {
@@ -130,14 +106,10 @@ class LongPollEventsHandler(
                     this::class,
                     "markDeleted: updated $affectedRows rows."
                 )
-
-                emitEvent(LongPollEvent.MESSAGE_DELETED, event)
             }
 
             is LongPollParsedEvent.MessageEdited -> {
                 messagesUseCase.storeMessage(event.message)
-
-                emitEvent(LongPollEvent.MESSAGE_EDITED, event)
             }
 
             is LongPollParsedEvent.MessageMarkedAsImportant -> {
@@ -151,14 +123,10 @@ class LongPollEventsHandler(
                     this::class,
                     "markImportant: updated $affectedRows rows."
                 )
-
-                emitEvent(LongPollEvent.MARKED_AS_IMPORTANT, event)
             }
 
             is LongPollParsedEvent.MessageMarkedAsNotSpam -> {
                 messagesUseCase.storeMessage(event.message)
-
-                emitEvent(LongPollEvent.MARKED_AS_NOT_SPAM, event)
             }
 
             is LongPollParsedEvent.MessageMarkedAsSpam -> {
@@ -172,26 +140,18 @@ class LongPollEventsHandler(
                     this::class,
                     "markSpam: updated $affectedRows rows."
                 )
-
-                emitEvent(LongPollEvent.MARKED_AS_SPAM, event)
             }
 
             is LongPollParsedEvent.MessageRestored -> {
                 messagesUseCase.storeMessage(event.message)
-
-                emitEvent(LongPollEvent.MESSAGE_RESTORED, event)
             }
 
             is LongPollParsedEvent.MessageUpdated -> {
                 messagesUseCase.storeMessage(event.message)
-
-                emitEvent(LongPollEvent.MESSAGE_UPDATED, event)
             }
 
-            is LongPollParsedEvent.MessageNew -> {
+            is LongPollParsedEvent.NewMessage -> {
                 messagesUseCase.storeMessage(event.message)
-
-                emitEvent(LongPollEvent.MESSAGE_NEW, event)
             }
 
             is LongPollParsedEvent.IncomingMessageRead -> {
@@ -205,8 +165,6 @@ class LongPollEventsHandler(
                     this::class,
                     "inMessageRead: updated $affectedRows rows."
                 )
-
-                emitEvent(LongPollEvent.INCOMING_MESSAGE_READ, event)
             }
 
             is LongPollParsedEvent.OutgoingMessageRead -> {
@@ -220,113 +178,11 @@ class LongPollEventsHandler(
                     this::class,
                     "outMessageRead: updated $affectedRows rows."
                 )
-
-                emitEvent(LongPollEvent.OUTGOING_MESSAGE_READ, event)
             }
 
             is LongPollParsedEvent.UnreadCounter -> {
-                emitEvent(LongPollEvent.UNREAD_COUNTER_UPDATE, event)
+
             }
         }
     }
-
-    private fun <T : LongPollParsedEvent> emitEvent(eventType: LongPollEvent, event: T) {
-        listenersMap[eventType]?.forEach { it(event) }
-    }
-
-    private fun <T : LongPollParsedEvent> registerListener(
-        eventType: LongPollEvent,
-        listener: (T) -> Unit
-    ) {
-        if (listenersMap[eventType] == null) {
-            listenersMap[eventType] = mutableListOf()
-        }
-
-        @Suppress("UNCHECKED_CAST")
-        listenersMap[eventType]?.add(listener as EventListener)
-    }
-
-    private fun <T : LongPollParsedEvent> registerListeners(
-        eventTypes: List<LongPollEvent>,
-        listener: (T) -> Unit
-    ) {
-        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
-    }
-
-    fun onMessageSetFlags(block: (LongPollParsedEvent) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_SET_FLAGS, block)
-    }
-
-    fun onMessageMarkAsImportant(block: (LongPollParsedEvent.MessageMarkedAsImportant) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_IMPORTANT, block)
-    }
-
-    fun onMessageMarkAsSpam(block: (LongPollParsedEvent.MessageMarkedAsSpam) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_SPAM, block)
-    }
-
-    fun onMessageDelete(block: (LongPollParsedEvent.MessageDeleted) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_DELETED, block)
-    }
-
-    fun onMessageClearFlags(block: (LongPollParsedEvent) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, block)
-    }
-
-    fun onMessageMarkAsNotSpam(block: (LongPollParsedEvent.MessageMarkedAsNotSpam) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, block)
-    }
-
-    fun onMessageRestore(block: (LongPollParsedEvent.MessageRestored) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_RESTORED, block)
-    }
-
-    fun onMessageNew(block: (LongPollParsedEvent.MessageNew) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_NEW, block)
-    }
-
-    fun onMessageEdit(block: (LongPollParsedEvent.MessageEdited) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_EDITED, block)
-    }
-
-    fun onMessageIncomingRead(block: (LongPollParsedEvent.IncomingMessageRead) -> Unit) {
-        registerListener(LongPollEvent.INCOMING_MESSAGE_READ, block)
-    }
-
-    fun onMessageOutgoingRead(block: (LongPollParsedEvent.OutgoingMessageRead) -> Unit) {
-        registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, block)
-    }
-
-    fun onChatClear(block: (LongPollParsedEvent.ChatCleared) -> Unit) {
-        registerListener(LongPollEvent.CHAT_CLEARED, block)
-    }
-
-    fun onChatMajorChange(block: (LongPollParsedEvent.ChatMajorChanged) -> Unit) {
-        registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, block)
-    }
-
-    fun onChatMinorChange(block: (LongPollParsedEvent.ChatMinorChanged) -> Unit) {
-        registerListener(LongPollEvent.CHAT_MINOR_CHANGED, block)
-    }
-
-    fun onChatArchive(block: (LongPollParsedEvent.ChatArchived) -> Unit) {
-        registerListener(LongPollEvent.CHAT_ARCHIVED, block)
-    }
-
-    fun onInteraction(block: (LongPollParsedEvent.Interaction) -> Unit) {
-        registerListeners(
-            eventTypes = listOf(
-                LongPollEvent.TYPING,
-                LongPollEvent.AUDIO_MESSAGE_RECORDING,
-                LongPollEvent.PHOTO_UPLOADING,
-                LongPollEvent.VIDEO_UPLOADING,
-                LongPollEvent.FILE_UPLOADING
-            ),
-            listener = block
-        )
-    }
-
-    fun onDestroy() {
-        listenersMap.clear()
-    }
 }

core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollUpdatesParser.kt

@@ -11,6 +11,7 @@ import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.model.ApiEvent
 import dev.meloda.fast.model.ConvoFlags
 import dev.meloda.fast.model.InteractionType
+import dev.meloda.fast.model.LongPollEvent
 import dev.meloda.fast.model.LongPollParsedEvent
 import dev.meloda.fast.model.MessageFlags
 import dev.meloda.fast.model.api.domain.VkConvo
@@ -42,6 +43,9 @@ class LongPollUpdatesParser(
 
     private val coroutineScope = CoroutineScope(coroutineContext)
 
+    private val listenersMap: MutableMap<LongPollEvent, MutableList<VkEventCallback<LongPollParsedEvent>>> =
+        mutableMapOf()
+
     suspend fun parseNextUpdate(event: List<Any>): List<LongPollParsedEvent> {
         val eventId = event.first().asInt()
 
@@ -97,6 +101,9 @@ class LongPollUpdatesParser(
                         marked = true
                     )
                     eventsToSend += eventToSend
+
+                    listenersMap[LongPollEvent.MARKED_AS_IMPORTANT]
+                        ?.forEach { it.onEvent(eventToSend) }
                 }
 
                 MessageFlags.SPAM -> {
@@ -105,6 +112,7 @@ class LongPollUpdatesParser(
                         cmId = cmId
                     )
                     eventsToSend += eventToSend
+                    listenersMap[LongPollEvent.MARKED_AS_SPAM]?.forEach { it.onEvent(eventToSend) }
                 }
 
                 MessageFlags.DELETED -> {
@@ -123,6 +131,7 @@ class LongPollUpdatesParser(
                             )
                         }
                     eventsToSend += eventToSend
+                    listenersMap[LongPollEvent.MESSAGE_DELETED]?.forEach { it.onEvent(eventToSend) }
                 }
 
                 MessageFlags.AUDIO_LISTENED -> {
@@ -131,6 +140,9 @@ class LongPollUpdatesParser(
                         cmId = cmId
                     )
                     eventsToSend += eventToSend
+
+                    listenersMap[LongPollEvent.AUDIO_MESSAGE_LISTENED]
+                        ?.forEach { it.onEvent(eventToSend) }
                 }
 
                 MessageFlags.UNREAD -> Unit
@@ -144,6 +156,14 @@ class LongPollUpdatesParser(
             }
         }
 
+        eventsToSend.forEach { eventToSend ->
+            listenersMap[LongPollEvent.MESSAGE_SET_FLAGS]?.let { listeners ->
+                listeners.forEach { vkEventCallback ->
+                    vkEventCallback.onEvent(eventToSend)
+                }
+            }
+        }
+
         return eventsToSend
     }
 
@@ -173,6 +193,9 @@ class LongPollUpdatesParser(
                             marked = false
                         )
                         eventsToSend += eventToSend
+
+                        listenersMap[LongPollEvent.MARKED_AS_IMPORTANT]
+                            ?.forEach { it.onEvent(eventToSend) }
                     }
 
                     MessageFlags.SPAM -> {
@@ -181,6 +204,9 @@ class LongPollUpdatesParser(
                                 val eventToSend =
                                     LongPollParsedEvent.MessageMarkedAsNotSpam(message = message)
                                 eventsToSend += eventToSend
+
+                                listenersMap[LongPollEvent.MARKED_AS_NOT_SPAM]
+                                    ?.forEach { it.onEvent(eventToSend) }
                             }
                         }
                     }
@@ -190,6 +216,9 @@ class LongPollUpdatesParser(
                             val eventToSend =
                                 LongPollParsedEvent.MessageRestored(message = message)
                             eventsToSend += eventToSend
+
+                            listenersMap[LongPollEvent.MESSAGE_RESTORED]
+                                ?.forEach { it.onEvent(eventToSend) }
                         }
                     }
 
@@ -205,6 +234,10 @@ class LongPollUpdatesParser(
                 }
             }
 
+            listenersMap[LongPollEvent.MESSAGE_CLEAR_FLAGS]?.forEach { listener ->
+                eventsToSend.forEach { listener.onEvent(it) }
+            }
+
             continuation.resume(eventsToSend)
         }
     }
@@ -231,7 +264,7 @@ class LongPollUpdatesParser(
                 }.await()
 
             if (message != null) {
-                val event = LongPollParsedEvent.MessageNew(
+                val event = LongPollParsedEvent.NewMessage(
                     message = message,
                     inArchive = convo?.isArchived == true
                     // TODO: 03-Apr-25, Danil Nikolaev:
@@ -239,6 +272,7 @@ class LongPollUpdatesParser(
                     // enabled notifications from archive
                 )
 
+                listenersMap[LongPollEvent.MESSAGE_NEW]?.forEach { it.onEvent(event) }
                 continuation.resume(listOf(event))
             } else {
                 continuation.resume(emptyList())
@@ -259,6 +293,7 @@ class LongPollUpdatesParser(
             val message = loadMessage(peerId = peerId, cmId = cmId)
             if (message != null) {
                 val event = LongPollParsedEvent.MessageEdited(message)
+                listenersMap[LongPollEvent.MESSAGE_EDITED]?.forEach { it.onEvent(event) }
                 continuation.resume(listOf(event))
             } else {
                 continuation.resume(emptyList())
@@ -281,6 +316,7 @@ class LongPollUpdatesParser(
             cmId = cmId,
             unreadCount = unreadCount
         )
+        listenersMap[LongPollEvent.INCOMING_MESSAGE_READ]?.forEach { it.onEvent(event) }
         return listOf(event)
     }
 
@@ -300,6 +336,7 @@ class LongPollUpdatesParser(
             unreadCount = unreadCount
         )
 
+        listenersMap[LongPollEvent.OUTGOING_MESSAGE_READ]?.forEach { it.onEvent(event) }
         return listOf(event)
     }
 
@@ -336,6 +373,8 @@ class LongPollUpdatesParser(
                             archived = false
                         )
                         eventsToSend += eventToSend
+
+                        listenersMap[LongPollEvent.CHAT_ARCHIVED]?.forEach { it.onEvent(eventToSend) }
                     }
 
                     ConvoFlags.DISABLE_PUSH -> Unit
@@ -353,6 +392,10 @@ class LongPollUpdatesParser(
                 }
             }
 
+            listenersMap[LongPollEvent.CHAT_CLEAR_FLAGS]?.forEach { listener ->
+                eventsToSend.forEach { listener.onEvent(it) }
+            }
+
             continuation.resume(eventsToSend)
         }
     }
@@ -390,6 +433,8 @@ class LongPollUpdatesParser(
                             archived = true
                         )
                         eventsToSend += eventToSend
+
+                        listenersMap[LongPollEvent.CHAT_ARCHIVED]?.forEach { it.onEvent(eventToSend) }
                     }
 
                     ConvoFlags.DISABLE_PUSH -> Unit
@@ -407,6 +452,10 @@ class LongPollUpdatesParser(
                 }
             }
 
+            listenersMap[LongPollEvent.CHAT_SET_FLAGS]?.forEach { listener ->
+                eventsToSend.forEach { listener.onEvent(it) }
+            }
+
             continuation.resume(eventsToSend)
         }
     }
@@ -424,6 +473,7 @@ class LongPollUpdatesParser(
             peerId = peerId,
             toCmId = cmId
         )
+        listenersMap[LongPollEvent.CHAT_CLEARED]?.forEach { it.onEvent(event) }
         return listOf(event)
     }
 
@@ -440,6 +490,7 @@ class LongPollUpdatesParser(
             peerId = peerId,
             majorId = majorId,
         )
+        listenersMap[LongPollEvent.CHAT_MAJOR_CHANGED]?.forEach { it.onEvent(event) }
         return listOf(event)
     }
 
@@ -456,6 +507,7 @@ class LongPollUpdatesParser(
             peerId = peerId,
             minorId = minorId,
         )
+        listenersMap[LongPollEvent.CHAT_MINOR_CHANGED]?.forEach { it.onEvent(event) }
         return listOf(event)
     }
 
@@ -474,6 +526,14 @@ class LongPollUpdatesParser(
             else -> return emptyList()
         }
 
+        val longPollEvent: LongPollEvent = when (eventType) {
+            ApiEvent.TYPING -> LongPollEvent.TYPING
+            ApiEvent.AUDIO_MESSAGE_RECORDING -> LongPollEvent.AUDIO_MESSAGE_RECORDING
+            ApiEvent.PHOTO_UPLOADING -> LongPollEvent.PHOTO_UPLOADING
+            ApiEvent.VIDEO_UPLOADING -> LongPollEvent.VIDEO_UPLOADING
+            ApiEvent.FILE_UPLOADING -> LongPollEvent.FILE_UPLOADING
+        }
+
         val peerId = event[1].asLong()
         val userIds = event[2].toList(Any::asLong).filter { it != UserConfig.userId }
         val totalCount = event[3].asInt()
@@ -490,6 +550,7 @@ class LongPollUpdatesParser(
             timestamp = timestamp
         )
 
+        listenersMap[longPollEvent]?.forEach { it.onEvent(event) }
         return listOf(event)
     }
 
@@ -516,6 +577,7 @@ class LongPollUpdatesParser(
             archiveUnmuted = archiveUnreadUnmutedCount,
             archiveMentions = archiveMentionsCount
         )
+        listenersMap[LongPollEvent.UNREAD_COUNTER_UPDATE]?.forEach { it.onEvent(event) }
         return listOf(event)
     }
 
@@ -533,6 +595,7 @@ class LongPollUpdatesParser(
 
             if (message != null) {
                 val event = LongPollParsedEvent.MessageUpdated(message)
+                listenersMap[LongPollEvent.MESSAGE_UPDATED]?.forEach { it.onEvent(event) }
                 continuation.resume(listOf(event))
             } else {
                 continuation.resume(emptyList())
@@ -552,6 +615,7 @@ class LongPollUpdatesParser(
             val message = loadMessage(messageId = messageId)
             if (message != null) {
                 val event = LongPollParsedEvent.MessageCacheClear(message)
+                listenersMap[LongPollEvent.MESSAGE_CACHE_CLEAR]?.forEach { it.onEvent(event) }
                 continuation.resume(listOf(event))
             } else {
                 continuation.resume(emptyList())
@@ -577,10 +641,7 @@ class LongPollUpdatesParser(
             ).listenValue(this) { state ->
                 state.processState(
                     error = { error ->
-                        logger.error(
-                            this@LongPollUpdatesParser::class,
-                            "loadMessage(): ERROR: $error"
-                        )
+                        logger.error(this::class, "loadMessage(): ERROR: $error")
                         continuation.resume(null)
                     },
                     success = { response ->
@@ -609,10 +670,7 @@ class LongPollUpdatesParser(
             ).listenValue(coroutineScope) { state ->
                 state.processState(
                     error = { error ->
-                        logger.error(
-                            this@LongPollUpdatesParser::class,
-                            "loadConvo(): ERROR: $error"
-                        )
+                        logger.error(this::class, "loadConvo(): ERROR: $error")
                         continuation.resume(null)
                     },
                     success = { response ->
@@ -627,4 +685,107 @@ class LongPollUpdatesParser(
             }
         }
     }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun <T : LongPollParsedEvent> registerListener(
+        eventType: LongPollEvent,
+        listener: VkEventCallback<T>
+    ) {
+        listenersMap.let { map ->
+            map[eventType] = (map[eventType] ?: mutableListOf())
+                .also {
+                    it.add(listener as VkEventCallback<LongPollParsedEvent>)
+                }
+        }
+    }
+
+    private fun <T : LongPollParsedEvent> registerListeners(
+        eventTypes: List<LongPollEvent>,
+        listener: VkEventCallback<T>
+    ) {
+        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
+    }
+
+    fun onMessageSetFlags(block: (LongPollParsedEvent) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_SET_FLAGS, assembleEventCallback(block))
+    }
+
+    fun onMessageMarkedAsImportant(block: (LongPollParsedEvent.MessageMarkedAsImportant) -> Unit) {
+        registerListener(LongPollEvent.MARKED_AS_IMPORTANT, assembleEventCallback(block))
+    }
+
+    fun onMessageMarkedAsSpam(block: (LongPollParsedEvent.MessageMarkedAsSpam) -> Unit) {
+        registerListener(LongPollEvent.MARKED_AS_SPAM, assembleEventCallback(block))
+    }
+
+    fun onMessageDeleted(block: (LongPollParsedEvent.MessageDeleted) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_DELETED, assembleEventCallback(block))
+    }
+
+    fun onMessageClearFlags(block: (LongPollParsedEvent) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, assembleEventCallback(block))
+    }
+
+    fun onMessageMarkedAsNotSpam(block: (LongPollParsedEvent.MessageMarkedAsNotSpam) -> Unit) {
+        registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, assembleEventCallback(block))
+    }
+
+    fun onMessageRestored(block: (LongPollParsedEvent.MessageRestored) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_RESTORED, assembleEventCallback(block))
+    }
+
+    fun onNewMessage(block: (LongPollParsedEvent.NewMessage) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_NEW, assembleEventCallback(block))
+    }
+
+    fun onMessageEdited(block: (LongPollParsedEvent.MessageEdited) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_EDITED, assembleEventCallback(block))
+    }
+
+    fun onMessageIncomingRead(block: (LongPollParsedEvent.IncomingMessageRead) -> Unit) {
+        registerListener(LongPollEvent.INCOMING_MESSAGE_READ, assembleEventCallback(block))
+    }
+
+    fun onMessageOutgoingRead(block: (LongPollParsedEvent.OutgoingMessageRead) -> Unit) {
+        registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, assembleEventCallback(block))
+    }
+
+    fun onChatCleared(block: (LongPollParsedEvent.ChatCleared) -> Unit) {
+        registerListener(LongPollEvent.CHAT_CLEARED, assembleEventCallback(block))
+    }
+
+    fun onChatMajorChanged(block: (LongPollParsedEvent.ChatMajorChanged) -> Unit) {
+        registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, assembleEventCallback(block))
+    }
+
+    fun onChatMinorChanged(block: (LongPollParsedEvent.ChatMinorChanged) -> Unit) {
+        registerListener(LongPollEvent.CHAT_MINOR_CHANGED, assembleEventCallback(block))
+    }
+
+    fun onChatArchived(block: (LongPollParsedEvent.ChatArchived) -> Unit) {
+        registerListener(LongPollEvent.CHAT_ARCHIVED, assembleEventCallback(block))
+    }
+
+    fun onInteractions(block: (LongPollParsedEvent.Interaction) -> Unit) {
+        registerListeners(
+            eventTypes = listOf(
+                LongPollEvent.TYPING,
+                LongPollEvent.AUDIO_MESSAGE_RECORDING,
+                LongPollEvent.PHOTO_UPLOADING,
+                LongPollEvent.VIDEO_UPLOADING,
+                LongPollEvent.FILE_UPLOADING
+            ),
+            listener = assembleEventCallback(block)
+        )
+    }
+}
+
+internal inline fun <R : LongPollParsedEvent> assembleEventCallback(
+    crossinline block: (R) -> Unit,
+): VkEventCallback<R> {
+    return VkEventCallback { event -> block.invoke(event) }
+}
+
+fun interface VkEventCallback<in T : LongPollParsedEvent> {
+    fun onEvent(event: T)
 }

core/domain/src/main/kotlin/dev/meloda/fast/domain/util/ConvoMapper.kt

@@ -52,7 +52,7 @@ fun VkConvo.extractTitle(
         } else {
             val userName = user?.let { user ->
                 if (useContactName) {
-                    VkMemoryCache.getContact(user.id)?.name ?: user.fullName
+                    VkMemoryCache.getContact(user.id)?.name
                 } else {
                     user.fullName
                 }

core/model/src/main/kotlin/dev/meloda/fast/model/AccountDto.kt

@@ -1,24 +0,0 @@
-package dev.meloda.fast.model
-
-import dev.meloda.fast.model.database.AccountEntity
-
-data class AccountDto(
-    val userId: Long,
-    val accessToken: String,
-    val fastToken: String?,
-    val trustedHash: String?,
-    val exchangeToken: String?
-) {
-
-    fun mapToEntity(): AccountEntity = AccountEntity(
-        userId = userId,
-        accessToken = accessToken,
-        fastToken = fastToken,
-        trustedHash = trustedHash,
-        exchangeToken = exchangeToken
-    )
-
-    override fun toString(): String {
-        return super.toString()
-    }
-}

core/model/src/main/kotlin/dev/meloda/fast/model/LongPollParsedEvent.kt

@@ -5,7 +5,7 @@ import dev.meloda.fast.model.api.domain.VkMessage
 
 sealed interface LongPollParsedEvent {
 
-    data class MessageNew(
+    data class NewMessage(
         val message: VkMessage,
         val inArchive: Boolean
     ) : LongPollParsedEvent

core/model/src/main/kotlin/dev/meloda/fast/model/api/requests/FriendsRequest.kt

@@ -4,8 +4,7 @@ data class GetFriendsRequest(
     val order: String?,
     val count: Int?,
     val offset: Int?,
-    val fields: String?,
-    val extended: Boolean?
+    val fields: String?
 ) {
 
     val map
@@ -15,7 +14,6 @@ data class GetFriendsRequest(
                 count?.let { this["count"] = it.toString() }
                 offset?.let { this["offset"] = it.toString() }
                 fields?.let { this["fields"] = it }
-                extended?.let { this["extended"] = it.toString() }
             }
 }
 

core/model/src/main/kotlin/dev/meloda/fast/model/api/responses/FriendsResponse.kt

@@ -1,13 +1,11 @@
 package dev.meloda.fast.model.api.responses
 
+import dev.meloda.fast.model.api.data.VkUserData
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
-import dev.meloda.fast.model.api.data.VkContactData
-import dev.meloda.fast.model.api.data.VkUserData
 
 @JsonClass(generateAdapter = true)
 data class GetFriendsResponse(
     @Json(name = "count") val count: Int,
-    @Json(name = "items") val items: List<VkUserData>,
-    @Json(name = "contacts") val contacts: List<VkContactData>?
+    @Json(name = "items") val items: List<VkUserData>
 )

core/model/src/main/kotlin/dev/meloda/fast/model/database/AccountEntity.kt

@@ -2,7 +2,6 @@ package dev.meloda.fast.model.database
 
 import androidx.room.Entity
 import androidx.room.PrimaryKey
-import dev.meloda.fast.model.AccountDto
 
 @Entity(tableName = "accounts")
 data class AccountEntity(
@@ -12,12 +11,4 @@ data class AccountEntity(
     val fastToken: String?,
     val trustedHash: String?,
     val exchangeToken: String?
-) {
-    fun mapToDto(): AccountDto = AccountDto(
-        userId = userId,
-        accessToken = accessToken,
-        fastToken = fastToken,
-        trustedHash = trustedHash,
-        exchangeToken = exchangeToken
-    )
-}
+)

core/network/src/main/kotlin/dev/meloda/fast/network/di/NetworkModule.kt

@@ -7,7 +7,6 @@ import com.slack.eithernet.integration.retrofit.ApiResultConverterFactory
 import com.squareup.moshi.Moshi
 import dev.meloda.fast.common.AppConstants
 import dev.meloda.fast.datastore.AppSettings
-import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.network.JsonConverter
 import dev.meloda.fast.network.MoshiConverter
 import dev.meloda.fast.network.OAuthResultCallFactory
@@ -124,12 +123,7 @@ private fun Scope.buildRetrofit(client: OkHttpClient): Retrofit {
         .baseUrl("${AppConstants.URL_API}/")
         .addConverterFactory(ApiResultConverterFactory)
         .addCallAdapterFactory(ApiResultCallAdapterFactory)
-        .addConverterFactory(
-            ResponseConverterFactory(
-                get<JsonConverter>(),
-                get<FastLogger>()
-            )
-        )
+        .addConverterFactory(ResponseConverterFactory(get<JsonConverter>()))
         .addConverterFactory(MoshiConverterFactory.create(get()))
         .client(client)
         .build()

core/ui/src/main/kotlin/dev/meloda/fast/ui/common/LocalNetworkState.kt

@@ -1,6 +0,0 @@
-package dev.meloda.fast.ui.common
-
-import androidx.compose.runtime.compositionLocalOf
-import dev.meloda.fast.common.model.NetworkState
-
-val LocalNetworkState = compositionLocalOf { NetworkState.DISCONNECTED }

core/ui/src/main/res/values/strings.xml

@@ -189,7 +189,6 @@
     <string name="title_application_language">Application language</string>
     <string name="action_refresh">Refresh</string>
     <string name="title_loading">Loading&#8230;</string>
-    <string name="title_no_network">No network&#8230;</string>
     <string name="title_convos">Conversations</string>
     <string name="title_archive">Archive</string>
     <string name="title_friends">Friends</string>

feature/auth/src/main/kotlin/dev/meloda/fast/auth/captcha/presentation/CaptchaScreen.kt

@@ -154,8 +154,7 @@ fun CaptchaScreen(
                                         // TODO: 03/05/2026, Danil Nikolaev: show error
                                     }
                                 },
-                                onCloseRequested = { showExitAlert = true },
-                                logger = logger
+                                onCloseRequested = { showExitAlert = true }
                             ),
                             "AndroidBridge"
                         )

feature/auth/src/main/kotlin/dev/meloda/fast/auth/login/LoginViewModel.kt

@@ -28,7 +28,7 @@ import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.LoadUserByIdUseCase
 import dev.meloda.fast.domain.OAuthUseCase
 import dev.meloda.fast.logger.FastLogger
-import dev.meloda.fast.model.AccountDto
+import dev.meloda.fast.model.database.AccountEntity
 import dev.meloda.fast.network.OAuthErrorDomain
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.Dispatchers
@@ -236,7 +236,7 @@ class LoginViewModel(
 
                         // TODO: 30-Mar-25, Danil Nikolaev: get fast's app token
 
-                        val currentAccount = AccountDto(
+                        val currentAccount = AccountEntity(
                             userId = userId,
                             accessToken = accessToken,
                             fastToken = null,
@@ -251,7 +251,7 @@ class LoginViewModel(
                             UserConfig.exchangeToken = account.exchangeToken
                         }
 
-                        accountsRepository.storeAccounts(listOf(currentAccount.mapToEntity()))
+                        accountsRepository.storeAccounts(listOf(currentAccount))
 
                         startLongPoll()
 

feature/convos/src/main/kotlin/dev/meloda/fast/convos/ConvosViewModel.kt

@@ -9,14 +9,12 @@ import androidx.lifecycle.viewModelScope
 import coil.ImageLoader
 import coil.request.ImageRequest
 import com.conena.nanokt.collections.indexOfFirstOrNull
-import dev.meloda.fast.common.NetworkStateListener
 import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.common.extensions.createTimerFlow
 import dev.meloda.fast.common.extensions.findWithIndex
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
 import dev.meloda.fast.common.extensions.updateValue
-import dev.meloda.fast.common.model.NetworkState
 import dev.meloda.fast.convos.model.ConvoDialog
 import dev.meloda.fast.convos.model.ConvoIntent
 import dev.meloda.fast.convos.model.ConvoNavigationIntent
@@ -29,11 +27,10 @@ import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.ConvoUseCase
 import dev.meloda.fast.domain.LoadConvosByIdUseCase
-import dev.meloda.fast.domain.LongPollEventsHandler
+import dev.meloda.fast.domain.LongPollUpdatesParser
 import dev.meloda.fast.domain.MessagesUseCase
 import dev.meloda.fast.domain.util.asPresentation
 import dev.meloda.fast.domain.util.extractAvatar
-import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.model.ConvosFilter
 import dev.meloda.fast.model.InteractionType
 import dev.meloda.fast.model.LongPollParsedEvent
@@ -49,7 +46,7 @@ import kotlinx.coroutines.flow.launchIn
 
 @Immutable
 class ConvosViewModel(
-    eventsHandler: LongPollEventsHandler,
+    updatesParser: LongPollUpdatesParser,
     val filter: ConvosFilter,
     private val convoUseCase: ConvoUseCase,
     private val messagesUseCase: MessagesUseCase,
@@ -57,9 +54,7 @@ class ConvosViewModel(
     private val userSettings: UserSettings,
     private val imageLoader: ImageLoader,
     private val applicationContext: Context,
-    private val loadConvosByIdUseCase: LoadConvosByIdUseCase,
-    private val networkStateListener: NetworkStateListener,
-    private val logger: FastLogger
+    private val loadConvosByIdUseCase: LoadConvosByIdUseCase
 ) : ViewModel() {
 
     private val screenState = MutableStateFlow(ConvosScreenState.EMPTY)
@@ -79,29 +74,19 @@ class ConvosViewModel(
     init {
         loadConvos()
 
-        eventsHandler.onMessageNew(::handleNewMessage)
-        eventsHandler.onMessageEdit(::handleEditedMessage)
-        eventsHandler.onMessageIncomingRead(::handleReadIncomingMessage)
-        eventsHandler.onMessageOutgoingRead(::handleReadOutgoingMessage)
-        eventsHandler.onInteraction(::handleInteraction)
-        eventsHandler.onChatMajorChange(::handleChatMajorChanged)
-        eventsHandler.onChatMinorChange(::handleChatMinorChanged)
-        eventsHandler.onChatClear(::handleChatClearing)
-        eventsHandler.onChatArchive(::handleChatArchived)
+        updatesParser.onNewMessage(::handleNewMessage)
+        updatesParser.onMessageEdited(::handleEditedMessage)
+        updatesParser.onMessageIncomingRead(::handleReadIncomingMessage)
+        updatesParser.onMessageOutgoingRead(::handleReadOutgoingMessage)
+        updatesParser.onInteractions(::handleInteraction)
+        updatesParser.onChatMajorChanged(::handleChatMajorChanged)
+        updatesParser.onChatMinorChanged(::handleChatMinorChanged)
+        updatesParser.onChatCleared(::handleChatClearing)
+        updatesParser.onChatArchived(::handleChatArchived)
 
         userSettings.useContactNames.listenValue(viewModelScope) {
             syncUiConvos()
         }
-
-        networkStateListener.networkStateFlow.listenValue { state ->
-            logger.debug(this@ConvosViewModel::class, "network state changed: $state")
-
-            if (state == NetworkState.CONNECTED) {
-                if (screenState.value.error != null) {
-                    onRefresh()
-                }
-            }
-        }
     }
 
     fun handleIntent(intent: ConvoIntent) {
@@ -208,12 +193,12 @@ class ConvosViewModel(
         loadConvos()
     }
 
-    private fun clearError() {
+    private fun onErrorConsumed() {
         screenState.updateValue { copy(error = null) }
     }
 
     private fun onRefresh() {
-        clearError()
+        onErrorConsumed()
         loadConvos(offset = 0)
     }
 
@@ -397,7 +382,7 @@ class ConvosViewModel(
     }
 
     // TODO: 03-Apr-25, Danil Nikolaev: handle business messages
-    private fun handleNewMessage(event: LongPollParsedEvent.MessageNew) {
+    private fun handleNewMessage(event: LongPollParsedEvent.NewMessage) {
         val message = event.message
 
         val newConvos = convos.toMutableList()

feature/convos/src/main/kotlin/dev/meloda/fast/convos/di/ConvosModule.kt

@@ -25,15 +25,13 @@ val convosModule = module {
 private fun Scope.createConvosViewModel(filter: ConvosFilter): ConvosViewModel {
     return ConvosViewModel(
         filter = filter,
-        eventsHandler = get(),
+        updatesParser = get(),
         convoUseCase = get(),
         messagesUseCase = get(),
         resources = get(),
         userSettings = get(),
         imageLoader = get(),
         applicationContext = get(),
-        loadConvosByIdUseCase = get(),
-        networkStateListener = get(),
-        logger = get()
+        loadConvosByIdUseCase = get()
     )
 }

feature/convos/src/main/kotlin/dev/meloda/fast/convos/presentation/ConvosScreen.kt

@@ -56,18 +56,15 @@ import dev.chrisbanes.haze.hazeEffect
 import dev.chrisbanes.haze.hazeSource
 import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
 import dev.chrisbanes.haze.materials.HazeMaterials
-import dev.meloda.fast.common.model.NetworkState
 import dev.meloda.fast.convos.model.ConvoIntent
 import dev.meloda.fast.convos.model.ConvosScreenState
 import dev.meloda.fast.convos.navigation.ConvoGraph
 import dev.meloda.fast.datastore.AppSettings
 import dev.meloda.fast.ui.R
-import dev.meloda.fast.ui.common.LocalNetworkState
 import dev.meloda.fast.ui.components.FullScreenContainedLoader
 import dev.meloda.fast.ui.components.NoItemsView
 import dev.meloda.fast.ui.components.SegmentedButtonItem
 import dev.meloda.fast.ui.components.SegmentedButtonsRow
-import dev.meloda.fast.ui.components.VkErrorView
 import dev.meloda.fast.ui.theme.LocalBottomPadding
 import dev.meloda.fast.ui.theme.LocalHazeState
 import dev.meloda.fast.ui.theme.LocalReselectedTab
@@ -158,8 +155,6 @@ fun ConvosScreen(
         animationSpec = tween(durationMillis = 50)
     )
 
-    val networkState = LocalNetworkState.current
-
     Scaffold(
         modifier = Modifier.fillMaxSize(),
         contentWindowInsets = WindowInsets.statusBars,
@@ -170,7 +165,6 @@ fun ConvosScreen(
                         Text(
                             text = stringResource(
                                 id = when {
-                                    networkState == NetworkState.DISCONNECTED -> R.string.title_no_network
                                     screenState.isLoading -> R.string.title_loading
                                     isArchive -> R.string.title_archive
                                     else -> R.string.title_convos
@@ -288,12 +282,12 @@ fun ConvosScreen(
     ) { padding ->
         when {
             // TODO: 30.05.2026, Danil Nikolaev: move to UI State
-            screenState.error != null -> {
-                VkErrorView(
-                    baseError = screenState.error,
-                    onButtonClick = { handleIntent(ConvoIntent.ErrorActionButtonClick) }
-                )
-            }
+//            baseError != null -> {
+//                VkErrorView(
+//                    baseError = baseError,
+//                    onButtonClick = onErrorViewButtonClicked
+//                )
+//            }
 
             screenState.isLoading && screenState.convos.isEmpty() -> FullScreenContainedLoader()
 

feature/friends/src/main/kotlin/dev/meloda/fast/friends/navigation/FriendsNavigation.kt

@@ -21,11 +21,11 @@ fun NavGraphBuilder.friendsScreen(
     onMessageClicked: (userId: Long) -> Unit,
     onScrolledToTop: () -> Unit
 ) {
-    composable<Friends> {
-        val friendsViewModel: FriendsViewModel = activity.getViewModel<FriendsViewModelImpl>()
-        val onlineFriendsViewModel =
-            activity.getViewModel<OnlineFriendsViewModelImpl>()
+    val friendsViewModel: FriendsViewModel = activity.getViewModel<FriendsViewModelImpl>()
+    val onlineFriendsViewModel =
+        activity.getViewModel<OnlineFriendsViewModelImpl>()
 
+    composable<Friends> {
         FriendsRoute(
             friendsViewModel = friendsViewModel,
             onlineFriendsViewModel = onlineFriendsViewModel,

feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/MessagesHistoryViewModelImpl.kt

@@ -39,7 +39,7 @@ import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.ConvoUseCase
 import dev.meloda.fast.domain.GetMessageReadPeersUseCase
 import dev.meloda.fast.domain.LoadConvosByIdUseCase
-import dev.meloda.fast.domain.LongPollEventsHandler
+import dev.meloda.fast.domain.LongPollUpdatesParser
 import dev.meloda.fast.domain.MessagesUseCase
 import dev.meloda.fast.domain.util.asPresentation
 import dev.meloda.fast.domain.util.extractAvatar
@@ -84,7 +84,7 @@ class MessagesHistoryViewModelImpl(
     private val userSettings: UserSettings,
     private val loadConvosByIdUseCase: LoadConvosByIdUseCase,
     private val getMessageReadPeersUseCase: GetMessageReadPeersUseCase,
-    eventsHandler: LongPollEventsHandler,
+    updatesParser: LongPollUpdatesParser,
     savedStateHandle: SavedStateHandle
 ) : MessagesHistoryViewModel, ViewModel() {
 
@@ -124,15 +124,15 @@ class MessagesHistoryViewModelImpl(
         loadConvo()
         loadMessagesHistory()
 
-        eventsHandler.onMessageNew(::handleNewMessage)
-        eventsHandler.onMessageEdit(::handleEditedMessage)
-        eventsHandler.onMessageIncomingRead(::handleReadIncomingEvent)
-        eventsHandler.onMessageOutgoingRead(::handleReadOutgoingEvent)
-        eventsHandler.onMessageDelete(::handleMessageDeleted)
-        eventsHandler.onMessageRestore(::handleMessageRestored)
-        eventsHandler.onMessageMarkAsImportant(::handleMessageMarkedAsImportant)
-        eventsHandler.onMessageMarkAsSpam(::handleMessageMarkedAsSpam)
-        eventsHandler.onMessageMarkAsNotSpam(::handleMessageMarkedAsNotSpam)
+        updatesParser.onNewMessage(::handleNewMessage)
+        updatesParser.onMessageEdited(::handleEditedMessage)
+        updatesParser.onMessageIncomingRead(::handleReadIncomingEvent)
+        updatesParser.onMessageOutgoingRead(::handleReadOutgoingEvent)
+        updatesParser.onMessageDeleted(::handleMessageDeleted)
+        updatesParser.onMessageRestored(::handleMessageRestored)
+        updatesParser.onMessageMarkedAsImportant(::handleMessageMarkedAsImportant)
+        updatesParser.onMessageMarkedAsSpam(::handleMessageMarkedAsSpam)
+        updatesParser.onMessageMarkedAsNotSpam(::handleMessageMarkedAsNotSpam)
     }
 
     override fun onNavigationConsumed() {
@@ -681,7 +681,7 @@ class MessagesHistoryViewModelImpl(
             }
         }
 
-    private fun handleNewMessage(event: LongPollParsedEvent.MessageNew) {
+    private fun handleNewMessage(event: LongPollParsedEvent.NewMessage) {
         val message = event.message
 
         if (message.peerId != screenState.value.convoId) return

feature/profile/src/main/kotlin/dev/meloda/fast/profile/ProfileViewModel.kt

@@ -9,54 +9,47 @@ import dev.meloda.fast.data.UserConfig
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.domain.GetLocalUserByIdUseCase
 import dev.meloda.fast.domain.LoadUserByIdUseCase
-import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.profile.model.ProfileScreenState
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 
 class ProfileViewModel(
     private val getLocalUserByIdUseCase: GetLocalUserByIdUseCase,
-    private val loadUserByIdUseCase: LoadUserByIdUseCase,
-    private val logger: FastLogger
+    private val loadUserByIdUseCase: LoadUserByIdUseCase
 ) : ViewModel() {
 
     private val screenState = MutableStateFlow(ProfileScreenState.EMPTY)
-    val screenStateFlow get() = screenState.asStateFlow()
 
     init {
         getLocalAccountInfo()
     }
 
+    fun screenStateFlow(): StateFlow<ProfileScreenState> = screenState.asStateFlow()
+
     private fun getLocalAccountInfo() {
-        logger.debug(this@ProfileViewModel::class, "START")
-        emit(screenState.value.copy(isLoading = true))
-
-        getLocalUserByIdUseCase(UserConfig.userId).listenValue { state ->
-            logger.debug(this@ProfileViewModel::class, "LOADED: $state")
-
-            emit(screenState.value.copy(isLoading = false))
-
-            state.processState(
-                error = {
-                    logger.debug(this@ProfileViewModel::class, "ERROR")
-                    emit(screenState.value.copy(avatarUrl = null, fullName = null))
-                },
-                success = { user ->
-                    logger.debug(this@ProfileViewModel::class, "SUCCESS")
-                    emit(
-                        screenState.value.copy(
-                            avatarUrl = user?.photo200,
-                            fullName = user?.fullName
-                        )
-                    )
-                },
-                any = ::loadAccountInfo
-            )
-        }
-    }
-
-    private fun emit(state: ProfileScreenState) {
-        screenState.setValue { state }
+        getLocalUserByIdUseCase(UserConfig.userId)
+            .listenValue(viewModelScope) { state ->
+                state.processState(
+                    error = {
+                        screenState.setValue { old ->
+                            old.copy(
+                                avatarUrl = null,
+                                fullName = null
+                            )
+                        }
+                    },
+                    success = { user ->
+                        screenState.setValue { old ->
+                            old.copy(
+                                avatarUrl = user?.photo200,
+                                fullName = user?.fullName
+                            )
+                        }
+                    },
+                    any = ::loadAccountInfo
+                )
+            }
     }
 
     private fun loadAccountInfo() {

feature/profile/src/main/kotlin/dev/meloda/fast/profile/navigation/ProfileRoute.kt

@@ -18,9 +18,10 @@ fun NavGraphBuilder.profileScreen(
     onSettingsButtonClicked: () -> Unit,
     onPhotoClicked: (url: String) -> Unit
 ) {
+    val viewModel: ProfileViewModel = with(activity) { getViewModel() }
+
     composable<Profile> {
-        val viewModel: ProfileViewModel = activity.getViewModel()
-        val screenState by viewModel.screenStateFlow.collectAsStateWithLifecycle()
+        val screenState by viewModel.screenStateFlow().collectAsStateWithLifecycle()
 
         ProfileRoute(
             screenState = screenState,

feature/settings/src/main/kotlin/dev/meloda/fast/settings/SettingsViewModel.kt

@@ -11,10 +11,9 @@ import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.common.extensions.findWithIndex
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.common.extensions.updateValue
 import dev.meloda.fast.common.model.DarkMode
-import dev.meloda.fast.common.model.LongPollState
 import dev.meloda.fast.common.model.NetworkLogLevel
+import dev.meloda.fast.common.model.LongPollState
 import dev.meloda.fast.common.model.UiText
 import dev.meloda.fast.common.model.parseString
 import dev.meloda.fast.data.UserConfig
@@ -25,23 +24,19 @@ import dev.meloda.fast.datastore.SettingsKeys
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.GetCurrentAccountUseCase
 import dev.meloda.fast.domain.LoadUserByIdUseCase
-import dev.meloda.fast.logger.FastLogger
-import dev.meloda.fast.model.AccountDto
 import dev.meloda.fast.model.database.AccountEntity
 import dev.meloda.fast.settings.model.HapticType
 import dev.meloda.fast.settings.model.SettingsDialog
-import dev.meloda.fast.settings.model.SettingsEffect
-import dev.meloda.fast.settings.model.SettingsIntent
 import dev.meloda.fast.settings.model.SettingsItem
-import dev.meloda.fast.settings.model.SettingsNavigationIntent
 import dev.meloda.fast.settings.model.SettingsScreenState
 import dev.meloda.fast.settings.model.TextProvider
 import dev.meloda.fast.ui.R
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 
 class SettingsViewModel(
@@ -50,76 +45,35 @@ class SettingsViewModel(
     private val getCurrentAccountUseCase: GetCurrentAccountUseCase,
     private val userSettings: UserSettings,
     private val resources: Resources,
-    private val longPollController: LongPollController,
-    private val logger: FastLogger
+    private val longPollController: LongPollController
 ) : ViewModel() {
 
-    private val screenState = MutableStateFlow(SettingsScreenState.EMPTY)
-    val screenStateFlow get() = screenState.asStateFlow()
+    private val _screenState = MutableStateFlow(SettingsScreenState.EMPTY)
+    val screenState = _screenState.asStateFlow()
 
-    private val screenEffect = MutableSharedFlow<SettingsEffect>(extraBufferCapacity = 1)
-    val screenEffectFlow = screenEffect.asSharedFlow()
+    private val _hapticType = MutableStateFlow<HapticType?>(null)
+    val hapticType = _hapticType.asStateFlow()
 
-    private val settings = mutableListOf<SettingsItem<*>>()
-    private var showDebugCategory: Boolean = userSettings.showDebugCategory.value
+    private val _dialog = MutableStateFlow<SettingsDialog?>(null)
+    val dialog = _dialog.asStateFlow()
+
+    private val _isNeedToRestart = MutableStateFlow(false)
+    val isNeedToRestart = _isNeedToRestart.asStateFlow()
+
+    private val settings = MutableStateFlow<List<SettingsItem<*>>>(emptyList())
 
     init {
         createSettings()
     }
 
-    fun handleIntent(intent: SettingsIntent) {
-        when (intent) {
-            SettingsIntent.BackClick -> {
-                screenEffect.tryEmit(SettingsEffect.Navigate(SettingsNavigationIntent.Back))
-            }
-
-            is SettingsIntent.ItemClick -> {
-                onSettingsItemClicked(intent.key)
-            }
-
-            is SettingsIntent.ItemLongClick -> {
-                onSettingsItemLongClicked(intent.key)
-            }
-
-            is SettingsIntent.ItemValueChanged -> {
-                onSettingsItemChanged(intent.key, intent.newValue)
-            }
-
-            is SettingsIntent.Dialog -> {
-                when (intent) {
-                    SettingsIntent.Dialog.CancelClick -> Unit
-
-                    is SettingsIntent.Dialog.ConfirmClick -> {
-                        onDialogConfirmed(intent.bundle)
-                    }
-
-                    SettingsIntent.Dialog.Dismiss -> {
-                        onDialogDismissed()
-                    }
-
-                    is SettingsIntent.Dialog.ItemPick -> {
-                        onDialogItemPicked(intent.bundle)
-                    }
-                }
-            }
-        }
-    }
-
-    private fun setDialog(dialog: SettingsDialog?) {
-        screenState.updateValue { copy(dialog = dialog) }
-    }
-
-    private fun onDialogConfirmed(bundle: Bundle?) {
-        val dialog = screenState.value.dialog ?: return
-        onDialogDismissed()
+    fun onDialogConfirmed(dialog: SettingsDialog, bundle: Bundle) {
+        onDialogDismissed(dialog)
 
         when (dialog) {
             is SettingsDialog.LogOut -> onLogOutAlertPositiveClick()
             is SettingsDialog.PerformCrash -> onPerformCrashPositiveButtonClicked()
 
             is SettingsDialog.ImportAuthData -> {
-                if (bundle == null) return
-
                 val accessToken = bundle.getString("ACCESS_TOKEN") ?: return
                 val exchangeToken = bundle.getString("EXCHANGE_TOKEN")
                 val trustedHash = bundle.getString("TRUSTED_HASH")
@@ -135,29 +89,21 @@ class SettingsViewModel(
                     ).listenValue(viewModelScope) { state ->
                         state.processState(
                             error = { error ->
-                                logger.error(
-                                    this@SettingsViewModel::class,
-                                    "importAuthInfo(): loadUserById(): ERROR: $error"
-                                )
                                 UserConfig.accessToken = oldToken
                             },
                             success = { user ->
-                                if (user == null) {
-                                    UserConfig.accessToken = oldToken
-                                    return@listenValue
-                                }
+                                if (user == null) return@listenValue
 
                                 UserConfig.currentUserId = user.id
 
                                 val account = getCurrentAccountUseCase()
-                                    ?.mapToDto()
                                     ?.copy(
                                         userId = user.id,
                                         accessToken = accessToken,
                                         fastToken = null,
                                         exchangeToken = exchangeToken,
                                         trustedHash = trustedHash
-                                    ) ?: AccountDto(
+                                    ) ?: AccountEntity(
                                     userId = user.id,
                                     accessToken = accessToken,
                                     fastToken = null,
@@ -165,11 +111,9 @@ class SettingsViewModel(
                                     exchangeToken = exchangeToken
                                 )
 
-                                accountsRepository.storeAccounts(listOf(account.mapToEntity()))
+                                accountsRepository.storeAccounts(listOf(account))
 
-                                screenEffect.tryEmit(
-                                    SettingsEffect.Navigate(SettingsNavigationIntent.Restart)
-                                )
+                                _isNeedToRestart.setValue { true }
                             }
                         )
                     }
@@ -180,8 +124,7 @@ class SettingsViewModel(
         }
     }
 
-    private fun onDialogDismissed() {
-        val dialog = screenState.value.dialog ?: return
+    fun onDialogDismissed(dialog: SettingsDialog) {
         when (dialog) {
             is SettingsDialog.LogOut -> Unit
             is SettingsDialog.PerformCrash -> Unit
@@ -189,11 +132,10 @@ class SettingsViewModel(
             is SettingsDialog.ExportAuthData -> Unit
         }
 
-        setDialog(null)
+        _dialog.setValue { null }
     }
 
-    private fun onDialogItemPicked(bundle: Bundle?) {
-        val dialog = screenState.value.dialog ?: return
+    fun onDialogItemPicked(dialog: SettingsDialog, bundle: Bundle) {
         when (dialog) {
             is SettingsDialog.LogOut -> Unit
             is SettingsDialog.PerformCrash -> Unit
@@ -202,52 +144,55 @@ class SettingsViewModel(
         }
     }
 
-    private fun onLogOutAlertPositiveClick() {
+    fun onLogOutAlertPositiveClick() {
         viewModelScope.launch(Dispatchers.IO) {
-            accountsRepository.storeAccounts(
-                listOf(
-                    AccountEntity(
-                        userId = UserConfig.userId,
-                        accessToken = "",
-                        fastToken = UserConfig.fastToken,
-                        trustedHash = UserConfig.trustedHash,
-                        exchangeToken = null
+            val tasks = listOf(
+                async {
+                    accountsRepository.storeAccounts(
+                        listOf(
+                            AccountEntity(
+                                userId = UserConfig.userId,
+                                accessToken = "",
+                                fastToken = UserConfig.fastToken,
+                                trustedHash = UserConfig.trustedHash,
+                                exchangeToken = null
+                            )
+                        )
                     )
-                )
+                },
+                async { UserConfig.clear() }
             )
 
-            UserConfig.clear()
-
-            screenEffect.tryEmit(SettingsEffect.Navigate(SettingsNavigationIntent.LogOut))
+            tasks.awaitAll()
         }
     }
 
-    private fun onPerformCrashPositiveButtonClicked() {
+    fun onPerformCrashPositiveButtonClicked() {
         throw Exception("Test exception")
     }
 
-    private fun onSettingsItemClicked(key: String) {
+    fun onSettingsItemClicked(key: String) {
         when (key) {
             SettingsKeys.KEY_ACCOUNT_LOGOUT -> {
-                setDialog(SettingsDialog.LogOut)
+                _dialog.setValue { SettingsDialog.LogOut }
             }
 
             SettingsKeys.KEY_DEBUG_PERFORM_CRASH -> {
-                setDialog(SettingsDialog.PerformCrash)
+                _dialog.setValue { SettingsDialog.PerformCrash }
             }
 
             SettingsKeys.KEY_DEBUG_IMPORT_AUTH_DATA -> {
-                setDialog(SettingsDialog.ImportAuthData)
+                _dialog.setValue { SettingsDialog.ImportAuthData }
             }
 
             SettingsKeys.KEY_DEBUG_EXPORT_AUTH_DATA -> {
-                setDialog(
+                _dialog.setValue {
                     SettingsDialog.ExportAuthData(
                         accessToken = UserConfig.accessToken,
                         exchangeToken = UserConfig.exchangeToken,
                         trustedHash = UserConfig.trustedHash
                     )
-                )
+                }
             }
 
             SettingsKeys.KEY_DEBUG_HIDE_DEBUG_LIST -> {
@@ -258,13 +203,13 @@ class SettingsViewModel(
 
                 createSettings()
 
-                screenEffect.tryEmit(SettingsEffect.PerformHaptic(HapticType.REJECT))
-                showDebugCategory = false
+                _hapticType.update { HapticType.REJECT }
+                _screenState.setValue { old -> old.copy(showDebugOptions = false) }
             }
         }
     }
 
-    private fun onSettingsItemLongClicked(key: String) {
+    fun onSettingsItemLongClicked(key: String) {
         when (key) {
             SettingsKeys.KEY_ACTIVITY_SEND_ONLINE_STATUS -> {
                 if (AppSettings.Debug.showDebugCategory) return
@@ -274,18 +219,18 @@ class SettingsViewModel(
 
                 createSettings()
 
-                screenEffect.tryEmit(SettingsEffect.PerformHaptic(HapticType.LONG_PRESS))
-                showDebugCategory = true
+                _hapticType.update { HapticType.LONG_PRESS }
+                _screenState.setValue { old -> old.copy(showDebugOptions = true) }
             }
         }
     }
 
-    private fun onSettingsItemChanged(key: String, newValue: Any?) {
-        settings.findWithIndex { it.key == key }?.let { (index, item) ->
+    fun onSettingsItemChanged(key: String, newValue: Any?) {
+        settings.value.findWithIndex { it.key == key }?.let { (index, item) ->
             item.updateValue(newValue)
             item.updateText()
 
-            screenState.setValue { old ->
+            _screenState.setValue { old ->
                 old.copy(
                     settings = old.settings.toMutableList().apply {
                         this[index] = item.asPresentation(resources)
@@ -366,6 +311,10 @@ class SettingsViewModel(
         }
     }
 
+    fun onHapticPerformed() {
+        _hapticType.update { null }
+    }
+
     private fun createSettings() {
         val accountVisible = UserConfig.isLoggedIn()
         val accountTitle = SettingsItem.Title(
@@ -563,8 +512,7 @@ class SettingsViewModel(
             values = logLevelValues.keys.toList().map(NetworkLogLevel::value)
         ).apply {
             textProvider = TextProvider { item ->
-                val textValue =
-                    logLevelValues[NetworkLogLevel.parse(item.value)].parseString(resources)
+                val textValue = logLevelValues[NetworkLogLevel.parse(item.value)].parseString(resources)
 
                 UiText.Simple("Current value: $textValue")
             }
@@ -654,10 +602,12 @@ class SettingsViewModel(
     }
 
     private fun emitSettings(newSettings: List<SettingsItem<*>>) {
-        settings.clear()
-        settings.addAll(newSettings)
+        settings.update { newSettings }
 
-        val uiSettings = newSettings.map { it.asPresentation(resources) }
-        screenState.setValue { old -> old.copy(settings = uiSettings) }
+        val uiSettings = newSettings.map { item ->
+            item.asPresentation(resources)
+        }
+
+        _screenState.setValue { old -> old.copy(settings = uiSettings) }
     }
 }

feature/settings/src/main/kotlin/dev/meloda/fast/settings/model/SettingsEffect.kt

@@ -1,6 +0,0 @@
-package dev.meloda.fast.settings.model
-
-sealed interface SettingsEffect {
-    data class Navigate(val intent: SettingsNavigationIntent) : SettingsEffect
-    data class PerformHaptic(val type: HapticType) : SettingsEffect
-}

feature/settings/src/main/kotlin/dev/meloda/fast/settings/model/SettingsIntent.kt

@@ -1,18 +0,0 @@
-package dev.meloda.fast.settings.model
-
-import android.os.Bundle
-
-sealed class SettingsIntent {
-    data object BackClick : SettingsIntent()
-
-    data class ItemClick(val key: String) : SettingsIntent()
-    data class ItemLongClick(val key: String) : SettingsIntent()
-    data class ItemValueChanged(val key: String, val newValue: Any?) : SettingsIntent()
-
-    sealed class Dialog : SettingsIntent() {
-        data object Dismiss : Dialog()
-        data class ConfirmClick(val bundle: Bundle? = null) : Dialog()
-        data object CancelClick : Dialog()
-        data class ItemPick(val bundle: Bundle? = null) : Dialog()
-    }
-}

feature/settings/src/main/kotlin/dev/meloda/fast/settings/model/SettingsItem.kt

@@ -1,13 +1,13 @@
 package dev.meloda.fast.settings.model
 
 import android.content.res.Resources
-import androidx.compose.runtime.Stable
+import androidx.compose.runtime.Immutable
 import dev.meloda.fast.common.model.UiText
 import dev.meloda.fast.common.model.parseString
 import dev.meloda.fast.datastore.AppSettings
 import kotlin.reflect.KClass
 
-@Stable
+@Immutable
 sealed class SettingsItem<T>(
     val key: String,
     value: T,

feature/settings/src/main/kotlin/dev/meloda/fast/settings/model/SettingsNavigationIntent.kt

@@ -1,8 +0,0 @@
-package dev.meloda.fast.settings.model
-
-sealed class SettingsNavigationIntent {
-    data object Back : SettingsNavigationIntent()
-    data object Language : SettingsNavigationIntent()
-    data object Restart : SettingsNavigationIntent()
-    data object LogOut : SettingsNavigationIntent()
-}

feature/settings/src/main/kotlin/dev/meloda/fast/settings/model/SettingsScreenState.kt

@@ -6,13 +6,13 @@ import dev.meloda.fast.datastore.AppSettings
 @Immutable
 data class SettingsScreenState(
     val settings: List<UiItem>,
-    val dialog: SettingsDialog?
+    val showDebugOptions: Boolean
 ) {
 
     companion object {
         val EMPTY: SettingsScreenState = SettingsScreenState(
             settings = emptyList(),
-            dialog = null
+            showDebugOptions = AppSettings.Debug.showDebugCategory
         )
     }
 }

feature/settings/src/main/kotlin/dev/meloda/fast/settings/navigation/SettingsNavigation.kt

@@ -1,49 +1,26 @@
 package dev.meloda.fast.settings.navigation
 
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.platform.LocalView
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
 import androidx.navigation.NavGraphBuilder
 import androidx.navigation.compose.composable
-import dev.meloda.fast.datastore.AppSettings
-import dev.meloda.fast.settings.SettingsViewModel
-import dev.meloda.fast.settings.model.SettingsEffect
-import dev.meloda.fast.settings.model.SettingsNavigationIntent
 import dev.meloda.fast.settings.presentation.SettingsRoute
-import kotlinx.coroutines.flow.collect
-import kotlinx.coroutines.flow.onEach
 import kotlinx.serialization.Serializable
-import org.koin.androidx.compose.koinViewModel
 
 @Serializable
 object Settings
 
 fun NavGraphBuilder.settingsScreen(
-    handleNavigationIntent: (SettingsNavigationIntent) -> Unit
+    onBack: () -> Unit,
+    onLogOutButtonClicked: () -> Unit,
+    onLanguageItemClicked: () -> Unit,
+    onRestartRequired: () -> Unit,
 ) {
     composable<Settings> {
-        val view = LocalView.current
-        val viewModel: SettingsViewModel = koinViewModel()
-        val screenState by viewModel.screenStateFlow.collectAsStateWithLifecycle()
-
-        LaunchedEffect(Unit) {
-            viewModel.screenEffectFlow.onEach { effect ->
-                when (effect) {
-                    is SettingsEffect.Navigate -> handleNavigationIntent(effect.intent)
-                    is SettingsEffect.PerformHaptic -> {
-                        if (AppSettings.General.enableHaptic) {
-                            view.performHapticFeedback(effect.type.getHaptic())
-                        }
-                    }
-                }
-            }.collect()
-        }
-
         SettingsRoute(
-            handleIntent = viewModel::handleIntent,
-            screenState = screenState,
+            onBack = onBack,
+            onLogOutButtonClicked = onLogOutButtonClicked,
+            onLanguageItemClicked = onLanguageItemClicked,
+            onRestartRequired = onRestartRequired
         )
     }
 }

feature/settings/src/main/kotlin/dev/meloda/fast/settings/presentation/SettingsDialogs.kt

@@ -3,6 +3,7 @@ package dev.meloda.fast.settings.presentation
 import android.content.ClipData
 import android.content.ClipboardManager
 import android.content.Context
+import android.os.Bundle
 import android.widget.Toast
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
@@ -25,18 +26,20 @@ import androidx.core.os.bundleOf
 import dev.meloda.fast.data.UserConfig
 import dev.meloda.fast.datastore.SettingsKeys
 import dev.meloda.fast.settings.model.SettingsDialog
-import dev.meloda.fast.settings.model.SettingsIntent
 import dev.meloda.fast.settings.model.SettingsScreenState
-import dev.meloda.fast.ui.R
 import dev.meloda.fast.ui.components.ActionInvokeDismiss
 import dev.meloda.fast.ui.components.MaterialDialog
+import dev.meloda.fast.ui.R
 
 @Composable
 fun HandleDialogs(
-    handleIntent: (SettingsIntent.Dialog) -> Unit,
     screenState: SettingsScreenState,
+    dialog: SettingsDialog?,
+    onConfirmed: (SettingsDialog, Bundle) -> Unit = { _, _ -> },
+    onDismissed: (SettingsDialog) -> Unit = {},
+    onItemPicked: (SettingsDialog, Bundle) -> Unit = { _, _ -> }
 ) {
-    val dialog = screenState.dialog ?: return
+    if (dialog == null) return
 
     val context = LocalContext.current
 
@@ -45,13 +48,13 @@ fun HandleDialogs(
             val isEasterEgg = UserConfig.userId == SettingsKeys.ID_DMITRY
 
             MaterialDialog(
-                onDismissRequest = { handleIntent(SettingsIntent.Dialog.Dismiss) },
+                onDismissRequest = { onDismissed(dialog) },
                 title = stringResource(
                     id = if (isEasterEgg) R.string.easter_egg_log_out_dmitry
                     else R.string.sign_out_confirm_title
                 ),
                 text = stringResource(id = R.string.sign_out_confirm),
-                confirmAction = { handleIntent(SettingsIntent.Dialog.ConfirmClick()) },
+                confirmAction = { onConfirmed(dialog, bundleOf()) },
                 confirmText = stringResource(
                     id = if (isEasterEgg) R.string.easter_egg_log_out_dmitry
                     else R.string.action_sign_out
@@ -63,10 +66,10 @@ fun HandleDialogs(
 
         is SettingsDialog.PerformCrash -> {
             MaterialDialog(
-                onDismissRequest = { handleIntent(SettingsIntent.Dialog.Dismiss) },
+                onDismissRequest = { onDismissed(dialog) },
                 title = "Perform crash",
                 text = "App will be crashed. Are you sure?",
-                confirmAction = { handleIntent(SettingsIntent.Dialog.ConfirmClick()) },
+                confirmAction = { onConfirmed(dialog, bundleOf()) },
                 confirmText = stringResource(id = R.string.yes),
                 cancelText = stringResource(id = R.string.cancel),
                 actionInvokeDismiss = ActionInvokeDismiss.Always
@@ -85,16 +88,15 @@ fun HandleDialogs(
             }
 
             MaterialDialog(
-                onDismissRequest = { handleIntent(SettingsIntent.Dialog.Dismiss) },
+                onDismissRequest = { onDismissed(dialog) },
                 title = "Import auth data",
                 confirmAction = {
-                    handleIntent(
-                        SettingsIntent.Dialog.ConfirmClick(
-                            bundleOf(
-                                "ACCESS_TOKEN" to accessToken,
-                                "EXCHANGE_TOKEN" to exchangeToken.ifEmpty { null },
-                                "TRUSTED_HASH" to trustedHash.ifEmpty { null }
-                            )
+                    onConfirmed(
+                        dialog,
+                        bundleOf(
+                            "ACCESS_TOKEN" to accessToken,
+                            "EXCHANGE_TOKEN" to exchangeToken.ifEmpty { null },
+                            "TRUSTED_HASH" to trustedHash.ifEmpty { null }
                         )
                     )
                 },
@@ -196,16 +198,15 @@ fun HandleDialogs(
             }
 
             MaterialDialog(
-                onDismissRequest = { handleIntent(SettingsIntent.Dialog.Dismiss) },
+                onDismissRequest = { onDismissed(dialog) },
                 title = "Export auth data",
                 confirmAction = {
-                    handleIntent(
-                        SettingsIntent.Dialog.ConfirmClick(
-                            bundleOf(
-                                "ACCESS_TOKEN" to accessToken,
-                                "EXCHANGE_TOKEN" to exchangeToken.ifEmpty { null },
-                                "TRUSTED_HASH" to trustedHash.ifEmpty { null }
-                            )
+                    onConfirmed(
+                        dialog,
+                        bundleOf(
+                            "ACCESS_TOKEN" to accessToken,
+                            "EXCHANGE_TOKEN" to exchangeToken.ifEmpty { null },
+                            "TRUSTED_HASH" to trustedHash.ifEmpty { null }
                         )
                     )
                 },
@@ -268,8 +269,7 @@ fun HandleDialogs(
                                 "Auth data copied to clipboard. Be careful with this data. If another person gets it, your account will be at risk",
                                 Toast.LENGTH_LONG
                             ).show()
-
-                            handleIntent(SettingsIntent.Dialog.Dismiss)
+                            onDismissed(dialog)
                         },
                         modifier = Modifier.align(Alignment.CenterHorizontally)
                     ) {

feature/settings/src/main/kotlin/dev/meloda/fast/settings/presentation/SettingsRoute.kt

@@ -1,21 +1,65 @@
 package dev.meloda.fast.settings.presentation
 
 import androidx.compose.runtime.Composable
-import dev.meloda.fast.settings.model.SettingsIntent
-import dev.meloda.fast.settings.model.SettingsScreenState
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import dev.meloda.fast.datastore.SettingsKeys
+import dev.meloda.fast.settings.SettingsViewModel
+import dev.meloda.fast.settings.model.SettingsDialog
+import org.koin.compose.viewmodel.koinViewModel
 
 @Composable
 fun SettingsRoute(
-    handleIntent: (SettingsIntent) -> Unit,
-    screenState: SettingsScreenState,
+    onBack: () -> Unit,
+    onLogOutButtonClicked: () -> Unit,
+    onLanguageItemClicked: () -> Unit,
+    onRestartRequired: () -> Unit,
+    viewModel: SettingsViewModel = koinViewModel()
 ) {
+    val screenState by viewModel.screenState.collectAsStateWithLifecycle()
+    val hapticType by viewModel.hapticType.collectAsStateWithLifecycle()
+    val dialog by viewModel.dialog.collectAsStateWithLifecycle()
+    val isNeedToRestart by viewModel.isNeedToRestart.collectAsStateWithLifecycle()
+
+    LaunchedEffect(isNeedToRestart) {
+        if (isNeedToRestart) {
+            onRestartRequired()
+        }
+    }
+
     SettingsScreen(
-        handleIntent = handleIntent,
         screenState = screenState,
+        hapticType = hapticType,
+        onBack = onBack,
+        onHapticPerformed = viewModel::onHapticPerformed,
+        onSettingsItemClicked = { key ->
+            when (key) {
+                SettingsKeys.KEY_APPEARANCE_LANGUAGE -> {
+                    onLanguageItemClicked()
+                }
+
+                else -> viewModel.onSettingsItemClicked(key)
+            }
+        },
+        onSettingsItemLongClicked = viewModel::onSettingsItemLongClicked,
+        onSettingsItemValueChanged = viewModel::onSettingsItemChanged
     )
 
     HandleDialogs(
-        handleIntent = handleIntent,
         screenState = screenState,
+        dialog = dialog,
+        onConfirmed = { dialog, bundle ->
+            when (dialog) {
+                is SettingsDialog.LogOut -> {
+                    onLogOutButtonClicked()
+                }
+
+                else -> Unit
+            }
+            viewModel.onDialogConfirmed(dialog, bundle)
+        },
+        onDismissed = viewModel::onDialogDismissed,
+        onItemPicked = viewModel::onDialogItemPicked
     )
 }

feature/settings/src/main/kotlin/dev/meloda/fast/settings/presentation/SettingsScreen.kt

@@ -21,10 +21,10 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
@@ -34,7 +34,8 @@ import dev.chrisbanes.haze.hazeEffect
 import dev.chrisbanes.haze.hazeSource
 import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
 import dev.chrisbanes.haze.materials.HazeMaterials
-import dev.meloda.fast.settings.model.SettingsIntent
+import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.settings.model.HapticType
 import dev.meloda.fast.settings.model.SettingsScreenState
 import dev.meloda.fast.settings.model.UiItem
 import dev.meloda.fast.settings.presentation.item.ListItem
@@ -42,8 +43,8 @@ import dev.meloda.fast.settings.presentation.item.SwitchItem
 import dev.meloda.fast.settings.presentation.item.TextFieldItem
 import dev.meloda.fast.settings.presentation.item.TitleItem
 import dev.meloda.fast.settings.presentation.item.TitleTextItem
-import dev.meloda.fast.ui.R
 import dev.meloda.fast.ui.theme.LocalThemeConfig
+import dev.meloda.fast.ui.R
 
 
 @OptIn(
@@ -52,19 +53,23 @@ import dev.meloda.fast.ui.theme.LocalThemeConfig
 )
 @Composable
 fun SettingsScreen(
-    handleIntent: (SettingsIntent) -> Unit,
     screenState: SettingsScreenState = SettingsScreenState.EMPTY,
+    hapticType: HapticType? = null,
+    onBack: () -> Unit = {},
+    onHapticPerformed: () -> Unit = {},
+    onSettingsItemClicked: (key: String) -> Unit = {},
+    onSettingsItemLongClicked: (key: String) -> Unit = {},
+    onSettingsItemValueChanged: (key: String, newValue: Any?) -> Unit = { _, _ -> }
 ) {
-    val onSettingsItemClicked by rememberUpdatedState { key: String ->
-        handleIntent(SettingsIntent.ItemClick(key))
-    }
+    val view = LocalView.current
 
-    val onSettingsItemLongClicked by rememberUpdatedState { key: String ->
-        handleIntent(SettingsIntent.ItemLongClick(key))
-    }
-
-    val onSettingsItemValueChanged by rememberUpdatedState { key: String, newValue: Any? ->
-        handleIntent(SettingsIntent.ItemValueChanged(key, newValue))
+    LaunchedEffect(hapticType) {
+        if (hapticType != null) {
+            if (AppSettings.General.enableHaptic) {
+                view.performHapticFeedback(hapticType.getHaptic())
+            }
+            onHapticPerformed()
+        }
     }
 
     val themeConfig = LocalThemeConfig.current
@@ -85,7 +90,7 @@ fun SettingsScreen(
                     )
                 },
                 navigationIcon = {
-                    IconButton(onClick = { handleIntent(SettingsIntent.BackClick) }) {
+                    IconButton(onClick = onBack) {
                         Icon(
                             painter = painterResource(id = R.drawable.ic_arrow_back_round_24),
                             contentDescription = "Back button"