build: update gradle wrapper and build logic conventions

TECH_DEBT_AUDIT.md

@@ -1,131 +0,0 @@
-# Fast Messenger Tech Debt Audit
-
-## Critical
-
-### `core/network/src/main/kotlin/dev/meloda/fast/network/interceptor/Error14HandlingInterceptor.kt`
-- captcha flow is built around `wait/notify`, a raw executor, and shared mutable state.
-- risk: deadlocks, leaked jobs, hard-to-reproduce auth hangs.
-- fix: rewrite as suspend-based flow with timeout and explicit cancellation.
-
-### `core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollEventParser.kt`
-- file mixes parsing, dispatching, IO loading, and concurrency orchestration.
-- risk: regressions when VK event format changes.
-- fix: split by event family and add parser tests.
-
-### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/MessagesHistoryViewModelImpl.kt`
-- view model is doing too much: loaders, navigation, selection, long poll hooks, read peers, dialog flow.
-- risk: brittle state transitions and untestable branching.
-- fix: extract coordinators/handlers per concern.
-
-### `app/src/main/kotlin/dev/meloda/fast/MainViewModel.kt`
-- root bootstrap handles auth, locale, long poll, permissions, profile, and start destination in one class.
-- risk: startup bugs and hidden coupling between flows.
-- fix: move startup/permission orchestration into dedicated controllers.
-
-### `app/src/main/kotlin/dev/meloda/fast/presentation/RootScreen.kt`
-- root composable owns too many top-level flows and dialogs.
-- risk: UI orchestration drift and hard-to-read navigation logic.
-- fix: split dialogs, bootstrap, and navigation concern into smaller composables.
-
-## High
-
-### `core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollEventParser.kt`
-- uses many `Log.d` calls and large `when` branches.
-- fix: reduce logging noise and add structured tracing only where needed.
-
-### `core/network/src/main/kotlin/dev/meloda/fast/network/ResponseConverterFactory.kt`
-- double-parsing response bodies and only logging malformed payloads.
-- risk: opaque failures and harder debugging.
-- fix: normalize error conversion and surface typed failures.
-
-### `feature/profile/src/main/kotlin/dev/meloda/fast/profile/ProfileViewModel.kt`
-- `loadAccountInfo()` has an empty error branch.
-- risk: profile can fail silently.
-- fix: set `baseError` and show fallback UI.
-
-### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/attachments/Attachments.kt`
-- attachment preview logic still sits in UI layer and mixes fallback behavior.
-- risk: silent drops of unsupported attachments.
-- fix: move preview mapping to domain/ui-model layer.
-
-### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/Link.kt`
-- title handling is nullable and duplicated with preview logic.
-- fix: create a small UI model for link rendering.
-
-### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/File.kt`
-- preview extraction is inline and branches on raw model internals.
-- fix: extract to mapper/UI model.
-
-### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/MessagesList.kt`
-- message-item interaction is dense and repeated.
-- fix: normalize scroll/reply handlers and reduce nested callbacks.
-
-## Medium
-
-### `core/data/src/main/kotlin/dev/meloda/fast/data/VkUsersMap.kt`
-- lookup helpers were using unsafe assumptions on external data.
-- status: already improved, but should stay covered by tests.
-
-### `core/data/src/main/kotlin/dev/meloda/fast/data/VkGroupsMap.kt`
-- same risk profile as users map.
-- status: already improved, still needs tests.
-
-### `core/domain/src/main/kotlin/dev/meloda/fast/domain/OAuthUseCaseImpl.kt`
-- auth success mapping used forced unwraps on server data.
-- status: already improved, but auth contract should be validated.
-
-### `app/src/main/kotlin/dev/meloda/fast/presentation/MainActivity.kt`
-- service lifecycle now respects config changes, but app exit semantics should be documented.
-- fix: keep explicit separation of app-close vs config-change behavior.
-
-### `build-logic/convention/src/main/kotlin/dev/meloda/fast/KotlinAndroid.kt`
-- build-tools are pinned to the local environment.
-- risk: portable builds may drift between machines.
-- fix: prefer SDK-managed consistency or document required SDK version.
-
-### `app/src/main/kotlin/dev/meloda/fast/presentation/RootErrorDialog.kt`
-- currently hardcodes English strings for some errors.
-- fix: localize all texts through resources.
-
-### `app/src/main/kotlin/dev/meloda/fast/presentation/RootScreen.kt`
-- root-level error dialog is better, but some orchestration still remains in the root composable.
-- fix: split into smaller root flows over time.
-
-## Low
-
-### `core/ui/src/main/kotlin/dev/meloda/fast/ui/components/AnimatedDots.kt`
-- marked TODO rewrite.
-- fix when touching related loading UI.
-
-### `core/ui/src/main/kotlin/dev/meloda/fast/ui/theme/AppTheme.kt`
-- color picker TODO suggests unfinished theme customization.
-
-### `core/model/src/main/kotlin/dev/meloda/fast/model/api/data/LongPollUpdates.kt`
-- `List<List<Any>>` is a weakly typed API boundary.
-- fix: introduce explicit event DTOs.
-
-### `core/model/src/main/kotlin/dev/meloda/fast/model/api/domain/VkMessage.kt`
-- attachment persistence is still a TODO area.
-
-### `core/model/src/main/kotlin/dev/meloda/fast/model/database/VkMessageEntity.kt`
-- attachment storage/restoration is unresolved.
-
-### `core/common/src/main/kotlin/dev/meloda/fast/common/model/LongPollState.kt`
-- Android 15 support TODO.
-
-### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/MessagesHistoryViewModelImpl.kt`
-- large commented-out legacy block should be removed once upload flow is reimplemented.
-
-### `feature/auth/src/main/kotlin/dev/meloda/fast/auth/login/LoginViewModel.kt`
-- debug/auth token acquisition TODO indicates unfinished auth path.
-
-## What To Do First
-1. Rewrite captcha interceptor.
-2. Split `LongPollEventParser`.
-3. Extract `MessagesHistoryViewModelImpl` orchestration.
-4. Localize `RootErrorDialog` strings.
-5. Add tests for auth, long poll parsing, and attachment mapping.
-
-## Note
-- Current code is already better on crash-prone nullable handling and service lifecycle.
-- Remaining work is mostly structural and testability-focused.

app/build.gradle.kts

@@ -43,11 +43,10 @@ android {
 
     buildTypes {
         named("debug") {
-            signingConfig = signingConfigs.getByName("debugSigning")
             applicationIdSuffix = ".debug"
         }
         named("release") {
-            signingConfig = signingConfigs.getByName("release")
+            signingConfig = signingConfigs.getByName("debug")
 
             isMinifyEnabled = true
             isShrinkResources = true

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

@@ -2,6 +2,7 @@ package dev.meloda.fast
 
 import android.content.Intent
 import android.os.Build
+import android.util.Log
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.core.app.NotificationCompat
 import androidx.core.os.LocaleListCompat
@@ -37,7 +38,6 @@ interface MainViewModel {
     val startDestination: StateFlow<Any?>
     val isNeedToReplaceWithAuth: StateFlow<Boolean>
     val currentUser: StateFlow<VkUser?>
-    val baseError: StateFlow<BaseError?>
 
     val isNeedToShowNotificationsDeniedDialog: StateFlow<Boolean>
     val isNeedToShowNotificationsRationaleDialog: StateFlow<Boolean>
@@ -45,7 +45,6 @@ interface MainViewModel {
     val isNeedToRequestNotifications: StateFlow<Boolean>
 
     fun onError(error: BaseError)
-    fun onErrorConsumed()
 
     fun onNavigatedToAuth()
 
@@ -74,7 +73,6 @@ class MainViewModelImpl(
     override val startDestination = MutableStateFlow<Any?>(null)
     override val isNeedToReplaceWithAuth = MutableStateFlow(false)
     override val currentUser = MutableStateFlow<VkUser?>(null)
-    override val baseError = MutableStateFlow<BaseError?>(null)
 
     override val isNeedToShowNotificationsDeniedDialog = MutableStateFlow(false)
     override val isNeedToShowNotificationsRationaleDialog = MutableStateFlow(false)
@@ -84,10 +82,6 @@ class MainViewModelImpl(
     private var openNotificationsSettings = false
     private var openAppSettings = false
 
-    init {
-        listenLongPollState()
-    }
-
     override fun onError(error: BaseError) {
         when (error) {
             BaseError.SessionExpired,
@@ -95,16 +89,10 @@ class MainViewModelImpl(
                 isNeedToReplaceWithAuth.update { true }
             }
 
-            else -> {
+            else -> Unit // TODO: 21-Mar-25, Danil Nikolaev: show error in ui
-                baseError.update { error }
-            }
         }
     }
 
-    override fun onErrorConsumed() {
-        baseError.update { null }
-    }
-
     override fun onNavigatedToAuth() {
         isNeedToReplaceWithAuth.update { false }
     }
@@ -215,6 +203,10 @@ class MainViewModelImpl(
         viewModelScope.launch(Dispatchers.IO) {
             val currentAccount = getCurrentAccountUseCase()
 
+            Log.d("MainViewModel", "currentAccount: $currentAccount")
+
+            listenLongPollState()
+
             if (currentAccount != null) {
                 UserConfig.apply {
                     this.userId = currentAccount.userId

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

@@ -9,6 +9,7 @@ import android.content.res.Configuration
 import android.os.Build
 import android.os.Bundle
 import android.provider.Settings
+import android.util.Log
 import androidx.activity.SystemBarStyle
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
@@ -64,6 +65,9 @@ class MainActivity : AppCompatActivity() {
 
         setContent {
             val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
+            LaunchedEffect(viewModel) {
+                Log.d("VM_CREATE", "onCreate: viewModel: $viewModel")
+            }
 
             LifecycleResumeEffect(true) {
                 viewModel.onAppResumed(intent)

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

@@ -45,7 +45,6 @@ import dev.meloda.fast.friends.navigation.friendsScreen
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.BottomNavigationItem
 import dev.meloda.fast.navigation.MainGraph
-import dev.meloda.fast.profile.navigation.Profile
 import dev.meloda.fast.profile.navigation.profileScreen
 import dev.meloda.fast.ui.theme.LocalBottomPadding
 import dev.meloda.fast.ui.theme.LocalHazeState
@@ -70,18 +69,15 @@ fun MainScreen(
     val theme = LocalThemeConfig.current
     val hazeState = remember { HazeState(true) }
     val navController = rememberNavController()
-    val defaultTabIndex = remember(navigationItems) {
-        navigationItems.indexOfFirst { it.route == ConvoGraph }.takeIf { it >= 0 } ?: 0
-    }
 
     var selectedItemIndex by rememberSaveable {
-        mutableIntStateOf(defaultTabIndex)
+        mutableIntStateOf(1)
     }
 
-    BackHandler(enabled = selectedItemIndex != defaultTabIndex) {
+    BackHandler(enabled = selectedItemIndex != 1) {
         val currentRoute = navigationItems[selectedItemIndex].route
 
-        selectedItemIndex = defaultTabIndex
+        selectedItemIndex = 1
         navController.navigate(navigationItems[selectedItemIndex].route) {
             popUpTo(route = currentRoute) {
                 inclusive = true
@@ -131,7 +127,7 @@ fun MainScreen(
                             }
                         },
                         icon = {
-                            if (item.route == Profile) {
+                            if (index == navigationItems.size - 1) {
                                 var isLoading by remember {
                                     mutableStateOf(true)
                                 }

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

@@ -1,38 +0,0 @@
-package dev.meloda.fast.presentation
-
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.stringResource
-import dev.meloda.fast.model.BaseError
-import dev.meloda.fast.ui.R
-
-@Composable
-fun RootErrorDialog(
-    baseError: BaseError?,
-    onDismiss: () -> Unit,
-    onConfirm: () -> Unit,
-) {
-    if (baseError == null) return
-
-    val errorText = when (baseError) {
-        BaseError.ConnectionError -> "Connection error"
-        BaseError.InternalError -> "Internal error"
-        BaseError.UnknownError -> "Unknown error"
-        is BaseError.SimpleError -> baseError.message
-        BaseError.SessionExpired -> "Session expired"
-        BaseError.AccountBlocked -> "Account blocked"
-    }
-
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = { Text(text = stringResource(id = R.string.warning)) },
-        text = { Text(text = errorText) },
-        confirmButton = {
-            TextButton(onClick = onConfirm) {
-                Text(text = stringResource(id = R.string.try_again))
-            }
-        }
-    )
-}

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

@@ -4,12 +4,16 @@ import android.Manifest
 import android.content.Intent
 import android.net.Uri
 import android.provider.Settings
+import android.util.Log
 import androidx.activity.compose.LocalActivity
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
@@ -87,7 +91,10 @@ fun RootScreen(
     val longPollCurrentState by longPollController.currentState.collectAsStateWithLifecycle()
     val longPollStateToApply by longPollController.stateToApply.collectAsStateWithLifecycle()
 
-            val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
+    val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
+    LaunchedEffect(viewModel) {
+        Log.d("VM_CREATE", "RootScreen(): viewModel: $viewModel")
+    }
 
     val currentUser: VkUser? by viewModel.currentUser.collectAsStateWithLifecycle()
 
@@ -118,12 +125,14 @@ fun RootScreen(
         }
     }
 
-        LifecycleResumeEffect(longPollStateToApply) {
+    LifecycleResumeEffect(longPollStateToApply) {
+        Log.d("LongPollMainActivity", "longPollStateToApply: $longPollStateToApply")
         if (longPollStateToApply != LongPollState.Background) {
             if (longPollStateToApply.isLaunched() && longPollCurrentState.isLaunched()
                 && longPollCurrentState != longPollStateToApply
             ) {
                 toggleLongPollService(false, null)
+                Log.d("LongPoll", "recreate()")
             }
 
             toggleLongPollService(
@@ -232,7 +241,6 @@ fun RootScreen(
             val context = LocalContext.current
             val startDestination by viewModel.startDestination.collectAsStateWithLifecycle()
             val isNeedToOpenAuth by viewModel.isNeedToReplaceWithAuth.collectAsStateWithLifecycle()
-            val baseError by viewModel.baseError.collectAsStateWithLifecycle()
             val isNeedToShowDeniedDialog by viewModel.isNeedToShowNotificationsDeniedDialog.collectAsStateWithLifecycle()
             val isNeedToShowRationaleDialog by viewModel.isNeedToShowNotificationsRationaleDialog.collectAsStateWithLifecycle()
 
@@ -296,12 +304,6 @@ fun RootScreen(
                 )
             }
 
-            RootErrorDialog(
-                baseError = baseError,
-                onDismiss = viewModel::onErrorConsumed,
-                onConfirm = viewModel::onErrorConsumed
-            )
-
             if (startDestination != null) {
                 CompositionLocalProvider(
                     LocalNavRootController provides navController,

app/src/main/kotlin/dev/meloda/fast/service/longpolling/LongPollingService.kt

@@ -16,17 +16,11 @@ import dev.meloda.fast.common.LongPollController
 import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.model.LongPollState
-import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.data.UserConfig
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.AppSettings
 import dev.meloda.fast.domain.LongPollUpdatesParser
 import dev.meloda.fast.domain.LongPollUseCase
-import dev.meloda.fast.domain.MessagesUseCase
-import dev.meloda.fast.domain.StoreUsersUseCase
-import dev.meloda.fast.model.api.data.VkGroupData
-import dev.meloda.fast.model.api.data.VkUserData
-import dev.meloda.fast.model.api.data.asDomain
 import dev.meloda.fast.model.api.data.LongPollUpdates
 import dev.meloda.fast.model.api.data.VkLongPollData
 import dev.meloda.fast.ui.R
@@ -39,7 +33,6 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlinx.coroutines.flow.last
 import org.koin.android.ext.android.inject
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
@@ -62,8 +55,6 @@ class LongPollingService : Service() {
     private val coroutineScope = CoroutineScope(coroutineContext)
 
     private val longPollUseCase: LongPollUseCase by inject()
-    private val messagesUseCase: MessagesUseCase by inject()
-    private val storeUsersUseCase: StoreUsersUseCase by inject()
     private val updatesParser: LongPollUpdatesParser by inject()
 
     private var currentJob: Job? = null
@@ -159,8 +150,6 @@ class LongPollingService : Service() {
             var serverInfo = getServerInfo()
                 ?: throw LongPollException(message = "bad VK response (server info)")
 
-            syncLongPollHistory(serverInfo)
-
             var lastUpdatesResponse: LongPollUpdates? = getUpdatesResponse(serverInfo)
                 ?: throw LongPollException(message = "initiation error: bad VK response (last updates)")
 
@@ -171,7 +160,6 @@ class LongPollingService : Service() {
                     failCount++
                     serverInfo = getServerInfo()
                         ?: throw LongPollException(message = "failed retrieving server info after error: bad VK response (server info #2)")
-                    syncLongPollHistory(serverInfo)
                     lastUpdatesResponse = getUpdatesResponse(serverInfo)
                     continue
                 }
@@ -191,7 +179,6 @@ class LongPollingService : Service() {
                             ?: throw LongPollException(
                                 message = "failed retrieving server info after error: bad VK response (server info #3)"
                             )
-                        syncLongPollHistory(serverInfo)
                         lastUpdatesResponse = getUpdatesResponse(serverInfo)
                     }
 
@@ -209,9 +196,6 @@ class LongPollingService : Service() {
                                 updates.forEach(updatesParser::parseNextUpdate)
                             }
 
-                            AppSettings.LongPoll.ts = lastUpdatesResponse.ts ?: serverInfo.ts
-                            AppSettings.LongPoll.pts = lastUpdatesResponse.pts ?: AppSettings.LongPoll.pts
-
                             lastUpdatesResponse = getUpdatesResponse(serverInfo.copy(ts = newTs))
                         }
                     }
@@ -262,73 +246,6 @@ class LongPollingService : Service() {
         }
     }
 
-    private suspend fun syncLongPollHistory(serverInfo: VkLongPollData) {
-        val cursorTs = AppSettings.LongPoll.ts ?: serverInfo.ts
-        val cursorPts = AppSettings.LongPoll.pts ?: serverInfo.pts
-        val maxMsgId = messagesUseCase.getLocalMaxMessageId()
-
-        var currentTs = cursorTs
-        var currentPts = cursorPts
-        var more: Int?
-
-        do {
-            val historyResponse = getLongPollHistory(
-                ts = currentTs,
-                pts = currentPts,
-                maxMsgId = maxMsgId
-            ) ?: return
-
-            historyResponse.history.orEmpty().forEach(updatesParser::parseNextUpdate)
-
-            historyResponse.messages?.items.orEmpty().takeIf { it.isNotEmpty() }?.let { rawMessages ->
-                val messages = rawMessages.map { it.asDomain() }
-                messagesUseCase.storeMessages(messages)
-            }
-
-            historyResponse.profiles.orEmpty().takeIf { it.isNotEmpty() }?.let { profiles ->
-                val users = profiles.map(VkUserData::mapToDomain)
-                VkMemoryCache.appendUsers(users)
-                storeUsersUseCase(users).last()
-            }
-
-            historyResponse.groups.orEmpty().takeIf { it.isNotEmpty() }?.let { groups ->
-                VkMemoryCache.appendGroups(groups.map(VkGroupData::mapToDomain))
-            }
-
-            currentTs = historyResponse.ts ?: historyResponse.fromPts ?: currentTs
-            currentPts = historyResponse.newPts ?: historyResponse.pts ?: currentPts
-            more = historyResponse.more
-
-            AppSettings.LongPoll.ts = currentTs
-            AppSettings.LongPoll.pts = currentPts
-        } while (more == 1)
-    }
-
-    private suspend fun getLongPollHistory(
-        ts: Int,
-        pts: Int,
-        maxMsgId: Long?
-    ): dev.meloda.fast.model.api.data.LongPollHistoryResponse? = suspendCancellableCoroutine {
-        longPollUseCase.getLongPollHistory(
-            ts = ts,
-            pts = pts,
-            lpVersion = VkConstants.LP_VERSION,
-            maxMsgId = maxMsgId,
-            eventsLimit = 1000,
-            msgsLimit = 200
-        ).listenValue(coroutineScope) { state ->
-            state.processState(
-                success = { response ->
-                    it.resume(response)
-                },
-                error = { error ->
-                    Log.e(TAG, "getLongPollHistory: error: $error")
-                    it.resume(null)
-                }
-            )
-        }
-    }
-
     private fun handleError(throwable: Throwable) {
         Log.e(TAG, "error: $throwable")
 

app/src/main/kotlin/dev/meloda/fast/service/longpolling/di/LongPollModule.kt

@@ -1,7 +1,6 @@
 package dev.meloda.fast.service.longpolling.di
 
 import dev.meloda.fast.domain.LongPollUpdatesParser
-import dev.meloda.fast.domain.LongPollUpdatesReducer
 import dev.meloda.fast.domain.LongPollUseCase
 import dev.meloda.fast.domain.LongPollUseCaseImpl
 import org.koin.core.module.dsl.singleOf
@@ -11,5 +10,4 @@ import org.koin.dsl.module
 val longPollModule = module {
     singleOf(::LongPollUseCaseImpl) bind LongPollUseCase::class
     singleOf(::LongPollUpdatesParser)
-    singleOf(::LongPollUpdatesReducer)
 }

build-logic/convention/src/main/kotlin/AndroidApplicationConventionPlugin.kt

@@ -19,6 +19,9 @@ class AndroidApplicationConventionPlugin : Plugin<Project> {
                     compileSdk = getVersionInt("compileSdk")
                     targetSdk = getVersionInt("targetSdk")
                 }
+                lint {
+                    abortOnError = false
+                }
             }
         }
     }

build-logic/convention/src/main/kotlin/AndroidLibraryConventionPlugin.kt

@@ -2,6 +2,7 @@ import com.android.build.api.dsl.LibraryExtension
 import com.android.build.api.variant.LibraryAndroidComponentsExtension
 import dev.meloda.fast.configureKotlinAndroid
 import dev.meloda.fast.disableUnnecessaryAndroidTests
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -20,7 +21,13 @@ class AndroidLibraryConventionPlugin : Plugin<Project> {
             extensions.configure<LibraryExtension> {
                 configureKotlinAndroid(this)
                 androidResources.enable = false
-                defaultConfig.testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                }
+                lint {
+                    abortOnError = false
+                }
             }
             extensions.configure<LibraryAndroidComponentsExtension> {
                 disableUnnecessaryAndroidTests(target)

build-logic/convention/src/main/kotlin/dev/meloda/fast/KotlinAndroid.kt

@@ -25,7 +25,6 @@ internal fun Project.configureKotlinAndroid(
 
     commonExtension.apply {
         compileSdk = getVersionInt("compileSdk")
-        buildToolsVersion = "36.1.0"
     }
 
     configureKotlin<KotlinAndroidProjectExtension>()

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

@@ -13,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
@@ -46,14 +45,6 @@ fun <T> Flow<T>.listenValue(
     action: suspend (T) -> Unit
 ): Job = onEach(action::invoke).launchIn(coroutineScope)
 
-fun CoroutineScope.launchDbRefresh(
-    load: suspend () -> Unit,
-    after: suspend () -> Unit
-): Job = launch {
-    load()
-    after()
-}
-
 fun createTimerFlow(
     time: Int,
     onStartAction: (suspend () -> Unit)? = null,

core/common/src/main/kotlin/dev/meloda/fast/common/paging/Paging.kt

@@ -1,25 +0,0 @@
-package dev.meloda.fast.common.paging
-
-fun canPaginate(pageSize: Int, loadedCount: Int): Boolean = loadedCount == pageSize
-
-fun isPaginationExhausted(
-    pageSize: Int,
-    loadedCount: Int,
-    hasExistingItems: Boolean
-): Boolean = loadedCount != pageSize && hasExistingItems
-
-fun <T> mergePage(
-    existing: List<T>,
-    page: List<T>,
-    offset: Int
-): List<T> = if (offset == 0) page else existing + page
-
-data class LoadingFlags(
-    val isLoading: Boolean,
-    val isPaginating: Boolean
-)
-
-fun loadingFlags(offset: Int, isLoading: Boolean): LoadingFlags = LoadingFlags(
-    isLoading = offset == 0 && isLoading,
-    isPaginating = offset > 0 && isLoading
-)

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

@@ -1,18 +1,24 @@
 package dev.meloda.fast.data
 
+import androidx.core.net.toUri
 import okhttp3.Interceptor
 import okhttp3.Response
+import java.net.URLEncoder
 
 class AccessTokenInterceptor : Interceptor {
 
     override fun intercept(chain: Interceptor.Chain): Response {
-        val request = chain.request()
+        val builder = chain.request().url.newBuilder()
-        val urlBuilder = request.url.newBuilder()
 
-        if (request.url.queryParameter("access_token") == null) {
+        val uri = builder.build().toUri().toString().toUri()
-            urlBuilder.addQueryParameter("access_token", UserConfig.accessToken)
+
+        if (uri.getQueryParameter("access_token") == null) {
+            builder.addQueryParameter(
+                "access_token",
+                URLEncoder.encode(UserConfig.accessToken, "utf-8")
+            )
         }
 
-        return chain.proceed(request.newBuilder().url(urlBuilder.build()).build())
+        return chain.proceed(chain.request().newBuilder().apply { url(builder.build()) }.build())
     }
 }

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

@@ -24,9 +24,6 @@ object UserConfig {
         accessToken = ""
         fastToken = ""
         userId = -1
-        trustedHash = null
-        exchangeToken = null
-        AppSettings.LongPoll.clear()
     }
 
     fun isLoggedIn(): Boolean {

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

@@ -21,10 +21,12 @@ class VkGroupsMap(
         else map[abs(convo.id)]
 
     fun messageActionGroup(message: VkMessage): VkGroupDomain? =
-        message.actionMemberId?.takeIf { it < 0 }?.let { map[abs(it)] }
+        if (message.actionMemberId == null || message.actionMemberId!! >= 0) null
+        else map[abs(message.actionMemberId!!)]
 
     fun messageActionGroup(message: VkMessageData): VkGroupDomain? =
-        message.action?.memberId?.takeIf { it < 0 }?.let { map[abs(it)] }
+        if (message.action?.memberId == null || message.action!!.memberId!! >= 0) null
+        else map[abs(message.action!!.memberId!!)]
 
     fun messageGroup(message: VkMessage): VkGroupDomain? =
         if (!message.isGroup()) null

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

@@ -1,5 +1,6 @@
 package dev.meloda.fast.data
 
+import dev.meloda.fast.data.UserConfig.userId
 import dev.meloda.fast.model.api.domain.VkContactDomain
 import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkGroupDomain
@@ -37,15 +38,7 @@ object VkMemoryCache {
         contacts.forEach { contact -> VkMemoryCache.contacts[contact.userId] = contact }
     }
 
-    fun clear() {
+    operator fun set(userid: Long, user: VkUser) {
-        users.clear()
-        groups.clear()
-        messages.clear()
-        convos.clear()
-        contacts.clear()
-    }
-
-    operator fun set(userId: Long, user: VkUser) {
         users[userId] = user
     }
 

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

@@ -20,10 +20,12 @@ class VkUsersMap(
         else map[convo.id]
 
     fun messageActionUser(message: VkMessage): VkUser? =
-        message.actionMemberId?.takeIf { it > 0 }?.let(map::get)
+        if (message.actionMemberId == null || message.actionMemberId!! <= 0) null
+        else map[message.actionMemberId]
 
     fun messageActionUser(message: VkMessageData): VkUser? =
-        message.action?.memberId?.takeIf { it > 0 }?.let(map::get)
+        if (message.action?.memberId == null || message.action!!.memberId!! <= 0) null
+        else map[message.action!!.memberId]
 
     fun messageUser(message: VkMessage): VkUser? =
         if (!message.isUser()) null

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

@@ -8,9 +8,6 @@ import dev.meloda.fast.network.RestApiErrorDomain
 interface ConvosRepository {
 
     suspend fun storeConvos(convos: List<VkConvo>)
-    suspend fun getLocalConvos(): List<VkConvo>
-    suspend fun getLocalConvoById(peerId: Long): VkConvo?
-    suspend fun deleteLocalConvo(peerId: Long)
 
     suspend fun getConvos(
         count: Int?,

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

@@ -19,13 +19,11 @@ import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.model.api.domain.asEntity
-import dev.meloda.fast.model.database.VkConvoEntity
 import dev.meloda.fast.model.api.requests.ConvosGetRequest
 import dev.meloda.fast.network.RestApiErrorDomain
 import dev.meloda.fast.network.mapApiDefault
 import dev.meloda.fast.network.mapApiResult
 import dev.meloda.fast.network.service.convos.ConvosService
-import dev.meloda.fast.model.database.asExternalModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -42,28 +40,6 @@ class ConvosRepositoryImpl(
         convoDao.insertAll(convos.map(VkConvo::asEntity))
     }
 
-    override suspend fun getLocalConvos(): List<VkConvo> = withContext(Dispatchers.IO) {
-        convoDao.getAllWithMessage().map { convoWithMessage ->
-            convoWithMessage.convo.asExternalModel().copy(
-                lastMessage = convoWithMessage.message?.asExternalModel()
-            )
-        }.sorted()
-    }
-
-    override suspend fun getLocalConvoById(peerId: Long): VkConvo? = withContext(Dispatchers.IO) {
-        convoDao.getByIdWithMessage(peerId)?.let { convoWithMessage ->
-            convoWithMessage.convo.asExternalModel().copy(
-                lastMessage = convoWithMessage.message?.asExternalModel()
-            )
-        }
-    }
-
-    override suspend fun deleteLocalConvo(peerId: Long) {
-        withContext(Dispatchers.IO) {
-            convoDao.deleteById(peerId)
-        }
-    }
-
     override suspend fun getConvos(
         count: Int?,
         offset: Int?,
@@ -222,28 +198,4 @@ class ConvosRepositoryImpl(
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
         convosService.unarchive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
-
-    private fun List<VkConvo>.sorted(): List<VkConvo> {
-        val newConvos = toMutableList()
-
-        val pinnedConvos = newConvos
-            .filter(VkConvo::isPinned)
-            .sortedWith { c1, c2 ->
-                val diff = c2.majorId - c1.majorId
-
-                if (diff == 0) {
-                    c2.minorId - c1.minorId
-                } else {
-                    diff
-                }
-            }
-
-        newConvos.removeAll(pinnedConvos)
-        newConvos.sortWith { c1, c2 ->
-            (c2.lastMessage?.date ?: 0) - (c1.lastMessage?.date ?: 0)
-        }
-
-        newConvos.addAll(0, pinnedConvos)
-        return newConvos
-    }
 }

core/data/src/main/kotlin/dev/meloda/fast/data/api/longpoll/LongPollRepository.kt

@@ -1,7 +1,6 @@
 package dev.meloda.fast.data.api.longpoll
 
 import dev.meloda.fast.model.api.data.LongPollUpdates
-import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.VkLongPollData
 import dev.meloda.fast.network.RestApiErrorDomain
 import com.slack.eithernet.ApiResult
@@ -22,14 +21,4 @@ interface LongPollRepository {
         mode: Int,
         version: Int
     ): ApiResult<LongPollUpdates, RestApiErrorDomain>
-
-    suspend fun getLongPollHistory(
-        ts: Int,
-        pts: Int,
-        lpVersion: Int,
-        lastN: Int? = null,
-        maxMsgId: Long? = null,
-        eventsLimit: Int? = null,
-        msgsLimit: Int? = null
-    ): ApiResult<LongPollHistoryResponse, RestApiErrorDomain>
 }

core/data/src/main/kotlin/dev/meloda/fast/data/api/longpoll/LongPollRepositoryImpl.kt

@@ -1,9 +1,7 @@
 package dev.meloda.fast.data.api.longpoll
 
 import dev.meloda.fast.model.api.data.LongPollUpdates
-import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.VkLongPollData
-import dev.meloda.fast.model.api.requests.LongPollGetHistoryRequest
 import dev.meloda.fast.model.api.requests.LongPollGetUpdatesRequest
 import dev.meloda.fast.model.api.requests.MessagesGetLongPollServerRequest
 import dev.meloda.fast.network.RestApiErrorDomain
@@ -54,29 +52,4 @@ class LongPollRepositoryImpl(
 
         longPollService.getResponse(serverUrl, requestModel.map).mapDefault()
     }
-
-    override suspend fun getLongPollHistory(
-        ts: Int,
-        pts: Int,
-        lpVersion: Int,
-        lastN: Int?,
-        maxMsgId: Long?,
-        eventsLimit: Int?,
-        msgsLimit: Int?
-    ): ApiResult<LongPollHistoryResponse, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        val requestModel = LongPollGetHistoryRequest(
-            ts = ts,
-            pts = pts,
-            lpVersion = lpVersion,
-            lastN = lastN,
-            maxMsgId = maxMsgId,
-            eventsLimit = eventsLimit,
-            msgsLimit = msgsLimit
-        )
-
-        messagesService.getLongPollHistory(requestModel.map).mapApiResult(
-            successMapper = { response -> response.requireResponse() },
-            errorMapper = { error -> error?.toDomain() }
-        )
-    }
 }

core/data/src/main/kotlin/dev/meloda/fast/data/api/messages/MessagesRepository.kt

@@ -14,12 +14,6 @@ interface MessagesRepository {
 
     suspend fun storeMessages(messages: List<VkMessage>)
 
-    suspend fun getLocalMessages(convoId: Long): List<VkMessage>
-    suspend fun getLocalMessageById(messageId: Long): VkMessage?
-    suspend fun getLocalMessageByConvoMessageId(convoId: Long, cmId: Long): VkMessage?
-    suspend fun getLocalMaxMessageId(): Long?
-    suspend fun deleteLocalMessages(messageIds: List<Long>)
-
     suspend fun getHistory(
         convoId: Long,
         offset: Int?,

core/data/src/main/kotlin/dev/meloda/fast/data/api/messages/MessagesRepositoryImpl.kt

@@ -22,7 +22,6 @@ import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.model.api.domain.asEntity
-import dev.meloda.fast.model.database.VkMessageEntity
 import dev.meloda.fast.model.api.requests.MessagesCreateChatRequest
 import dev.meloda.fast.model.api.requests.MessagesDeleteRequest
 import dev.meloda.fast.model.api.requests.MessagesEditRequest
@@ -40,7 +39,6 @@ import dev.meloda.fast.model.api.requests.MessagesUnpinMessageRequest
 import dev.meloda.fast.model.api.responses.MessagesGetConvoMembersResponse
 import dev.meloda.fast.model.api.responses.MessagesGetReadPeersResponse
 import dev.meloda.fast.model.api.responses.MessagesSendResponse
-import dev.meloda.fast.model.database.asExternalModel
 import dev.meloda.fast.network.RestApiErrorDomain
 import dev.meloda.fast.network.mapApiDefault
 import dev.meloda.fast.network.mapApiResult
@@ -356,28 +354,6 @@ class MessagesRepositoryImpl(
         messageDao.insertAll(messages.map(VkMessage::asEntity))
     }
 
-    override suspend fun getLocalMessages(convoId: Long): List<VkMessage> = withContext(Dispatchers.IO) {
-        messageDao.getAll(convoId).map(VkMessageEntity::asExternalModel)
-    }
-
-    override suspend fun getLocalMessageById(messageId: Long): VkMessage? = withContext(Dispatchers.IO) {
-        messageDao.getById(messageId)?.asExternalModel()
-    }
-
-    override suspend fun getLocalMessageByConvoMessageId(convoId: Long, cmId: Long): VkMessage? = withContext(Dispatchers.IO) {
-        messageDao.getByConvoMessageId(convoId, cmId)?.asExternalModel()
-    }
-
-    override suspend fun getLocalMaxMessageId(): Long? = withContext(Dispatchers.IO) {
-        messageDao.getMaxId()
-    }
-
-    override suspend fun deleteLocalMessages(messageIds: List<Long>) {
-        withContext(Dispatchers.IO) {
-            messageDao.deleteByIds(messageIds)
-        }
-    }
-
     override suspend fun edit(
         peerId: Long,
         messageId: Long?,

core/database/src/main/kotlin/dev/meloda/fast/database/dao/ConvoDao.kt

@@ -9,13 +9,9 @@ import dev.meloda.fast.model.database.VkConvoEntity
 @Dao
 abstract class ConvoDao : EntityDao<VkConvoEntity> {
 
-    @Query("SELECT * FROM convos ORDER BY majorId DESC, minorId DESC")
+    @Query("SELECT * FROM convos")
     abstract suspend fun getAll(): List<VkConvoEntity>
 
-    @Transaction
-    @Query("SELECT * FROM convos ORDER BY majorId DESC, minorId DESC")
-    abstract suspend fun getAllWithMessage(): List<ConvoWithMessage>
-
     @Query("SELECT * FROM convos WHERE id IN (:ids)")
     abstract suspend fun getAllByIds(ids: List<Int>): List<VkConvoEntity>
 
@@ -26,9 +22,6 @@ abstract class ConvoDao : EntityDao<VkConvoEntity> {
     @Query("SELECT * FROM convos WHERE id IS (:id)")
     abstract suspend fun getByIdWithMessage(id: Long): ConvoWithMessage?
 
-    @Query("DELETE FROM convos WHERE id IS (:id)")
-    abstract suspend fun deleteById(id: Long): Int
-
     @Query("DELETE FROM convos WHERE rowid IN (:ids)")
     abstract suspend fun deleteByIds(ids: List<Int>): Int
 }

core/database/src/main/kotlin/dev/meloda/fast/database/dao/MessageDao.kt

@@ -10,21 +10,15 @@ abstract class MessageDao : EntityDao<VkMessageEntity> {
     @Query("SELECT * FROM messages")
     abstract suspend fun getAll(): List<VkMessageEntity>
 
-    @Query("SELECT * FROM messages WHERE peerId IS (:convoId) ORDER BY date DESC, id DESC")
+    @Query("SELECT * FROM messages WHERE peerId IS (:convoId)")
     abstract suspend fun getAll(convoId: Long): List<VkMessageEntity>
 
     @Query("SELECT * FROM messages WHERE id IN (:ids)")
-    abstract suspend fun getAllByIds(ids: List<Long>): List<VkMessageEntity>
+    abstract suspend fun getAllByIds(ids: List<Int>): List<VkMessageEntity>
 
     @Query("SELECT * FROM messages WHERE id IS (:messageId)")
     abstract suspend fun getById(messageId: Long): VkMessageEntity?
 
-    @Query("SELECT * FROM messages WHERE peerId IS (:convoId) AND cmId IS (:cmId)")
-    abstract suspend fun getByConvoMessageId(convoId: Long, cmId: Long): VkMessageEntity?
-
-    @Query("SELECT MAX(id) FROM messages")
-    abstract suspend fun getMaxId(): Long?
-
     @Query("DELETE FROM messages WHERE id IN (:ids)")
-    abstract suspend fun deleteByIds(ids: List<Long>): Int
+    abstract suspend fun deleteByIds(ids: List<Int>): Int
 }

core/datastore/src/main/kotlin/dev/meloda/fast/datastore/AppSettings.kt

@@ -230,21 +230,6 @@ object AppSettings {
             set(value) = put(SettingsKeys.KEY_MORE_ANIMATIONS, value)
     }
 
-    object LongPoll {
-        var ts: Int?
-            get() = get(SettingsKeys.KEY_LONG_POLL_TS, 0).takeIf { it > 0 }
-            set(value) = put(SettingsKeys.KEY_LONG_POLL_TS, value ?: 0)
-
-        var pts: Int?
-            get() = get(SettingsKeys.KEY_LONG_POLL_PTS, 0).takeIf { it > 0 }
-            set(value) = put(SettingsKeys.KEY_LONG_POLL_PTS, value ?: 0)
-
-        fun clear() {
-            ts = null
-            pts = null
-        }
-    }
-
     object Debug {
         var showAlertAfterCrash: Boolean
             get() = get(

core/datastore/src/main/kotlin/dev/meloda/fast/datastore/SettingsKeys.kt

@@ -39,8 +39,6 @@ object SettingsKeys {
     const val DEFAULT_VALUE_FEATURES_FAST_TEXT = "¯\\_(ツ)_/¯"
     const val KEY_LONG_POLL_IN_BACKGROUND = "lp_background"
     const val DEFAULT_LONG_POLL_IN_BACKGROUND = false
-    const val KEY_LONG_POLL_TS = "lp_ts"
-    const val KEY_LONG_POLL_PTS = "lp_pts"
 
     const val KEY_ACTIVITY_SEND_ONLINE_STATUS = "activity_send_online_status"
     const val DEFAULT_VALUE_KEY_ACTIVITY_SEND_ONLINE_STATUS = false

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

@@ -8,9 +8,6 @@ import kotlinx.coroutines.flow.Flow
 interface ConvoUseCase : BaseUseCase {
 
     suspend fun storeConvos(convos: List<VkConvo>)
-    suspend fun getLocalConvos(): List<VkConvo>
-    suspend fun getLocalConvoById(peerId: Long): VkConvo?
-    suspend fun deleteLocalConvo(peerId: Long)
 
     fun getConvos(
         count: Int? = null,

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

@@ -19,18 +19,6 @@ class ConvoUseCaseImpl(
         repository.storeConvos(convos)
     }
 
-    override suspend fun getLocalConvos(): List<VkConvo> = withContext(Dispatchers.IO) {
-        repository.getLocalConvos()
-    }
-
-    override suspend fun getLocalConvoById(peerId: Long): VkConvo? = withContext(Dispatchers.IO) {
-        repository.getLocalConvoById(peerId)
-    }
-
-    override suspend fun deleteLocalConvo(peerId: Long) = withContext(Dispatchers.IO) {
-        repository.deleteLocalConvo(peerId)
-    }
-
     override fun getConvos(
         count: Int?,
         offset: Int?,

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

@@ -1,36 +0,0 @@
-package dev.meloda.fast.domain
-
-import dev.meloda.fast.model.LongPollEvent
-import dev.meloda.fast.model.LongPollParsedEvent
-
-internal class LongPollEventDispatcher {
-    private val listenersMap: MutableMap<LongPollEvent, MutableList<VkEventCallback<LongPollParsedEvent>>> =
-        mutableMapOf()
-
-    @Suppress("UNCHECKED_CAST")
-    fun <T : LongPollParsedEvent> dispatch(eventType: LongPollEvent, event: T) {
-        listenersMap[eventType]?.forEach { callback ->
-            (callback as? VkEventCallback<T>)?.onEvent(event)
-        }
-    }
-
-    fun dispatchAll(eventType: LongPollEvent, events: List<LongPollParsedEvent>) {
-        events.forEach { event -> dispatch(eventType, event) }
-    }
-
-    @Suppress("UNCHECKED_CAST")
-    fun <T : LongPollParsedEvent> registerListener(
-        eventType: LongPollEvent,
-        listener: VkEventCallback<T>
-    ) {
-        listenersMap[eventType] = (listenersMap[eventType] ?: mutableListOf())
-            .also { it.add(listener as VkEventCallback<LongPollParsedEvent>) }
-    }
-
-    fun <T : LongPollParsedEvent> registerListeners(
-        eventTypes: List<LongPollEvent>,
-        listener: VkEventCallback<T>
-    ) {
-        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
-    }
-}

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

@@ -1,537 +0,0 @@
-package dev.meloda.fast.domain
-
-import android.util.Log
-import dev.meloda.fast.common.VkConstants
-import dev.meloda.fast.common.extensions.asInt
-import dev.meloda.fast.common.extensions.asLong
-import dev.meloda.fast.common.extensions.listenValue
-import dev.meloda.fast.common.extensions.toList
-import dev.meloda.fast.data.UserConfig
-import dev.meloda.fast.data.processState
-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
-import dev.meloda.fast.model.api.domain.VkMessage
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-
-internal class LongPollEventParser(
-    private val coroutineScope: CoroutineScope,
-    private val convoUseCase: ConvoUseCase,
-    private val messagesUseCase: MessagesUseCase,
-    private val dispatch: (LongPollEvent, LongPollParsedEvent) -> Unit,
-    private val dispatchAll: (LongPollEvent, List<LongPollParsedEvent>) -> Unit
-) {
-    fun parseNextUpdate(event: List<Any>) {
-        val eventId = event.first().asInt()
-
-        when (val eventType = ApiEvent.parseOrNull(eventId)) {
-            null -> Unit
-
-            ApiEvent.MESSAGE_SET_FLAGS -> parseMessageSetFlags(eventType, event)
-            ApiEvent.MESSAGE_CLEAR_FLAGS -> parseMessageClearFlags(eventType, event)
-            ApiEvent.MESSAGE_NEW -> parseMessageNew(eventType, event)
-            ApiEvent.MESSAGE_EDIT -> parseMessageEdit(eventType, event)
-            ApiEvent.MESSAGE_READ_INCOMING -> parseMessageReadIncoming(eventType, event)
-            ApiEvent.MESSAGE_READ_OUTGOING -> parseMessageReadOutgoing(eventType, event)
-            ApiEvent.CHAT_CLEAR_FLAGS -> parseChatClearFlags(eventType, event)
-            ApiEvent.CHAT_SET_FLAGS -> parseChatSetFlags(eventType, event)
-            ApiEvent.MESSAGES_DELETED -> parseMessagesDeleted(eventType, event)
-            ApiEvent.CHAT_MAJOR_CHANGED -> parseChatMajorChanged(eventType, event)
-            ApiEvent.CHAT_MINOR_CHANGED -> parseChatMinorChanged(eventType, event)
-
-            ApiEvent.TYPING,
-            ApiEvent.AUDIO_MESSAGE_RECORDING,
-            ApiEvent.PHOTO_UPLOADING,
-            ApiEvent.VIDEO_UPLOADING,
-            ApiEvent.FILE_UPLOADING -> parseInteraction(eventType, event)
-
-            ApiEvent.UNREAD_COUNT_UPDATE -> parseUnreadCounterUpdate(eventType, event)
-            ApiEvent.MESSAGE_UPDATED -> parseMessageUpdated(eventType, event)
-            ApiEvent.MESSAGE_CACHE_CLEAR -> parseMessageCacheClear(eventType, event)
-        }
-    }
-
-    private fun parseMessageSetFlags(eventType: ApiEvent, event: List<Any>) {
-        val cmId = event[1].asLong()
-        val flags = event[2].asInt()
-        val peerId = event[3].asLong()
-
-        val eventsToSend = mutableListOf<LongPollParsedEvent>()
-
-        val parsedFlags = MessageFlags.parse(flags)
-        parsedFlags.forEach { flag ->
-            when (flag) {
-                MessageFlags.IMPORTANT -> {
-                    val eventToSend = LongPollParsedEvent.MessageMarkedAsImportant(
-                        peerId = peerId,
-                        cmId = cmId,
-                        marked = true
-                    )
-                    eventsToSend += eventToSend
-                    dispatch(LongPollEvent.MARKED_AS_IMPORTANT, eventToSend)
-                }
-
-                MessageFlags.SPAM -> {
-                    val eventToSend = LongPollParsedEvent.MessageMarkedAsSpam(
-                        peerId = peerId,
-                        cmId = cmId
-                    )
-                    eventsToSend += eventToSend
-                    dispatch(LongPollEvent.MARKED_AS_SPAM, eventToSend)
-                }
-
-                MessageFlags.DELETED -> {
-                    val eventToSend =
-                        if (parsedFlags.contains(MessageFlags.DELETED_FOR_ALL)) {
-                            LongPollParsedEvent.MessageDeleted(
-                                peerId = peerId,
-                                cmId = cmId,
-                                forAll = true
-                            )
-                        } else {
-                            LongPollParsedEvent.MessageDeleted(
-                                peerId = peerId,
-                                cmId = cmId,
-                                forAll = false
-                            )
-                        }
-                    eventsToSend += eventToSend
-                    dispatch(LongPollEvent.MESSAGE_DELETED, eventToSend)
-                }
-
-                MessageFlags.AUDIO_LISTENED -> {
-                    val eventToSend = LongPollParsedEvent.AudioMessageListened(
-                        peerId = peerId,
-                        cmId = cmId
-                    )
-                    eventsToSend += eventToSend
-                    dispatch(LongPollEvent.AUDIO_MESSAGE_LISTENED, eventToSend)
-                }
-
-                else -> Unit
-            }
-        }
-
-        dispatchAll(LongPollEvent.MESSAGE_SET_FLAGS, eventsToSend)
-    }
-
-    private fun parseMessageClearFlags(eventType: ApiEvent, event: List<Any>) {
-        val cmId = event[1].asLong()
-        val flags = event[2].asInt()
-        val peerId = event[3].asLong()
-
-        val eventsToSend = mutableListOf<LongPollParsedEvent>()
-
-        val parsedFlags = MessageFlags.parse(flags)
-
-        coroutineScope.launch {
-            parsedFlags.forEach { flag ->
-                when (flag) {
-                    MessageFlags.IMPORTANT -> {
-                        val eventToSend = LongPollParsedEvent.MessageMarkedAsImportant(
-                            peerId = peerId,
-                            cmId = cmId,
-                            marked = false
-                        )
-                        eventsToSend += eventToSend
-                        dispatch(LongPollEvent.MARKED_AS_IMPORTANT, eventToSend)
-                    }
-
-                    MessageFlags.SPAM -> {
-                        if (parsedFlags.contains(MessageFlags.CANCEL_SPAM)) {
-                            withContext(Dispatchers.IO) {
-                                val message = loadMessage(
-                                    peerId = peerId,
-                                    cmId = cmId
-                                )
-                                message?.let {
-                                    val eventToSend =
-                                        LongPollParsedEvent.MessageMarkedAsNotSpam(message = message)
-                                    eventsToSend += eventToSend
-                                    dispatch(LongPollEvent.MARKED_AS_NOT_SPAM, eventToSend)
-                                }
-                            }
-                        }
-                    }
-
-                    MessageFlags.DELETED -> {
-                        withContext(Dispatchers.IO) {
-                            val message = loadMessage(
-                                peerId = peerId,
-                                cmId = cmId
-                            )
-                            message?.let {
-                                val eventToSend =
-                                    LongPollParsedEvent.MessageRestored(message = message)
-                                eventsToSend += eventToSend
-                                dispatch(LongPollEvent.MESSAGE_RESTORED, eventToSend)
-                            }
-                        }
-                    }
-
-                    else -> Unit
-                }
-            }
-
-            dispatchAll(LongPollEvent.MESSAGE_CLEAR_FLAGS, eventsToSend)
-        }
-    }
-
-    private fun parseMessageNew(eventType: ApiEvent, event: List<Any>) {
-        val cmId = event[1].asLong()
-        val peerId = event[4].asLong()
-
-        coroutineScope.launch(Dispatchers.IO) {
-            val message =
-                async { loadMessage(peerId = peerId, cmId = cmId) }.await()
-
-            val convo =
-                async {
-                    loadConvo(
-                        peerId = peerId,
-                        extended = true,
-                        fields = VkConstants.ALL_FIELDS
-                    )
-                }.await()
-
-            message?.let {
-                dispatch(
-                    LongPollEvent.MESSAGE_NEW,
-                    LongPollParsedEvent.NewMessage(
-                        message = message,
-                        inArchive = convo?.isArchived == true
-                    )
-                )
-            }
-        }
-    }
-
-    private fun parseMessageEdit(eventType: ApiEvent, event: List<Any>) {
-        val cmId = event[1].asLong()
-        val peerId = event[3].asLong()
-
-        coroutineScope.launch(Dispatchers.IO) {
-            loadMessage(
-                peerId = peerId,
-                cmId = cmId
-            )?.let { message ->
-                dispatch(LongPollEvent.MESSAGE_EDITED, LongPollParsedEvent.MessageEdited(message))
-            }
-        }
-    }
-
-    private fun parseMessageReadIncoming(eventType: ApiEvent, event: List<Any>) {
-        dispatchMessageRead(
-            longPollEvent = LongPollEvent.INCOMING_MESSAGE_READ,
-            parsedEvent = LongPollParsedEvent.IncomingMessageRead(
-                peerId = event[1].asLong(),
-                cmId = event[2].asLong(),
-                unreadCount = event[3].asInt()
-            )
-        )
-    }
-
-    private fun parseMessageReadOutgoing(eventType: ApiEvent, event: List<Any>) {
-        dispatchMessageRead(
-            longPollEvent = LongPollEvent.OUTGOING_MESSAGE_READ,
-            parsedEvent = LongPollParsedEvent.OutgoingMessageRead(
-                peerId = event[1].asLong(),
-                cmId = event[2].asLong(),
-                unreadCount = event[3].asInt()
-            )
-        )
-    }
-
-    private fun parseChatClearFlags(eventType: ApiEvent, event: List<Any>) {
-        val peerId = event[1].asLong()
-        val flags = event[2].asInt()
-
-        val eventsToSend = mutableListOf<LongPollParsedEvent>()
-
-        val parsedFlags = ConvoFlags.parse(flags)
-
-        coroutineScope.launch(Dispatchers.IO) {
-            parsedFlags.forEach { flag ->
-                when (flag) {
-                    ConvoFlags.ARCHIVED -> {
-                        handleArchivedChat(
-                            peerId = peerId,
-                            archived = false,
-                            eventsToSend = eventsToSend
-                        )
-                    }
-
-                    else -> Unit
-                }
-            }
-
-            dispatchAll(LongPollEvent.CHAT_CLEAR_FLAGS, eventsToSend)
-        }
-    }
-
-    private fun parseChatSetFlags(eventType: ApiEvent, event: List<Any>) {
-        val peerId = event[1].asLong()
-        val flags = event[2].asInt()
-
-        val eventsToSend = mutableListOf<LongPollParsedEvent>()
-
-        val parsedFlags = ConvoFlags.parse(flags)
-
-        coroutineScope.launch(Dispatchers.IO) {
-            parsedFlags.forEach { flag ->
-                when (flag) {
-                    ConvoFlags.ARCHIVED -> {
-                        handleArchivedChat(
-                            peerId = peerId,
-                            archived = true,
-                            eventsToSend = eventsToSend
-                        )
-                    }
-
-                    else -> Unit
-                }
-            }
-
-            dispatchAll(LongPollEvent.CHAT_SET_FLAGS, eventsToSend)
-        }
-    }
-
-    private fun parseMessagesDeleted(eventType: ApiEvent, event: List<Any>) {
-        val peerId = event[1].asLong()
-        val cmId = event[2].asLong()
-
-        dispatch(
-            LongPollEvent.CHAT_CLEARED,
-            LongPollParsedEvent.ChatCleared(
-                peerId = peerId,
-                toCmId = cmId
-            )
-        )
-    }
-
-    private fun parseChatMajorChanged(eventType: ApiEvent, event: List<Any>) {
-        val peerId = event[1].asLong()
-        val majorId = event[2].asInt()
-
-        dispatch(
-            LongPollEvent.CHAT_MAJOR_CHANGED,
-            LongPollParsedEvent.ChatMajorChanged(
-                peerId = peerId,
-                majorId = majorId,
-            )
-        )
-    }
-
-    private fun parseChatMinorChanged(eventType: ApiEvent, event: List<Any>) {
-        val peerId = event[1].asLong()
-        val minorId = event[2].asInt()
-
-        dispatch(
-            LongPollEvent.CHAT_MINOR_CHANGED,
-            LongPollParsedEvent.ChatMinorChanged(
-                peerId = peerId,
-                minorId = minorId,
-            )
-        )
-    }
-
-    private fun parseInteraction(eventType: ApiEvent, event: List<Any>) {
-        val interactionType = when (eventType) {
-            ApiEvent.TYPING -> InteractionType.Typing
-            ApiEvent.AUDIO_MESSAGE_RECORDING -> InteractionType.VoiceMessage
-            ApiEvent.PHOTO_UPLOADING -> InteractionType.Photo
-            ApiEvent.VIDEO_UPLOADING -> InteractionType.Video
-            ApiEvent.FILE_UPLOADING -> InteractionType.File
-            else -> return
-        }
-
-        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
-            else -> return
-        }
-
-        val peerId = event[1].asLong()
-        val userIds = event[2].toList(Any::asLong).filter { it != UserConfig.userId }
-        val totalCount = event[3].asInt()
-        val timestamp = event[4].asInt()
-
-        if (userIds.isEmpty()) return
-
-        dispatch(
-            longPollEvent,
-            LongPollParsedEvent.Interaction(
-                interactionType = interactionType,
-                peerId = peerId,
-                userIds = userIds,
-                totalCount = totalCount,
-                timestamp = timestamp
-            )
-        )
-    }
-
-    private fun parseUnreadCounterUpdate(eventType: ApiEvent, event: List<Any>) {
-        val unreadCount = event[1].asInt()
-        val unreadUnmutedCount = event[2].asInt()
-        val showOnlyMuted = event[3].asInt() == 1
-        val businessNotifyUnreadCount = event[4].asInt()
-        val archiveUnreadCount = event[7].asInt()
-        val archiveUnreadUnmutedCount = event[8].asInt()
-        val archiveMentionsCount = event[9].asInt()
-
-        dispatch(
-            LongPollEvent.UNREAD_COUNTER_UPDATE,
-            LongPollParsedEvent.UnreadCounter(
-                unread = unreadCount,
-                unreadUnmuted = unreadUnmutedCount,
-                showOnlyMuted = showOnlyMuted,
-                business = businessNotifyUnreadCount,
-                archive = archiveUnreadCount,
-                archiveUnmuted = archiveUnreadUnmutedCount,
-                archiveMentions = archiveMentionsCount
-            )
-        )
-    }
-
-    private fun parseMessageUpdated(eventType: ApiEvent, event: List<Any>) {
-        val cmId = event[1].asLong()
-        val peerId = event[4].asLong()
-
-        coroutineScope.launch(Dispatchers.IO) {
-            loadMessage(
-                peerId = peerId,
-                cmId = cmId
-            )?.let { message ->
-                dispatch(LongPollEvent.MESSAGE_UPDATED, LongPollParsedEvent.MessageUpdated(message))
-            }
-        }
-    }
-
-    private fun parseMessageCacheClear(eventType: ApiEvent, event: List<Any>) {
-        val messageId = event[1].asLong()
-
-        coroutineScope.launch(Dispatchers.IO) {
-            loadMessage(messageId = messageId)?.let { message ->
-                dispatch(
-                    LongPollEvent.MESSAGE_CACHE_CLEAR,
-                    LongPollParsedEvent.MessageCacheClear(message)
-                )
-            }
-        }
-    }
-
-    private suspend fun loadMessage(
-        peerId: Long? = null,
-        cmId: Long? = null,
-        messageId: Long? = null
-    ): VkMessage? = suspendCancellableCoroutine { continuation ->
-        require((peerId != null && cmId != null) || messageId != null)
-
-        val job = coroutineScope.launch(Dispatchers.IO) {
-            messagesUseCase.getById(
-                peerCmIds = null,
-                peerId = peerId,
-                messageIds = messageId?.let(::listOf),
-                cmIds = cmId?.let(::listOf),
-                extended = true,
-                fields = VkConstants.ALL_FIELDS
-            ).listenValue(this) { state ->
-                state.processState(
-                    error = { error ->
-                        Log.e("LongPollEventParser", "loadMessage: error: $error")
-                        continuation.resume(null)
-                    },
-                    success = { response ->
-                        val message = response.singleOrNull() ?: run {
-                            continuation.resume(null)
-                            return@listenValue
-                        }
-
-                        continuation.resume(message)
-                    }
-                )
-            }
-        }
-
-        continuation.invokeOnCancellation {
-            job.cancel()
-        }
-    }
-
-    private suspend fun loadConvo(
-        peerId: Long,
-        extended: Boolean = false,
-        fields: String? = null
-    ): VkConvo? = suspendCancellableCoroutine { continuation ->
-        val job = coroutineScope.launch(Dispatchers.IO) {
-            convoUseCase.getById(
-                peerIds = listOf(peerId),
-                extended = extended,
-                fields = fields
-            ).listenValue(coroutineScope) { state ->
-                state.processState(
-                    error = { error ->
-                        Log.e("LongPollEventParser", "loadConvo: error: $error")
-                        continuation.resume(null)
-                    },
-                    success = { response ->
-                        val convo = response.singleOrNull() ?: run {
-                            continuation.resume(null)
-                            return@listenValue
-                        }
-
-                        continuation.resume(convo)
-                    }
-                )
-            }
-        }
-
-        continuation.invokeOnCancellation {
-            job.cancel()
-        }
-    }
-
-    private suspend fun handleArchivedChat(
-        peerId: Long,
-        archived: Boolean,
-        eventsToSend: MutableList<LongPollParsedEvent>
-    ) {
-        val convo = loadConvo(
-            peerId = peerId,
-            extended = true,
-            fields = VkConstants.ALL_FIELDS
-        ) ?: return
-
-        val message = loadMessage(
-            peerId = peerId,
-            cmId = convo.lastCmId
-        )
-
-        val eventToSend = LongPollParsedEvent.ChatArchived(
-            convo = convo.copy(lastMessage = message),
-            archived = archived
-        )
-        eventsToSend += eventToSend
-        dispatch(LongPollEvent.CHAT_ARCHIVED, eventToSend)
-    }
-
-    private fun dispatchMessageRead(
-        longPollEvent: LongPollEvent,
-        parsedEvent: LongPollParsedEvent
-    ) {
-        dispatch(longPollEvent, parsedEvent)
-    }
-}

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

@@ -1,17 +1,35 @@
 package dev.meloda.fast.domain
 
 import android.util.Log
+import dev.meloda.fast.common.VkConstants
+import dev.meloda.fast.common.extensions.asInt
+import dev.meloda.fast.common.extensions.asLong
+import dev.meloda.fast.common.extensions.listenValue
+import dev.meloda.fast.common.extensions.toList
+import dev.meloda.fast.data.UserConfig
+import dev.meloda.fast.data.processState
+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
+import dev.meloda.fast.model.api.domain.VkMessage
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 
 class LongPollUpdatesParser(
-    convoUseCase: ConvoUseCase,
+    private val convoUseCase: ConvoUseCase,
-    messagesUseCase: MessagesUseCase
+    private val messagesUseCase: MessagesUseCase
 ) {
     private val job = SupervisorJob()
 
@@ -25,89 +43,747 @@ class LongPollUpdatesParser(
         get() = Dispatchers.Default + job + exceptionHandler
 
     private val coroutineScope = CoroutineScope(coroutineContext)
-    private val eventDispatcher = LongPollEventDispatcher()
+
-    private val eventParser = LongPollEventParser(
+    private val listenersMap: MutableMap<LongPollEvent, MutableList<VkEventCallback<LongPollParsedEvent>>> =
-        coroutineScope = coroutineScope,
+        mutableMapOf()
-        convoUseCase = convoUseCase,
-        messagesUseCase = messagesUseCase,
-        dispatch = eventDispatcher::dispatch,
-        dispatchAll = eventDispatcher::dispatchAll
-    )
 
     fun parseNextUpdate(event: List<Any>) {
-        eventParser.parseNextUpdate(event)
+        val eventId = event.first().asInt()
+
+        when (val eventType = ApiEvent.parseOrNull(eventId)) {
+            null -> Log.d("LongPollUpdatesParser", "parseNextUpdate: unknownEvent: $event")
+
+            ApiEvent.MESSAGE_SET_FLAGS -> parseMessageSetFlags(eventType, event)
+            ApiEvent.MESSAGE_CLEAR_FLAGS -> parseMessageClearFlags(eventType, event)
+            ApiEvent.MESSAGE_NEW -> parseMessageNew(eventType, event)
+            ApiEvent.MESSAGE_EDIT -> parseMessageEdit(eventType, event)
+            ApiEvent.MESSAGE_READ_INCOMING -> parseMessageReadIncoming(eventType, event)
+            ApiEvent.MESSAGE_READ_OUTGOING -> parseMessageReadOutgoing(eventType, event)
+            ApiEvent.CHAT_CLEAR_FLAGS -> parseChatClearFlags(eventType, event)
+            ApiEvent.CHAT_SET_FLAGS -> parseChatSetFlags(eventType, event)
+            ApiEvent.MESSAGES_DELETED -> parseMessagesDeleted(eventType, event)
+            ApiEvent.CHAT_MAJOR_CHANGED -> parseChatMajorChanged(eventType, event)
+            ApiEvent.CHAT_MINOR_CHANGED -> parseChatMinorChanged(eventType, event)
+
+            ApiEvent.TYPING,
+            ApiEvent.AUDIO_MESSAGE_RECORDING,
+            ApiEvent.PHOTO_UPLOADING,
+            ApiEvent.VIDEO_UPLOADING,
+            ApiEvent.FILE_UPLOADING -> parseInteraction(eventType, event)
+
+            ApiEvent.UNREAD_COUNT_UPDATE -> parseUnreadCounterUpdate(eventType, event)
+            ApiEvent.MESSAGE_UPDATED -> parseMessageUpdated(eventType, event)
+            ApiEvent.MESSAGE_CACHE_CLEAR -> parseMessageCacheClear(eventType, event)
+        }
+    }
+
+    private fun parseMessageSetFlags(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val cmId = event[1].asLong()
+        val flags = event[2].asInt()
+        val peerId = event[3].asLong()
+
+        val eventsToSend = mutableListOf<LongPollParsedEvent>()
+
+        val parsedFlags = MessageFlags.parse(flags)
+        parsedFlags.forEach { flag ->
+            when (flag) {
+                MessageFlags.IMPORTANT -> {
+                    val eventToSend = LongPollParsedEvent.MessageMarkedAsImportant(
+                        peerId = peerId,
+                        cmId = cmId,
+                        marked = true
+                    )
+                    eventsToSend += eventToSend
+
+                    listenersMap[LongPollEvent.MARKED_AS_IMPORTANT]?.let { listeners ->
+                        listeners.map { vkEventCallback ->
+                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsImportant>)
+                                ?.onEvent(eventToSend)
+                        }
+                    }
+                }
+
+                MessageFlags.SPAM -> {
+                    val eventToSend = LongPollParsedEvent.MessageMarkedAsSpam(
+                        peerId = peerId,
+                        cmId = cmId
+                    )
+                    eventsToSend += eventToSend
+
+                    listenersMap[LongPollEvent.MARKED_AS_SPAM]?.let { listeners ->
+                        listeners.map { vkEventCallback ->
+                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsSpam>)
+                                ?.onEvent(eventToSend)
+                        }
+                    }
+                }
+
+                MessageFlags.DELETED -> {
+                    val eventToSend =
+                        if (parsedFlags.contains(MessageFlags.DELETED_FOR_ALL)) {
+                            LongPollParsedEvent.MessageDeleted(
+                                peerId = peerId,
+                                cmId = cmId,
+                                forAll = true
+                            )
+                        } else {
+                            LongPollParsedEvent.MessageDeleted(
+                                peerId = peerId,
+                                cmId = cmId,
+                                forAll = false
+                            )
+                        }
+                    eventsToSend += eventToSend
+
+                    listenersMap[LongPollEvent.MESSAGE_DELETED]?.let { listeners ->
+                        listeners.map { vkEventCallback ->
+                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageDeleted>)
+                                ?.onEvent(eventToSend)
+                        }
+                    }
+                }
+
+                MessageFlags.AUDIO_LISTENED -> {
+                    val eventToSend = LongPollParsedEvent.AudioMessageListened(
+                        peerId = peerId,
+                        cmId = cmId
+                    )
+                    eventsToSend += eventToSend
+
+                    listenersMap[LongPollEvent.AUDIO_MESSAGE_LISTENED]?.let { listeners ->
+                        listeners.map { vkEventCallback ->
+                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.AudioMessageListened>)
+                                ?.onEvent(eventToSend)
+                        }
+                    }
+                }
+
+                else -> Unit
+            }
+        }
+
+        eventsToSend.forEach { eventToSend ->
+            listenersMap[LongPollEvent.MESSAGE_SET_FLAGS]?.let { listeners ->
+                listeners.map { vkEventCallback ->
+                    (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(eventToSend)
+                }
+            }
+        }
+    }
+
+    private fun parseMessageClearFlags(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val cmId = event[1].asLong()
+        val flags = event[2].asInt()
+        val peerId = event[3].asLong()
+
+        val eventsToSend = mutableListOf<LongPollParsedEvent>()
+
+        val parsedFlags = MessageFlags.parse(flags)
+
+        coroutineScope.launch {
+            parsedFlags.forEach { flag ->
+                when (flag) {
+                    MessageFlags.IMPORTANT -> {
+                        val eventToSend = LongPollParsedEvent.MessageMarkedAsImportant(
+                            peerId = peerId,
+                            cmId = cmId,
+                            marked = false
+                        )
+                        eventsToSend += eventToSend
+
+                        listenersMap[LongPollEvent.MARKED_AS_IMPORTANT]?.let { listeners ->
+                            listeners.map { vkEventCallback ->
+                                (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsImportant>)
+                                    ?.onEvent(eventToSend)
+                            }
+                        }
+                    }
+
+                    MessageFlags.SPAM -> {
+                        if (parsedFlags.contains(MessageFlags.CANCEL_SPAM)) {
+                            withContext(Dispatchers.IO) {
+                                val message = loadMessage(
+                                    peerId = peerId,
+                                    cmId = cmId
+                                )
+                                message?.let {
+                                    val eventToSend =
+                                        LongPollParsedEvent.MessageMarkedAsNotSpam(message = message)
+                                    eventsToSend += eventToSend
+
+                                    listenersMap[LongPollEvent.MARKED_AS_NOT_SPAM]?.let { listeners ->
+                                        listeners.map { vkEventCallback ->
+                                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsNotSpam>)
+                                                ?.onEvent(eventToSend)
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    MessageFlags.DELETED -> {
+                        withContext(Dispatchers.IO) {
+                            val message = loadMessage(
+                                peerId = peerId,
+                                cmId = cmId
+                            )
+                            message?.let {
+                                val eventToSend =
+                                    LongPollParsedEvent.MessageRestored(message = message)
+                                eventsToSend += eventToSend
+
+                                listenersMap[LongPollEvent.MESSAGE_RESTORED]?.let { listeners ->
+                                    listeners.map { vkEventCallback ->
+                                        (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageRestored>)
+                                            ?.onEvent(eventToSend)
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    else -> Unit
+                }
+            }
+
+            eventsToSend.forEach { eventToSend ->
+                listenersMap[LongPollEvent.MESSAGE_CLEAR_FLAGS]?.let { listeners ->
+                    listeners.map { vkEventCallback ->
+                        vkEventCallback.onEvent(eventToSend)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun parseMessageNew(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val cmId = event[1].asLong()
+        val peerId = event[4].asLong()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            val message =
+                async { loadMessage(peerId = peerId, cmId = cmId) }.await()
+
+            val convo =
+                async {
+                    loadConvo(
+                        peerId = peerId,
+                        extended = true,
+                        fields = VkConstants.ALL_FIELDS
+                    )
+                }.await()
+
+            message?.let {
+                listenersMap[LongPollEvent.MESSAGE_NEW]?.let {
+                    it.map { vkEventCallback ->
+                        (vkEventCallback as VkEventCallback<LongPollParsedEvent.NewMessage>)
+                            .onEvent(
+                                LongPollParsedEvent.NewMessage(
+                                    message = message,
+                                    inArchive = convo?.isArchived == true
+                                    // TODO: 03-Apr-25, Danil Nikolaev:
+                                    // load user settings about restoring chats with
+                                    // enabled notifications from archive
+                                )
+                            )
+                    }
+                }
+            }
+        }
+    }
+
+    private fun parseMessageEdit(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val cmId = event[1].asLong()
+        val peerId = event[3].asLong()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            loadMessage(
+                peerId = peerId,
+                cmId = cmId
+            )?.let { message ->
+                listenersMap[LongPollEvent.MESSAGE_EDITED]?.let {
+                    it.map { vkEventCallback ->
+                        (vkEventCallback as VkEventCallback<LongPollParsedEvent.MessageEdited>)
+                            .onEvent(LongPollParsedEvent.MessageEdited(message))
+                    }
+                }
+            }
+        }
+    }
+
+    private fun parseMessageReadIncoming(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+        val peerId = event[1].asLong()
+        val cmId = event[2].asLong()
+        val unreadCount = event[3].asInt()
+
+        listenersMap[LongPollEvent.INCOMING_MESSAGE_READ]?.let { listeners ->
+            listeners.map { vkEventCallback ->
+                (vkEventCallback as VkEventCallback<LongPollParsedEvent.IncomingMessageRead>)
+                    .onEvent(
+                        LongPollParsedEvent.IncomingMessageRead(
+                            peerId = peerId,
+                            cmId = cmId,
+                            unreadCount = unreadCount
+                        )
+                    )
+            }
+        }
+    }
+
+    private fun parseMessageReadOutgoing(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+        val peerId = event[1].asLong()
+        val cmId = event[2].asLong()
+        val unreadCount = event[3].asInt()
+
+        listenersMap[LongPollEvent.OUTGOING_MESSAGE_READ]?.let { listeners ->
+            listeners.map { vkEventCallback ->
+                (vkEventCallback as VkEventCallback<LongPollParsedEvent.OutgoingMessageRead>)
+                    .onEvent(
+                        LongPollParsedEvent.OutgoingMessageRead(
+                            peerId = peerId,
+                            cmId = cmId,
+                            unreadCount = unreadCount
+                        )
+                    )
+            }
+        }
+    }
+
+    private fun parseChatClearFlags(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val peerId = event[1].asLong()
+        val flags = event[2].asInt()
+
+        val eventsToSend = mutableListOf<LongPollParsedEvent>()
+
+        val parsedFlags = ConvoFlags.parse(flags)
+
+        coroutineScope.launch(Dispatchers.IO) {
+            parsedFlags.forEach { flag ->
+                when (flag) {
+                    ConvoFlags.ARCHIVED -> {
+                        val convo = loadConvo(
+                            peerId = peerId,
+                            extended = true,
+                            fields = VkConstants.ALL_FIELDS
+                        ) ?: return@forEach
+
+                        val message = loadMessage(
+                            peerId = peerId,
+                            cmId = convo.lastCmId
+                        )
+
+                        val eventToSend = LongPollParsedEvent.ChatArchived(
+                            convo = convo.copy(lastMessage = message),
+                            archived = false
+                        )
+                        eventsToSend += eventToSend
+
+                        listenersMap[LongPollEvent.CHAT_ARCHIVED]?.let { listeners ->
+                            listeners.map { vkEventCallback ->
+                                (vkEventCallback as? VkEventCallback<LongPollParsedEvent.ChatArchived>)
+                                    ?.onEvent(eventToSend)
+                            }
+                        }
+                    }
+
+                    else -> Unit
+                }
+            }
+
+            eventsToSend.forEach { eventToSend ->
+                listenersMap[LongPollEvent.CHAT_CLEAR_FLAGS]?.let { listeners ->
+                    listeners.map { vkEventCallback ->
+                        (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(
+                            eventToSend
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    private fun parseChatSetFlags(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val peerId = event[1].asLong()
+        val flags = event[2].asInt()
+
+        val eventsToSend = mutableListOf<LongPollParsedEvent>()
+
+        val parsedFlags = ConvoFlags.parse(flags)
+
+        coroutineScope.launch(Dispatchers.IO) {
+            parsedFlags.forEach { flag ->
+                when (flag) {
+                    ConvoFlags.ARCHIVED -> {
+                        val convo = loadConvo(
+                            peerId = peerId,
+                            extended = true,
+                            fields = VkConstants.ALL_FIELDS
+                        ) ?: return@forEach
+
+                        val message = loadMessage(
+                            peerId = peerId,
+                            cmId = convo.lastCmId
+                        )
+
+                        val eventToSend = LongPollParsedEvent.ChatArchived(
+                            convo = convo.copy(lastMessage = message),
+                            archived = true
+                        )
+                        eventsToSend += eventToSend
+
+                        listenersMap[LongPollEvent.CHAT_ARCHIVED]?.let { listeners ->
+                            listeners.map { vkEventCallback ->
+                                (vkEventCallback as? VkEventCallback<LongPollParsedEvent.ChatArchived>)
+                                    ?.onEvent(eventToSend)
+                            }
+                        }
+                    }
+
+                    else -> Unit
+                }
+            }
+
+            eventsToSend.forEach { eventToSend ->
+                listenersMap[LongPollEvent.CHAT_SET_FLAGS]?.let { listeners ->
+                    listeners.map { vkEventCallback ->
+                        (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(
+                            eventToSend
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    private fun parseMessagesDeleted(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val peerId = event[1].asLong()
+        val cmId = event[2].asLong()
+
+        listenersMap[LongPollEvent.CHAT_CLEARED]?.let { listeners ->
+            listeners.forEach { vkEventCallback ->
+                (vkEventCallback as VkEventCallback<LongPollParsedEvent.ChatCleared>)
+                    .onEvent(
+                        LongPollParsedEvent.ChatCleared(
+                            peerId = peerId,
+                            toCmId = cmId
+                        )
+                    )
+            }
+        }
+    }
+
+    private fun parseChatMajorChanged(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val peerId = event[1].asLong()
+        val majorId = event[2].asInt()
+
+        listenersMap[LongPollEvent.CHAT_MAJOR_CHANGED]?.let { listeners ->
+            listeners.forEach { vkEventCallback ->
+                (vkEventCallback as VkEventCallback<LongPollParsedEvent.ChatMajorChanged>)
+                    .onEvent(
+                        LongPollParsedEvent.ChatMajorChanged(
+                            peerId = peerId,
+                            majorId = majorId,
+                        )
+                    )
+            }
+        }
+    }
+
+    private fun parseChatMinorChanged(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val peerId = event[1].asLong()
+        val minorId = event[2].asInt()
+
+        listenersMap[LongPollEvent.CHAT_MINOR_CHANGED]?.let { listeners ->
+            listeners.forEach { vkEventCallback ->
+                (vkEventCallback as VkEventCallback<LongPollParsedEvent.ChatMinorChanged>)
+                    .onEvent(
+                        LongPollParsedEvent.ChatMinorChanged(
+                            peerId = peerId,
+                            minorId = minorId,
+                        )
+                    )
+            }
+        }
+    }
+
+    private fun parseInteraction(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val interactionType = when (eventType) {
+            ApiEvent.TYPING -> InteractionType.Typing
+            ApiEvent.AUDIO_MESSAGE_RECORDING -> InteractionType.VoiceMessage
+            ApiEvent.PHOTO_UPLOADING -> InteractionType.Photo
+            ApiEvent.VIDEO_UPLOADING -> InteractionType.Video
+            ApiEvent.FILE_UPLOADING -> InteractionType.File
+            else -> return
+        }
+
+        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
+            else -> return
+        }
+
+        val peerId = event[1].asLong()
+        val userIds = event[2].toList(Any::asLong).filter { it != UserConfig.userId }
+        val totalCount = event[3].asInt()
+        val timestamp = event[4].asInt()
+
+        // if userIds contains only account's id, then we don't need to show our status
+        if (userIds.isEmpty()) return
+
+        listenersMap[longPollEvent]?.let { listeners ->
+            listeners.forEach { vkEventCallback ->
+                (vkEventCallback as VkEventCallback<LongPollParsedEvent.Interaction>)
+                    .onEvent(
+                        LongPollParsedEvent.Interaction(
+                            interactionType = interactionType,
+                            peerId = peerId,
+                            userIds = userIds,
+                            totalCount = totalCount,
+                            timestamp = timestamp
+                        )
+                    )
+            }
+        }
+    }
+
+    private fun parseUnreadCounterUpdate(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType $event")
+
+        val unreadCount = event[1].asInt()
+        val unreadUnmutedCount = event[2].asInt()
+        val showOnlyMuted = event[3].asInt() == 1
+        val businessNotifyUnreadCount = event[4].asInt()
+        val archiveUnreadCount = event[7].asInt()
+        val archiveUnreadUnmutedCount = event[8].asInt()
+        val archiveMentionsCount = event[9].asInt()
+
+        listenersMap[LongPollEvent.UNREAD_COUNTER_UPDATE]?.let { listeners ->
+            listeners.forEach { vkEventCallback ->
+                (vkEventCallback as VkEventCallback<LongPollParsedEvent.UnreadCounter>)
+                    .onEvent(
+                        LongPollParsedEvent.UnreadCounter(
+                            unread = unreadCount,
+                            unreadUnmuted = unreadUnmutedCount,
+                            showOnlyMuted = showOnlyMuted,
+                            business = businessNotifyUnreadCount,
+                            archive = archiveUnreadCount,
+                            archiveUnmuted = archiveUnreadUnmutedCount,
+                            archiveMentions = archiveMentionsCount
+                        )
+                    )
+            }
+        }
+    }
+
+    private fun parseMessageUpdated(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType $event")
+
+        val cmId = event[1].asLong()
+        val peerId = event[4].asLong()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            loadMessage(
+                peerId = peerId,
+                cmId = cmId
+            )?.let { message ->
+                listenersMap[LongPollEvent.MESSAGE_UPDATED]?.let {
+                    it.map { vkEventCallback ->
+                        (vkEventCallback as VkEventCallback<LongPollParsedEvent.MessageUpdated>)
+                            .onEvent(LongPollParsedEvent.MessageUpdated(message))
+                    }
+                }
+            }
+        }
+    }
+
+    private fun parseMessageCacheClear(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType $event")
+
+        val messageId = event[1].asLong()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            loadMessage(messageId = messageId)?.let { message ->
+                listenersMap[LongPollEvent.MESSAGE_CACHE_CLEAR]?.let {
+                    it.map { vkEventCallback ->
+                        (vkEventCallback as VkEventCallback<LongPollParsedEvent.MessageCacheClear>)
+                            .onEvent(LongPollParsedEvent.MessageCacheClear(message))
+                    }
+                }
+            }
+        }
+    }
+
+    private suspend fun loadMessage(
+        peerId: Long? = null,
+        cmId: Long? = null,
+        messageId: Long? = null
+    ): VkMessage? = suspendCoroutine { continuation ->
+        require((peerId != null && cmId != null) || messageId != null)
+
+        coroutineScope.launch(Dispatchers.IO) {
+            messagesUseCase.getById(
+                peerCmIds = null,
+                peerId = peerId,
+                messageIds = messageId?.let(::listOf),
+                cmIds = cmId?.let(::listOf),
+                extended = true,
+                fields = VkConstants.ALL_FIELDS
+            ).listenValue(this) { state ->
+                state.processState(
+                    error = { error ->
+                        Log.e("LongPollUpdatesParser", "loadMessage: error: $error")
+                        continuation.resume(null)
+                    },
+                    success = { response ->
+                        val message = response.singleOrNull() ?: run {
+                            continuation.resume(null)
+                            return@listenValue
+                        }
+
+                        continuation.resume(message)
+                    }
+                )
+            }
+        }
+    }
+
+    private suspend fun loadConvo(
+        peerId: Long,
+        extended: Boolean = false,
+        fields: String? = null
+    ): VkConvo? = suspendCoroutine { continuation ->
+        coroutineScope.launch(Dispatchers.IO) {
+            convoUseCase.getById(
+                peerIds = listOf(peerId),
+                extended = extended,
+                fields = fields
+            ).listenValue(coroutineScope) { state ->
+                state.processState(
+                    error = { error ->
+                        Log.e("LongPollUpdatesParser", "loadConvo: error: $error")
+                        continuation.resume(null)
+                    },
+                    success = { response ->
+                        val convo = response.singleOrNull() ?: run {
+                            continuation.resume(null)
+                            return@listenValue
+                        }
+
+                        continuation.resume(convo)
+                    }
+                )
+            }
+        }
+    }
+
+    @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) {
-        eventDispatcher.registerListener(LongPollEvent.MESSAGE_SET_FLAGS, assembleEventCallback(block))
+        registerListener(LongPollEvent.MESSAGE_SET_FLAGS, assembleEventCallback(block))
     }
 
     fun onMessageMarkedAsImportant(block: (LongPollParsedEvent.MessageMarkedAsImportant) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_IMPORTANT, assembleEventCallback(block))
+        registerListener(LongPollEvent.MARKED_AS_IMPORTANT, assembleEventCallback(block))
     }
 
     fun onMessageMarkedAsSpam(block: (LongPollParsedEvent.MessageMarkedAsSpam) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_SPAM, assembleEventCallback(block))
+        registerListener(LongPollEvent.MARKED_AS_SPAM, assembleEventCallback(block))
     }
 
     fun onMessageDeleted(block: (LongPollParsedEvent.MessageDeleted) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MESSAGE_DELETED, assembleEventCallback(block))
+        registerListener(LongPollEvent.MESSAGE_DELETED, assembleEventCallback(block))
     }
 
     fun onMessageClearFlags(block: (LongPollParsedEvent) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, assembleEventCallback(block))
+        registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, assembleEventCallback(block))
     }
 
     fun onMessageMarkedAsNotSpam(block: (LongPollParsedEvent.MessageMarkedAsNotSpam) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, assembleEventCallback(block))
+        registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, assembleEventCallback(block))
     }
 
     fun onMessageRestored(block: (LongPollParsedEvent.MessageRestored) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MESSAGE_RESTORED, assembleEventCallback(block))
+        registerListener(LongPollEvent.MESSAGE_RESTORED, assembleEventCallback(block))
-    }
-
-    fun onMessageUpdated(block: (LongPollParsedEvent.MessageUpdated) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MESSAGE_UPDATED, assembleEventCallback(block))
-    }
-
-    fun onMessageCacheClear(block: (LongPollParsedEvent.MessageCacheClear) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MESSAGE_CACHE_CLEAR, assembleEventCallback(block))
     }
 
     fun onNewMessage(block: (LongPollParsedEvent.NewMessage) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MESSAGE_NEW, assembleEventCallback(block))
+        registerListener(LongPollEvent.MESSAGE_NEW, assembleEventCallback(block))
     }
 
     fun onMessageEdited(block: (LongPollParsedEvent.MessageEdited) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.MESSAGE_EDITED, assembleEventCallback(block))
+        registerListener(LongPollEvent.MESSAGE_EDITED, assembleEventCallback(block))
     }
 
     fun onMessageIncomingRead(block: (LongPollParsedEvent.IncomingMessageRead) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.INCOMING_MESSAGE_READ, assembleEventCallback(block))
+        registerListener(LongPollEvent.INCOMING_MESSAGE_READ, assembleEventCallback(block))
     }
 
     fun onMessageOutgoingRead(block: (LongPollParsedEvent.OutgoingMessageRead) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, assembleEventCallback(block))
+        registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, assembleEventCallback(block))
     }
 
     fun onChatCleared(block: (LongPollParsedEvent.ChatCleared) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.CHAT_CLEARED, assembleEventCallback(block))
+        registerListener(LongPollEvent.CHAT_CLEARED, assembleEventCallback(block))
     }
 
     fun onChatMajorChanged(block: (LongPollParsedEvent.ChatMajorChanged) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, assembleEventCallback(block))
+        registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, assembleEventCallback(block))
     }
 
     fun onChatMinorChanged(block: (LongPollParsedEvent.ChatMinorChanged) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.CHAT_MINOR_CHANGED, assembleEventCallback(block))
+        registerListener(LongPollEvent.CHAT_MINOR_CHANGED, assembleEventCallback(block))
     }
 
     fun onChatArchived(block: (LongPollParsedEvent.ChatArchived) -> Unit) {
-        eventDispatcher.registerListener(LongPollEvent.CHAT_ARCHIVED, assembleEventCallback(block))
+        registerListener(LongPollEvent.CHAT_ARCHIVED, assembleEventCallback(block))
     }
 
     fun onInteractions(block: (LongPollParsedEvent.Interaction) -> Unit) {
-        eventDispatcher.registerListeners(
+        registerListeners(
             eventTypes = listOf(
                 LongPollEvent.TYPING,
                 LongPollEvent.AUDIO_MESSAGE_RECORDING,

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

@@ -1,213 +0,0 @@
-package dev.meloda.fast.domain
-
-import android.util.Log
-import dev.meloda.fast.model.LongPollParsedEvent
-import dev.meloda.fast.model.api.domain.VkMessage
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.filterIsInstance
-import kotlinx.coroutines.launch
-
-class LongPollUpdatesReducer(
-    updatesParser: LongPollUpdatesParser,
-    private val messagesUseCase: MessagesUseCase,
-    private val convoUseCase: ConvoUseCase
-) {
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
-
-    private val _events = MutableSharedFlow<LongPollParsedEvent>(extraBufferCapacity = 256)
-    val events: SharedFlow<LongPollParsedEvent> = _events.asSharedFlow()
-
-    val newMessages = events.filterIsInstance<LongPollParsedEvent.NewMessage>()
-    val messageEdited = events.filterIsInstance<LongPollParsedEvent.MessageEdited>()
-    val messageIncomingRead = events.filterIsInstance<LongPollParsedEvent.IncomingMessageRead>()
-    val messageOutgoingRead = events.filterIsInstance<LongPollParsedEvent.OutgoingMessageRead>()
-    val messageDeleted = events.filterIsInstance<LongPollParsedEvent.MessageDeleted>()
-    val messageRestored = events.filterIsInstance<LongPollParsedEvent.MessageRestored>()
-    val messageMarkedAsImportant = events.filterIsInstance<LongPollParsedEvent.MessageMarkedAsImportant>()
-    val messageMarkedAsSpam = events.filterIsInstance<LongPollParsedEvent.MessageMarkedAsSpam>()
-    val messageMarkedAsNotSpam = events.filterIsInstance<LongPollParsedEvent.MessageMarkedAsNotSpam>()
-    val interactions = events.filterIsInstance<LongPollParsedEvent.Interaction>()
-    val chatMajorChanged = events.filterIsInstance<LongPollParsedEvent.ChatMajorChanged>()
-    val chatMinorChanged = events.filterIsInstance<LongPollParsedEvent.ChatMinorChanged>()
-    val chatCleared = events.filterIsInstance<LongPollParsedEvent.ChatCleared>()
-    val chatArchived = events.filterIsInstance<LongPollParsedEvent.ChatArchived>()
-    val messageUpdated = events.filterIsInstance<LongPollParsedEvent.MessageUpdated>()
-    val messageCacheClear = events.filterIsInstance<LongPollParsedEvent.MessageCacheClear>()
-
-    init {
-        updatesParser.onNewMessage { publish(it) }
-        updatesParser.onMessageEdited { publish(it) }
-        updatesParser.onMessageIncomingRead { publish(it) }
-        updatesParser.onMessageOutgoingRead { publish(it) }
-        updatesParser.onMessageDeleted { publish(it) }
-        updatesParser.onMessageRestored { publish(it) }
-        updatesParser.onMessageUpdated { publish(it) }
-        updatesParser.onMessageCacheClear { publish(it) }
-        updatesParser.onMessageMarkedAsImportant { publish(it) }
-        updatesParser.onMessageMarkedAsSpam { publish(it) }
-        updatesParser.onMessageMarkedAsNotSpam { publish(it) }
-        updatesParser.onInteractions { publish(it) }
-        updatesParser.onChatMajorChanged { publish(it) }
-        updatesParser.onChatMinorChanged { publish(it) }
-        updatesParser.onChatCleared { publish(it) }
-        updatesParser.onChatArchived { publish(it) }
-    }
-
-    private fun publish(event: LongPollParsedEvent) {
-        scope.launch {
-            runCatching { applyCommon(event) }
-                .onFailure { throwable ->
-                    Log.e("LongPollUpdatesReducer", "applyCommon failed: $event", throwable)
-                }
-            _events.emit(event)
-        }
-    }
-
-    private suspend fun applyCommon(event: LongPollParsedEvent) {
-        when (event) {
-            is LongPollParsedEvent.NewMessage -> {
-                messagesUseCase.storeMessages(listOf(event.message))
-                updateConvoForMessage(event.message, unreadIncrement = if (event.message.isOut) 0 else 1)
-            }
-
-            is LongPollParsedEvent.MessageEdited -> {
-                messagesUseCase.storeMessage(event.message)
-            }
-
-            is LongPollParsedEvent.MessageUpdated -> {
-                messagesUseCase.storeMessage(event.message)
-            }
-
-            is LongPollParsedEvent.MessageCacheClear -> {
-                messagesUseCase.storeMessage(event.message)
-            }
-
-            is LongPollParsedEvent.IncomingMessageRead -> {
-                updateConvoReadState(
-                    peerId = event.peerId,
-                    inReadCmId = event.cmId,
-                    unreadCount = event.unreadCount
-                )
-            }
-
-            is LongPollParsedEvent.OutgoingMessageRead -> {
-                updateConvoReadState(
-                    peerId = event.peerId,
-                    outReadCmId = event.cmId,
-                    unreadCount = event.unreadCount
-                )
-            }
-
-            is LongPollParsedEvent.MessageDeleted -> {
-                val message = messagesUseCase.getLocalMessageByConvoMessageId(
-                    convoId = event.peerId,
-                    cmId = event.cmId
-                )
-                if (message != null) {
-                    messagesUseCase.deleteLocalMessages(listOf(message.id))
-                }
-            }
-
-            is LongPollParsedEvent.MessageRestored -> {
-                messagesUseCase.storeMessage(event.message)
-            }
-
-            is LongPollParsedEvent.MessageMarkedAsImportant -> {
-                val message = messagesUseCase.getLocalMessageByConvoMessageId(
-                    convoId = event.peerId,
-                    cmId = event.cmId
-                ) ?: return
-
-                messagesUseCase.storeMessage(message.copy(isImportant = event.marked))
-            }
-
-            is LongPollParsedEvent.MessageMarkedAsSpam -> {
-                val message = messagesUseCase.getLocalMessageByConvoMessageId(
-                    convoId = event.peerId,
-                    cmId = event.cmId
-                )
-                if (message != null) {
-                    messagesUseCase.deleteLocalMessages(listOf(message.id))
-                }
-            }
-
-            is LongPollParsedEvent.MessageMarkedAsNotSpam -> {
-                messagesUseCase.storeMessage(event.message)
-            }
-
-            is LongPollParsedEvent.ChatMajorChanged -> {
-                updateConvoSortState(event.peerId, majorId = event.majorId)
-            }
-
-            is LongPollParsedEvent.ChatMinorChanged -> {
-                updateConvoSortState(event.peerId, minorId = event.minorId)
-            }
-
-            is LongPollParsedEvent.ChatCleared -> {
-                convoUseCase.deleteLocalConvo(event.peerId)
-            }
-
-            is LongPollParsedEvent.ChatArchived -> {
-                event.convo.lastMessage?.let(messagesUseCase::storeMessage)
-                convoUseCase.storeConvos(listOf(event.convo.copy(isArchived = event.archived)))
-            }
-
-            is LongPollParsedEvent.Interaction -> Unit
-        }
-    }
-
-    private suspend fun updateConvoReadState(
-        peerId: Long,
-        inReadCmId: Long? = null,
-        outReadCmId: Long? = null,
-        unreadCount: Int
-    ) {
-        val convo = convoUseCase.getLocalConvoById(peerId) ?: return
-        convoUseCase.storeConvos(
-            listOf(
-                convo.copy(
-                    inReadCmId = inReadCmId ?: convo.inReadCmId,
-                    outReadCmId = outReadCmId ?: convo.outReadCmId,
-                    unreadCount = unreadCount
-                )
-            )
-        )
-    }
-
-    private suspend fun updateConvoSortState(
-        peerId: Long,
-        majorId: Int? = null,
-        minorId: Int? = null
-    ) {
-        val convo = convoUseCase.getLocalConvoById(peerId) ?: return
-        convoUseCase.storeConvos(
-            listOf(
-                convo.copy(
-                    majorId = majorId ?: convo.majorId,
-                    minorId = minorId ?: convo.minorId
-                )
-            )
-        )
-    }
-
-    private suspend fun updateConvoForMessage(
-        message: VkMessage,
-        unreadIncrement: Int
-    ) {
-        val convo = convoUseCase.getLocalConvoById(message.peerId) ?: return
-        convoUseCase.storeConvos(
-            listOf(
-                convo.copy(
-                    lastMessageId = message.id,
-                    lastCmId = message.cmId,
-                    unreadCount = convo.unreadCount + unreadIncrement
-                )
-            )
-        )
-    }
-}

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

@@ -1,7 +1,6 @@
 package dev.meloda.fast.domain
 
 import dev.meloda.fast.data.State
-import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.LongPollUpdates
 import dev.meloda.fast.model.api.data.VkLongPollData
 import kotlinx.coroutines.flow.Flow
@@ -22,14 +21,4 @@ interface LongPollUseCase {
         mode: Int,
         version: Int
     ): Flow<State<LongPollUpdates>>
-
-    fun getLongPollHistory(
-        ts: Int,
-        pts: Int,
-        lpVersion: Int,
-        lastN: Int? = null,
-        maxMsgId: Long? = null,
-        eventsLimit: Int? = null,
-        msgsLimit: Int? = null
-    ): Flow<State<LongPollHistoryResponse>>
 }

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

@@ -3,7 +3,6 @@ package dev.meloda.fast.domain
 import dev.meloda.fast.data.State
 import dev.meloda.fast.data.api.longpoll.LongPollRepository
 import dev.meloda.fast.data.mapToState
-import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.LongPollUpdates
 import dev.meloda.fast.model.api.data.VkLongPollData
 import kotlinx.coroutines.flow.Flow
@@ -49,27 +48,4 @@ class LongPollUseCaseImpl(
         ).mapToState()
         emit(newState)
     }
-
-    override fun getLongPollHistory(
-        ts: Int,
-        pts: Int,
-        lpVersion: Int,
-        lastN: Int?,
-        maxMsgId: Long?,
-        eventsLimit: Int?,
-        msgsLimit: Int?
-    ): Flow<State<LongPollHistoryResponse>> = flow {
-        emit(State.Loading)
-
-        val newState = repository.getLongPollHistory(
-            ts = ts,
-            pts = pts,
-            lpVersion = lpVersion,
-            lastN = lastN,
-            maxMsgId = maxMsgId,
-            eventsLimit = eventsLimit,
-            msgsLimit = msgsLimit
-        ).mapToState()
-        emit(newState)
-    }
 }

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

@@ -12,11 +12,6 @@ interface MessagesUseCase : BaseUseCase {
 
     suspend fun storeMessage(message: VkMessage)
     suspend fun storeMessages(messages: List<VkMessage>)
-    suspend fun getLocalMessages(convoId: Long): List<VkMessage>
-    suspend fun getLocalMessageById(messageId: Long): VkMessage?
-    suspend fun getLocalMessageByConvoMessageId(convoId: Long, cmId: Long): VkMessage?
-    suspend fun getLocalMaxMessageId(): Long?
-    suspend fun deleteLocalMessages(messageIds: List<Long>)
 
     fun getMessagesHistory(
         convoId: Long,

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

@@ -22,26 +22,6 @@ class MessagesUseCaseImpl(
         repository.storeMessages(messages)
     }
 
-    override suspend fun getLocalMessages(convoId: Long): List<VkMessage> {
-        return repository.getLocalMessages(convoId)
-    }
-
-    override suspend fun getLocalMessageById(messageId: Long): VkMessage? {
-        return repository.getLocalMessageById(messageId)
-    }
-
-    override suspend fun getLocalMessageByConvoMessageId(convoId: Long, cmId: Long): VkMessage? {
-        return repository.getLocalMessageByConvoMessageId(convoId, cmId)
-    }
-
-    override suspend fun getLocalMaxMessageId(): Long? {
-        return repository.getLocalMaxMessageId()
-    }
-
-    override suspend fun deleteLocalMessages(messageIds: List<Long>) {
-        repository.deleteLocalMessages(messageIds)
-    }
-
     override fun getMessagesHistory(
         convoId: Long,
         count: Int?,

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

@@ -22,35 +22,22 @@ class OAuthUseCaseImpl(
     ): Flow<State<AuthInfo>> = flow {
         emit(State.Loading)
 
-        val newState = when (val authResult = oAuthRepository.auth(
+        val newState = oAuthRepository.auth(
             login = login,
             password = password,
             forceSms = forceSms,
             validationCode = validationCode,
             captchaSid = captchaSid,
             captchaKey = captchaKey
-        )) {
+        ).asState(
-            is com.slack.eithernet.ApiResult.Success -> {
+            successMapper = {
-                val value = authResult.value
+                AuthInfo(
-                val userId = value.userId
+                    userId = it.userId!!,
-                val accessToken = value.accessToken
+                    accessToken = it.accessToken!!,
-                val validationHash = value.validationHash
+                    validationHash = it.validationHash!!
-
+                )
-                if (userId == null || accessToken == null || validationHash == null) {
-                    State.Error.InternalError
-                } else {
-                    State.Success(
-                        AuthInfo(
-                            userId = userId,
-                            accessToken = accessToken,
-                            validationHash = validationHash
-                        )
-                    )
-                }
             }
-
+        )
-            else -> authResult.asState()
-        }
 
         emit(newState)
     }

core/model/src/main/kotlin/dev/meloda/fast/model/api/data/LongPollHistoryResponse.kt

@@ -1,24 +0,0 @@
-package dev.meloda.fast.model.api.data
-
-import com.squareup.moshi.Json
-import com.squareup.moshi.JsonClass
-
-@JsonClass(generateAdapter = true)
-data class LongPollHistoryResponse(
-    @Json(name = "history") val history: List<List<Any>>? = null,
-    @Json(name = "messages") val messages: Messages? = null,
-    @Json(name = "profiles") val profiles: List<VkUserData>? = null,
-    @Json(name = "groups") val groups: List<VkGroupData>? = null,
-    @Json(name = "new_pts") val newPts: Int? = null,
-    @Json(name = "from_pts") val fromPts: Int? = null,
-    @Json(name = "ts") val ts: Int? = null,
-    @Json(name = "pts") val pts: Int? = null,
-    @Json(name = "more") val more: Int? = null,
-    @Json(name = "conversations") val conversations: List<VkConvoData>? = null
-) {
-    @JsonClass(generateAdapter = true)
-    data class Messages(
-        @Json(name = "count") val count: Int? = null,
-        @Json(name = "items") val items: List<VkMessageData>? = null
-    )
-}

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

@@ -19,27 +19,3 @@ data class LongPollGetUpdatesRequest(
             "version" to version.toString()
         )
 }
-
-data class LongPollGetHistoryRequest(
-    val ts: Int,
-    val pts: Int,
-    val lpVersion: Int,
-    val lastN: Int? = null,
-    val maxMsgId: Long? = null,
-    val eventsLimit: Int? = null,
-    val msgsLimit: Int? = null,
-    val extended: Boolean = true,
-) {
-    val map: Map<String, String>
-        get() = mutableMapOf(
-            "ts" to ts.toString(),
-            "pts" to pts.toString(),
-            "lp_version" to lpVersion.toString(),
-            "extended" to if (extended) "1" else "0",
-        ).apply {
-            lastN?.let { this["last_n"] = it.toString() }
-            maxMsgId?.let { this["max_msg_id"] = it.toString() }
-            eventsLimit?.let { this["events_limit"] = it.toString() }
-            msgsLimit?.let { this["msgs_limit"] = it.toString() }
-        }
-}

core/network/src/main/kotlin/dev/meloda/fast/network/interceptor/Error14HandlingInterceptor.kt

@@ -1,62 +1,90 @@
 package dev.meloda.fast.network.interceptor
 
+import android.util.Log
+import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.datastore.AppSettings
 import dev.meloda.fast.datastore.CaptchaTokenResult
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.Job
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withTimeout
 import okhttp3.Interceptor
 import okhttp3.Request
 import okhttp3.Response
 import org.json.JSONObject
-import java.io.IOException
+import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicReference
-import kotlin.time.Duration.Companion.minutes
 
-class Error14HandlingInterceptor : Interceptor {
+class Error14HandlingInterceptor(
+//    private val domains: Set<String> = emptySet(),
+) : Interceptor {
 
     private val cookie = AtomicReference<String?>(null)
-    private val captchaMutex = Mutex()
+
+    private companion object {
+        private const val CAPTCHA_ERROR_CODE = 14
+        private const val CAPTCHA_ERROR_KIND = "need_captcha"
+        private val executor = Executors.newSingleThreadExecutor()
+    }
 
     override fun intercept(chain: Interceptor.Chain): Response {
         val request = chain.request().withCookie()
         val response = chain.proceed(request)
         response.parseCookie()
-
         if (request.shouldSkipCaptcha()) return response
-
         val redirectUri = response.getRedirectUri() ?: return response
-        val token = awaitCaptchaToken(redirectUri)
+        val token = passCaptchaAndGetToken(redirectUri)
-
         return chain.proceed(chain.request().withCookie().withSuccessToken(token))
     }
 
-    private fun awaitCaptchaToken(redirectUri: String): String = runBlocking(Dispatchers.IO) {
+    private fun passCaptchaAndGetToken(redirectUri: String): String = synchronized(this) {
-        captchaMutex.withLock {
+        val tokenResult = AtomicReference<Result<String>>(Result.failure(Exception("No result")))
-            AppSettings.setCaptchaResult(CaptchaTokenResult.Initial)
-            AppSettings.setCaptchaRedirectUri(redirectUri)
 
-            try {
+        executor.submit {
-                withTimeout(CAPTCHA_TIMEOUT) {
+            AppSettings.setCaptchaRedirectUri(redirectUri)
-                    AppSettings.getCaptchaResultFlow()
+            Log.d("Error14Interceptor", "passCaptchaAndGetToken: $redirectUri")
-                        .first { it != CaptchaTokenResult.Initial }
+
-                        .toToken()
+            var job: Job? = null
+            job = AppSettings.getCaptchaResultFlow()
+                .listenValue(CoroutineScope(Dispatchers.IO)) {
+                    Log.d("Error14Interceptor", "passCaptchaAndGetToken: $it")
+                    if (it != CaptchaTokenResult.Initial) {
+                        synchronized(tokenResult) {
+                            Log.d(
+                                "Error14Interceptor",
+                                "passCaptchaAndGetToken: SYNCHRONIZED: $it"
+                            )
+                            tokenResult.set(wrapResult(it))
+                            tokenResult.notifyAll()
+                            job?.cancel()
+                            Log.d(
+                                "Error14Interceptor",
+                                "passCaptchaAndGetToken: NULL RESULT"
+                            )
+                            AppSettings.setCaptchaResult(CaptchaTokenResult.Initial)
+                            AppSettings.setCaptchaRedirectUri(null)
+                        }
+                    }
                 }
-            } finally {
+        }
-                AppSettings.setCaptchaResult(CaptchaTokenResult.Initial)
+        synchronized(tokenResult) {
-                AppSettings.setCaptchaRedirectUri(null)
+            if (tokenResult.get().getOrNull() == null) {
+                tokenResult.wait()
             }
+
+            Log.d("Error14Interceptor", "passCaptchaAndGetToken: GET VALUE")
+            tokenResult.get().getOrThrow()
         }
     }
 
-    private fun CaptchaTokenResult.toToken(): String = when (this) {
+    private fun wrapResult(result: CaptchaTokenResult): Result<String> {
-        is CaptchaTokenResult.Success -> token
+        return when (result) {
-        CaptchaTokenResult.Cancelled -> throw IOException("Captcha cancelled")
+            // TODO: 03/05/2026, Danil Nikolaev: check again?
-        CaptchaTokenResult.Null -> throw IOException("Captcha result is empty")
+            CaptchaTokenResult.Null -> Result.success("")
-        CaptchaTokenResult.Initial -> throw IllegalStateException("Captcha result not ready")
+
+            CaptchaTokenResult.Cancelled, CaptchaTokenResult.Initial -> Result.success("")
+
+            is CaptchaTokenResult.Success -> Result.success(result.token)
+        }
     }
 
     private fun Request.withSuccessToken(token: String): Request {
@@ -105,10 +133,13 @@ class Error14HandlingInterceptor : Interceptor {
     private fun Request.withCookie(): Request {
         return newBuilder().apply { cookie.get()?.let { addHeader("Cookie", it) } }.build()
     }
-
-    private companion object {
-        private const val CAPTCHA_ERROR_CODE = 14
-        private const val CAPTCHA_ERROR_KIND = "need_captcha"
-        private val CAPTCHA_TIMEOUT = 10.minutes
-    }
 }
+
+@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "NOTHING_TO_INLINE")
+private inline fun Any.wait() = (this as Object).wait()
+
+@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "NOTHING_TO_INLINE")
+private inline fun Any.notify() = (this as Object).notify()
+
+@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "NOTHING_TO_INLINE")
+private inline fun Any.notifyAll() = (this as Object).notifyAll()

core/network/src/main/kotlin/dev/meloda/fast/network/service/messages/MessagesService.kt

@@ -2,7 +2,6 @@ package dev.meloda.fast.network.service.messages
 
 import com.slack.eithernet.ApiResult
 import dev.meloda.fast.model.api.data.VkChatData
-import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.VkLongPollData
 import dev.meloda.fast.model.api.data.VkMessageData
 import dev.meloda.fast.model.api.responses.MessagesCreateChatResponse
@@ -45,12 +44,6 @@ interface MessagesService {
         @FieldMap params: Map<String, String>
     ): ApiResult<ApiResponse<VkLongPollData>, RestApiError>
 
-    @FormUrlEncoded
-    @POST(MessagesUrls.GET_LONG_POLL_HISTORY)
-    suspend fun getLongPollHistory(
-        @FieldMap params: Map<String, String>
-    ): ApiResult<ApiResponse<LongPollHistoryResponse>, RestApiError>
-
     @FormUrlEncoded
     @POST(MessagesUrls.MARK_AS_READ)
     suspend fun markAsRead(

core/ui/src/main/kotlin/dev/meloda/fast/ui/util/Extensions.kt

@@ -18,6 +18,7 @@ import androidx.compose.ui.graphics.luminance
 import androidx.compose.ui.graphics.painter.Painter
 import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.input.key.onKeyEvent
+import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.colorResource
 import androidx.compose.ui.res.painterResource
@@ -113,11 +114,12 @@ fun LazyListState.isScrollingUp(): Boolean {
 @Composable
 fun isNeedToEnableDarkMode(darkMode: DarkMode): Boolean {
     val context = LocalContext.current
+    val configuration = LocalConfiguration.current
 
     val appForceDarkMode = darkMode == DarkMode.ENABLED
     val appBatterySaver = darkMode == DarkMode.AUTO_BATTERY
 
-    val systemUiNightMode = context.resources.configuration.uiMode
+    val systemUiNightMode = configuration.uiMode
 
     val isSystemBatterySaver = context.getSystemService<PowerManager>()?.isPowerSaveMode == true
     val isSystemUsingDarkTheme =

feature/chatmaterials/src/main/kotlin/dev/meloda/fast/chatmaterials/ChatMaterialsViewModel.kt

@@ -9,16 +9,12 @@ import dev.meloda.fast.chatmaterials.navigation.ChatMaterials
 import dev.meloda.fast.chatmaterials.util.asPresentation
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
-import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
-import dev.meloda.fast.common.paging.loadingFlags
-import dev.meloda.fast.common.paging.mergePage
 import dev.meloda.fast.data.State
-import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.domain.MessagesUseCase
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.api.domain.VkAttachmentHistoryMessage
+import dev.meloda.fast.network.VkErrorCode
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 
@@ -93,14 +89,11 @@ class ChatMaterialsViewModelImpl(
             state.processState(
                 error = ::handleError,
                 success = { response ->
-                    val itemsCountSufficient = canPaginatePage(LOAD_COUNT, response.size)
+                    val itemsCountSufficient = response.size == LOAD_COUNT
                     canPaginate.setValue { itemsCountSufficient }
 
-                    val paginationExhausted = isPaginationExhaustedPage(
+                    val paginationExhausted = !itemsCountSufficient
-                        pageSize = LOAD_COUNT,
+                            && screenState.value.materials.isNotEmpty()
-                        loadedCount = response.size,
-                        hasExistingItems = screenState.value.materials.isNotEmpty()
-                    )
 
                     val loadedMaterials = response.mapNotNull(VkAttachmentHistoryMessage::asPresentation)
 
@@ -114,27 +107,64 @@ class ChatMaterialsViewModelImpl(
                         }
                     )
 
-                    screenState.setValue {
+                    if (offset == 0) {
-                        newState.copy(
+                        screenState.setValue {
-                            materials = mergePage(newState.materials, loadedMaterials, offset)
+                            newState.copy(materials = loadedMaterials)
-                        )
+                        }
+                    } else {
+                        screenState.setValue {
+                            newState.copy(
+                                materials = newState.materials.plus(loadedMaterials)
+                            )
+                        }
                     }
                 }
             )
 
-            val flags = loadingFlags(offset, state.isLoading())
             screenState.setValue { old ->
                 old.copy(
-                    isLoading = flags.isLoading,
+                    isLoading = offset == 0 && state.isLoading(),
-                    isPaginating = flags.isPaginating
+                    isPaginating = offset > 0 && state.isLoading()
                 )
             }
         }
     }
 
     private fun handleError(error: State.Error) {
-        VkUtils.parseError(error)?.let { newBaseError ->
+        when (error) {
-            baseError.setValue { newBaseError }
+            is State.Error.ApiError -> {
+                when (error.errorCode) {
+                    VkErrorCode.USER_AUTHORIZATION_FAILED -> {
+                        baseError.setValue { BaseError.SessionExpired }
+                    }
+
+                    else -> {
+                        baseError.setValue {
+                            BaseError.SimpleError(message = error.errorMessage)
+                        }
+                    }
+                }
+            }
+
+            State.Error.ConnectionError -> {
+                baseError.setValue {
+                    BaseError.SimpleError(message = "Connection error")
+                }
+            }
+
+            State.Error.InternalError -> {
+                baseError.setValue {
+                    BaseError.SimpleError(message = "Internal error")
+                }
+            }
+
+            State.Error.UnknownError -> {
+                baseError.setValue {
+                    BaseError.SimpleError(message = "Unknown error")
+                }
+            }
+
+            else -> Unit
         }
     }
 

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

@@ -8,16 +8,12 @@ import androidx.lifecycle.viewModelScope
 import coil.ImageLoader
 import coil.request.ImageRequest
 import com.conena.nanokt.collections.indexOfFirstOrNull
+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.launchDbRefresh
 import dev.meloda.fast.common.extensions.updateValue
-import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
-import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
-import dev.meloda.fast.common.paging.loadingFlags
-import dev.meloda.fast.common.paging.mergePage
 import dev.meloda.fast.convos.model.ConvoDialog
 import dev.meloda.fast.convos.model.ConvoNavigation
 import dev.meloda.fast.convos.model.ConvosScreenState
@@ -27,7 +23,8 @@ import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.ConvoUseCase
-import dev.meloda.fast.domain.LongPollUpdatesReducer
+import dev.meloda.fast.domain.LoadConvosByIdUseCase
+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
@@ -43,21 +40,20 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
 
 class ConvosViewModel(
-    updatesReducer: LongPollUpdatesReducer,
+    updatesParser: LongPollUpdatesParser,
     private val filter: ConvosFilter,
     private val convoUseCase: ConvoUseCase,
     private val messagesUseCase: MessagesUseCase,
     private val resources: Resources,
     private val userSettings: UserSettings,
     private val imageLoader: ImageLoader,
-    private val applicationContext: Context
+    private val applicationContext: Context,
+    private val loadConvosByIdUseCase: LoadConvosByIdUseCase
 ) : ViewModel() {
     private val _screenState = MutableStateFlow(ConvosScreenState.EMPTY)
     val screenState = _screenState.asStateFlow()
@@ -98,15 +94,15 @@ class ConvosViewModel(
 
         loadConvos()
 
-        updatesReducer.newMessages.onEach(::handleNewMessage).launchIn(viewModelScope)
+        updatesParser.onNewMessage(::handleNewMessage)
-        updatesReducer.messageEdited.onEach(::handleEditedMessage).launchIn(viewModelScope)
+        updatesParser.onMessageEdited(::handleEditedMessage)
-        updatesReducer.messageIncomingRead.onEach(::handleReadIncomingMessage).launchIn(viewModelScope)
+        updatesParser.onMessageIncomingRead(::handleReadIncomingMessage)
-        updatesReducer.messageOutgoingRead.onEach(::handleReadOutgoingMessage).launchIn(viewModelScope)
+        updatesParser.onMessageOutgoingRead(::handleReadOutgoingMessage)
-        updatesReducer.interactions.onEach(::handleInteraction).launchIn(viewModelScope)
+        updatesParser.onInteractions(::handleInteraction)
-        updatesReducer.chatMajorChanged.onEach(::handleChatMajorChanged).launchIn(viewModelScope)
+        updatesParser.onChatMajorChanged(::handleChatMajorChanged)
-        updatesReducer.chatMinorChanged.onEach(::handleChatMinorChanged).launchIn(viewModelScope)
+        updatesParser.onChatMinorChanged(::handleChatMinorChanged)
-        updatesReducer.chatCleared.onEach(::handleChatClearing).launchIn(viewModelScope)
+        updatesParser.onChatCleared(::handleChatClearing)
-        updatesReducer.chatArchived.onEach(::handleChatArchived).launchIn(viewModelScope)
+        updatesParser.onChatArchived(::handleChatArchived)
 
         userSettings.useContactNames.listenValue(viewModelScope) {
             syncUiConvos()
@@ -257,10 +253,6 @@ class ConvosViewModel(
     private fun loadConvos(
         offset: Int = currentOffset.value
     ) {
-        if (offset == 0) {
-            refreshConvosFromDb()
-        }
-
         convoUseCase.getConvos(
             count = LOAD_COUNT,
             offset = offset,
@@ -272,12 +264,17 @@ class ConvosViewModel(
                     _baseError.update { newBaseError }
                 },
                 success = { response ->
-                    val itemsCountSufficient = canPaginatePage(LOAD_COUNT, response.size)
+                    val convos = response
-                    val paginationExhausted = isPaginationExhaustedPage(
+                    val fullConvos = if (offset == 0) {
-                        pageSize = LOAD_COUNT,
+                        convos
-                        loadedCount = response.size,
+                    } else {
-                        hasExistingItems = this.convos.value.isNotEmpty()
+                        this.convos.value.plus(convos)
-                    )
+                    }
+
+                    val itemsCountSufficient = response.size == LOAD_COUNT
+
+                    val paginationExhausted = !itemsCountSufficient &&
+                            this.convos.value.isNotEmpty()
 
                     _screenState.updateValue {
                         copy(isPaginationExhausted = paginationExhausted)
@@ -296,17 +293,16 @@ class ConvosViewModel(
 
                     convoUseCase.storeConvos(response)
 
-                    _convos.emit(mergePage(this.convos.value, response, offset))
+                    _convos.emit(fullConvos)
                     syncUiConvos()
                     _canPaginate.setValue { itemsCountSufficient }
                 }
             )
 
-            val flags = loadingFlags(offset, state.isLoading())
             _screenState.setValue { old ->
                 old.copy(
-                    isLoading = flags.isLoading,
+                    isLoading = offset == 0 && state.isLoading(),
-                    isPaginating = flags.isPaginating
+                    isPaginating = offset > 0 && state.isLoading()
                 )
             }
         }
@@ -317,10 +313,14 @@ class ConvosViewModel(
             state.processState(
                 error = {},
                 success = {
-                    viewModelScope.launch {
+                    val newConvos = convos.value.toMutableList()
-                        convoUseCase.deleteLocalConvo(peerId)
+                    val convoIndex =
-                        refreshConvosFromDb()
+                        newConvos.indexOfFirstOrNull { it.id == peerId }
-                    }
+                            ?: return@processState
+
+                    newConvos.removeAt(convoIndex)
+                    _convos.update { newConvos.sorted() }
+                    syncUiConvos()
                 }
             )
             _screenState.emit(screenState.value.copy(isLoading = state.isLoading()))
@@ -333,22 +333,16 @@ class ConvosViewModel(
                 state.processState(
                     error = {},
                     success = {
-                        viewModelScope.launch {
+                        handleChatMajorChanged(
-                            convoUseCase.getLocalConvoById(peerId)?.let { convo ->
+                            LongPollParsedEvent.ChatMajorChanged(
-                                convoUseCase.storeConvos(
+                                peerId = peerId,
-                                    listOf(
+                                majorId = if (pin) {
-                                        convo.copy(
+                                    pinnedConvosCount.value.plus(1) * 16
-                                            majorId = if (pin) {
+                                } else {
-                                                pinnedConvosCount.value.plus(1) * 16
+                                    0
-                                            } else {
+                                }
-                                                0
+                            )
-                                            }
+                        )
-                                        )
-                                    )
-                                )
-                            }
-                            refreshConvosFromDb()
-                        }
                     }
                 )
 
@@ -362,35 +356,145 @@ class ConvosViewModel(
                 state.processState(
                     error = {},
                     success = {
-                        viewModelScope.launch {
+                        convos.value.find { it.id == peerId }?.let { convo ->
-                            convoUseCase.getLocalConvoById(peerId)?.let { convo ->
+                            handleChatArchived(
-                                convoUseCase.storeConvos(
+                                LongPollParsedEvent.ChatArchived(
-                                    listOf(
+                                    convo = convo,
-                                        convo.copy(isArchived = archive)
+                                    archived = archive
-                                    )
                                 )
-                            }
+                            )
-                            refreshConvosFromDb()
                         }
                     }
                 )
             }
     }
 
+    // TODO: 03-Apr-25, Danil Nikolaev: handle business messages
     private fun handleNewMessage(event: LongPollParsedEvent.NewMessage) {
-        refreshConvosFromDb()
+        val message = event.message
+
+        val newConvos = convos.value.toMutableList()
+        val convoIndex =
+            newConvos.indexOfFirstOrNull { it.id == message.peerId }
+
+        if (convoIndex == null) {
+            if (event.inArchive != (filter == ConvosFilter.ARCHIVE)) return
+
+            loadConvosByIdUseCase(
+                peerIds = listOf(message.peerId),
+                extended = true,
+                fields = VkConstants.ALL_FIELDS
+            ).listenValue(viewModelScope) { state ->
+                state.processState(
+                    error = {},
+                    success = { response ->
+                        val convo = (response.firstOrNull() ?: return@listenValue)
+                            .copy(lastMessage = message)
+
+                        newConvos.add(pinnedConvosCount.value, convo)
+                        _convos.update { newConvos.sorted() }
+                        syncUiConvos()
+                    }
+                )
+            }
+        } else {
+            val convo = newConvos[convoIndex]
+            var newConvo = convo.copy(
+                lastMessage = message,
+                lastMessageId = message.id,
+                lastCmId = message.cmId,
+                unreadCount = if (message.isOut) convo.unreadCount
+                else convo.unreadCount + 1
+            )
+
+            interactionsTimers[convo.id]?.let { job ->
+                if (job.interactionType == InteractionType.Typing
+                    && message.fromId in convo.interactionIds
+                ) {
+                    val newInteractionIds = newConvo.interactionIds.filter { id ->
+                        id != message.fromId
+                    }
+
+                    newConvo = newConvo.copy(
+                        interactionType = if (newInteractionIds.isEmpty()) -1 else {
+                            newConvo.interactionType
+                        },
+                        interactionIds = newInteractionIds
+                    )
+                }
+            }
+
+            if (convo.isPinned()) {
+                newConvos[convoIndex] = newConvo
+            } else {
+                newConvos.removeAt(convoIndex)
+
+                val toPosition = pinnedConvosCount.value
+                newConvos.add(toPosition, newConvo)
+            }
+
+            _convos.update { newConvos.sorted() }
+            syncUiConvos()
+        }
     }
 
     private fun handleEditedMessage(event: LongPollParsedEvent.MessageEdited) {
-        refreshConvosFromDb()
+        val message = event.message
+        val newConvos = convos.value.toMutableList()
+
+        val convoIndex = newConvos.indexOfFirstOrNull { it.id == message.peerId }
+        if (convoIndex == null) { // диалога нет в списке
+            //  pizdets
+        } else {
+            val convo = newConvos[convoIndex]
+            newConvos[convoIndex] = convo.copy(
+                lastMessage = message,
+                lastMessageId = message.id,
+                lastCmId = message.cmId
+            )
+            _convos.update { newConvos }
+            syncUiConvos()
+        }
     }
 
     private fun handleReadIncomingMessage(event: LongPollParsedEvent.IncomingMessageRead) {
-        refreshConvosFromDb()
+        val newConvos = convos.value.toMutableList()
+
+        val convoIndex =
+            newConvos.indexOfFirstOrNull { it.id == event.peerId }
+
+        if (convoIndex == null) { // диалога нет в списке
+            // pizdets
+        } else {
+            newConvos[convoIndex] =
+                newConvos[convoIndex].copy(
+                    inReadCmId = event.cmId,
+                    unreadCount = event.unreadCount
+                )
+
+            _convos.update { newConvos }
+            syncUiConvos()
+        }
     }
 
     private fun handleReadOutgoingMessage(event: LongPollParsedEvent.OutgoingMessageRead) {
-        refreshConvosFromDb()
+        val newConvos = convos.value.toMutableList()
+
+        val convoIndex =
+            newConvos.indexOfFirstOrNull { it.id == event.peerId }
+
+        if (convoIndex == null) { // диалога нет в списке
+            // pizdets
+        } else {
+            newConvos[convoIndex] =
+                newConvos[convoIndex].copy(
+                    outReadCmId = event.cmId,
+                    unreadCount = event.unreadCount
+                )
+
+            _convos.update { newConvos }
+            syncUiConvos()
+        }
     }
 
     private fun handleInteraction(event: LongPollParsedEvent.Interaction) {
@@ -459,19 +563,88 @@ class ConvosViewModel(
     }
 
     private fun handleChatMajorChanged(event: LongPollParsedEvent.ChatMajorChanged) {
-        refreshConvosFromDb()
+        val newConvos = convos.value.toMutableList()
+        val convoIndex =
+            newConvos.indexOfFirstOrNull { it.id == event.peerId }
+
+        if (convoIndex == null) { // диалога нет в списке
+            // pizdets
+        } else {
+            newConvos[convoIndex] =
+                newConvos[convoIndex].copy(majorId = event.majorId)
+
+            _convos.setValue { newConvos.sorted() }
+            syncUiConvos()
+        }
     }
 
     private fun handleChatMinorChanged(event: LongPollParsedEvent.ChatMinorChanged) {
-        refreshConvosFromDb()
+        val newConvos = convos.value.toMutableList()
+        val convoIndex =
+            newConvos.indexOfFirstOrNull { it.id == event.peerId }
+
+        if (convoIndex == null) { // диалога нет в списке
+            // pizdets
+        } else {
+            newConvos[convoIndex] =
+                newConvos[convoIndex].copy(minorId = event.minorId)
+
+            _convos.setValue { newConvos.sorted() }
+            syncUiConvos()
+        }
     }
 
     private fun handleChatClearing(event: LongPollParsedEvent.ChatCleared) {
-        refreshConvosFromDb()
+        val newConvos = convos.value.toMutableList()
+
+        val convoIndex = newConvos.indexOfFirstOrNull { it.id == event.peerId }
+
+        if (convoIndex == null) { // диалога нет в списке
+            // pizdets
+        } else {
+            newConvos.removeAt(convoIndex)
+
+            _convos.setValue { newConvos.sorted() }
+            syncUiConvos()
+        }
     }
 
     private fun handleChatArchived(event: LongPollParsedEvent.ChatArchived) {
-        refreshConvosFromDb()
+        val convo = event.convo
+
+        val newConvos = convos.value.toMutableList()
+
+        when (filter) {
+            ConvosFilter.BUSINESS_NOTIFY -> Unit
+
+            ConvosFilter.ARCHIVE -> {
+                if (event.archived) {
+                    newConvos.add(0, convo)
+                } else {
+                    val index = newConvos.indexOfFirstOrNull { it.id == convo.id }
+                    if (index == null) return
+
+                    newConvos.removeAt(index)
+                }
+
+                _convos.update { newConvos }
+                syncUiConvos()
+            }
+
+            else -> {
+                if (event.archived) {
+                    val index = newConvos.indexOfFirstOrNull { it.id == convo.id }
+                    if (index == null) return
+
+                    newConvos.removeAt(index)
+                } else {
+                    newConvos.add(pinnedConvosCount.value, convo)
+                }
+
+                _convos.update { newConvos.sorted() }
+                syncUiConvos()
+            }
+        }
     }
 
     private fun readConvo(peerId: Long, startMessageId: Long) {
@@ -482,42 +655,21 @@ class ConvosViewModel(
             state.processState(
                 error = {},
                 success = {
-                    viewModelScope.launch {
+                    val newConvos = convos.value.toMutableList()
-                        convoUseCase.getLocalConvoById(peerId)?.let { convo ->
+                    val convoIndex =
-                            convoUseCase.storeConvos(
+                        newConvos.indexOfFirstOrNull { it.id == peerId }
-                                listOf(
+                            ?: return@listenValue
-                                    convo.copy(
+
-                                        inRead = startMessageId,
+                    newConvos[convoIndex] =
-                                        unreadCount = 0
+                        newConvos[convoIndex].copy(inRead = startMessageId)
-                                    )
+
-                                )
+                    _convos.update { newConvos }
-                            )
+                    syncUiConvos()
-                        }
-                        refreshConvosFromDb()
-                    }
                 }
             )
         }
     }
 
-    private fun refreshConvosFromDb() {
-        viewModelScope.launchDbRefresh(
-            load = {
-            val localConvos = convoUseCase.getLocalConvos()
-
-            val filteredConvos = when (filter) {
-                ConvosFilter.ARCHIVE -> localConvos.filter(VkConvo::isArchived)
-                ConvosFilter.UNREAD -> localConvos.filter { !it.isArchived && it.unreadCount > 0 }
-                ConvosFilter.ALL -> localConvos.filterNot(VkConvo::isArchived)
-                ConvosFilter.BUSINESS_NOTIFY -> localConvos
-            }
-
-            _convos.emit(filteredConvos)
-        },
-            after = ::syncUiConvos
-        )
-    }
-
     private fun List<VkConvo>.sorted(): List<VkConvo> {
         val newConvos = toMutableList()
 

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

@@ -31,6 +31,7 @@ private fun Scope.createConvosViewModel(filter: ConvosFilter): ConvosViewModel {
         resources = get(),
         userSettings = get(),
         imageLoader = get(),
-        applicationContext = get()
+        applicationContext = get(),
+        loadConvosByIdUseCase = get()
     )
 }

feature/createchat/src/main/kotlin/dev/meloda/fast/convos/CreateChatViewModel.kt

@@ -7,14 +7,9 @@ import coil.ImageLoader
 import coil.request.ImageRequest
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
-import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
-import dev.meloda.fast.common.paging.loadingFlags
-import dev.meloda.fast.common.paging.mergePage
 import dev.meloda.fast.convos.model.CreateChatScreenState
 import dev.meloda.fast.data.State
 import dev.meloda.fast.data.UserConfig
-import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.FriendsUseCase
@@ -23,6 +18,7 @@ import dev.meloda.fast.domain.MessagesUseCase
 import dev.meloda.fast.domain.util.asPresentation
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.api.domain.VkUser
+import dev.meloda.fast.network.VkErrorCode
 import dev.meloda.fast.ui.model.vk.UiFriend
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -158,16 +154,13 @@ class CreateChatViewModel(
         friendsUseCase.getFriends(count = LOAD_COUNT, offset = offset)
             .listenValue(viewModelScope) { state ->
                 state.processState(
-                error = ::handleError,
+                    error = ::handleError,
-                success = { response ->
+                    success = { response ->
-                    val itemsCountSufficient = canPaginatePage(LOAD_COUNT, response.size)
+                        val itemsCountSufficient = response.size == LOAD_COUNT
-                    _canPaginate.setValue { itemsCountSufficient }
+                        _canPaginate.setValue { itemsCountSufficient }
 
-                    val paginationExhausted = isPaginationExhaustedPage(
+                        val paginationExhausted = !itemsCountSufficient &&
-                        pageSize = LOAD_COUNT,
+                                screenState.value.friends.isNotEmpty()
-                        loadedCount = response.size,
-                        hasExistingItems = screenState.value.friends.isNotEmpty()
-                    )
 
                         val imagesToPreload =
                             response.mapNotNull { it.photo100.takeIf { p -> !p.isNullOrEmpty() } }
@@ -189,19 +182,24 @@ class CreateChatViewModel(
                         val newState = screenState.value.copy(
                             isPaginationExhausted = paginationExhausted
                         )
-                        _screenState.setValue {
+                        if (offset == 0) {
-                            newState.copy(
+                            _screenState.setValue {
-                                friends = mergePage(newState.friends, loadedFriends, offset)
+                                newState.copy(friends = loadedFriends)
-                            )
+                            }
+                        } else {
+                            _screenState.setValue {
+                                newState.copy(
+                                    friends = newState.friends.plus(loadedFriends)
+                                )
+                            }
                         }
                     }
                 )
 
-                val flags = loadingFlags(offset, state.isLoading())
                 _screenState.setValue { old ->
                     old.copy(
-                        isLoading = flags.isLoading,
+                        isLoading = offset == 0 && state.isLoading(),
-                        isPaginating = flags.isPaginating
+                        isPaginating = offset > 0 && state.isLoading()
                     )
                 }
             }
@@ -230,8 +228,40 @@ class CreateChatViewModel(
     }
 
     private fun handleError(error: State.Error) {
-        VkUtils.parseError(error)?.let { newBaseError ->
+        when (error) {
-            _baseError.setValue { newBaseError }
+            is State.Error.ApiError -> {
+                when (error.errorCode) {
+                    VkErrorCode.USER_AUTHORIZATION_FAILED -> {
+                        _baseError.setValue { BaseError.SessionExpired }
+                    }
+
+                    else -> {
+                        _baseError.setValue {
+                            BaseError.SimpleError(message = error.errorMessage)
+                        }
+                    }
+                }
+            }
+
+            State.Error.ConnectionError -> {
+                _baseError.setValue {
+                    BaseError.SimpleError(message = "Connection error")
+                }
+            }
+
+            State.Error.InternalError -> {
+                _baseError.setValue {
+                    BaseError.SimpleError(message = "Internal error")
+                }
+            }
+
+            State.Error.UnknownError -> {
+                _baseError.setValue {
+                    BaseError.SimpleError(message = "Unknown error")
+                }
+            }
+
+            else -> Unit
         }
     }
 

feature/friends/src/main/kotlin/dev/meloda/fast/friends/FriendsViewModel.kt

@@ -4,12 +4,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
-import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
-import dev.meloda.fast.common.paging.loadingFlags
-import dev.meloda.fast.common.paging.mergePage
 import dev.meloda.fast.data.State
-import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.FriendsUseCase
@@ -18,6 +13,7 @@ import dev.meloda.fast.domain.util.asPresentation
 import dev.meloda.fast.friends.model.FriendsScreenState
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.api.domain.VkUser
+import dev.meloda.fast.network.VkErrorCode
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
@@ -84,8 +80,40 @@ abstract class BaseFriendsViewModelImpl : ViewModel(), FriendsViewModel {
     abstract fun loadFriends(offset: Int = currentOffset.value)
 
     protected fun handleError(error: State.Error) {
-        VkUtils.parseError(error)?.let { newBaseError ->
+        when (error) {
-            baseError.setValue { newBaseError }
+            is State.Error.ApiError -> {
+                when (error.errorCode) {
+                    VkErrorCode.USER_AUTHORIZATION_FAILED -> {
+                        baseError.setValue { BaseError.SessionExpired }
+                    }
+
+                    else -> {
+                        baseError.setValue {
+                            BaseError.SimpleError(message = error.errorMessage)
+                        }
+                    }
+                }
+            }
+
+            State.Error.ConnectionError -> {
+                baseError.setValue {
+                    BaseError.SimpleError(message = "Connection error")
+                }
+            }
+
+            State.Error.InternalError -> {
+                baseError.setValue {
+                    BaseError.SimpleError(message = "Internal error")
+                }
+            }
+
+            State.Error.UnknownError -> {
+                baseError.setValue {
+                    BaseError.SimpleError(message = "Unknown error")
+                }
+            }
+
+            else -> Unit
         }
     }
 
@@ -126,14 +154,11 @@ class FriendsViewModelImpl(
             state.processState(
                 error = ::handleError,
                 success = { response ->
-                    val itemsCountSufficient = canPaginatePage(LOAD_COUNT, response.size)
+                    val itemsCountSufficient = response.size == LOAD_COUNT
                     canPaginate.setValue { itemsCountSufficient }
 
-                    val paginationExhausted = isPaginationExhaustedPage(
+                    val paginationExhausted = !itemsCountSufficient
-                        pageSize = LOAD_COUNT,
+                            && screenState.value.friends.isNotEmpty()
-                        loadedCount = response.size,
-                        hasExistingItems = screenState.value.friends.isNotEmpty()
-                    )
 
                     imagesToPreload.setValue {
                         response.mapNotNull(VkUser::photo100)
@@ -149,20 +174,24 @@ class FriendsViewModelImpl(
                         isPaginationExhausted = paginationExhausted
                     )
 
-                    friends.emit(mergePage(friends.value, response, offset))
+                    if (offset == 0) {
-                    screenState.setValue {
+                        friends.emit(response)
-                        newState.copy(
+                        screenState.setValue {
-                            friends = mergePage(newState.friends, loadedFriends, offset)
+                            newState.copy(friends = loadedFriends)
-                        )
+                        }
+                    } else {
+                        friends.emit(friends.value.plus(response))
+                        screenState.setValue {
+                            newState.copy(friends = newState.friends.plus(loadedFriends))
+                        }
                     }
                 }
             )
 
-            val flags = loadingFlags(offset, state.isLoading())
             screenState.setValue { old ->
                 old.copy(
-                    isLoading = flags.isLoading,
+                    isLoading = offset == 0 && state.isLoading(),
-                    isPaginating = flags.isPaginating
+                    isPaginating = offset > 0 && state.isLoading()
                 )
             }
         }
@@ -200,14 +229,10 @@ class OnlineFriendsViewModelImpl(
                                 }
                             )
 
-                            val flags = loadingFlags(
-                                offset = offset,
-                                isLoading = onlineState.isLoading() || state.isLoading()
-                            )
                             screenState.setValue { old ->
                                 old.copy(
-                                    isLoading = flags.isLoading,
+                                    isLoading = offset == 0 && (onlineState.isLoading() || state.isLoading()),
-                                    isPaginating = flags.isPaginating
+                                    isPaginating = offset > 0 && (onlineState.isLoading() || state.isLoading())
                                 )
                             }
                         }

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

@@ -1,267 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import android.os.Bundle
-import com.conena.nanokt.collections.indexOfFirstOrNull
-import dev.meloda.fast.common.extensions.getParcelableCompat
-import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.messageshistory.model.MessageDialog
-import dev.meloda.fast.messageshistory.model.MessageOption
-import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
-import dev.meloda.fast.model.api.domain.VkMessage
-import dev.meloda.fast.ui.model.vk.MessageUiItem
-import kotlinx.coroutines.flow.MutableStateFlow
-
-internal class MessagesHistoryInteractionHandler(
-    private val screenState: MutableStateFlow<MessagesHistoryScreenState>,
-    private val messages: MutableStateFlow<List<VkMessage>>,
-    private val dialog: MutableStateFlow<MessageDialog?>,
-    private val selectedMessages: MutableStateFlow<List<VkMessage>>,
-    private val uiMessages: MutableStateFlow<List<MessageUiItem>>,
-    private val isNeedToScrollToIndex: MutableStateFlow<Int?>,
-    private val messageActions: MessagesHistoryMessageActions,
-    private val messageTransportActions: MessagesHistoryMessageTransportActions,
-    private val syncUiMessages: () -> Unit
-) {
-    fun onDialogConfirmed(dialog: MessageDialog, bundle: Bundle) {
-        onDialogDismissed(dialog)
-
-        when (dialog) {
-            is MessageDialog.MessageOptions -> Unit
-
-            is MessageDialog.MessageDelete -> {
-                val deleteForEveryone = bundle.getBoolean("everyone")
-
-                if (dialog.message.id <= 0) {
-                    val newMessages = messages.value.toMutableList()
-                    newMessages.remove(dialog.message)
-                    messages.setValue { newMessages }
-                    syncUiMessages()
-                    return
-                }
-
-                messageTransportActions.deleteMessage(
-                    messageIds = listOf(dialog.message.id),
-                    deleteForAll = deleteForEveryone
-                )
-            }
-
-            is MessageDialog.MessagesDelete -> {
-                val deleteForEveryone = bundle.getBoolean("everyone")
-
-                val failedMessages = dialog.messages.filter { it.id <= 0 }
-                val messageIdsToDelete =
-                    dialog.messages
-                        .filter { it.id > 0 }
-                        .map(VkMessage::id)
-
-                messageTransportActions.deleteMessage(
-                    messageIds = messageIdsToDelete,
-                    deleteForAll = deleteForEveryone,
-                    onSuccess = {
-                        val newMessages = messages.value.toMutableList()
-                        newMessages.removeAll(failedMessages)
-                        messages.setValue { newMessages }
-                        selectedMessages.setValue { emptyList() }
-                        syncUiMessages()
-                    }
-                )
-            }
-
-            is MessageDialog.MessagePin -> {
-                messageTransportActions.pinMessage(dialog.messageId)
-            }
-
-            is MessageDialog.MessageUnpin -> {
-                messageTransportActions.unpinMessage(dialog.messageId)
-            }
-
-            is MessageDialog.MessageMarkImportance -> {
-                messageTransportActions.markAsImportant(
-                    messageIds = listOf(dialog.message.id),
-                    important = dialog.isImportant
-                )
-            }
-
-            is MessageDialog.MessageSpam -> {
-                if (dialog.isSpam) {
-                    messageTransportActions.deleteMessage(
-                        messageIds = listOf(dialog.message.id),
-                        spam = true
-                    )
-                } else {
-                    // TODO: 29-Mar-25, Danil Nikolaev: report as not spam
-                }
-            }
-        }
-    }
-
-    fun onDialogDismissed(dialog: MessageDialog) {
-        this.dialog.setValue { null }
-    }
-
-    fun onDialogItemPicked(dialog: MessageDialog, bundle: Bundle) {
-        when (dialog) {
-            is MessageDialog.MessageOptions -> {
-                val cmId = bundle.getLong("cmId")
-
-                when (val option = bundle.getParcelableCompat("option", MessageOption::class)) {
-                    null -> Unit
-
-                    MessageOption.Retry -> {
-                        // TODO: 28-Mar-25, Danil Nikolaev: retry sending
-                    }
-
-                    MessageOption.Reply -> messageActions.replyToMessage(cmId)
-
-                    MessageOption.ForwardHere -> {
-
-                    }
-
-                    MessageOption.Forward -> {
-
-                    }
-
-                    MessageOption.Pin -> {
-                        this.dialog.setValue {
-                            MessageDialog.MessagePin(dialog.message.id)
-                        }
-                    }
-
-                    MessageOption.Unpin -> {
-                        this.dialog.setValue {
-                            MessageDialog.MessageUnpin(dialog.message.id)
-                        }
-                    }
-
-                    MessageOption.Read -> {
-                        messageTransportActions.readMessage(dialog.message)
-                    }
-
-                    MessageOption.Copy -> {
-                        messageTransportActions.copyMessage(dialog.message)
-                    }
-
-                    MessageOption.MarkAsImportant,
-                    MessageOption.UnmarkAsImportant -> {
-                        this.dialog.setValue {
-                            MessageDialog.MessageMarkImportance(
-                                message = dialog.message,
-                                isImportant = option is MessageOption.MarkAsImportant
-                            )
-                        }
-                    }
-
-                    MessageOption.MarkAsSpam,
-                    MessageOption.UnmarkAsSpam -> {
-                        this.dialog.setValue {
-                            MessageDialog.MessageSpam(
-                                message = dialog.message,
-                                isSpam = option is MessageOption.MarkAsSpam
-                            )
-                        }
-                    }
-
-                    MessageOption.Edit -> {
-                        messageActions.editMessage(cmId)
-                        syncUiMessages()
-                    }
-
-                    MessageOption.Delete -> {
-                        this.dialog.setValue {
-                            MessageDialog.MessageDelete(dialog.message)
-                        }
-                    }
-                }
-            }
-
-            is MessageDialog.MessageDelete -> Unit
-            is MessageDialog.MessageUnpin -> Unit
-            is MessageDialog.MessageMarkImportance -> Unit
-            is MessageDialog.MessageSpam -> Unit
-            is MessageDialog.MessagePin -> Unit
-            is MessageDialog.MessagesDelete -> Unit
-        }
-    }
-
-    fun onCloseButtonClicked() {
-        if (selectedMessages.value.isNotEmpty()) {
-            selectedMessages.setValue { emptyList() }
-        }
-
-        if (screenState.value.editCmId != null) {
-            messageActions.stopEditMessage()
-        }
-
-        syncUiMessages()
-    }
-
-    fun onMessageClicked(messageId: Long) {
-        val currentMessage = messages.value.firstOrNull { it.id == messageId } ?: return
-
-        if (selectedMessages.value.isNotEmpty()) {
-            val isSelected = selectedMessages.value.contains(currentMessage)
-
-            selectedMessages.setValue { old ->
-                old.toMutableList().also {
-                    if (isSelected) {
-                        it.remove(currentMessage)
-                    } else {
-                        it.add(currentMessage)
-                    }
-                }
-            }
-            syncUiMessages()
-        } else {
-            dialog.setValue {
-                MessageDialog.MessageOptions(currentMessage)
-            }
-        }
-    }
-
-    fun onMessageLongClicked(messageId: Long) {
-        val currentMessage = messages.value.firstOrNull { it.id == messageId } ?: return
-
-        val isSelected = selectedMessages.value.contains(currentMessage)
-        if (isSelected) return
-
-        selectedMessages.setValue { old ->
-            old.toMutableList().also {
-                it.add(currentMessage)
-            }
-        }
-        syncUiMessages()
-    }
-
-    fun onEditSelectedMessageClicked() {
-        val cmId = selectedMessages.value.firstOrNull()?.cmId ?: return
-
-        selectedMessages.setValue { emptyList() }
-
-        messageActions.editMessage(cmId)
-
-        syncUiMessages()
-    }
-
-    fun onDeleteSelectedMessagesClicked() {
-        dialog.setValue {
-            MessageDialog.MessagesDelete(selectedMessages.value)
-        }
-    }
-
-    fun onPinnedMessageClicked(messageId: Long) {
-        val messageIndex = uiMessages.value.indexOfFirstOrNull {
-            it is MessageUiItem.Message && it.id == messageId
-        }
-
-        if (messageIndex != null) {
-            isNeedToScrollToIndex.setValue { messageIndex }
-        }
-    }
-
-    fun onUnpinMessageClicked() {
-        val pinnedMessageId = screenState.value.pinnedMessage?.id ?: return
-        dialog.setValue {
-            MessageDialog.MessageUnpin(pinnedMessageId)
-        }
-    }
-}

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

@@ -1,179 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import android.util.Log
-import dev.meloda.fast.common.VkConstants
-import dev.meloda.fast.common.extensions.listenValue
-import dev.meloda.fast.common.extensions.launchDbRefresh
-import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
-import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
-import dev.meloda.fast.common.paging.loadingFlags
-import dev.meloda.fast.common.paging.mergePage
-import dev.meloda.fast.common.provider.ResourceProvider
-import dev.meloda.fast.data.State
-import dev.meloda.fast.data.VkUtils
-import dev.meloda.fast.data.processState
-import dev.meloda.fast.datastore.AppSettings
-import dev.meloda.fast.domain.ConvoUseCase
-import dev.meloda.fast.domain.MessagesUseCase
-import dev.meloda.fast.domain.util.extractAvatar
-import dev.meloda.fast.domain.util.extractTitle
-import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
-import dev.meloda.fast.model.BaseError
-import dev.meloda.fast.model.api.domain.VkMessage
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.MutableStateFlow
-
-internal class MessagesHistoryLoaders(
-    private val convoUseCase: ConvoUseCase,
-    private val messagesUseCase: MessagesUseCase,
-    private val resourceProvider: ResourceProvider,
-    private val screenState: MutableStateFlow<MessagesHistoryScreenState>,
-    private val messages: MutableStateFlow<List<VkMessage>>,
-    private val imagesToPreload: MutableStateFlow<List<String>>,
-    private val canPaginate: MutableStateFlow<Boolean>,
-    private val baseError: MutableStateFlow<BaseError?>,
-    private val scope: CoroutineScope,
-    private val syncUiMessages: () -> Unit,
-    private val onPinnedMessage: (VkMessage?) -> Unit,
-) {
-    fun loadConvo() {
-        Log.d("MessagesHistoryViewModelImpl", "loadConvo()")
-
-        scope.launchDbRefresh(
-            load = {
-                convoUseCase.getLocalConvoById(screenState.value.convoId)?.let { convo ->
-                    val title = convo.extractTitle(
-                        useContactName = AppSettings.General.useContactNames,
-                        resources = resourceProvider.resources
-                    )
-                    val avatar = convo.extractAvatar()
-
-                    screenState.setValue { old ->
-                        old.copy(
-                            convo = convo,
-                            title = title,
-                            avatar = avatar
-                        )
-                    }
-
-                    onPinnedMessage(convo.pinnedMessage)
-                }
-            },
-            after = {}
-        )
-
-        convoUseCase.getById(
-            peerIds = listOf(screenState.value.convoId),
-            extended = true,
-            fields = VkConstants.ALL_FIELDS
-        ).listenValue(scope) { state ->
-            state.processState(
-                error = ::handleError,
-                success = { response ->
-                    val convo = response.firstOrNull() ?: return@listenValue
-                    val title = convo.extractTitle(
-                        useContactName = AppSettings.General.useContactNames,
-                        resources = resourceProvider.resources
-                    )
-                    val avatar = convo.extractAvatar()
-
-                    screenState.setValue { old ->
-                        old.copy(
-                            convo = convo,
-                            title = title,
-                            avatar = avatar
-                        )
-                    }
-
-                    onPinnedMessage(convo.pinnedMessage)
-                }
-            )
-        }
-    }
-
-    fun loadMessagesHistory(offset: Int) {
-        Log.d("MessagesHistoryViewModel", "loadMessagesHistory: $offset")
-
-        if (offset == 0) {
-            scope.launchDbRefresh(
-                load = {
-                    val cachedMessages = messagesUseCase.getLocalMessages(screenState.value.convoId)
-                    if (cachedMessages.isNotEmpty()) {
-                        messages.emit(cachedMessages.sorted())
-                    }
-                },
-                after = {
-                    if (messages.value.isNotEmpty()) {
-                        syncUiMessages()
-                    }
-                }
-            )
-        }
-
-        messagesUseCase.getMessagesHistory(
-            convoId = screenState.value.convoId,
-            count = MessagesHistoryViewModelImpl.MESSAGES_LOAD_COUNT,
-            offset = offset,
-        ).listenValue(scope) { state ->
-            state.processState(
-                error = ::handleError,
-                success = { response ->
-                    val messages = response.messages
-                    val fullMessages = mergePage(this.messages.value, messages, offset)
-                        .sorted()
-
-                    imagesToPreload.setValue {
-                        messages.mapNotNull { it.extractAvatar().extractUrl() }
-                    }
-
-                    messagesUseCase.storeMessages(messages)
-                    convoUseCase.storeConvos(response.convos)
-
-                    val itemsCountSufficient = canPaginatePage(
-                        MessagesHistoryViewModelImpl.MESSAGES_LOAD_COUNT,
-                        messages.size
-                    )
-                    val paginationExhausted = isPaginationExhaustedPage(
-                        pageSize = MessagesHistoryViewModelImpl.MESSAGES_LOAD_COUNT,
-                        loadedCount = messages.size,
-                        hasExistingItems = this.messages.value.isNotEmpty()
-                    )
-                    screenState.setValue { old ->
-                        old.copy(isPaginationExhausted = paginationExhausted)
-                    }
-
-                    this.messages.emit(fullMessages)
-                    syncUiMessages()
-                    canPaginate.setValue { itemsCountSufficient }
-                }
-            )
-
-            val flags = loadingFlags(offset, state.isLoading())
-            screenState.setValue { old ->
-                old.copy(
-                    isLoading = flags.isLoading,
-                    isPaginating = flags.isPaginating
-                )
-            }
-        }
-    }
-
-    private fun handleError(error: State.Error) {
-        VkUtils.parseError(error)?.let { newBaseError ->
-            baseError.setValue { newBaseError }
-        }
-    }
-
-    private fun List<VkMessage>.sorted(): List<VkMessage> {
-        return sortedWith { m1, m2 ->
-            val dateDiff = m2.date - m1.date
-            if (dateDiff != 0) {
-                dateDiff
-            } else {
-                val idDiff = m2.id - m1.id
-                idDiff.toInt()
-            }
-        }
-    }
-}

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

@@ -1,99 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import android.util.Log
-import dev.meloda.fast.common.extensions.launchDbRefresh
-import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.domain.ConvoUseCase
-import dev.meloda.fast.domain.MessagesUseCase
-import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
-import dev.meloda.fast.model.LongPollParsedEvent
-import dev.meloda.fast.model.api.domain.VkMessage
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.MutableStateFlow
-
-internal class MessagesHistoryLongPollEventHandler(
-    private val scope: CoroutineScope,
-    private val convoUseCase: ConvoUseCase,
-    private val messagesUseCase: MessagesUseCase,
-    private val screenState: MutableStateFlow<MessagesHistoryScreenState>,
-    private val messages: MutableStateFlow<List<VkMessage>>,
-    private val syncUiMessages: () -> Unit,
-    private val onPinnedMessageChanged: (VkMessage?) -> Unit
-) {
-    fun onNewMessage(event: LongPollParsedEvent.NewMessage) {
-        val message = event.message
-
-        Log.d("MessagesHistoryViewModel", "handleNewMessage: $message")
-
-        if (message.peerId != screenState.value.convoId) return
-        refreshFromDb(refreshMessages = true)
-    }
-
-    fun onMessageEdited(event: LongPollParsedEvent.MessageEdited) {
-        val message = event.message
-        if (message.peerId != screenState.value.convoId) return
-
-        refreshFromDb(refreshMessages = true)
-    }
-
-    fun onReadIncoming(event: LongPollParsedEvent.IncomingMessageRead) {
-        if (event.peerId != screenState.value.convoId) return
-
-        refreshFromDb(refreshMessages = false)
-    }
-
-    fun onReadOutgoing(event: LongPollParsedEvent.OutgoingMessageRead) {
-        if (event.peerId != screenState.value.convoId) return
-
-        refreshFromDb(refreshMessages = false)
-    }
-
-    fun onMessageDeleted(event: LongPollParsedEvent.MessageDeleted) {
-        if (event.peerId != screenState.value.convoId) return
-
-        refreshFromDb(refreshMessages = true)
-    }
-
-    fun onMessageRestored(event: LongPollParsedEvent.MessageRestored) {
-        if (event.message.peerId != screenState.value.convoId) return
-
-        refreshFromDb(refreshMessages = true)
-    }
-
-    fun onMessageMarkedAsImportant(event: LongPollParsedEvent.MessageMarkedAsImportant) {
-        if (event.peerId != screenState.value.convoId) return
-
-        refreshFromDb(refreshMessages = true)
-    }
-
-    fun onMessageMarkedAsSpam(event: LongPollParsedEvent.MessageMarkedAsSpam) {
-        if (event.peerId != screenState.value.convoId) return
-
-        refreshFromDb(refreshMessages = true)
-    }
-
-    fun onMessageMarkedAsNotSpam(event: LongPollParsedEvent.MessageMarkedAsNotSpam) {
-        if (event.message.peerId != screenState.value.convoId) return
-
-        refreshFromDb(refreshMessages = true)
-    }
-
-    private fun refreshFromDb(refreshMessages: Boolean) {
-        scope.launchDbRefresh(
-            load = {
-                convoUseCase.getLocalConvoById(screenState.value.convoId)?.let { convo ->
-                    screenState.setValue { old ->
-                        old.copy(convo = convo)
-                    }
-                    onPinnedMessageChanged(convo.pinnedMessage)
-                }
-
-                if (refreshMessages) {
-                    val localMessages = messagesUseCase.getLocalMessages(screenState.value.convoId)
-                    messages.setValue { localMessages }
-                }
-            },
-            after = ::syncUiMessages
-        )
-    }
-}

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

@@ -1,23 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import androidx.compose.ui.text.input.TextFieldValue
-
-internal class MessagesHistoryMessageActions(
-    private val sendEditActions: MessagesHistoryMessageSendEditActions
-) {
-    fun replyToMessage(cmId: Long) = sendEditActions.replyToMessage(cmId)
-    fun onMessageInputChanged(newText: TextFieldValue) = sendEditActions.onMessageInputChanged(newText)
-    fun onEmojiButtonLongClicked() = sendEditActions.onEmojiButtonLongClicked()
-    fun editMessage(cmId: Long) = sendEditActions.editMessage(cmId)
-    fun stopEditMessage() = sendEditActions.stopEditMessage()
-    fun onBoldClicked() = sendEditActions.onBoldClicked()
-    fun onItalicClicked() = sendEditActions.onItalicClicked()
-    fun onUnderlineClicked() = sendEditActions.onUnderlineClicked()
-    fun onRegularClicked() = sendEditActions.onRegularClicked()
-    fun onActionButtonClicked() = sendEditActions.onActionButtonClicked()
-    fun onReplyCloseClicked() = sendEditActions.onReplyCloseClicked()
-    fun onKeyboardShown() = sendEditActions.onKeyboardShown()
-    fun sendMessage() = sendEditActions.sendMessage()
-    fun confirmDeleteCurrentEditMessage() = sendEditActions.confirmDeleteCurrentEditMessage()
-    fun editCurrentEditMessage() = sendEditActions.editCurrentEditMessage()
-}

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

@@ -1,400 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import android.util.Log
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.TextRange
-import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.text.style.TextDecoration
-import dev.meloda.fast.common.extensions.listenValue
-import dev.meloda.fast.common.extensions.launchDbRefresh
-import dev.meloda.fast.common.extensions.removeIfCompat
-import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.common.provider.ResourceProvider
-import dev.meloda.fast.data.UserConfig
-import dev.meloda.fast.data.VkMemoryCache
-import dev.meloda.fast.datastore.AppSettings
-import dev.meloda.fast.data.processState
-import dev.meloda.fast.domain.MessagesUseCase
-import dev.meloda.fast.domain.util.extractReplySummary
-import dev.meloda.fast.domain.util.extractReplyTitle
-import dev.meloda.fast.domain.util.extractTitle
-import dev.meloda.fast.messageshistory.model.ActionMode
-import dev.meloda.fast.messageshistory.model.MessageDialog
-import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
-import dev.meloda.fast.model.api.domain.FormatDataType
-import dev.meloda.fast.model.api.domain.VkMessage
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.serialization.json.add
-import kotlinx.serialization.json.buildJsonArray
-import kotlinx.serialization.json.buildJsonObject
-import kotlinx.serialization.json.put
-import kotlin.random.Random
-
-internal class MessagesHistoryMessageSendEditActions(
-    private val viewModelScope: CoroutineScope,
-    private val messagesUseCase: MessagesUseCase,
-    private val resourceProvider: ResourceProvider,
-    private val screenState: MutableStateFlow<MessagesHistoryScreenState>,
-    private val messages: MutableStateFlow<List<VkMessage>>,
-    private val showKeyboard: MutableStateFlow<Boolean>,
-    private val dialog: MutableStateFlow<MessageDialog?>,
-    private val syncUiMessages: () -> Unit
-) {
-    private var lastMessageText: String? = null
-    private val sendingMessages: MutableList<VkMessage> = mutableListOf()
-    private val failedMessages: MutableList<VkMessage> = mutableListOf()
-    private var replyToCmId: Long? = null
-    private var editMessage: VkMessage? = null
-    private var formatData = VkMessage.FormatData("1", emptyList())
-
-    fun replyToMessage(cmId: Long) {
-        val messageToReply = messages.value.find { it.cmId == cmId } ?: return
-
-        showKeyboard.setValue { true }
-        replyToCmId = cmId
-        screenState.setValue { old ->
-            old.copy(
-                replyTitle = messageToReply.extractTitle(),
-                replyText = messageToReply.extractReplySummary(resourceProvider.resources)
-            )
-        }
-    }
-
-    fun onMessageInputChanged(newText: TextFieldValue) {
-        screenState.setValue { old ->
-            old.copy(
-                message = newText,
-                actionMode =
-                    when {
-                        screenState.value.editCmId != null -> {
-                            // TODO: 13/03/2026, Danil Nikolaev: also check if attachments is empty
-                            if (newText.text.trim().isEmpty()) {
-                                ActionMode.DELETE
-                            } else {
-                                ActionMode.EDIT
-                            }
-                        }
-
-                        newText.text.trim().isEmpty() -> ActionMode.RECORD_AUDIO
-                        else -> ActionMode.SEND
-                    }
-            )
-        }
-        updateStyles()
-    }
-
-    fun onEmojiButtonLongClicked() {
-        AppSettings.Features.fastText.takeIf { it.isNotBlank() }?.let { text ->
-            val newText = "${screenState.value.message.text}$text"
-            onMessageInputChanged(
-                TextFieldValue(text = newText, selection = TextRange(newText.length))
-            )
-        }
-    }
-
-    fun editMessage(cmId: Long) {
-        screenState.setValue { old -> old.copy(editCmId = cmId) }
-
-        val messageToEdit = messages.value.firstOrNull { it.cmId == cmId } ?: return
-        editMessage = messageToEdit
-
-        lastMessageText = screenState.value.message.text
-
-        var newState = screenState.value.copy(
-            message = TextFieldValue(
-                text = messageToEdit.text.orEmpty(),
-                selection = TextRange(messageToEdit.text.orEmpty().length)
-            ),
-            actionMode = ActionMode.EDIT
-        )
-
-        messageToEdit.replyMessage?.let { reply ->
-            replyToCmId = reply.cmId
-            newState = newState.copy(
-                replyTitle = reply.extractReplyTitle(),
-                replyText = reply.extractReplySummary(resourceProvider.resources)
-            )
-        }
-
-        showKeyboard.setValue { true }
-        screenState.setValue { newState }
-    }
-
-    fun stopEditMessage() {
-        val lastText = lastMessageText.orEmpty().trim()
-
-        screenState.setValue { old ->
-            old.copy(
-                editCmId = null,
-                message = TextFieldValue(
-                    text = lastText,
-                    selection = TextRange(lastText.length)
-                ),
-                actionMode = if (lastText.isBlank()) ActionMode.RECORD_AUDIO else ActionMode.SEND,
-                replyTitle = null,
-                replyText = null
-            )
-        }
-    }
-
-    fun onBoldClicked() = updateFormatting(FormatDataType.BOLD)
-    fun onItalicClicked() = updateFormatting(FormatDataType.ITALIC)
-    fun onUnderlineClicked() = updateFormatting(FormatDataType.UNDERLINE)
-
-    fun onRegularClicked() {
-        formatData = formatData.copy(items = emptyList())
-        updateStyles()
-    }
-
-    fun onActionButtonClicked() {
-        when (screenState.value.actionMode) {
-            ActionMode.DELETE -> confirmDeleteCurrentEditMessage()
-            ActionMode.EDIT -> editCurrentEditMessage()
-            ActionMode.RECORD_AUDIO -> {
-                screenState.setValue { it.copy(actionMode = ActionMode.RECORD_VIDEO) }
-            }
-            ActionMode.RECORD_VIDEO -> {
-                screenState.setValue { it.copy(actionMode = ActionMode.RECORD_AUDIO) }
-            }
-            ActionMode.SEND -> sendMessage()
-        }
-    }
-
-    fun onReplyCloseClicked() {
-        replyToCmId = null
-        screenState.setValue { old ->
-            old.copy(
-                replyTitle = null,
-                replyText = null
-            )
-        }
-    }
-
-    fun onKeyboardShown() {
-        showKeyboard.setValue { false }
-    }
-
-    fun sendMessage() {
-        lastMessageText = screenState.value.message.text
-
-        val newMessage = VkMessage(
-            id = -1L - sendingMessages.size,
-            cmId = -1L - sendingMessages.size,
-            text = lastMessageText,
-            isOut = true,
-            peerId = screenState.value.convoId,
-            fromId = UserConfig.userId,
-            date = (System.currentTimeMillis() / 1000).toInt(),
-            randomId = Random.nextInt().toLong(),
-            action = null,
-            actionMemberId = null,
-            actionText = null,
-            actionCmId = null,
-            actionMessage = null,
-            updateTime = null,
-            isImportant = false,
-            forwards = null,
-            attachments = null,
-            replyMessage = when {
-                replyToCmId != null -> messages.value.find { it.cmId == replyToCmId }
-                else -> null
-            },
-            geoType = null,
-            user = VkMemoryCache.getUser(UserConfig.userId),
-            group = null,
-            actionUser = null,
-            actionGroup = null,
-            isPinned = false,
-            isSpam = false,
-            pinnedAt = null,
-            formatData = formatData,
-        )
-        formatData = formatData.copy(items = emptyList())
-        sendingMessages += newMessage
-        messages.setValue { old -> listOf(newMessage).plus(old) }
-        syncUiMessages()
-
-        screenState.setValue { old ->
-            old.copy(
-                message = TextFieldValue(),
-                actionMode = ActionMode.RECORD_AUDIO,
-                replyTitle = null,
-                replyText = null
-            )
-        }
-
-        val replyCmId = replyToCmId
-        replyToCmId = null
-
-        val forward = when {
-            replyCmId != null -> {
-                buildJsonObject {
-                    put("peer_id", screenState.value.convoId)
-                    put("conversation_message_ids", buildJsonArray { add(replyCmId) })
-                    put("is_reply", true)
-                }.toString()
-            }
-
-            else -> null
-        }
-
-        messagesUseCase.sendMessage(
-            peerId = screenState.value.convoId,
-            randomId = newMessage.randomId,
-            message = newMessage.text,
-            forward = forward,
-            attachments = null,
-            formatData = newMessage.formatData,
-        ).listenValue(viewModelScope) { state ->
-            state.processState(
-                any = { sendingMessages.remove(newMessage) },
-                error = { error ->
-                    Log.d("MessagesHistoryViewModelImpl", "sendMessage: ERROR: $error")
-
-                    val failedId = -500_000L - failedMessages.size
-                    val newFailedMessage = newMessage.copy(id = failedId)
-                    failedMessages += newFailedMessage
-
-                    val newMessages = messages.value.toMutableList()
-                    newMessages[newMessages.indexOf(newMessage)] = newFailedMessage
-                    messages.setValue { newMessages }
-                    syncUiMessages()
-                },
-                success = { response ->
-                    viewModelScope.launch {
-                        messagesUseCase.storeMessage(
-                            newMessage.copy(
-                                id = response.messageId,
-                                cmId = response.cmId
-                            )
-                        )
-                        refreshMessagesFromDb()
-                    }
-                }
-            )
-        }
-    }
-
-    fun confirmDeleteCurrentEditMessage() {
-        val currentMessage = editMessage ?: return
-        dialog.setValue { MessageDialog.MessageDelete(currentMessage) }
-    }
-
-    fun editCurrentEditMessage() {
-        val newText = screenState.value.message.text
-        val lastText = lastMessageText.orEmpty().trim()
-        val currentReplyToCmId = replyToCmId
-
-        screenState.setValue { old ->
-            old.copy(
-                editCmId = null,
-                message = TextFieldValue(
-                    text = lastText,
-                    selection = TextRange(lastText.length)
-                ),
-                actionMode = if (lastText.isBlank()) ActionMode.RECORD_AUDIO else ActionMode.SEND,
-                replyTitle = null,
-                replyText = null
-            )
-        }
-
-        syncUiMessages()
-
-        val newMessage = editMessage?.copy(
-            replyMessage = if (currentReplyToCmId == null) null else editMessage?.replyMessage,
-            text = newText
-        ) ?: return
-
-        Log.d("MessagesHistoryViewModelImpl", "editMessage: $newMessage")
-
-        messagesUseCase.edit(
-            peerId = screenState.value.convoId,
-            cmId = newMessage.cmId,
-            message = newMessage.text,
-            attachments = null,
-            formatData = newMessage.formatData
-        ).listenValue(viewModelScope) { state ->
-            state.processState(
-                error = { error ->
-                    Log.d("MessagesHistoryViewModelImpl", "editMessage: ERROR: $error")
-                },
-                success = {
-                    viewModelScope.launch {
-                        messagesUseCase.storeMessage(newMessage)
-                        refreshMessagesFromDb()
-                    }
-                }
-            )
-        }
-
-        replyToCmId = null
-    }
-
-    private fun updateFormatting(type: FormatDataType) {
-        val selectionRange = screenState.value.message.selection
-        val newItems = formatData.items.toMutableList()
-        val wasRemoved = newItems.removeIfCompat {
-            it.type == type &&
-                it.offset == selectionRange.start &&
-                it.offset + it.length == selectionRange.end
-        }
-
-        if (!wasRemoved) {
-            newItems += VkMessage.FormatData.Item(
-                offset = selectionRange.start,
-                length = selectionRange.end - selectionRange.start,
-                type = type,
-                url = null
-            )
-        }
-
-        formatData = formatData.copy(items = newItems)
-        updateStyles()
-    }
-
-    private fun updateStyles() {
-        val annotations =
-            mutableListOf<AnnotatedString.Range<out AnnotatedString.Annotation>>()
-
-        formatData.items.forEach { item ->
-            val spanStyle = when (item.type) {
-                FormatDataType.BOLD -> SpanStyle(fontWeight = FontWeight.SemiBold)
-                FormatDataType.ITALIC -> SpanStyle(fontStyle = FontStyle.Italic)
-                FormatDataType.UNDERLINE -> SpanStyle(textDecoration = TextDecoration.Underline)
-                FormatDataType.URL -> null
-            }
-
-            spanStyle?.let {
-                annotations += AnnotatedString.Range(
-                    item = spanStyle,
-                    start = item.offset,
-                    end = item.offset + item.length
-                )
-            }
-        }
-
-        val newText = AnnotatedString(
-            text = screenState.value.message.text,
-            annotations = annotations
-        )
-
-        screenState.setValue { old ->
-            old.copy(message = old.message.copy(annotatedString = newText))
-        }
-    }
-
-    private fun refreshMessagesFromDb() {
-        viewModelScope.launchDbRefresh(
-            load = {
-                val localMessages = messagesUseCase.getLocalMessages(screenState.value.convoId)
-                messages.setValue { localMessages }
-            },
-            after = ::syncUiMessages
-        )
-    }
-}

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

@@ -1,232 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import android.content.ClipData
-import android.content.ClipboardManager
-import android.content.Context
-import android.graphics.Bitmap
-import android.os.Build
-import android.widget.Toast
-import androidx.core.content.FileProvider
-import androidx.core.graphics.drawable.toBitmapOrNull
-import coil.imageLoader
-import coil.request.ImageRequest
-import dev.meloda.fast.common.extensions.launchDbRefresh
-import dev.meloda.fast.common.extensions.listenValue
-import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.data.State
-import dev.meloda.fast.data.VkUtils
-import dev.meloda.fast.data.processState
-import dev.meloda.fast.domain.ConvoUseCase
-import dev.meloda.fast.domain.MessagesUseCase
-import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
-import dev.meloda.fast.model.BaseError
-import dev.meloda.fast.model.api.domain.VkMessage
-import dev.meloda.fast.model.api.domain.VkPhotoDomain
-import dev.meloda.fast.ui.R
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import java.io.File
-import java.io.FileOutputStream
-
-internal class MessagesHistoryMessageTransportActions(
-    private val applicationContext: Context,
-    private val viewModelScope: CoroutineScope,
-    private val convoUseCase: ConvoUseCase,
-    private val messagesUseCase: MessagesUseCase,
-    private val screenState: MutableStateFlow<MessagesHistoryScreenState>,
-    private val messages: MutableStateFlow<List<VkMessage>>,
-    private val baseError: MutableStateFlow<BaseError?>,
-    private val syncUiMessages: () -> Unit,
-    private val onPinnedMessageChanged: (VkMessage?) -> Unit
-) {
-    fun markAsImportant(messageIds: List<Long>, important: Boolean) {
-        messagesUseCase.markAsImportant(
-            peerId = screenState.value.convoId,
-            messageIds = messageIds,
-            important = important
-        ).listenValue(viewModelScope) { state ->
-            state.processState(
-                error = ::handleError,
-                success = {
-                    viewModelScope.launch {
-                        messageIds.forEach { messageId ->
-                            messagesUseCase.getLocalMessageById(messageId)?.let { localMessage ->
-                                messagesUseCase.storeMessage(localMessage.copy(isImportant = important))
-                            }
-                        }
-                        refreshMessagesFromDb()
-                    }
-                }
-            )
-        }
-    }
-
-    fun deleteMessage(
-        messageIds: List<Long>,
-        spam: Boolean = false,
-        deleteForAll: Boolean = false,
-        onSuccess: () -> Unit = {}
-    ) {
-        messagesUseCase.delete(
-            peerId = screenState.value.convoId,
-            messageIds = messageIds,
-            spam = spam,
-            deleteForAll = deleteForAll
-        ).listenValue(viewModelScope) { state ->
-            state.processState(
-                error = ::handleError,
-                success = {
-                    viewModelScope.launch {
-                        onSuccess()
-                        val localMessageIds = mutableListOf<Long>()
-                        messageIds.forEach { messageId ->
-                            messagesUseCase.getLocalMessageById(messageId)?.let { localMessage ->
-                                localMessageIds += localMessage.id
-                            }
-                        }
-                        messagesUseCase.deleteLocalMessages(localMessageIds)
-                        refreshMessagesFromDb()
-                    }
-                }
-            )
-        }
-    }
-
-    fun pinMessage(messageId: Long) {
-        messagesUseCase.pin(
-            peerId = screenState.value.convoId,
-            messageId = messageId,
-            cmId = null
-        ).listenValue(viewModelScope) { state ->
-            state.processState(
-                error = ::handleError,
-                success = { pinnedMessage ->
-                    viewModelScope.launch {
-                        onPinnedMessageChanged(pinnedMessage)
-                        messagesUseCase.storeMessage(pinnedMessage)
-                        refreshMessagesFromDb()
-                    }
-                }
-            )
-        }
-    }
-
-    fun unpinMessage(messageId: Long) {
-        messagesUseCase.unpin(screenState.value.convoId)
-            .listenValue(viewModelScope) { state ->
-                state.processState(
-                error = ::handleError,
-                success = {
-                    viewModelScope.launch {
-                        messagesUseCase.getLocalMessageById(messageId)?.let { localMessage ->
-                            messagesUseCase.storeMessage(localMessage.copy(isPinned = false))
-                        }
-                        onPinnedMessageChanged(null)
-                        refreshMessagesFromDb()
-                    }
-                }
-            )
-        }
-    }
-
-    fun readMessage(message: VkMessage) {
-        messagesUseCase.markAsRead(
-            peerId = screenState.value.convoId,
-            startMessageId = message.id
-        ).listenValue(viewModelScope) { state ->
-            state.processState(
-                error = ::handleError,
-                success = {
-                    viewModelScope.launch {
-                        convoUseCase.getLocalConvoById(screenState.value.convoId)?.let { localConvo ->
-                            convoUseCase.storeConvos(
-                                listOf(
-                                    localConvo.copy(
-                                        inRead = if (!message.isOut) message.id else localConvo.inRead,
-                                        outRead = if (message.isOut) message.id else localConvo.outRead
-                                    )
-                                )
-                            )
-                        }
-                        refreshMessagesFromDb()
-                    }
-                }
-            )
-        }
-    }
-
-    fun copyMessage(message: VkMessage) {
-        val clipboardManager =
-            applicationContext.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-
-        val messageToCopy = message.text.orEmpty().trim()
-        if (messageToCopy.isEmpty()) {
-            val photo = with(message.attachments.orEmpty()) {
-                if (size == 1 && all { it is VkPhotoDomain }) {
-                    first() as? VkPhotoDomain
-                } else null
-            } ?: return
-
-            val photoMaxSize = photo.getMaxSize() ?: return
-
-            viewModelScope.launch(Dispatchers.IO) {
-                val drawable = applicationContext.imageLoader.execute(
-                    ImageRequest.Builder(applicationContext)
-                        .data(photoMaxSize.url)
-                        .build()
-                ).drawable ?: return@launch
-
-                val imagesDir = File(applicationContext.cacheDir, "images")
-                if (!imagesDir.exists()) imagesDir.mkdirs()
-                val imageFile = File(imagesDir, "shared_image_id${photo.id}.png")
-                FileOutputStream(imageFile).use {
-                    drawable.toBitmapOrNull()?.compress(Bitmap.CompressFormat.PNG, 100, it)
-                }
-
-                val uri = FileProvider.getUriForFile(
-                    applicationContext,
-                    "${applicationContext.packageName}.provider",
-                    imageFile
-                )
-
-                val clip = ClipData.newUri(applicationContext.contentResolver, "Image", uri)
-                clipboardManager.setPrimaryClip(clip)
-
-                withContext(Dispatchers.Main) {
-                    Toast.makeText(
-                        applicationContext,
-                        "Image copied to clipboard",
-                        Toast.LENGTH_SHORT
-                    ).show()
-                }
-            }
-            return
-        }
-
-        clipboardManager.setPrimaryClip(ClipData.newPlainText("Message", messageToCopy))
-
-        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.S) {
-            Toast.makeText(applicationContext, R.string.copied_to_clipboard, Toast.LENGTH_SHORT)
-                .show()
-        }
-    }
-
-    private fun handleError(error: State.Error) {
-        VkUtils.parseError(error)?.let { newBaseError ->
-            baseError.setValue { newBaseError }
-        }
-    }
-
-    private fun refreshMessagesFromDb() {
-        viewModelScope.launchDbRefresh(
-            load = {
-                val localMessages = messagesUseCase.getLocalMessages(screenState.value.convoId)
-                messages.setValue { localMessages }
-            },
-            after = ::syncUiMessages
-        )
-    }
-}

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

@@ -1,24 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.messageshistory.model.MessageNavigation
-import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
-import dev.meloda.fast.model.api.domain.VkMessage
-import kotlinx.coroutines.flow.MutableStateFlow
-
-internal class MessagesHistoryNavigationActions(
-    private val screenState: MutableStateFlow<MessagesHistoryScreenState>,
-    private val messages: MutableStateFlow<List<VkMessage>>,
-    private val navigation: MutableStateFlow<MessageNavigation?>
-) {
-    fun onTopBarClicked() {
-        val cmId = messages.value.firstOrNull()?.cmId ?: return
-
-        navigation.setValue {
-            MessageNavigation.ChatMaterials(
-                peerId = screenState.value.convoId,
-                cmId = cmId
-            )
-        }
-    }
-}

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

@@ -1,51 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import androidx.compose.ui.text.buildAnnotatedString
-import dev.meloda.fast.common.extensions.orDots
-import dev.meloda.fast.common.extensions.setValue
-import dev.meloda.fast.data.VkMemoryCache
-import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
-import dev.meloda.fast.model.api.domain.VkMessage
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlin.math.abs
-
-internal class MessagesHistoryPinnedMessageHandler(
-    private val screenState: MutableStateFlow<MessagesHistoryScreenState>
-) {
-    fun update(pinnedMessage: VkMessage?) {
-        if (pinnedMessage == null) {
-            screenState.setValue { old ->
-                old.copy(
-                    pinnedMessage = null,
-                    convo = old.convo.copy(
-                        pinnedMessage = null,
-                        pinnedMessageId = null
-                    ),
-                    pinnedSummary = null,
-                    pinnedTitle = null
-                )
-            }
-            return
-        }
-
-        val pinnedUser = VkMemoryCache.getUser(pinnedMessage.fromId)
-        val pinnedGroup = VkMemoryCache.getGroup(abs(pinnedMessage.fromId))
-        val pinnedTitle = pinnedUser?.fullName ?: pinnedGroup?.name
-
-        val pinnedSummary = buildAnnotatedString {
-            pinnedMessage.text?.let(::append) ?: append("...")
-        }
-
-        screenState.setValue { old ->
-            old.copy(
-                pinnedMessage = pinnedMessage,
-                convo = old.convo.copy(
-                    pinnedMessage = pinnedMessage,
-                    pinnedMessageId = pinnedMessage.id
-                ),
-                pinnedSummary = pinnedSummary,
-                pinnedTitle = pinnedTitle.orDots()
-            )
-        }
-    }
-}

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

@@ -1,28 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import dev.meloda.fast.common.extensions.listenValue
-import dev.meloda.fast.data.processState
-import dev.meloda.fast.domain.GetMessageReadPeersUseCase
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-
-internal class MessagesHistoryReadPeersLoader(
-    private val scope: CoroutineScope,
-    private val getMessageReadPeersUseCase: GetMessageReadPeersUseCase
-) {
-    suspend fun loadMessageReadPeers(peerId: Long, cmId: Long): Int =
-        suspendCancellableCoroutine { continuation ->
-            scope.launch {
-                getMessageReadPeersUseCase
-                    .invoke(peerId = peerId, cmId = cmId)
-                    .listenValue(scope) { state ->
-                        state.processState(
-                            error = { continuation.resume(-1) },
-                            success = { count -> continuation.resume(count) }
-                        )
-                    }
-            }
-        }
-}

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

@@ -1,27 +0,0 @@
-package dev.meloda.fast.messageshistory
-
-import com.conena.nanokt.collections.indexOfFirstOrNull
-import dev.meloda.fast.common.provider.ResourceProvider
-import dev.meloda.fast.datastore.AppSettings
-import dev.meloda.fast.domain.util.asPresentation
-import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
-import dev.meloda.fast.model.api.domain.VkMessage
-import dev.meloda.fast.ui.model.vk.MessageUiItem
-
-fun buildMessagesHistoryUiMessages(
-    messages: List<VkMessage>,
-    selectedMessages: List<VkMessage>,
-    screenState: MessagesHistoryScreenState,
-    resourceProvider: ResourceProvider,
-): List<MessageUiItem> = messages.mapIndexed { index, message ->
-    message.asPresentation(
-        resourceProvider = resourceProvider,
-        showName = true,
-        prevMessage = messages.getOrNull(index + 1),
-        nextMessage = messages.getOrNull(index - 1),
-        showTimeInActionMessages = AppSettings.Experimental.showTimeInActionMessages,
-        convo = screenState.convo,
-        isSelected = screenState.editCmId == message.cmId ||
-            selectedMessages.indexOfFirstOrNull { it.id == message.id } != null
-    )
-}

feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/MessagesList.kt

@@ -182,7 +182,7 @@ fun MessagesList(
                         item = item,
                         onClick = {
                             if (item.actionCmId != null) {
-                                onRequestScrollToCmId(item.actionCmId)
+                                onRequestScrollToCmId(item.actionCmId!!)
                             }
                         }
                     )
@@ -301,7 +301,7 @@ fun MessagesList(
                                 },
                                 onReplyClick = {
                                     if (item.replyCmId != null) {
-                                        onRequestScrollToCmId(item.replyCmId)
+                                        onRequestScrollToCmId(item.replyCmId!!)
                                     }
                                 },
                                 offsetX = offsetAnimatable.value
@@ -328,7 +328,7 @@ fun MessagesList(
                                 },
                                 onReplyClick = {
                                     if (item.replyCmId != null) {
-                                        onRequestScrollToCmId(item.replyCmId)
+                                        onRequestScrollToCmId(item.replyCmId!!)
                                     }
                                 },
                                 offsetX = offsetAnimatable.value

feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/attachments/Attachments.kt

@@ -214,10 +214,10 @@ fun Attachments(
     }
 }
 
-fun VkAttachment.asUiPhoto(): UiPreview? {
+fun VkAttachment.asUiPhoto(): UiPreview {
     return when (this) {
         is VkPhotoDomain -> {
-            val size = this.getDefault() ?: return null
+            val size = this.getDefault()!!
             UiPreview(
                 id = this.id,
                 url = size.url,
@@ -247,7 +247,7 @@ fun VkAttachment.asUiPhoto(): UiPreview? {
         is VkFileDomain -> {
             when {
                 this.preview?.video != null -> {
-                    val video = this.preview?.video ?: return null
+                    val video = this.preview?.video!!
 
                     UiPreview(
                         id = id,
@@ -259,7 +259,7 @@ fun VkAttachment.asUiPhoto(): UiPreview? {
                 }
 
                 this.preview?.photo != null -> {
-                    val photoSize = this.preview?.photo?.sizes?.firstOrNull() ?: return null
+                    val photoSize = this.preview?.photo?.sizes?.first()!!
 
                     UiPreview(
                         id = id,
@@ -270,11 +270,11 @@ fun VkAttachment.asUiPhoto(): UiPreview? {
                     )
                 }
 
-                else -> null
+                else -> error("Unsupported type: $this")
             }
         }
 
-        else -> null
+        else -> error("Unsupported type: $this")
     }
 }
 

feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/attachments/Link.kt

@@ -108,9 +108,8 @@ fun Link(
 
         Column(modifier = Modifier.weight(1f)) {
             if (item.title != null) {
-                val title = item.title
                 Text(
-                    text = title,
+                    text = item.title!!,
                     style = MaterialTheme.typography.bodyLarge,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis

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

@@ -7,11 +7,11 @@ import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
 import dev.meloda.fast.data.State
 import dev.meloda.fast.data.UserConfig
-import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.domain.GetLocalUserByIdUseCase
 import dev.meloda.fast.domain.LoadUserByIdUseCase
 import dev.meloda.fast.model.BaseError
+import dev.meloda.fast.network.VkErrorCode
 import dev.meloda.fast.profile.model.ProfileScreenState
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -38,8 +38,14 @@ class ProfileViewModelImpl(
             .listenValue(viewModelScope) { state ->
                 state.processState(
                     error = { error ->
-                        VkUtils.parseError(error)?.let { newBaseError ->
+                        if (error is State.Error.ApiError) {
-                            baseError.setValue { newBaseError }
+                            when (error.errorCode) {
+                                VkErrorCode.USER_AUTHORIZATION_FAILED -> {
+                                    baseError.setValue { BaseError.SessionExpired }
+                                }
+
+                                else -> Unit
+                            }
                         }
 
                         screenState.setValue { old ->
@@ -69,22 +75,9 @@ class ProfileViewModelImpl(
             nomCase = null
         ).listenValue(viewModelScope) { state ->
             state.processState(
-                    error = { error ->
+                error = { error ->
-                        VkUtils.parseError(error)?.let { newBaseError ->
+                    // TODO: 12/07/2024, Danil Nikolaev: if local info is null then show error view
-                            baseError.setValue { newBaseError }
+                },
-                        }
-
-                        if (baseError.value == null) {
-                            baseError.setValue { BaseError.InternalError }
-                        }
-
-                        screenState.setValue { old ->
-                            old.copy(
-                                avatarUrl = null,
-                                fullName = null
-                            )
-                        }
-                    },
                 success = { response ->
                     val user = requireNotNull(response)
 

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

@@ -17,7 +17,6 @@ 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
-import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.data.db.AccountsRepository
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.AppSettings
@@ -46,8 +45,7 @@ class SettingsViewModel(
     private val getCurrentAccountUseCase: GetCurrentAccountUseCase,
     private val userSettings: UserSettings,
     private val resources: Resources,
-    private val longPollController: LongPollController,
+    private val longPollController: LongPollController
-    private val vkMemoryCache: VkMemoryCache
 ) : ViewModel() {
 
     private val _screenState = MutableStateFlow(SettingsScreenState.EMPTY)
@@ -114,7 +112,6 @@ class SettingsViewModel(
                                 )
 
                                 accountsRepository.storeAccounts(listOf(account))
-                                vkMemoryCache.clear()
 
                                 _isNeedToRestart.setValue { true }
                             }
@@ -167,7 +164,6 @@ class SettingsViewModel(
             )
 
             tasks.awaitAll()
-            vkMemoryCache.clear()
         }
     }
 

gradle/libs.versions.toml

@@ -14,7 +14,7 @@ kotlin = "2.3.21"
 ksp = "2.3.7"
 moduleGraph = "2.9.1"
 versions = "0.54.0"
-stability-analyzer = "0.7.4"
+stability-analyzer = "0.7.5"
 
 compose-bom = "2026.04.01"
 koin = "4.2.1"

gradle/wrapper/gradle-wrapper.properties

@@ -2,6 +2,8 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.0-bin.zip
 networkTimeout=10000
+retries=0
+retryBackOffMs=500
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -57,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -86,8 +86,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
-' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -115,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -173,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -206,15 +203,14 @@ fi
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
 #     and any embedded shellness will be escaped.
 #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
 #     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
-        org.gradle.wrapper.GradleWrapperMain \
         "$@"
 
 # Stop when "xargs" is not available.

gradlew.bat

@@ -23,8 +23,8 @@
 @rem
 @rem ##########################################################################
 
-@rem Set local scope for the variables with windows NT shell
+@rem Set local scope for the variables, and ensure extensions are enabled
-if "%OS%"=="Windows_NT" setlocal
+setlocal EnableExtensions
 
 set DIRNAME=%~dp0
 if "%DIRNAME%"=="" set DIRNAME=.
@@ -51,7 +51,7 @@ echo. 1>&2
 echo Please set the JAVA_HOME variable in your environment to match the 1>&2
 echo location of your Java installation. 1>&2
 
-goto fail
+"%COMSPEC%" /c exit 1
 
 :findJavaFromJavaHome
 set JAVA_HOME=%JAVA_HOME:"=%
@@ -65,30 +65,18 @@ echo. 1>&2
 echo Please set the JAVA_HOME variable in your environment to match the 1>&2
 echo location of your Java installation. 1>&2
 
-goto fail
+"%COMSPEC%" /c exit 1
 
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
+@rem which allows us to clear the local environment before executing the java command
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
 
-:end
+:exitWithErrorLevel
-@rem End local scope for the variables with windows NT shell
+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
-if %ERRORLEVEL% equ 0 goto mainEnd
+"%COMSPEC%" /c exit %ERRORLEVEL%
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega