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/common/di/ApplicationModule.kt

@@ -22,7 +22,6 @@ 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
@@ -73,6 +72,4 @@ val applicationModule = module {
 
     singleOf(::LongPollControllerImpl) bind LongPollController::class
     singleOf(::ResourceProviderImpl) bind ResourceProvider::class
-
-    singleOf(::NetworkObserver)
 }

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

@@ -23,13 +23,11 @@ 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
 
@@ -183,8 +181,6 @@ class MainActivity : AppCompatActivity() {
     override fun onDestroy() {
         super.onDestroy()
         stopServices()
-        get<LongPollEventsHandler>().onDestroy()
-        get<NetworkObserver>().onDestroy()
     }
 
     companion object {

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

@@ -1,274 +0,0 @@
-package dev.meloda.fast.presentation
-
-import android.content.Context
-import android.net.ConnectivityManager
-import android.net.LinkProperties
-import android.net.Network
-import android.net.NetworkCapabilities
-import android.net.NetworkRequest
-import dev.meloda.fast.logger.FastLogger
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import java.util.concurrent.ConcurrentHashMap
-
-class NetworkObserver(
-    context: Context,
-    private val logger: FastLogger
-) {
-
-    private val connectivityManager =
-        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-
-    private val networkStatus = MutableStateFlow(NetworkStatus.UNAVAILABLE)
-    val networkStatusFlow = networkStatus.asStateFlow()
-
-    private val networkState = MutableStateFlow(NetworkState.DISCONNECTED)
-    val networkStateFlow = networkState.asStateFlow()
-
-    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
-        }
-
-        networkState.value = state
-        networkStatus.value = when (state) {
-            NetworkState.CONNECTED -> NetworkStatus.AVAILABLE
-            NetworkState.DISCONNECTED -> NetworkStatus.UNAVAILABLE
-        }
-
-        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
-                )
-
-                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 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 log(text: String) {
-        logger.debug(this::class, text)
-    }
-
-    private fun mapNetworkModel(
-        network: Network,
-        capabilities: NetworkCapabilities? = null,
-        properties: LinkProperties? = null,
-        status: NetworkStatus? = null,
-        maxMsToLive: Long? = null,
-        from: NetworkModel? = null
-    ): 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 = caps?.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
-            ?: from?.hasInternet
-            ?: false
-
-        val signalStrength =
-            if (android.os.Build.VERSION.SDK_INT >= android.os.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)
-        )
-    }
-
-    fun onDestroy() {
-        clearCallbacks?.let { unregisterCallback ->
-            runCatching { unregisterCallback() }
-                .onFailure { throwable ->
-                    logger.error(
-                        this::class.java,
-                        "Failed to unregister network callback",
-                        throwable
-                    )
-                }
-        }
-        clearCallbacks = null
-        networks.clear()
-        syncNetworkState()
-    }
-}
-
-enum class NetworkType {
-    CELLULAR, WIFI, UNKNOWN
-}
-
-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()
-}
-
-enum class NetworkStatus {
-    AVAILABLE, UNAVAILABLE, LOST, BLOCKED, UNBLOCKED;
-
-    fun isOk(): Boolean = when (this) {
-        AVAILABLE, UNBLOCKED -> true
-        UNAVAILABLE, LOST, BLOCKED -> false
-    }
-}
-
-enum class NetworkState { CONNECTED, DISCONNECTED }

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

@@ -59,7 +59,6 @@ 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
@@ -363,31 +362,18 @@ fun RootScreen(
                             )
 
                             settingsScreen(
-                                handleNavigationIntent = { intent ->
-                                    when (intent) {
-                                        SettingsNavigationIntent.Back -> navController.navigateUp()
-                                        SettingsNavigationIntent.Language -> navController.navigateToLanguagePicker()
-                                        SettingsNavigationIntent.Restart -> {
+                                onBack = navController::navigateUp,
+                                onLogOutButtonClicked = { navController.navigateToAuth(true) },
+                                onLanguageItemClicked = navController::navigateToLanguagePicker,
+                                onRestartRequired = {
                                     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()
+                                        val intent = Intent(activity, MainActivity::class.java)
+                                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
                                         activity.startActivity(intent)
-                                            }
-                                        }
-
-                                        SettingsNavigationIntent.LogOut -> {
-                                            navController.navigateToAuth(true)
-                                        }
+                                        activity.finish()
                                     }
                                 }
                             )
-
                             languagePickerScreen(onBack = navController::navigateUp)
                         }
 

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/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,16 +29,9 @@ 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) {
+    suspend fun handleEvents(events: List<LongPollParsedEvent>) {
         events.forEach { handleNextEvent(it) }
     }
-        }
-    }
 
     private suspend fun handleNextEvent(event: LongPollParsedEvent) {
         when (event) {
@@ -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/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/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()

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/convos/src/main/kotlin/dev/meloda/fast/convos/ConvosViewModel.kt

@@ -27,7 +27,7 @@ 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
@@ -46,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,
@@ -74,15 +74,15 @@ 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()
@@ -382,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,7 +25,7 @@ val convosModule = module {
 private fun Scope.createConvosViewModel(filter: ConvosFilter): ConvosViewModel {
     return ConvosViewModel(
         filter = filter,
-        eventsHandler = get(),
+        updatesParser = get(),
         convoUseCase = get(),
         messagesUseCase = get(),
         resources = get(),

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

@@ -65,7 +65,6 @@ 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
@@ -283,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>()
 
+    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,56 +9,49 @@ 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))
-
+        getLocalUserByIdUseCase(UserConfig.userId)
+            .listenValue(viewModelScope) { state ->
                 state.processState(
                     error = {
-                    logger.debug(this@ProfileViewModel::class, "ERROR")
-                    emit(screenState.value.copy(avatarUrl = null, fullName = null))
+                        screenState.setValue { old ->
+                            old.copy(
+                                avatarUrl = null,
+                                fullName = null
+                            )
+                        }
                     },
                     success = { user ->
-                    logger.debug(this@ProfileViewModel::class, "SUCCESS")
-                    emit(
-                        screenState.value.copy(
+                        screenState.setValue { old ->
+                            old.copy(
                                 avatarUrl = user?.photo200,
                                 fullName = user?.fullName
                             )
-                    )
+                        }
                     },
                     any = ::loadAccountInfo
                 )
             }
     }
 
-    private fun emit(state: ProfileScreenState) {
-        screenState.setValue { state }
-    }
-
     private fun loadAccountInfo() {
         loadUserByIdUseCase(
             userId = null,

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,22 +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.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(
@@ -49,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")
@@ -134,17 +89,10 @@ 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
 
@@ -165,9 +113,7 @@ class SettingsViewModel(
 
                                 accountsRepository.storeAccounts(listOf(account))
 
-                                screenEffect.tryEmit(
-                                    SettingsEffect.Navigate(SettingsNavigationIntent.Restart)
-                                )
+                                _isNeedToRestart.setValue { true }
                             }
                         )
                     }
@@ -178,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
@@ -187,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
@@ -200,8 +144,10 @@ class SettingsViewModel(
         }
     }
 
-    private fun onLogOutAlertPositiveClick() {
+    fun onLogOutAlertPositiveClick() {
         viewModelScope.launch(Dispatchers.IO) {
+            val tasks = listOf(
+                async {
                     accountsRepository.storeAccounts(
                         listOf(
                             AccountEntity(
@@ -213,39 +159,40 @@ class SettingsViewModel(
                             )
                         )
                     )
+                },
+                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 -> {
@@ -256,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
@@ -272,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)
@@ -364,6 +311,10 @@ class SettingsViewModel(
         }
     }
 
+    fun onHapticPerformed() {
+        _hapticType.update { null }
+    }
+
     private fun createSettings() {
         val accountVisible = UserConfig.isLoggedIn()
         val accountTitle = SettingsItem.Title(
@@ -561,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")
             }
@@ -652,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,18 +88,17 @@ fun HandleDialogs(
             }
 
             MaterialDialog(
-                onDismissRequest = { handleIntent(SettingsIntent.Dialog.Dismiss) },
+                onDismissRequest = { onDismissed(dialog) },
                 title = "Import auth data",
                 confirmAction = {
-                    handleIntent(
-                        SettingsIntent.Dialog.ConfirmClick(
+                    onConfirmed(
+                        dialog,
                         bundleOf(
                             "ACCESS_TOKEN" to accessToken,
                             "EXCHANGE_TOKEN" to exchangeToken.ifEmpty { null },
                             "TRUSTED_HASH" to trustedHash.ifEmpty { null }
                         )
                     )
-                    )
                 },
                 confirmText = "Import",
                 cancelText = stringResource(R.string.cancel)
@@ -196,18 +198,17 @@ fun HandleDialogs(
             }
 
             MaterialDialog(
-                onDismissRequest = { handleIntent(SettingsIntent.Dialog.Dismiss) },
+                onDismissRequest = { onDismissed(dialog) },
                 title = "Export auth data",
                 confirmAction = {
-                    handleIntent(
-                        SettingsIntent.Dialog.ConfirmClick(
+                    onConfirmed(
+                        dialog,
                         bundleOf(
                             "ACCESS_TOKEN" to accessToken,
                             "EXCHANGE_TOKEN" to exchangeToken.ifEmpty { null },
                             "TRUSTED_HASH" to trustedHash.ifEmpty { null }
                         )
                     )
-                    )
                 },
                 confirmText = stringResource(R.string.ok),
             ) {
@@ -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))
+    LaunchedEffect(hapticType) {
+        if (hapticType != null) {
+            if (AppSettings.General.enableHaptic) {
+                view.performHapticFeedback(hapticType.getHaptic())
+            }
+            onHapticPerformed()
         }
-
-    val onSettingsItemValueChanged by rememberUpdatedState { key: String, newValue: Any? ->
-        handleIntent(SettingsIntent.ItemValueChanged(key, newValue))
     }
 
     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"