temp

* Add uncaught exception handler that saves stacktraces to local crash log files
* Show a Compose crash dialog with stacktrace toggle and share action
* Register crash handler activity in a separate process with dialog theme
* Remove ACRA dependencies and configuration
* Add crash dialog strings and ignore `.hotswan/`

.gitea/workflows/android.yml

@@ -0,0 +1,56 @@
+name: Android CI
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
+  RELEASE_SIGN_KEY_ALIAS: ${{ secrets.RELEASE_SIGN_KEY_ALIAS }}
+  RELEASE_SIGN_KEY_PASSWORD: ${{ secrets.RELEASE_SIGN_KEY_PASSWORD }}
+
+jobs:
+  android:
+    runs-on: android-jdk21
+    name: Build artifacts
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Make Gradle executable
+        run: chmod +x ./gradlew
+
+      - name: Build and sign release APK
+        run: ./gradlew assembleRelease
+
+      - name: Find generated release APK name
+        id: find_apk_release
+        run: |
+          APK_PATH=$(find app/build/outputs/apk/release -name "*.apk" | head -n 1)
+          echo "APK_PATH=$APK_PATH" >> $GITEA_ENV
+          echo "APK_NAME=$(basename $APK_PATH)" >> $GITEA_ENV
+
+      - name: Upload APK with original name
+        uses: christopherhx/gitea-upload-artifact@v4
+        with:
+          name: ${{ env.APK_NAME }}
+          path: ${{ env.APK_PATH }}
+
+      - name: Build and sign debug APK
+        run: ./gradlew assembleDebug
+
+      - name: Find generated debug APK name
+        id: find_apk_debug
+        run: |
+          APK_PATH=$(find app/build/outputs/apk/debug -name "*.apk" | head -n 1)
+          echo "APK_PATH=$APK_PATH" >> $GITEA_ENV
+          echo "APK_NAME=$(basename $APK_PATH)" >> $GITEA_ENV
+
+      - name: Upload APK with original name
+        uses: christopherhx/gitea-upload-artifact@v4
+        with:
+          name: ${{ env.APK_NAME }}
+          path: ${{ env.APK_PATH }}

.github/workflows/build.yml

@@ -40,7 +40,7 @@ jobs:
           echo "APK_NAME=$(basename $APK_PATH)" >> $GITHUB_ENV
 
       - name: Upload APK with original name
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: ${{ env.APK_NAME }}
           path: ${{ env.APK_PATH }}
@@ -56,7 +56,7 @@ jobs:
             echo "APK_NAME=$(basename $APK_PATH)" >> $GITHUB_ENV
 
       - name: Upload APK with original name
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: ${{ env.APK_NAME }}
           path: ${{ env.APK_PATH }}

.github/workflows/create_release.yml

@@ -34,7 +34,7 @@ jobs:
         run: ./gradlew assembleRelease
 
       - name: Upload release APK
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: app-release.apk
           path: app/build/outputs/apk/release/app-release.apk
@@ -43,7 +43,7 @@ jobs:
         run: ./gradlew bundleRelease
 
       - name: Upload release Bundle
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: app-release.aab
           path: app/build/outputs/bundle/release/app-release.aab

.gitignore

@@ -15,3 +15,5 @@ build/
 local.properties
 .idea
 /.kotlin
+.hotswan/
+.java-version

README.md

@@ -43,6 +43,7 @@ Unofficial messenger for russian social network VKontakte
             - [ ] Forwarded messages
             - [ ] Wall post
             - [ ] Comment in wall post
+            - [ ] Comment in channel
             - [ ] Poll
             - [ ] TODO
     - [x] Send messages

app/build.gradle.kts

@@ -13,8 +13,8 @@ android {
     defaultConfig {
         applicationId = "dev.meloda.fastvk"
 
-        versionCode = 10
-        versionName = "0.2.2"
+        versionCode = 11
+        versionName = "0.2.3"
     }
 
     signingConfigs {
@@ -47,7 +47,7 @@ android {
             applicationIdSuffix = ".debug"
         }
         named("release") {
-            signingConfig = signingConfigs.getByName("release")
+            signingConfig = signingConfigs.getByName("debugSigning")
 
             isMinifyEnabled = true
             isShrinkResources = true
@@ -92,6 +92,7 @@ dependencies {
     implementation(projects.feature.photoviewer)
     implementation(projects.feature.createchat)
 
+    implementation(projects.core.logger)
     implementation(projects.core.common)
     implementation(projects.core.ui)
     implementation(projects.core.data)

app/src/main/AndroidManifest.xml

@@ -1,8 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:tools="http://schemas.android.com/tools"
-    xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
@@ -37,6 +38,12 @@
             </intent-filter>
         </activity>
 
+        <activity
+            android:name="dev.meloda.fast.presentation.CrashActivity"
+            android:exported="false"
+            android:process=":error_handler"
+            android:theme="@style/CrashDialogTheme" />
+
         <service
             android:name="dev.meloda.fast.service.longpolling.LongPollingService"
             android:enabled="true"

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

@@ -2,7 +2,6 @@ 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
@@ -23,66 +22,37 @@ import dev.meloda.fast.datastore.AppSettings
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.GetCurrentAccountUseCase
 import dev.meloda.fast.domain.LoadUserByIdUseCase
+import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.navigation.Main
 import dev.meloda.fast.settings.navigation.Settings
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 
-interface MainViewModel {
-
-    val startDestination: StateFlow<Any?>
-    val isNeedToReplaceWithAuth: StateFlow<Boolean>
-    val currentUser: StateFlow<VkUser?>
-
-    val isNeedToShowNotificationsDeniedDialog: StateFlow<Boolean>
-    val isNeedToShowNotificationsRationaleDialog: StateFlow<Boolean>
-    val isNeedToCheckNotificationsPermission: StateFlow<Boolean>
-    val isNeedToRequestNotifications: StateFlow<Boolean>
-
-    fun onError(error: BaseError)
-
-    fun onNavigatedToAuth()
-
-    fun onAppResumed(intent: Intent)
-
-    @OptIn(ExperimentalPermissionsApi::class)
-    fun onPermissionCheckStatus(status: PermissionStatus)
-    fun onPermissionsRequested()
-
-    fun onNotificationsDeniedDialogConfirmClicked()
-    fun onNotificationsDeniedDialogCancelClicked()
-    fun onNotificationsDeniedDialogDismissed()
-    fun onNotificationsRationaleDialogDismissed()
-    fun onNotificationsRationaleDialogCancelClicked()
-
-    fun onUserAuthenticated()
-}
-
-class MainViewModelImpl(
+class MainViewModel(
     private val getCurrentAccountUseCase: GetCurrentAccountUseCase,
     private val loadUserByIdUseCase: LoadUserByIdUseCase,
     private val userSettings: UserSettings,
-    private val longPollController: LongPollController
-) : MainViewModel, ViewModel() {
+    private val longPollController: LongPollController,
+    private val logger: FastLogger
+) : ViewModel() {
 
-    override val startDestination = MutableStateFlow<Any?>(null)
-    override val isNeedToReplaceWithAuth = MutableStateFlow(false)
-    override val currentUser = MutableStateFlow<VkUser?>(null)
+    val startDestination = MutableStateFlow<Any?>(null)
+    val isNeedToReplaceWithAuth = MutableStateFlow(false)
+    val currentUser = MutableStateFlow<VkUser?>(null)
 
-    override val isNeedToShowNotificationsDeniedDialog = MutableStateFlow(false)
-    override val isNeedToShowNotificationsRationaleDialog = MutableStateFlow(false)
-    override val isNeedToCheckNotificationsPermission = MutableStateFlow(false)
-    override val isNeedToRequestNotifications = MutableStateFlow(false)
+    val isNeedToShowNotificationsDeniedDialog = MutableStateFlow(false)
+    val isNeedToShowNotificationsRationaleDialog = MutableStateFlow(false)
+    val isNeedToCheckNotificationsPermission = MutableStateFlow(false)
+    val isNeedToRequestNotifications = MutableStateFlow(false)
 
     private var openNotificationsSettings = false
     private var openAppSettings = false
 
-    override fun onError(error: BaseError) {
+    fun onError(error: BaseError) {
         when (error) {
             BaseError.SessionExpired,
             BaseError.AccountBlocked -> {
@@ -93,11 +63,11 @@ class MainViewModelImpl(
         }
     }
 
-    override fun onNavigatedToAuth() {
+    fun onNavigatedToAuth() {
         isNeedToReplaceWithAuth.update { false }
     }
 
-    override fun onAppResumed(intent: Intent) {
+    fun onAppResumed(intent: Intent) {
         openNotificationsSettings =
             intent.hasCategory(NotificationCompat.INTENT_CATEGORY_NOTIFICATION_PREFERENCES)
         openAppSettings =
@@ -124,7 +94,7 @@ class MainViewModelImpl(
     }
 
     @ExperimentalPermissionsApi
-    override fun onPermissionCheckStatus(status: PermissionStatus) {
+    fun onPermissionCheckStatus(status: PermissionStatus) {
         isNeedToCheckNotificationsPermission.update { false }
 
         when (status) {
@@ -146,33 +116,33 @@ class MainViewModelImpl(
         }
     }
 
-    override fun onPermissionsRequested() {
+    fun onPermissionsRequested() {
         isNeedToRequestNotifications.update { false }
     }
 
-    override fun onNotificationsDeniedDialogConfirmClicked() {
+    fun onNotificationsDeniedDialogConfirmClicked() {
         isNeedToRequestNotifications.update { true }
     }
 
-    override fun onNotificationsDeniedDialogCancelClicked() {
+    fun onNotificationsDeniedDialogCancelClicked() {
         isNeedToShowNotificationsDeniedDialog.update { false }
         disableBackgroundLongPoll()
     }
 
-    override fun onNotificationsDeniedDialogDismissed() {
+    fun onNotificationsDeniedDialogDismissed() {
         isNeedToShowNotificationsDeniedDialog.update { false }
     }
 
-    override fun onNotificationsRationaleDialogDismissed() {
+    fun onNotificationsRationaleDialogDismissed() {
         isNeedToShowNotificationsRationaleDialog.update { false }
     }
 
-    override fun onNotificationsRationaleDialogCancelClicked() {
+    fun onNotificationsRationaleDialogCancelClicked() {
         isNeedToShowNotificationsRationaleDialog.update { false }
         disableBackgroundLongPoll()
     }
 
-    override fun onUserAuthenticated() {
+    fun onUserAuthenticated() {
         loadProfile()
     }
 
@@ -201,9 +171,18 @@ class MainViewModelImpl(
 
     private fun loadAccounts() {
         viewModelScope.launch(Dispatchers.IO) {
-            val currentAccount = getCurrentAccountUseCase()
+            val currentAccount = getCurrentAccountUseCase()?.mapToDto()
 
-            Log.d("MainViewModel", "currentAccount: $currentAccount")
+            logger.debug(
+                this@MainViewModel::class,
+                "loadAccounts(): currentAccount: %s"
+                    .format(
+                        currentAccount?.copy(
+                            accessToken = if (currentAccount.accessToken.isNotEmpty()) "<redacted>"
+                            else "null"
+                        )
+                    )
+            )
 
             listenLongPollState()
 

app/src/main/kotlin/dev/meloda/fast/common/AppGlobal.kt

@@ -1,15 +1,25 @@
 package dev.meloda.fast.common
 
 import android.app.Application
+import android.content.Intent
+import android.net.Uri
 import androidx.preference.PreferenceManager
 import coil.ImageLoader
 import coil.ImageLoaderFactory
+import com.skydoves.compose.stability.runtime.ComposeStabilityAnalyzer
+import dev.meloda.fast.auth.BuildConfig
 import dev.meloda.fast.common.di.applicationModule
 import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.logger.FastLogLevel
+import dev.meloda.fast.logger.FastLogger
+import dev.meloda.fast.presentation.CrashActivity
 import org.koin.android.ext.android.get
 import org.koin.android.ext.koin.androidContext
 import org.koin.android.ext.koin.androidLogger
 import org.koin.core.context.GlobalContext.startKoin
+import java.io.File
+import java.io.FileOutputStream
+import kotlin.system.exitProcess
 
 class AppGlobal : Application(), ImageLoaderFactory {
 
@@ -18,10 +28,22 @@ class AppGlobal : Application(), ImageLoaderFactory {
 
         val preferences = PreferenceManager.getDefaultSharedPreferences(this)
         AppSettings.init(preferences)
+        ComposeStabilityAnalyzer.setEnabled(BuildConfig.DEBUG)
 
         initKoin()
+        initCrashHandler()
+
+        val logLevel =
+            if (BuildConfig.DEBUG) FastLogLevel.DEBUG
+            else FastLogLevel.ERROR
+
+        get<FastLogger>()
+            .apply { setLogLevel(logLevel) }
+            .also { FastLogger.setInstance(it) }
     }
 
+    override fun newImageLoader(): ImageLoader = get()
+
     private fun initKoin() {
         startKoin {
             androidLogger()
@@ -30,5 +52,37 @@ class AppGlobal : Application(), ImageLoaderFactory {
         }
     }
 
-    override fun newImageLoader(): ImageLoader = get()
+    private fun initCrashHandler() {
+        val defaultExceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            val crashLogsDirectory = File(filesDir.absolutePath + "/crashlogs")
+            if (!crashLogsDirectory.exists()) {
+                crashLogsDirectory.mkdirs()
+            }
+
+            val crashLogFileName = "crash_" + System.currentTimeMillis() + ".txt"
+            val crashLogFile = File(crashLogsDirectory.absolutePath + "/" + crashLogFileName)
+
+            FileOutputStream(crashLogFile).use { stream ->
+                stream.write(throwable.stackTraceToString().toByteArray())
+            }
+
+            if (AppSettings.Debug.showAlertAfterCrash) {
+                try {
+                    val intent = Intent(this, CrashActivity::class.java)
+                    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                    intent.putExtra("CRASH_LOG_FILE_URI", Uri.fromFile(crashLogFile))
+                    startActivity(intent)
+
+                    exitProcess(0)
+                } catch (e: Exception) {
+                    if (e !is RuntimeException) {
+                        defaultExceptionHandler?.uncaughtException(thread, throwable)
+                    }
+                }
+            } else {
+                defaultExceptionHandler?.uncaughtException(thread, throwable)
+            }
+        }
+    }
 }

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

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

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

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

app/src/main/kotlin/dev/meloda/fast/navigation/MainGraph.kt

@@ -8,9 +8,9 @@ import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.BottomNavigationItem
 import dev.meloda.fast.presentation.MainScreen
 import dev.meloda.fast.profile.navigation.Profile
+import dev.meloda.fast.ui.R
 import dev.meloda.fast.ui.util.ImmutableList
 import kotlinx.serialization.Serializable
-import dev.meloda.fast.ui.R
 
 @Serializable
 object MainGraph

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

@@ -0,0 +1,35 @@
+package dev.meloda.fast.presentation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.window.DialogProperties
+import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.components.MaterialDialog
+
+@Composable
+fun AppCrashedDialog(
+    stacktrace: String,
+    onDismiss: () -> Unit,
+    onShare: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    var showTrace by rememberSaveable { mutableStateOf(false) }
+
+    MaterialDialog(
+        modifier = modifier,
+        onDismissRequest = onDismiss,
+        title = stringResource(R.string.title_error),
+        text = if (showTrace) stacktrace else stringResource(R.string.error_occurred),
+        confirmText = stringResource(R.string.action_share),
+        confirmAction = onShare,
+        cancelText = stringResource(if (showTrace) R.string.action_hide_stacktrace else R.string.action_show_stacktrace),
+        cancelAction = { showTrace = !showTrace },
+        neutralText = stringResource(R.string.action_close),
+        properties = DialogProperties(dismissOnBackPress = false, dismissOnClickOutside = false)
+    )
+}

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

@@ -0,0 +1,71 @@
+package dev.meloda.fast.presentation
+
+import android.content.ClipData
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.runtime.collectAsState
+import androidx.core.content.FileProvider
+import androidx.core.net.toFile
+import dev.meloda.fast.datastore.UserSettings
+import dev.meloda.fast.ui.theme.AppTheme
+import dev.meloda.fast.ui.util.isNeedToEnableDarkMode
+import org.koin.compose.koinInject
+import java.io.File
+
+class CrashActivity : ComponentActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+
+        val crashLogFileUri = intent.getParcelableExtra<Uri>("CRASH_LOG_FILE_URI") ?: run {
+            finish()
+            return
+        }
+        val crashLogFile = crashLogFileUri.toFile().takeIf(File::exists) ?: run {
+            finish()
+            return
+        }
+
+        val stacktrace = crashLogFile.bufferedReader().readText()
+
+        setContent {
+            val userSettings: UserSettings = koinInject()
+
+            AppTheme(
+                useDarkTheme = isNeedToEnableDarkMode(darkMode = userSettings.darkMode.collectAsState().value),
+                useDynamicColors = userSettings.enableDynamicColors.collectAsState().value,
+                selectedColorScheme = 0,
+                useAmoledBackground = userSettings.enableAmoledDark.collectAsState().value,
+                useSystemFont = userSettings.useSystemFont.collectAsState().value
+            ) {
+                AppCrashedDialog(
+                    stacktrace = stacktrace,
+                    onDismiss = { finish() },
+                    onShare = {
+                        val uri = FileProvider.getUriForFile(
+                            this,
+                            "$packageName.provider",
+                            crashLogFile
+                        )
+
+                        val sendIntent = Intent().apply {
+                            action = Intent.ACTION_SEND
+                            type = "text/plain"
+                            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                            putExtra(Intent.EXTRA_STREAM, uri)
+                            clipData = ClipData.newRawUri(null, uri)
+                        }
+
+                        val chooserIntent = Intent.createChooser(sendIntent, null)
+                        chooserIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                        startActivity(chooserIntent)
+                    }
+                )
+            }
+        }
+    }
+}

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

@@ -9,25 +9,28 @@ 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
 import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.compose.LifecycleResumeEffect
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import dev.meloda.fast.MainViewModel
-import dev.meloda.fast.MainViewModelImpl
 import dev.meloda.fast.common.AppConstants
 import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.domain.LongPollEventsHandler
+import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.service.OnlineService
 import dev.meloda.fast.service.longpolling.LongPollingService
 import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.common.LocalLogger
+import org.koin.android.ext.android.get
 import org.koin.androidx.compose.koinViewModel
+import org.koin.compose.koinInject
 
 class MainActivity : AppCompatActivity() {
 
@@ -64,25 +67,26 @@ class MainActivity : AppCompatActivity() {
         requestNotificationPermissions()
 
         setContent {
-            val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
-            LaunchedEffect(viewModel) {
-                Log.d("VM_CREATE", "onCreate: viewModel: $viewModel")
-            }
+            val logger: FastLogger = koinInject()
 
+            val viewModel: MainViewModel = koinViewModel()
             LifecycleResumeEffect(true) {
                 viewModel.onAppResumed(intent)
                 onPauseOrDispose {}
             }
 
-            RootScreen(
-                toggleLongPollService = { enable, inBackground ->
-                    toggleLongPollService(
-                        enable = enable,
-                        inBackground = inBackground ?: AppSettings.Experimental.longPollInBackground
-                    )
-                },
-                toggleOnlineService = ::toggleOnlineService
-            )
+            CompositionLocalProvider(LocalLogger provides logger) {
+                RootScreen(
+                    toggleLongPollService = { enable, inBackground ->
+                        toggleLongPollService(
+                            enable = enable,
+                            inBackground = inBackground
+                                ?: AppSettings.Experimental.longPollInBackground
+                        )
+                    },
+                    toggleOnlineService = ::toggleOnlineService
+                )
+            }
         }
     }
 
@@ -178,6 +182,7 @@ class MainActivity : AppCompatActivity() {
     override fun onDestroy() {
         super.onDestroy()
         stopServices()
+        get<LongPollEventsHandler>().onDestroy()
     }
 
     companion object {

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

@@ -38,7 +38,7 @@ import dev.chrisbanes.haze.HazeState
 import dev.chrisbanes.haze.hazeEffect
 import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
 import dev.chrisbanes.haze.materials.HazeMaterials
-import dev.meloda.fast.convos.navigation.ConvoGraph
+import dev.meloda.fast.convos.model.ConvoNavigationIntent
 import dev.meloda.fast.convos.navigation.convosGraph
 import dev.meloda.fast.friends.navigation.Friends
 import dev.meloda.fast.friends.navigation.friendsScreen
@@ -198,19 +198,20 @@ fun MainScreen(
                             },
                         )
                         convosGraph(
-                            activity = activity,
-                            onError = onError,
-                            onNavigateToMessagesHistory = onNavigateToMessagesHistory,
-                            onNavigateToCreateChat = onNavigateToCreateChat,
-                            onScrolledToTop = {
-                                tabReselected = tabReselected.toMutableMap().also {
-                                    it[ConvoGraph] = false
+                            handleNavigationIntent = { intent ->
+                                when (intent) {
+                                    ConvoNavigationIntent.Back -> {}
+                                    ConvoNavigationIntent.Archive -> {}
+                                    ConvoNavigationIntent.CreateChat -> onNavigateToCreateChat()
+                                    is ConvoNavigationIntent.MessagesHistory -> {
+                                        onNavigateToMessagesHistory(intent.convoId)
+                                    }
                                 }
-                            }
+                            },
+                            activity = activity,
                         )
                         profileScreen(
                             activity = activity,
-                            onError = onError,
                             onSettingsButtonClicked = onSettingsButtonClicked,
                             onPhotoClicked = onPhotoClicked
                         )

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

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

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

@@ -4,7 +4,6 @@ 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
@@ -39,15 +38,18 @@ import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
 import dev.meloda.fast.MainViewModel
-import dev.meloda.fast.MainViewModelImpl
 import dev.meloda.fast.auth.authNavGraph
+import dev.meloda.fast.auth.captcha.presentation.CaptchaScreen
 import dev.meloda.fast.auth.navigateToAuth
 import dev.meloda.fast.chatmaterials.navigation.chatMaterialsScreen
 import dev.meloda.fast.chatmaterials.navigation.navigateToChatMaterials
 import dev.meloda.fast.common.LongPollController
+import dev.meloda.fast.common.NetworkStateListener
 import dev.meloda.fast.common.model.LongPollState
 import dev.meloda.fast.convos.navigation.createChatScreen
 import dev.meloda.fast.convos.navigation.navigateToCreateChat
+import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.datastore.CaptchaTokenResult
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.languagepicker.navigation.languagePickerScreen
 import dev.meloda.fast.languagepicker.navigation.navigateToLanguagePicker
@@ -57,9 +59,12 @@ import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.navigation.Main
 import dev.meloda.fast.navigation.mainScreen
 import dev.meloda.fast.photoviewer.presentation.PhotoViewDialog
+import dev.meloda.fast.settings.model.SettingsNavigationIntent
 import dev.meloda.fast.settings.navigation.navigateToSettings
 import dev.meloda.fast.settings.navigation.settingsScreen
 import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.common.LocalLogger
+import dev.meloda.fast.ui.common.LocalNetworkState
 import dev.meloda.fast.ui.common.LocalSizeConfig
 import dev.meloda.fast.ui.model.DeviceSize
 import dev.meloda.fast.ui.model.SizeConfig
@@ -69,9 +74,7 @@ import dev.meloda.fast.ui.theme.LocalNavController
 import dev.meloda.fast.ui.theme.LocalNavRootController
 import dev.meloda.fast.ui.theme.LocalThemeConfig
 import dev.meloda.fast.ui.theme.LocalUser
-import dev.meloda.fast.ui.util.ImmutableList
 import dev.meloda.fast.ui.util.ImmutableList.Companion.toImmutableList
-import dev.meloda.fast.ui.util.immutableListOf
 import dev.meloda.fast.ui.util.isNeedToEnableDarkMode
 import org.koin.androidx.compose.koinViewModel
 import org.koin.compose.koinInject
@@ -82,6 +85,7 @@ fun RootScreen(
     toggleLongPollService: (enable: Boolean, inBackground: Boolean?) -> Unit,
     toggleOnlineService: (enable: Boolean) -> Unit
 ) {
+    val logger = LocalLogger.current
     val resources = LocalResources.current
 
     val userSettings: UserSettings = koinInject()
@@ -90,11 +94,7 @@ fun RootScreen(
     val longPollCurrentState by longPollController.currentState.collectAsStateWithLifecycle()
     val longPollStateToApply by longPollController.stateToApply.collectAsStateWithLifecycle()
 
-    val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
-    LaunchedEffect(viewModel) {
-        Log.d("VM_CREATE", "RootScreen(): viewModel: $viewModel")
-    }
-
+    val viewModel: MainViewModel = koinViewModel()
     val currentUser: VkUser? by viewModel.currentUser.collectAsStateWithLifecycle()
 
     val permissionState =
@@ -125,13 +125,12 @@ fun RootScreen(
     }
 
     LifecycleResumeEffect(longPollStateToApply) {
-        Log.d("LongPollMainActivity", "longPollStateToApply: $longPollStateToApply")
+        logger.debug("RootScreen", "longPollStateToApply: $longPollStateToApply")
         if (longPollStateToApply != LongPollState.Background) {
             if (longPollStateToApply.isLaunched() && longPollCurrentState.isLaunched()
                 && longPollCurrentState != longPollStateToApply
             ) {
                 toggleLongPollService(false, null)
-                Log.d("LongPoll", "recreate()")
             }
 
             toggleLongPollService(
@@ -223,10 +222,17 @@ fun RootScreen(
         }
     }
 
+    val networkStateListener: NetworkStateListener = koinInject()
+    val networkState by networkStateListener.networkStateFlow.collectAsStateWithLifecycle()
+    LaunchedEffect(networkState) {
+        logger.debug("RootScreen", "NetworkState: $networkState")
+    }
+
     CompositionLocalProvider(
         LocalThemeConfig provides themeConfig,
         LocalSizeConfig provides sizeConfig,
-        LocalUser provides currentUser
+        LocalUser provides currentUser,
+        LocalNetworkState provides networkState
     ) {
         AppTheme(
             useDarkTheme = themeConfig.darkMode,
@@ -309,9 +315,12 @@ fun RootScreen(
                     LocalNavController provides navController
                 ) {
                     var photoViewerInfo by rememberSaveable {
-                        mutableStateOf<Pair<ImmutableList<String>, Int?>?>(null)
+                        mutableStateOf<Pair<List<String>, Int?>?>(null)
                     }
 
+                    val captchaRedirectUri by AppSettings.getCaptchaRedirectUriFlow()
+                        .collectAsStateWithLifecycle()
+
                     Box(modifier = Modifier.fillMaxSize()) {
                         NavHost(
                             navController = navController,
@@ -333,10 +342,10 @@ fun RootScreen(
                                 onSettingsButtonClicked = navController::navigateToSettings,
                                 onNavigateToMessagesHistory = navController::navigateToMessagesHistory,
                                 onPhotoClicked = { url ->
-                                    photoViewerInfo = immutableListOf(url) to null
+                                    photoViewerInfo = listOf(url) to null
                                 },
                                 onMessageClicked = navController::navigateToMessagesHistory,
-                                onNavigateToCreateChat = navController::navigateToCreateChat
+                                onNavigateToCreateChat = navController::navigateToCreateChat,
                             )
 
                             messagesHistoryScreen(
@@ -344,13 +353,13 @@ fun RootScreen(
                                 onBack = navController::navigateUp,
                                 onNavigateToChatMaterials = navController::navigateToChatMaterials,
                                 onNavigateToPhotoViewer = { photos, index ->
-                                    photoViewerInfo = photos.toImmutableList() to index
+                                    photoViewerInfo = photos to index
                                 }
                             )
                             chatMaterialsScreen(
                                 onBack = navController::navigateUp,
                                 onPhotoClicked = { url ->
-                                    photoViewerInfo = immutableListOf(url) to null
+                                    photoViewerInfo = listOf(url) to null
                                 }
                             )
                             createChatScreen(
@@ -362,25 +371,52 @@ fun RootScreen(
                             )
 
                             settingsScreen(
-                                onBack = navController::navigateUp,
-                                onLogOutButtonClicked = { navController.navigateToAuth(true) },
-                                onLanguageItemClicked = navController::navigateToLanguagePicker,
-                                onRestartRequired = {
-                                    activity?.let {
-                                        val intent = Intent(activity, MainActivity::class.java)
-                                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
-                                        activity.startActivity(intent)
-                                        activity.finish()
+                                handleNavigationIntent = { intent ->
+                                    when (intent) {
+                                        SettingsNavigationIntent.Back -> navController.navigateUp()
+                                        SettingsNavigationIntent.Language -> navController.navigateToLanguagePicker()
+                                        SettingsNavigationIntent.Restart -> {
+                                            activity?.let {
+                                                val intent =
+                                                    Intent(activity, MainActivity::class.java)
+                                                intent.setFlags(
+                                                    Intent.FLAG_ACTIVITY_NEW_TASK or
+                                                            Intent.FLAG_ACTIVITY_CLEAR_TASK or
+                                                            Intent.FLAG_ACTIVITY_CLEAR_TOP
+                                                )
+                                                activity.finish()
+                                                activity.startActivity(intent)
+                                            }
+                                        }
+
+                                        SettingsNavigationIntent.LogOut -> {
+                                            navController.navigateToAuth(true)
+                                        }
                                     }
                                 }
                             )
+
                             languagePickerScreen(onBack = navController::navigateUp)
                         }
 
                         PhotoViewDialog(
-                            photoViewerInfo = photoViewerInfo,
+                            photoViewerInfo = photoViewerInfo?.let { info ->
+                                info.first.toImmutableList() to info.second
+                            },
                             onDismiss = { photoViewerInfo = null }
                         )
+
+                        CaptchaScreen(
+                            captchaRedirectUri = captchaRedirectUri,
+                            onBack = {
+                                AppSettings.setCaptchaResult(CaptchaTokenResult.Cancelled)
+                            },
+                            onResult = { result ->
+                                AppSettings.setCaptchaResult(
+                                    CaptchaTokenResult.Success(result)
+                                )
+                            },
+                        )
                     }
                 }
             }

app/src/main/kotlin/dev/meloda/fast/service/OnlineService.kt

@@ -6,8 +6,9 @@ import android.os.IBinder
 import android.util.Log
 import dev.meloda.fast.common.extensions.createTimerFlow
 import dev.meloda.fast.data.UserConfig
-import dev.meloda.fast.domain.AccountUseCase
 import dev.meloda.fast.data.processState
+import dev.meloda.fast.domain.AccountUseCase
+import dev.meloda.fast.logger.FastLogger
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -24,11 +25,12 @@ import kotlin.time.Duration.Companion.minutes
 
 class OnlineService : Service() {
 
+    private val logger: FastLogger by inject()
+
     private val job = SupervisorJob()
 
     private val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
-        Log.d(TAG, "error: $throwable")
-        throwable.printStackTrace()
+        logger.error(this::class.java, "CoroutineException", throwable)
     }
 
     private val coroutineContext: CoroutineContext
@@ -42,17 +44,20 @@ class OnlineService : Service() {
     private var onlineJob: Job? = null
 
     override fun onBind(intent: Intent?): IBinder? {
-        Log.d(STATE_TAG, "onBind: intent: $intent")
+        logger.debug(this::class, "STATE: onBind(): intent: $intent")
         return null
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         if (startId > 1) return START_STICKY
 
-        Log.d(STATE_TAG, "onStartCommand: flags: $flags; startId: $startId\ninstance: $this")
+        logger.debug(
+            this::class,
+            "STATE: onStartCommand(): flags: %s; startId: %s;\ninstance: %s"
+                .format("$flags", "$startId", "$this")
+        )
 
         createTimer()
-
         return START_STICKY
     }
 
@@ -68,13 +73,13 @@ class OnlineService : Service() {
     private fun setOnline() {
         if (onlineJob != null) return
 
-        Log.d(TAG, "setOnline()")
+        logger.debug(this::class, "setOnline()")
 
         onlineJob = coroutineScope.launch {
             val token = UserConfig.fastToken ?: UserConfig.accessToken
 
             if (token.isBlank()) {
-                Log.d(TAG, "setOnline: token is empty")
+                logger.debug(this::class, "setOnline(): token is empty")
                 return@launch
             }
 
@@ -84,10 +89,10 @@ class OnlineService : Service() {
             ).onEach { state ->
                 state.processState(
                     error = { error ->
-                        Log.w(TAG, "setOnline(): error: $error")
+                        logger.error(this@OnlineService::class, "setOnline(): ERROR: $error")
                     },
                     success = { response ->
-                        Log.d(TAG, "setOnline(): success: $response")
+                        logger.debug(this@OnlineService::class, "setOnline(): response: $response")
                     }
                 )
             }.collect()
@@ -96,7 +101,7 @@ class OnlineService : Service() {
     }
 
     override fun onDestroy() {
-        Log.d(STATE_TAG, "onDestroy")
+        logger.debug(this::class, "onDestroy()")
 
         timerJob?.cancel("OnlineService destroyed")
         onlineJob?.cancel("OnlineService destroyed")

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

@@ -7,7 +7,6 @@ import android.net.Uri
 import android.os.Build
 import android.os.IBinder
 import android.provider.Settings
-import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.ServiceCompat
 import com.conena.nanokt.android.app.stopForegroundCompat
@@ -19,8 +18,10 @@ import dev.meloda.fast.common.model.LongPollState
 import dev.meloda.fast.data.UserConfig
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.domain.LongPollEventsHandler
 import dev.meloda.fast.domain.LongPollUpdatesParser
 import dev.meloda.fast.domain.LongPollUseCase
+import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.model.api.data.LongPollUpdates
 import dev.meloda.fast.model.api.data.VkLongPollData
 import dev.meloda.fast.ui.R
@@ -32,14 +33,16 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
 import org.koin.android.ext.android.inject
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 import kotlin.time.Duration.Companion.seconds
 
 class LongPollingService : Service() {
 
+    private val logger: FastLogger by inject()
+
     private val longPollController: LongPollController by inject()
 
     private val job = SupervisorJob()
@@ -56,6 +59,7 @@ class LongPollingService : Service() {
 
     private val longPollUseCase: LongPollUseCase by inject()
     private val updatesParser: LongPollUpdatesParser by inject()
+    private val eventsHandler: LongPollEventsHandler by inject()
 
     private var currentJob: Job? = null
 
@@ -63,20 +67,21 @@ class LongPollingService : Service() {
 
     override fun onCreate() {
         super.onCreate()
-        Log.d(STATE_TAG, "onCreate()")
+        logger.debug(this::class, "STATE: onCreate()")
     }
 
     override fun onBind(intent: Intent?): IBinder? {
-        Log.d(STATE_TAG, "onBind: intent: $intent")
+        logger.debug(this::class, "STATE: onBind(): intent: $intent")
         return null
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         if (startId > 1) return START_STICKY
 
-        Log.d(
-            STATE_TAG,
-            "onStartCommand: asForeground: $inBackground; flags: $flags; startId: $startId;\ninstance: $this"
+        logger.debug(
+            this::class,
+            "STATE: onStartCommand(): asForeground: %s; flags: %s; startId: %s;\ninstance: %s"
+                .format("$inBackground", "$flags", "$startId", "$this")
         )
 
         startJob()
@@ -131,11 +136,15 @@ class LongPollingService : Service() {
 
     private fun startPolling(): Job {
         if (job.isCompleted || job.isCancelled) {
-            Log.d(STATE_TAG, "Job is completed or cancelled")
+            logger.debug(
+                this::class,
+                "startPolling(): Job is already done. isCompleted: %s; isCancelled: %s"
+                    .format("${job.isCompleted}", "${job.isCancelled}")
+            )
             throw Exception("Job is over")
         }
 
-        Log.d(STATE_TAG, "Starting job...")
+        logger.debug(this::class, "startPolling(): Starting job.")
 
         return coroutineScope.launch(coroutineContext) {
             longPollController.updateCurrentState(
@@ -193,7 +202,7 @@ class LongPollingService : Service() {
                             if (updates == null) {
                                 failCount++
                             } else {
-                                updates.forEach(updatesParser::parseNextUpdate)
+                                parseUpdates(updates)
                             }
 
                             lastUpdatesResponse = getUpdatesResponse(serverInfo.copy(ts = newTs))
@@ -204,18 +213,18 @@ class LongPollingService : Service() {
         }
     }
 
-    private suspend fun getServerInfo(): VkLongPollData? = suspendCoroutine {
+    private suspend fun getServerInfo(): VkLongPollData? = suspendCancellableCoroutine {
         longPollUseCase.getLongPollServer(
             needPts = true,
             version = VkConstants.LP_VERSION
         ).listenValue(coroutineScope) { state ->
             state.processState(
                 success = { response ->
-                    Log.d(TAG, "getServerInfo: serverInfoResponse: $response")
+                    logger.debug(this::class, "getServerInfo(): response: $response")
                     it.resume(response)
                 },
                 error = { error ->
-                    Log.e(TAG, "getServerInfo: $error")
+                    logger.error(this::class, "getServerInfo(): ERROR: $error")
                     it.resume(null)
                 }
             )
@@ -224,7 +233,7 @@ class LongPollingService : Service() {
 
     private suspend fun getUpdatesResponse(
         server: VkLongPollData
-    ): LongPollUpdates? = suspendCoroutine {
+    ): LongPollUpdates? = suspendCancellableCoroutine {
         longPollUseCase.getLongPollUpdates(
             serverUrl = "https://${server.server}",
             key = server.key,
@@ -235,19 +244,24 @@ class LongPollingService : Service() {
         ).listenValue(coroutineScope) { state ->
             state.processState(
                 success = { response ->
-                    Log.d(TAG, "lastUpdateResponse: $response")
+                    logger.debug(this::class, "getUpdatesResponse(): response: $response")
                     it.resume(response)
                 },
                 error = { error ->
-                    Log.d(TAG, "getUpdatesResponse: error: $error")
+                    logger.debug(this::class, "getUpdatesResponse(): error: $error")
                     it.resume(null)
                 }
             )
         }
     }
 
+    private suspend fun parseUpdates(updates: List<List<Any>>) {
+        val parsedUpdates = updates.flatMap { updatesParser.parseNextUpdate(it) }
+        eventsHandler.handleEvents(parsedUpdates)
+    }
+
     private fun handleError(throwable: Throwable) {
-        Log.e(TAG, "error: $throwable")
+        logger.error(this::class, "CoroutineException", throwable)
 
         if (throwable !is NoAccessTokenException) {
             throwable.printStackTrace()
@@ -262,7 +276,7 @@ class LongPollingService : Service() {
     }
 
     override fun onDestroy() {
-        Log.d(STATE_TAG, "onDestroy")
+        logger.debug(this::class, "STATE: onDestroy()")
         longPollController.updateCurrentState(LongPollState.Stopped)
         try {
             AppSettings.edit { putBoolean(KEY_LONG_POLL_WAS_DESTROYED, true) }
@@ -274,7 +288,7 @@ class LongPollingService : Service() {
     }
 
     override fun onTrimMemory(level: Int) {
-        Log.d(STATE_TAG, "onTrimMemory. Level: $level")
+        logger.debug(this::class, "STATE: onTrimMemory(): Level: $level")
         super.onTrimMemory(level)
     }
 

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

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

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

@@ -10,6 +10,7 @@ class AndroidApplicationComposeConventionPlugin : Plugin<Project> {
         with(target) {
             apply(plugin = "com.android.application")
             apply(plugin = "org.jetbrains.kotlin.plugin.compose")
+            apply(plugin = "com.github.skydoves.compose.stability.analyzer")
 
             val extension = extensions.getByType<ApplicationExtension>()
             configureAndroidCompose(extension)

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

@@ -1,5 +1,6 @@
 import com.android.build.api.dsl.ApplicationExtension
 import dev.meloda.fast.configureKotlinAndroid
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -14,9 +15,12 @@ class AndroidApplicationConventionPlugin : Plugin<Project> {
             extensions.configure<ApplicationExtension> {
                 configureKotlinAndroid(this)
                 defaultConfig {
-                    targetSdk = 36
-                    compileSdk = 36
-                    minSdk = 23
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                    targetSdk = getVersionInt("targetSdk")
+                }
+                lint {
+                    abortOnError = false
                 }
             }
         }

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

@@ -1,19 +1,26 @@
 import com.android.build.api.dsl.LibraryExtension
 import dev.meloda.fast.configureAndroidCompose
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.configure
 
 class AndroidLibraryComposeConventionPlugin : Plugin<Project> {
     override fun apply(target: Project) {
         with(target) {
             apply(plugin = "com.android.library")
             apply(plugin = "org.jetbrains.kotlin.plugin.compose")
+            apply(plugin = "com.github.skydoves.compose.stability.analyzer")
 
-            val extension = extensions.getByType<LibraryExtension>()
-            extension.androidResources.enable = false
-            configureAndroidCompose(extension)
+            extensions.configure<LibraryExtension> {
+                configureAndroidCompose(this)
+                androidResources.enable = false
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                }
+            }
         }
     }
 }

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/AndroidTestConventionPlugin.kt

@@ -1,5 +1,6 @@
 import com.android.build.api.dsl.TestExtension
 import dev.meloda.fast.configureKotlinAndroid
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -13,7 +14,11 @@ class AndroidTestConventionPlugin : Plugin<Project> {
 
             extensions.configure<TestExtension> {
                 configureKotlinAndroid(this)
-                defaultConfig.targetSdk = 36
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                    targetSdk = getVersionInt("targetSdk")
+                }
             }
         }
     }

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

@@ -24,7 +24,7 @@ internal fun Project.configureKotlinAndroid(
     }
 
     commonExtension.apply {
-        compileSdk = 36
+        compileSdk = getVersionInt("compileSdk")
     }
 
     configureKotlin<KotlinAndroidProjectExtension>()
@@ -61,6 +61,7 @@ private inline fun <reified T : KotlinBaseExtension> Project.configureKotlin() =
             "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
             "-opt-in=kotlinx.coroutines.FlowPreview",
             "-Xannotation-default-target=param-property",
+            "-Xcontext-parameters"
         )
     }
 }

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

@@ -7,3 +7,8 @@ import org.gradle.kotlin.dsl.getByType
 
 val Project.libs
     get(): VersionCatalog = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+
+fun Project.getVersionInt(alias: String): Int {
+    return libs.findVersion(alias).get().requiredVersion.toInt()
+}

build.gradle.kts

@@ -9,4 +9,5 @@ plugins {
     alias(libs.plugins.ksp) apply false
     alias(libs.plugins.module.graph) apply true
     alias(libs.plugins.versions) apply true
+    alias(libs.plugins.stability.analyzer) apply false
 }

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

@@ -4,7 +4,7 @@ object AppConstants {
 
     const val INSTALL_APP_MIME_TYPE = "application/vnd.android.package-archive"
     
-    const val API_VERSION = "5.238"
+    const val API_VERSION = "5.263"
     const val URL_OAUTH = "https://oauth.vk.ru"
     const val URL_API = "https://api.vk.ru/method"
 

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

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

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

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

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

@@ -1,13 +1,13 @@
 package dev.meloda.fast.common.model
 
-enum class LogLevel(val value: Int) {
+enum class NetworkLogLevel(val value: Int) {
     NONE(0),
     BASIC(1),
     HEADERS(2),
     BODY(3);
 
     companion object {
-        fun parse(value: Int): LogLevel = entries.firstOrNull { it.value == value }
+        fun parse(value: Int): NetworkLogLevel = entries.firstOrNull { it.value == value }
             ?: throw IllegalArgumentException("Unknown log level with value: $value")
     }
 }

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

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

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

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

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

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

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

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

core/common/src/main/kotlin/dev/meloda/fast/common/util/TimeUtils.kt

@@ -1,7 +1,6 @@
 package dev.meloda.fast.common.util
 
 import com.conena.nanokt.jvm.util.dayOfMonth
-import com.conena.nanokt.jvm.util.hour
 import com.conena.nanokt.jvm.util.hourOfDay
 import com.conena.nanokt.jvm.util.millisecond
 import com.conena.nanokt.jvm.util.minute
@@ -12,6 +11,12 @@ import java.text.SimpleDateFormat
 import java.util.Calendar
 import java.util.Date
 import java.util.Locale
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.days
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.Instant
 
 object TimeUtils {
 
@@ -56,37 +61,23 @@ object TimeUtils {
         monthShort: () -> String,
         weekShort: () -> String,
         dayShort: () -> String,
+        minuteShort: () -> String,
+        secondShort: () -> String,
         now: () -> String
     ): String {
-        val now = Calendar.getInstance()
-        val then = Calendar.getInstance().also { it.timeInMillis = date }
+        val now = Clock.System.now()
+        val then = Instant.fromEpochMilliseconds(date)
+        val diff = now - then
 
         return when {
-            now.year != then.year -> {
-                "${now.year - then.year}${yearShort().lowercase()}"
-            }
-
-            now.month != then.month -> {
-                "${now.month - then.month}${monthShort().lowercase()}"
-            }
-
-            now.dayOfMonth != then.dayOfMonth -> {
-                val change = now.dayOfMonth - then.dayOfMonth
-
-                if (change % 7 == 0) {
-                    "${change / 7}${weekShort().lowercase()}"
-                } else {
-                    "$change${dayShort().lowercase()}"
-                }
-            }
-
-            now.hour == then.hour && now.minute == then.minute -> {
-                now().lowercase()
-            }
-
-            else -> {
-                SimpleDateFormat("HH:mm", Locale.getDefault()).format(date)
-            }
+            diff > 365.days -> "${diff.inWholeDays / 365}${yearShort().lowercase()}"
+            diff > 30.days -> "${diff.inWholeDays / 30}${monthShort().lowercase()}"
+            diff > 7.days -> "${diff.inWholeDays / 7}${weekShort().lowercase()}"
+            diff > 1.days -> "${diff.inWholeDays}${dayShort().lowercase()}"
+            diff > 1.hours -> "${diff.inWholeHours}h"
+            diff > 1.minutes -> "${diff.inWholeMinutes}${minuteShort().lowercase()}"
+            diff > 1.seconds -> "${diff.inWholeSeconds}${secondShort().lowercase()}"
+            else -> now().lowercase()
         }
     }
 }

core/common/src/main/kotlin/dev/meloda/fast/common/util/Utils.kt

@@ -1,7 +1,17 @@
 package dev.meloda.fast.common.util
 
 import java.net.URLEncoder
+import java.security.MessageDigest
 
 fun String.urlEncode(encoding: String = "utf-8"): String {
     return URLEncoder.encode(this, encoding)
 }
+
+fun String.sha256() = this.hashString("SHA-256")
+
+fun String.hashString(algorithm: String): String {
+    return MessageDigest
+        .getInstance(algorithm)
+        .digest(this.toByteArray())
+        .fold("") { str, it -> str + "%02x".format(it) }
+}

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

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

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

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

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

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

core/data/src/main/kotlin/dev/meloda/fast/data/api/oauth/OAuthRepository.kt

@@ -23,5 +23,6 @@ interface OAuthRepository {
         validationCode: String?,
         captchaSid: String?,
         captchaKey: String?,
+        successToken: String?
     ): ApiResult<GetSilentTokenResponse, OAuthErrorDomain>
 }

core/data/src/main/kotlin/dev/meloda/fast/data/api/oauth/OAuthRepositoryImpl.kt

@@ -79,7 +79,8 @@ class OAuthRepositoryImpl(
                     VkOAuthError.NEED_CAPTCHA -> {
                         OAuthErrorDomain.CaptchaRequiredError(
                             captchaSid = response.captchaSid.orEmpty(),
-                            captchaImageUrl = response.captchaImage.orEmpty()
+                            captchaImageUrl = response.captchaImage.orEmpty(),
+                            redirectUri = response.redirectUri
                         )
                     }
 
@@ -122,6 +123,7 @@ class OAuthRepositoryImpl(
         validationCode: String?,
         captchaSid: String?,
         captchaKey: String?,
+        successToken: String?
     ): ApiResult<GetSilentTokenResponse, OAuthErrorDomain> =
         withContext(Dispatchers.IO) {
             val requestModel = AuthDirectRequest(
@@ -135,6 +137,7 @@ class OAuthRepositoryImpl(
                 validationCode = validationCode,
                 captchaSid = captchaSid,
                 captchaKey = captchaKey,
+                successToken = successToken
             )
 
             oAuthService.getSilentToken(requestModel.map).mapResult(
@@ -175,7 +178,8 @@ class OAuthRepositoryImpl(
                         VkOAuthError.NEED_CAPTCHA -> {
                             OAuthErrorDomain.CaptchaRequiredError(
                                 captchaSid = response.captchaSid.orEmpty(),
-                                captchaImageUrl = response.captchaImage.orEmpty()
+                                captchaImageUrl = response.captchaImage.orEmpty(),
+                                redirectUri = response.redirectUri
                             )
                         }
 

core/database/schemas/dev.meloda.fast.database.CacheDatabase/12.json

@@ -0,0 +1,425 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 12,
+    "identityHash": "5eca3b3da167aaf7e772977a1f4e56e2",
+    "entities": [
+      {
+        "tableName": "users",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `firstName` TEXT NOT NULL, `lastName` TEXT NOT NULL, `isOnline` INTEGER NOT NULL, `isOnlineMobile` INTEGER NOT NULL, `onlineAppId` INTEGER, `lastSeen` INTEGER, `lastSeenStatus` TEXT, `birthday` TEXT, `photo50` TEXT, `photo100` TEXT, `photo200` TEXT, `photo400Orig` TEXT, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "firstName",
+            "columnName": "firstName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastName",
+            "columnName": "lastName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isOnline",
+            "columnName": "isOnline",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isOnlineMobile",
+            "columnName": "isOnlineMobile",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "onlineAppId",
+            "columnName": "onlineAppId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "lastSeen",
+            "columnName": "lastSeen",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "lastSeenStatus",
+            "columnName": "lastSeenStatus",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "birthday",
+            "columnName": "birthday",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo50",
+            "columnName": "photo50",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo100",
+            "columnName": "photo100",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo200",
+            "columnName": "photo200",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo400Orig",
+            "columnName": "photo400Orig",
+            "affinity": "TEXT"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "groups",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `name` TEXT NOT NULL, `screenName` TEXT NOT NULL, `photo50` TEXT, `photo100` TEXT, `photo200` TEXT, `membersCount` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "screenName",
+            "columnName": "screenName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "photo50",
+            "columnName": "photo50",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo100",
+            "columnName": "photo100",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo200",
+            "columnName": "photo200",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "membersCount",
+            "columnName": "membersCount",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "messages",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `cmId` INTEGER NOT NULL, `text` TEXT, `isOut` INTEGER NOT NULL, `peerId` INTEGER NOT NULL, `fromId` INTEGER NOT NULL, `date` INTEGER NOT NULL, `randomId` INTEGER NOT NULL, `action` TEXT, `actionMemberId` INTEGER, `actionText` TEXT, `actionCmId` INTEGER, `actionMessage` TEXT, `updateTime` INTEGER, `isImportant` INTEGER NOT NULL, `forwardIds` TEXT, `attachments` TEXT, `replyMessageId` INTEGER, `geoType` TEXT, `pinnedAt` INTEGER, `isPinned` INTEGER NOT NULL, `isDeleted` INTEGER NOT NULL, `isSpam` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "cmId",
+            "columnName": "cmId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "text",
+            "columnName": "text",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "isOut",
+            "columnName": "isOut",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "peerId",
+            "columnName": "peerId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fromId",
+            "columnName": "fromId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "date",
+            "columnName": "date",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "randomId",
+            "columnName": "randomId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "action",
+            "columnName": "action",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "actionMemberId",
+            "columnName": "actionMemberId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "actionText",
+            "columnName": "actionText",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "actionCmId",
+            "columnName": "actionCmId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "actionMessage",
+            "columnName": "actionMessage",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "updateTime",
+            "columnName": "updateTime",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "isImportant",
+            "columnName": "isImportant",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "forwardIds",
+            "columnName": "forwardIds",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "attachments",
+            "columnName": "attachments",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "replyMessageId",
+            "columnName": "replyMessageId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "geoType",
+            "columnName": "geoType",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pinnedAt",
+            "columnName": "pinnedAt",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "isPinned",
+            "columnName": "isPinned",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isDeleted",
+            "columnName": "isDeleted",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isSpam",
+            "columnName": "isSpam",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "convos",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `localId` INTEGER NOT NULL, `ownerId` INTEGER, `title` TEXT, `photo50` TEXT, `photo100` TEXT, `photo200` TEXT, `isPhantom` INTEGER NOT NULL, `lastCmId` INTEGER NOT NULL, `inReadCmId` INTEGER NOT NULL, `outReadCmId` INTEGER NOT NULL, `inRead` INTEGER NOT NULL, `outRead` INTEGER NOT NULL, `lastMessageId` INTEGER, `unreadCount` INTEGER NOT NULL, `membersCount` INTEGER, `canChangePin` INTEGER NOT NULL, `canChangeInfo` INTEGER NOT NULL, `majorId` INTEGER NOT NULL, `minorId` INTEGER NOT NULL, `pinnedMessageId` INTEGER, `peerType` TEXT NOT NULL, `isArchived` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "localId",
+            "columnName": "localId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "ownerId",
+            "columnName": "ownerId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "title",
+            "columnName": "title",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo50",
+            "columnName": "photo50",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo100",
+            "columnName": "photo100",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo200",
+            "columnName": "photo200",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "isPhantom",
+            "columnName": "isPhantom",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastCmId",
+            "columnName": "lastCmId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "inReadCmId",
+            "columnName": "inReadCmId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "outReadCmId",
+            "columnName": "outReadCmId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "inRead",
+            "columnName": "inRead",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "outRead",
+            "columnName": "outRead",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastMessageId",
+            "columnName": "lastMessageId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "unreadCount",
+            "columnName": "unreadCount",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "membersCount",
+            "columnName": "membersCount",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "canChangePin",
+            "columnName": "canChangePin",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "canChangeInfo",
+            "columnName": "canChangeInfo",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "majorId",
+            "columnName": "majorId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "minorId",
+            "columnName": "minorId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "pinnedMessageId",
+            "columnName": "pinnedMessageId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "peerType",
+            "columnName": "peerType",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isArchived",
+            "columnName": "isArchived",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '5eca3b3da167aaf7e772977a1f4e56e2')"
+    ]
+  }
+}

core/database/src/main/kotlin/dev/meloda/fast/database/CacheDatabase.kt

@@ -21,7 +21,7 @@ import dev.meloda.fast.model.database.VkUserEntity
         VkConvoEntity::class
     ],
 
-    version = 11
+    version = 12
 )
 @TypeConverters(Converters::class)
 abstract class CacheDatabase : RoomDatabase() {

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

@@ -13,7 +13,7 @@ abstract class ConvoDao : EntityDao<VkConvoEntity> {
     abstract suspend fun getAll(): List<VkConvoEntity>
 
     @Query("SELECT * FROM convos WHERE id IN (:ids)")
-    abstract suspend fun getAllByIds(ids: List<Int>): List<VkConvoEntity>
+    abstract suspend fun getAllByIds(ids: List<Long>): List<VkConvoEntity>
 
     @Query("SELECT * FROM convos WHERE id IS (:id)")
     abstract suspend fun getById(id: Long): VkConvoEntity?
@@ -23,8 +23,23 @@ abstract class ConvoDao : EntityDao<VkConvoEntity> {
     abstract suspend fun getByIdWithMessage(id: Long): ConvoWithMessage?
 
     @Query("DELETE FROM convos WHERE rowid IN (:ids)")
-    abstract suspend fun deleteByIds(ids: List<Int>): Int
+    abstract suspend fun deleteByIds(ids: List<Long>): Int
+
+    @Query("UPDATE convos SET inReadCmId = :cmId, unreadCount = :unreadCount WHERE id = :convoId")
+    abstract suspend fun updateReadIncoming(convoId: Long, cmId: Long, unreadCount: Int): Int
+
+    @Query("UPDATE convos SET outReadCmId = :cmId, unreadCount = :unreadCount WHERE id = :convoId")
+    abstract suspend fun updateReadOutgoing(convoId: Long, cmId: Long, unreadCount: Int): Int
+
+    @Query("UPDATE convos SET isArchived = :isArchived WHERE id = :convoId")
+    abstract suspend fun updateIsArchived(convoId: Long, isArchived: Boolean): Int
+
+    @Query("UPDATE convos SET majorId = :majorId WHERE id = :convoId")
+    abstract suspend fun updateMajorId(convoId: Long, majorId: Int): Int
+
+    @Query("UPDATE convos SET minorId = :minorId WHERE id = :convoId")
+    abstract suspend fun updateMinorId(convoId: Long, minorId: Int): Int
+
+    @Query("UPDATE convos SET lastCmId = :cmId WHERE id = :convoId")
+    abstract suspend fun updateLastCmId(convoId: Long, cmId: Long): Int
 }
-
-
-

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

@@ -7,7 +7,7 @@ import dev.meloda.fast.model.database.VkMessageEntity
 @Dao
 abstract class MessageDao : EntityDao<VkMessageEntity> {
 
-    @Query("SELECT * FROM messages")
+    @Query("SELECT * FROM messages WHERE isDeleted = 0 AND isSpam = 0")
     abstract suspend fun getAll(): List<VkMessageEntity>
 
     @Query("SELECT * FROM messages WHERE peerId IS (:convoId)")
@@ -21,4 +21,13 @@ abstract class MessageDao : EntityDao<VkMessageEntity> {
 
     @Query("DELETE FROM messages WHERE id IN (:ids)")
     abstract suspend fun deleteByIds(ids: List<Int>): Int
+
+    @Query("UPDATE messages SET isDeleted = :isDeleted WHERE peerId = :convoId AND cmId = :cmId")
+    abstract suspend fun markAsDeleted(convoId: Long, cmId: Long, isDeleted: Boolean): Int
+
+    @Query("UPDATE messages SET isImportant = :isImportant WHERE peerId = :convoId AND cmId = :cmId")
+    abstract suspend fun markAsImportant(convoId: Long, cmId: Long, isImportant: Boolean): Int
+
+    @Query("UPDATE messages SET isSpam = :isSpam WHERE peerId = :convoId AND cmId = :cmId")
+    abstract suspend fun markAsSpam(convoId: Long, cmId: Long, isSpam: Boolean): Int
 }

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

@@ -3,14 +3,33 @@ package dev.meloda.fast.datastore
 import android.content.SharedPreferences
 import androidx.core.content.edit
 import dev.meloda.fast.common.model.DarkMode
-import dev.meloda.fast.common.model.LogLevel
+import dev.meloda.fast.common.model.NetworkLogLevel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 import kotlin.properties.Delegates
 import kotlin.reflect.KClass
 
+sealed class CaptchaTokenResult {
+    data object Initial : CaptchaTokenResult()
+    data object Null : CaptchaTokenResult()
+    data object Cancelled : CaptchaTokenResult()
+    data class Success(val token: String) : CaptchaTokenResult()
+}
+
 object AppSettings {
 
     private var preferences: SharedPreferences by Delegates.notNull()
 
+    private val captchaResult = MutableStateFlow<CaptchaTokenResult>(CaptchaTokenResult.Initial)
+    fun getCaptchaResultFlow(): StateFlow<CaptchaTokenResult> = captchaResult.asStateFlow()
+    fun setCaptchaResult(result: CaptchaTokenResult) = captchaResult.update { result }
+
+    private val captchaRedirectUri = MutableStateFlow<String?>(null)
+    fun getCaptchaRedirectUriFlow() = captchaRedirectUri.asStateFlow()
+    fun setCaptchaRedirectUri(redirectUri: String?) = captchaRedirectUri.update { redirectUri }
+
     fun init(preferences: SharedPreferences) {
         this.preferences = preferences
     }
@@ -219,11 +238,11 @@ object AppSettings {
             )
             set(value) = put(SettingsKeys.KEY_DEBUG_SHOW_CRASH_ALERT, value)
 
-        var networkLogLevel: LogLevel
+        var networkLogLevel: NetworkLogLevel
             get() = get(
                 SettingsKeys.KEY_DEBUG_NETWORK_LOG_LEVEL,
                 SettingsKeys.DEFAULT_NETWORK_LOG_LEVEL
-            ).let(LogLevel::parse)
+            ).let(NetworkLogLevel::parse)
             set(level) = put(SettingsKeys.KEY_DEBUG_NETWORK_LOG_LEVEL, level.value)
 
         var showDebugCategory: Boolean

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

@@ -6,10 +6,7 @@ import dev.meloda.fast.model.database.AccountEntity
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
-class GetCurrentAccountUseCase(
-    private val accountsRepository: AccountsRepository
-) {
-
+class GetCurrentAccountUseCase(private val accountsRepository: AccountsRepository) {
     suspend operator fun invoke(): AccountEntity? = withContext(Dispatchers.IO) {
         accountsRepository.getAccountById(UserConfig.currentUserId)
     }

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

@@ -0,0 +1,332 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.database.dao.ConvoDao
+import dev.meloda.fast.database.dao.MessageDao
+import dev.meloda.fast.logger.FastLogger
+import dev.meloda.fast.model.InteractionType
+import dev.meloda.fast.model.LongPollEvent
+import dev.meloda.fast.model.LongPollParsedEvent
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.CoroutineContext
+
+typealias EventListener = (event: LongPollParsedEvent) -> Unit
+typealias EventListenerMap = MutableMap<LongPollEvent, MutableList<EventListener>>
+
+class LongPollEventsHandler(
+    private val logger: FastLogger,
+    private val convoUseCase: ConvoUseCase,
+    private val messagesUseCase: MessagesUseCase,
+    private val convoDao: ConvoDao,
+    private val messageDao: MessageDao,
+) {
+    private val job = SupervisorJob()
+
+    private val exceptionHandler =
+        CoroutineExceptionHandler { _, throwable ->
+            logger.error(this::class, "CoroutineException", throwable)
+        }
+
+    private val coroutineContext: CoroutineContext
+        get() = Dispatchers.Default + job + exceptionHandler
+
+    private val coroutineScope = CoroutineScope(coroutineContext)
+
+    private val listenersMap: EventListenerMap = mutableMapOf()
+
+    fun handleEvents(events: List<LongPollParsedEvent>) {
+        coroutineScope.launch {
+            // TODO: 30.05.2026, Danil Nikolaev: switch to interactors or something else
+            withContext(Dispatchers.IO) {
+                events.forEach { handleNextEvent(it) }
+            }
+        }
+    }
+
+    private suspend fun handleNextEvent(event: LongPollParsedEvent) {
+        when (event) {
+            is LongPollParsedEvent.AudioMessageListened -> {
+
+            }
+
+            is LongPollParsedEvent.ChatArchived -> {
+                val affectedRows = convoDao.updateIsArchived(
+                    convoId = event.convo.id,
+                    isArchived = event.convo.isArchived
+                )
+
+                logger.debug(
+                    this::class,
+                    "isArchived ${event.convo.isArchived}: updated $affectedRows rows."
+                )
+            }
+
+            is LongPollParsedEvent.ChatCleared -> {
+                val affectedRows = convoDao.updateLastCmId(
+                    convoId = event.peerId,
+                    cmId = event.toCmId
+                )
+
+                logger.debug(
+                    this::class,
+                    "updateLastCmId: updated $affectedRows rows."
+                )
+            }
+
+            is LongPollParsedEvent.ChatMajorChanged -> {
+                val affectedRows = convoDao.updateMajorId(
+                    convoId = event.peerId,
+                    majorId = event.majorId
+                )
+
+                logger.debug(
+                    this::class,
+                    "updateMajorId: updated $affectedRows rows."
+                )
+            }
+
+            is LongPollParsedEvent.ChatMinorChanged -> {
+                val affectedRows = convoDao.updateMinorId(
+                    convoId = event.peerId,
+                    minorId = event.minorId
+                )
+
+                logger.debug(
+                    this::class,
+                    "updateMinorId: updated $affectedRows rows."
+                )
+            }
+
+            is LongPollParsedEvent.Interaction -> {
+                val eventType = when (event.interactionType) {
+                    InteractionType.Typing -> LongPollEvent.TYPING
+                    InteractionType.VoiceMessage -> LongPollEvent.AUDIO_MESSAGE_RECORDING
+                    InteractionType.Photo -> LongPollEvent.PHOTO_UPLOADING
+                    InteractionType.Video -> LongPollEvent.VIDEO_UPLOADING
+                    InteractionType.File -> LongPollEvent.FILE_UPLOADING
+                }
+
+                emitEvent(eventType, event)
+            }
+
+            is LongPollParsedEvent.MessageCacheClear -> {
+                messagesUseCase.storeMessage(event.message)
+
+                emitEvent(LongPollEvent.MESSAGE_CACHE_CLEAR, event)
+            }
+
+            is LongPollParsedEvent.MessageDeleted -> {
+                val affectedRows = messageDao.markAsDeleted(
+                    convoId = event.peerId,
+                    cmId = event.cmId,
+                    isDeleted = true
+                )
+
+                logger.debug(
+                    this::class,
+                    "markDeleted: updated $affectedRows rows."
+                )
+
+                emitEvent(LongPollEvent.MESSAGE_DELETED, event)
+            }
+
+            is LongPollParsedEvent.MessageEdited -> {
+                messagesUseCase.storeMessage(event.message)
+
+                emitEvent(LongPollEvent.MESSAGE_EDITED, event)
+            }
+
+            is LongPollParsedEvent.MessageMarkedAsImportant -> {
+                val affectedRows = messageDao.markAsImportant(
+                    convoId = event.peerId,
+                    cmId = event.cmId,
+                    isImportant = event.marked
+                )
+
+                logger.debug(
+                    this::class,
+                    "markImportant: updated $affectedRows rows."
+                )
+
+                emitEvent(LongPollEvent.MARKED_AS_IMPORTANT, event)
+            }
+
+            is LongPollParsedEvent.MessageMarkedAsNotSpam -> {
+                messagesUseCase.storeMessage(event.message)
+
+                emitEvent(LongPollEvent.MARKED_AS_NOT_SPAM, event)
+            }
+
+            is LongPollParsedEvent.MessageMarkedAsSpam -> {
+                val affectedRows = messageDao.markAsSpam(
+                    convoId = event.peerId,
+                    cmId = event.cmId,
+                    isSpam = true
+                )
+
+                logger.debug(
+                    this::class,
+                    "markSpam: updated $affectedRows rows."
+                )
+
+                emitEvent(LongPollEvent.MARKED_AS_SPAM, event)
+            }
+
+            is LongPollParsedEvent.MessageRestored -> {
+                messagesUseCase.storeMessage(event.message)
+
+                emitEvent(LongPollEvent.MESSAGE_RESTORED, event)
+            }
+
+            is LongPollParsedEvent.MessageUpdated -> {
+                messagesUseCase.storeMessage(event.message)
+
+                emitEvent(LongPollEvent.MESSAGE_UPDATED, event)
+            }
+
+            is LongPollParsedEvent.MessageNew -> {
+                messagesUseCase.storeMessage(event.message)
+
+                emitEvent(LongPollEvent.MESSAGE_NEW, event)
+            }
+
+            is LongPollParsedEvent.IncomingMessageRead -> {
+                val affectedRows = convoDao.updateReadIncoming(
+                    convoId = event.peerId,
+                    cmId = event.cmId,
+                    unreadCount = event.unreadCount
+                )
+
+                logger.debug(
+                    this::class,
+                    "inMessageRead: updated $affectedRows rows."
+                )
+
+                emitEvent(LongPollEvent.INCOMING_MESSAGE_READ, event)
+            }
+
+            is LongPollParsedEvent.OutgoingMessageRead -> {
+                val affectedRows = convoDao.updateReadOutgoing(
+                    convoId = event.peerId,
+                    cmId = event.cmId,
+                    unreadCount = event.unreadCount
+                )
+
+                logger.debug(
+                    this::class,
+                    "outMessageRead: updated $affectedRows rows."
+                )
+
+                emitEvent(LongPollEvent.OUTGOING_MESSAGE_READ, event)
+            }
+
+            is LongPollParsedEvent.UnreadCounter -> {
+                emitEvent(LongPollEvent.UNREAD_COUNTER_UPDATE, event)
+            }
+        }
+    }
+
+    private fun <T : LongPollParsedEvent> emitEvent(eventType: LongPollEvent, event: T) {
+        listenersMap[eventType]?.forEach { it(event) }
+    }
+
+    private fun <T : LongPollParsedEvent> registerListener(
+        eventType: LongPollEvent,
+        listener: (T) -> Unit
+    ) {
+        if (listenersMap[eventType] == null) {
+            listenersMap[eventType] = mutableListOf()
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        listenersMap[eventType]?.add(listener as EventListener)
+    }
+
+    private fun <T : LongPollParsedEvent> registerListeners(
+        eventTypes: List<LongPollEvent>,
+        listener: (T) -> Unit
+    ) {
+        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
+    }
+
+    fun onMessageSetFlags(block: (LongPollParsedEvent) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_SET_FLAGS, block)
+    }
+
+    fun onMessageMarkAsImportant(block: (LongPollParsedEvent.MessageMarkedAsImportant) -> Unit) {
+        registerListener(LongPollEvent.MARKED_AS_IMPORTANT, block)
+    }
+
+    fun onMessageMarkAsSpam(block: (LongPollParsedEvent.MessageMarkedAsSpam) -> Unit) {
+        registerListener(LongPollEvent.MARKED_AS_SPAM, block)
+    }
+
+    fun onMessageDelete(block: (LongPollParsedEvent.MessageDeleted) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_DELETED, block)
+    }
+
+    fun onMessageClearFlags(block: (LongPollParsedEvent) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, block)
+    }
+
+    fun onMessageMarkAsNotSpam(block: (LongPollParsedEvent.MessageMarkedAsNotSpam) -> Unit) {
+        registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, block)
+    }
+
+    fun onMessageRestore(block: (LongPollParsedEvent.MessageRestored) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_RESTORED, block)
+    }
+
+    fun onMessageNew(block: (LongPollParsedEvent.MessageNew) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_NEW, block)
+    }
+
+    fun onMessageEdit(block: (LongPollParsedEvent.MessageEdited) -> Unit) {
+        registerListener(LongPollEvent.MESSAGE_EDITED, block)
+    }
+
+    fun onMessageIncomingRead(block: (LongPollParsedEvent.IncomingMessageRead) -> Unit) {
+        registerListener(LongPollEvent.INCOMING_MESSAGE_READ, block)
+    }
+
+    fun onMessageOutgoingRead(block: (LongPollParsedEvent.OutgoingMessageRead) -> Unit) {
+        registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, block)
+    }
+
+    fun onChatClear(block: (LongPollParsedEvent.ChatCleared) -> Unit) {
+        registerListener(LongPollEvent.CHAT_CLEARED, block)
+    }
+
+    fun onChatMajorChange(block: (LongPollParsedEvent.ChatMajorChanged) -> Unit) {
+        registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, block)
+    }
+
+    fun onChatMinorChange(block: (LongPollParsedEvent.ChatMinorChanged) -> Unit) {
+        registerListener(LongPollEvent.CHAT_MINOR_CHANGED, block)
+    }
+
+    fun onChatArchive(block: (LongPollParsedEvent.ChatArchived) -> Unit) {
+        registerListener(LongPollEvent.CHAT_ARCHIVED, block)
+    }
+
+    fun onInteraction(block: (LongPollParsedEvent.Interaction) -> Unit) {
+        registerListeners(
+            eventTypes = listOf(
+                LongPollEvent.TYPING,
+                LongPollEvent.AUDIO_MESSAGE_RECORDING,
+                LongPollEvent.PHOTO_UPLOADING,
+                LongPollEvent.VIDEO_UPLOADING,
+                LongPollEvent.FILE_UPLOADING
+            ),
+            listener = block
+        )
+    }
+
+    fun onDestroy() {
+        listenersMap.clear()
+    }
+}

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

@@ -1,6 +1,5 @@
 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
@@ -8,10 +7,10 @@ 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.logger.FastLogger
 import dev.meloda.fast.model.ApiEvent
 import dev.meloda.fast.model.ConvoFlags
 import dev.meloda.fast.model.InteractionType
-import dev.meloda.fast.model.LongPollEvent
 import dev.meloda.fast.model.LongPollParsedEvent
 import dev.meloda.fast.model.MessageFlags
 import dev.meloda.fast.model.api.domain.VkConvo
@@ -22,12 +21,12 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.async
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 
 class LongPollUpdatesParser(
+    private val logger: FastLogger,
     private val convoUseCase: ConvoUseCase,
     private val messagesUseCase: MessagesUseCase
 ) {
@@ -35,8 +34,7 @@ class LongPollUpdatesParser(
 
     private val exceptionHandler =
         CoroutineExceptionHandler { _, throwable ->
-            Log.e("LongPollUpdatesParser", "error: $throwable")
-            throwable.printStackTrace()
+            logger.error(this::class, "CoroutineException", throwable)
         }
 
     private val coroutineContext: CoroutineContext
@@ -44,14 +42,14 @@ class LongPollUpdatesParser(
 
     private val coroutineScope = CoroutineScope(coroutineContext)
 
-    private val listenersMap: MutableMap<LongPollEvent, MutableList<VkEventCallback<LongPollParsedEvent>>> =
-        mutableMapOf()
-
-    fun parseNextUpdate(event: List<Any>) {
+    suspend fun parseNextUpdate(event: List<Any>): List<LongPollParsedEvent> {
         val eventId = event.first().asInt()
 
-        when (val eventType = ApiEvent.parseOrNull(eventId)) {
-            null -> Log.d("LongPollUpdatesParser", "parseNextUpdate: unknownEvent: $event")
+        return when (val eventType = ApiEvent.parseOrNull(eventId)) {
+            null -> {
+                logger.debug(this::class, "parseNextUpdate(): unknownEvent: $event")
+                emptyList()
+            }
 
             ApiEvent.MESSAGE_SET_FLAGS -> parseMessageSetFlags(eventType, event)
             ApiEvent.MESSAGE_CLEAR_FLAGS -> parseMessageClearFlags(eventType, event)
@@ -77,8 +75,11 @@ class LongPollUpdatesParser(
         }
     }
 
-    private fun parseMessageSetFlags(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private fun parseMessageSetFlags(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> {
+        logger.debug(this::class, "parseMessageSetFlags(): $eventType: $event")
 
         val cmId = event[1].asLong()
         val flags = event[2].asInt()
@@ -96,13 +97,6 @@ class LongPollUpdatesParser(
                         marked = true
                     )
                     eventsToSend += eventToSend
-
-                    listenersMap[LongPollEvent.MARKED_AS_IMPORTANT]?.let { listeners ->
-                        listeners.map { vkEventCallback ->
-                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsImportant>)
-                                ?.onEvent(eventToSend)
-                        }
-                    }
                 }
 
                 MessageFlags.SPAM -> {
@@ -111,13 +105,6 @@ class LongPollUpdatesParser(
                         cmId = cmId
                     )
                     eventsToSend += eventToSend
-
-                    listenersMap[LongPollEvent.MARKED_AS_SPAM]?.let { listeners ->
-                        listeners.map { vkEventCallback ->
-                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsSpam>)
-                                ?.onEvent(eventToSend)
-                        }
-                    }
                 }
 
                 MessageFlags.DELETED -> {
@@ -136,13 +123,6 @@ class LongPollUpdatesParser(
                             )
                         }
                     eventsToSend += eventToSend
-
-                    listenersMap[LongPollEvent.MESSAGE_DELETED]?.let { listeners ->
-                        listeners.map { vkEventCallback ->
-                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageDeleted>)
-                                ?.onEvent(eventToSend)
-                        }
-                    }
                 }
 
                 MessageFlags.AUDIO_LISTENED -> {
@@ -151,30 +131,27 @@ class LongPollUpdatesParser(
                         cmId = cmId
                     )
                     eventsToSend += eventToSend
-
-                    listenersMap[LongPollEvent.AUDIO_MESSAGE_LISTENED]?.let { listeners ->
-                        listeners.map { vkEventCallback ->
-                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.AudioMessageListened>)
-                                ?.onEvent(eventToSend)
-                        }
-                    }
                 }
 
-                else -> Unit
+                MessageFlags.UNREAD -> Unit
+                MessageFlags.OUTGOING -> Unit
+                MessageFlags.FROM_GROUP_CHAT -> Unit
+                MessageFlags.CANCEL_SPAM -> Unit
+                MessageFlags.DELETED_FOR_ALL -> Unit
+                MessageFlags.DO_NOT_SHOW_NOTIFICATION -> Unit
+                MessageFlags.MESSAGE_WITH_REPLY -> Unit
+                MessageFlags.REACTION -> Unit
             }
         }
 
-        eventsToSend.forEach { eventToSend ->
-            listenersMap[LongPollEvent.MESSAGE_SET_FLAGS]?.let { listeners ->
-                listeners.map { vkEventCallback ->
-                    (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(eventToSend)
-                }
-            }
-        }
+        return eventsToSend
     }
 
-    private fun parseMessageClearFlags(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private suspend fun parseMessageClearFlags(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> = suspendCancellableCoroutine { continuation ->
+        logger.debug(this::class, "parseMessageClearFlags(): $eventType: $event")
 
         val cmId = event[1].asLong()
         val flags = event[2].asInt()
@@ -184,7 +161,9 @@ class LongPollUpdatesParser(
 
         val parsedFlags = MessageFlags.parse(flags)
 
-        coroutineScope.launch {
+        coroutineScope.launch(Dispatchers.IO) {
+            val message = loadMessage(peerId = peerId, cmId = cmId)
+
             parsedFlags.forEach { flag ->
                 when (flag) {
                     MessageFlags.IMPORTANT -> {
@@ -194,82 +173,53 @@ class LongPollUpdatesParser(
                             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)
-                                        }
-                                    }
-                                }
+                            if (message != null) {
+                                val eventToSend =
+                                    LongPollParsedEvent.MessageMarkedAsNotSpam(message = message)
+                                eventsToSend += 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)
-                                    }
-                                }
-                            }
+                        if (message != null) {
+                            val eventToSend =
+                                LongPollParsedEvent.MessageRestored(message = message)
+                            eventsToSend += eventToSend
                         }
                     }
 
-                    else -> Unit
+                    MessageFlags.UNREAD -> Unit
+                    MessageFlags.OUTGOING -> Unit
+                    MessageFlags.AUDIO_LISTENED -> Unit
+                    MessageFlags.FROM_GROUP_CHAT -> Unit
+                    MessageFlags.CANCEL_SPAM -> Unit
+                    MessageFlags.DELETED_FOR_ALL -> Unit
+                    MessageFlags.DO_NOT_SHOW_NOTIFICATION -> Unit
+                    MessageFlags.MESSAGE_WITH_REPLY -> Unit
+                    MessageFlags.REACTION -> Unit
                 }
             }
 
-            eventsToSend.forEach { eventToSend ->
-                listenersMap[LongPollEvent.MESSAGE_CLEAR_FLAGS]?.let { listeners ->
-                    listeners.map { vkEventCallback ->
-                        vkEventCallback.onEvent(eventToSend)
-                    }
-                }
-            }
+            continuation.resume(eventsToSend)
         }
     }
 
-    private fun parseMessageNew(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private suspend fun parseMessageNew(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> = suspendCancellableCoroutine { continuation ->
+        logger.debug(this::class, "parseMessageNew(): $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 message = async { loadMessage(peerId = peerId, cmId = cmId) }.await()
 
             val convo =
                 async {
@@ -280,88 +230,84 @@ class LongPollUpdatesParser(
                     )
                 }.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
-                                )
-                            )
-                    }
-                }
+            if (message != null) {
+                val event = LongPollParsedEvent.MessageNew(
+                    message = message,
+                    inArchive = convo?.isArchived == true
+                    // TODO: 03-Apr-25, Danil Nikolaev:
+                    // load user settings about restoring chats with
+                    // enabled notifications from archive
+                )
+
+                continuation.resume(listOf(event))
+            } else {
+                continuation.resume(emptyList())
             }
         }
     }
 
-    private fun parseMessageEdit(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private suspend fun parseMessageEdit(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> = suspendCancellableCoroutine { continuation ->
+        logger.debug(this::class, "parseMessageEdit(): $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))
-                    }
-                }
+            val message = loadMessage(peerId = peerId, cmId = cmId)
+            if (message != null) {
+                val event = LongPollParsedEvent.MessageEdited(message)
+                continuation.resume(listOf(event))
+            } else {
+                continuation.resume(emptyList())
             }
         }
     }
 
-    private fun parseMessageReadIncoming(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private fun parseMessageReadIncoming(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> {
+        logger.debug(this::class, "parseMessageReadIncoming(): $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
-                        )
-                    )
-            }
-        }
+        val event = LongPollParsedEvent.IncomingMessageRead(
+            peerId = peerId,
+            cmId = cmId,
+            unreadCount = unreadCount
+        )
+        return listOf(event)
     }
 
-    private fun parseMessageReadOutgoing(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private fun parseMessageReadOutgoing(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> {
+        logger.debug(this::class, "parseMessageReadOutgoing(): $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
-                        )
-                    )
-            }
-        }
+        val event = LongPollParsedEvent.OutgoingMessageRead(
+            peerId = peerId,
+            cmId = cmId,
+            unreadCount = unreadCount
+        )
+
+        return listOf(event)
     }
 
-    private fun parseChatClearFlags(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private suspend fun parseChatClearFlags(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> = suspendCancellableCoroutine { continuation ->
+        logger.debug(this::class, "parseChatClearFlags(): $eventType: $event")
 
         val peerId = event[1].asLong()
         val flags = event[2].asInt()
@@ -390,33 +336,32 @@ class LongPollUpdatesParser(
                             archived = false
                         )
                         eventsToSend += eventToSend
-
-                        listenersMap[LongPollEvent.CHAT_ARCHIVED]?.let { listeners ->
-                            listeners.map { vkEventCallback ->
-                                (vkEventCallback as? VkEventCallback<LongPollParsedEvent.ChatArchived>)
-                                    ?.onEvent(eventToSend)
-                            }
-                        }
                     }
 
-                    else -> Unit
+                    ConvoFlags.DISABLE_PUSH -> Unit
+                    ConvoFlags.DISABLE_SOUND -> Unit
+                    ConvoFlags.INCOMING_CHAT_REQUEST -> Unit
+                    ConvoFlags.DECLINED_CHAT_REQUEST -> Unit
+                    ConvoFlags.MENTION -> Unit
+                    ConvoFlags.HIDE_CHAT_FROM_SEARCH -> Unit
+                    ConvoFlags.BUSINESS_CHAT -> Unit
+                    ConvoFlags.MARKED_MESSAGE -> Unit
+                    ConvoFlags.DO_NOT_NOTIFY_MENTIONS_ALL_ONLINE -> Unit
+                    ConvoFlags.DO_NOT_NOTIFY_ALL_MENTIONS -> Unit
+                    ConvoFlags.MARKED_AS_UNREAD -> Unit
+                    ConvoFlags.CALL_IN_PROGRESS -> Unit
                 }
             }
 
-            eventsToSend.forEach { eventToSend ->
-                listenersMap[LongPollEvent.CHAT_CLEAR_FLAGS]?.let { listeners ->
-                    listeners.map { vkEventCallback ->
-                        (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(
-                            eventToSend
-                        )
-                    }
-                }
-            }
+            continuation.resume(eventsToSend)
         }
     }
 
-    private fun parseChatSetFlags(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private suspend fun parseChatSetFlags(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> = suspendCancellableCoroutine { continuation ->
+        logger.debug(this::class, "parseChatSetFlags(): $eventType: $event")
 
         val peerId = event[1].asLong()
         val flags = event[2].asInt()
@@ -445,90 +390,80 @@ class LongPollUpdatesParser(
                             archived = true
                         )
                         eventsToSend += eventToSend
-
-                        listenersMap[LongPollEvent.CHAT_ARCHIVED]?.let { listeners ->
-                            listeners.map { vkEventCallback ->
-                                (vkEventCallback as? VkEventCallback<LongPollParsedEvent.ChatArchived>)
-                                    ?.onEvent(eventToSend)
-                            }
-                        }
                     }
 
-                    else -> Unit
+                    ConvoFlags.DISABLE_PUSH -> Unit
+                    ConvoFlags.DISABLE_SOUND -> Unit
+                    ConvoFlags.INCOMING_CHAT_REQUEST -> Unit
+                    ConvoFlags.DECLINED_CHAT_REQUEST -> Unit
+                    ConvoFlags.MENTION -> Unit
+                    ConvoFlags.HIDE_CHAT_FROM_SEARCH -> Unit
+                    ConvoFlags.BUSINESS_CHAT -> Unit
+                    ConvoFlags.MARKED_MESSAGE -> Unit
+                    ConvoFlags.DO_NOT_NOTIFY_MENTIONS_ALL_ONLINE -> Unit
+                    ConvoFlags.DO_NOT_NOTIFY_ALL_MENTIONS -> Unit
+                    ConvoFlags.MARKED_AS_UNREAD -> Unit
+                    ConvoFlags.CALL_IN_PROGRESS -> Unit
                 }
             }
 
-            eventsToSend.forEach { eventToSend ->
-                listenersMap[LongPollEvent.CHAT_SET_FLAGS]?.let { listeners ->
-                    listeners.map { vkEventCallback ->
-                        (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(
-                            eventToSend
-                        )
-                    }
-                }
-            }
+            continuation.resume(eventsToSend)
         }
     }
 
-    private fun parseMessagesDeleted(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private fun parseMessagesDeleted(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> {
+        logger.debug(this::class, "parseMessagesDeleted(): $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
-                        )
-                    )
-            }
-        }
+        val event = LongPollParsedEvent.ChatCleared(
+            peerId = peerId,
+            toCmId = cmId
+        )
+        return listOf(event)
     }
 
-    private fun parseChatMajorChanged(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private fun parseChatMajorChanged(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> {
+        logger.debug(this::class, "parseChatMajorChanged(): $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,
-                        )
-                    )
-            }
-        }
+        val event = LongPollParsedEvent.ChatMajorChanged(
+            peerId = peerId,
+            majorId = majorId,
+        )
+        return listOf(event)
     }
 
-    private fun parseChatMinorChanged(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private fun parseChatMinorChanged(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> {
+        logger.debug(this::class, "parseChatMinorChanged(): $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,
-                        )
-                    )
-            }
-        }
+        val event = LongPollParsedEvent.ChatMinorChanged(
+            peerId = peerId,
+            minorId = minorId,
+        )
+        return listOf(event)
     }
 
-    private fun parseInteraction(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    private fun parseInteraction(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> {
+        logger.debug(this::class, "parseInteraction(): $eventType: $event")
 
         val interactionType = when (eventType) {
             ApiEvent.TYPING -> InteractionType.Typing
@@ -536,16 +471,7 @@ class LongPollUpdatesParser(
             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
+            else -> return emptyList()
         }
 
         val peerId = event[1].asLong()
@@ -554,26 +480,24 @@ class LongPollUpdatesParser(
         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
+        if (userIds.isEmpty()) return emptyList()
 
-        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
-                        )
-                    )
-            }
-        }
+        val event = LongPollParsedEvent.Interaction(
+            interactionType = interactionType,
+            peerId = peerId,
+            userIds = userIds,
+            totalCount = totalCount,
+            timestamp = timestamp
+        )
+
+        return listOf(event)
     }
 
-    private fun parseUnreadCounterUpdate(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType $event")
+    private fun parseUnreadCounterUpdate(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> {
+        logger.debug(this::class, "parseUnreadCounterUpdate(): $eventType: $event")
 
         val unreadCount = event[1].asInt()
         val unreadUnmutedCount = event[2].asInt()
@@ -583,58 +507,54 @@ class LongPollUpdatesParser(
         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
-                        )
-                    )
-            }
-        }
+        val event = LongPollParsedEvent.UnreadCounter(
+            unread = unreadCount,
+            unreadUnmuted = unreadUnmutedCount,
+            showOnlyMuted = showOnlyMuted,
+            business = businessNotifyUnreadCount,
+            archive = archiveUnreadCount,
+            archiveUnmuted = archiveUnreadUnmutedCount,
+            archiveMentions = archiveMentionsCount
+        )
+        return listOf(event)
     }
 
-    private fun parseMessageUpdated(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType $event")
+    private suspend fun parseMessageUpdated(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> = suspendCancellableCoroutine { continuation ->
+        logger.debug(this::class, "parseMessageUpdated(): $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))
-                    }
-                }
+            val message = loadMessage(peerId = peerId, cmId = cmId)
+
+            if (message != null) {
+                val event = LongPollParsedEvent.MessageUpdated(message)
+                continuation.resume(listOf(event))
+            } else {
+                continuation.resume(emptyList())
             }
         }
     }
 
-    private fun parseMessageCacheClear(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType $event")
+    private suspend fun parseMessageCacheClear(
+        eventType: ApiEvent,
+        event: List<Any>
+    ): List<LongPollParsedEvent> = suspendCancellableCoroutine { continuation ->
+        logger.debug(this::class, "parseMessageCacheClear(): $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))
-                    }
-                }
+            val message = loadMessage(messageId = messageId)
+            if (message != null) {
+                val event = LongPollParsedEvent.MessageCacheClear(message)
+                continuation.resume(listOf(event))
+            } else {
+                continuation.resume(emptyList())
             }
         }
     }
@@ -643,7 +563,7 @@ class LongPollUpdatesParser(
         peerId: Long? = null,
         cmId: Long? = null,
         messageId: Long? = null
-    ): VkMessage? = suspendCoroutine { continuation ->
+    ): VkMessage? = suspendCancellableCoroutine { continuation ->
         require((peerId != null && cmId != null) || messageId != null)
 
         coroutineScope.launch(Dispatchers.IO) {
@@ -657,7 +577,10 @@ class LongPollUpdatesParser(
             ).listenValue(this) { state ->
                 state.processState(
                     error = { error ->
-                        Log.e("LongPollUpdatesParser", "loadMessage: error: $error")
+                        logger.error(
+                            this@LongPollUpdatesParser::class,
+                            "loadMessage(): ERROR: $error"
+                        )
                         continuation.resume(null)
                     },
                     success = { response ->
@@ -677,7 +600,7 @@ class LongPollUpdatesParser(
         peerId: Long,
         extended: Boolean = false,
         fields: String? = null
-    ): VkConvo? = suspendCoroutine { continuation ->
+    ): VkConvo? = suspendCancellableCoroutine { continuation ->
         coroutineScope.launch(Dispatchers.IO) {
             convoUseCase.getById(
                 peerIds = listOf(peerId),
@@ -686,7 +609,10 @@ class LongPollUpdatesParser(
             ).listenValue(coroutineScope) { state ->
                 state.processState(
                     error = { error ->
-                        Log.e("LongPollUpdatesParser", "loadConvo: error: $error")
+                        logger.error(
+                            this@LongPollUpdatesParser::class,
+                            "loadConvo(): ERROR: $error"
+                        )
                         continuation.resume(null)
                     },
                     success = { response ->
@@ -701,107 +627,4 @@ class LongPollUpdatesParser(
             }
         }
     }
-
-    @Suppress("UNCHECKED_CAST")
-    private fun <T : LongPollParsedEvent> registerListener(
-        eventType: LongPollEvent,
-        listener: VkEventCallback<T>
-    ) {
-        listenersMap.let { map ->
-            map[eventType] = (map[eventType] ?: mutableListOf())
-                .also {
-                    it.add(listener as VkEventCallback<LongPollParsedEvent>)
-                }
-        }
-    }
-
-    private fun <T : LongPollParsedEvent> registerListeners(
-        eventTypes: List<LongPollEvent>,
-        listener: VkEventCallback<T>
-    ) {
-        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
-    }
-
-    fun onMessageSetFlags(block: (LongPollParsedEvent) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_SET_FLAGS, assembleEventCallback(block))
-    }
-
-    fun onMessageMarkedAsImportant(block: (LongPollParsedEvent.MessageMarkedAsImportant) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_IMPORTANT, assembleEventCallback(block))
-    }
-
-    fun onMessageMarkedAsSpam(block: (LongPollParsedEvent.MessageMarkedAsSpam) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_SPAM, assembleEventCallback(block))
-    }
-
-    fun onMessageDeleted(block: (LongPollParsedEvent.MessageDeleted) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_DELETED, assembleEventCallback(block))
-    }
-
-    fun onMessageClearFlags(block: (LongPollParsedEvent) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, assembleEventCallback(block))
-    }
-
-    fun onMessageMarkedAsNotSpam(block: (LongPollParsedEvent.MessageMarkedAsNotSpam) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, assembleEventCallback(block))
-    }
-
-    fun onMessageRestored(block: (LongPollParsedEvent.MessageRestored) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_RESTORED, assembleEventCallback(block))
-    }
-
-    fun onNewMessage(block: (LongPollParsedEvent.NewMessage) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_NEW, assembleEventCallback(block))
-    }
-
-    fun onMessageEdited(block: (LongPollParsedEvent.MessageEdited) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_EDITED, assembleEventCallback(block))
-    }
-
-    fun onMessageIncomingRead(block: (LongPollParsedEvent.IncomingMessageRead) -> Unit) {
-        registerListener(LongPollEvent.INCOMING_MESSAGE_READ, assembleEventCallback(block))
-    }
-
-    fun onMessageOutgoingRead(block: (LongPollParsedEvent.OutgoingMessageRead) -> Unit) {
-        registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, assembleEventCallback(block))
-    }
-
-    fun onChatCleared(block: (LongPollParsedEvent.ChatCleared) -> Unit) {
-        registerListener(LongPollEvent.CHAT_CLEARED, assembleEventCallback(block))
-    }
-
-    fun onChatMajorChanged(block: (LongPollParsedEvent.ChatMajorChanged) -> Unit) {
-        registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, assembleEventCallback(block))
-    }
-
-    fun onChatMinorChanged(block: (LongPollParsedEvent.ChatMinorChanged) -> Unit) {
-        registerListener(LongPollEvent.CHAT_MINOR_CHANGED, assembleEventCallback(block))
-    }
-
-    fun onChatArchived(block: (LongPollParsedEvent.ChatArchived) -> Unit) {
-        registerListener(LongPollEvent.CHAT_ARCHIVED, assembleEventCallback(block))
-    }
-
-    fun onInteractions(block: (LongPollParsedEvent.Interaction) -> Unit) {
-        registerListeners(
-            eventTypes = listOf(
-                LongPollEvent.TYPING,
-                LongPollEvent.AUDIO_MESSAGE_RECORDING,
-                LongPollEvent.PHOTO_UPLOADING,
-                LongPollEvent.VIDEO_UPLOADING,
-                LongPollEvent.FILE_UPLOADING
-            ),
-            listener = assembleEventCallback(block)
-        )
-    }
-}
-
-internal inline fun <R : LongPollParsedEvent> assembleEventCallback(
-    crossinline block: (R) -> Unit,
-): VkEventCallback<R> {
-    return VkEventCallback { event -> block.invoke(event) }
-}
-
-fun interface VkEventCallback<in T : LongPollParsedEvent> {
-    fun onEvent(event: T)
 }

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

@@ -21,7 +21,8 @@ interface OAuthUseCase {
         password: String,
         forceSms: Boolean,
         validationCode: String?,
-        captchaSid: String?,
-        captchaKey: String?
+        captchaSid: String? = null,
+        captchaKey: String? = null,
+        successToken: String? = null
     ): Flow<State<GetSilentTokenResponse>>
 }

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

@@ -48,7 +48,8 @@ class OAuthUseCaseImpl(
         forceSms: Boolean,
         validationCode: String?,
         captchaSid: String?,
-        captchaKey: String?
+        captchaKey: String?,
+        successToken: String?
     ): Flow<State<GetSilentTokenResponse>> = flow {
         emit(State.Loading)
 
@@ -58,7 +59,8 @@ class OAuthUseCaseImpl(
             forceSms = forceSms,
             validationCode = validationCode,
             captchaSid = captchaSid,
-            captchaKey = captchaKey
+            captchaKey = captchaKey,
+            successToken = successToken
         ).asState()
 
         emit(newState)

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

@@ -52,7 +52,7 @@ fun VkConvo.extractTitle(
         } else {
             val userName = user?.let { user ->
                 if (useContactName) {
-                    VkMemoryCache.getContact(user.id)?.name
+                    VkMemoryCache.getContact(user.id)?.name ?: user.fullName
                 } else {
                     user.fullName
                 }
@@ -598,6 +598,7 @@ private fun getAttachmentIconByType(attachmentType: AttachmentType): UiImage? {
         AttachmentType.VIDEO_MESSAGE -> null
         AttachmentType.GROUP_CHAT_STICKER -> R.drawable.ic_sticker_fill_round_24
         AttachmentType.STICKER_PACK_PREVIEW -> null
+        AttachmentType.CHANNEL_MESSAGE -> null
     }?.let(UiImage::Resource)
 }
 
@@ -687,6 +688,7 @@ fun getAttachmentUiText(
         AttachmentType.VIDEO_MESSAGE -> R.string.message_attachments_video_message
         AttachmentType.GROUP_CHAT_STICKER -> R.string.message_attachments_group_sticker
         AttachmentType.STICKER_PACK_PREVIEW -> R.string.message_attachments_sticker_pack_preview
+        AttachmentType.CHANNEL_MESSAGE -> R.string.message_attachments_channel_message
     }.let(UiText::Resource)
 }
 

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

@@ -27,6 +27,8 @@ fun VkConvo.asPresentation(
         monthShort = { resources.getString(R.string.month_short) },
         weekShort = { resources.getString(R.string.week_short) },
         dayShort = { resources.getString(R.string.day_short) },
+        minuteShort = { resources.getString(R.string.minute_short) },
+        secondShort = { resources.getString(R.string.second_short) },
         now = { resources.getString(R.string.time_now) },
     ),
     message = extractMessage(resources, lastMessage, id, peerType),

core/logger/.gitignore

@@ -0,0 +1 @@
+/build

core/logger/build.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+    alias(libs.plugins.fast.android.library)
+}
+
+android {
+    namespace = "dev.meloda.fast.logger"
+}
+
+dependencies {
+    implementation(libs.koin.android)
+}

core/logger/src/main/kotlin/dev/meloda/fast/logger/FastLogLevel.kt

@@ -0,0 +1,17 @@
+package dev.meloda.fast.logger;
+
+enum class FastLogLevel {
+    VERBOSE,
+    DEBUG,
+    INFO,
+    WARNING,
+    ERROR,
+    ASSERT;
+
+    companion object {
+        fun parse(value: Int): FastLogLevel {
+            if (value !in 0..5) throw IllegalArgumentException("Unknown LogLevel value $value")
+            return entries.first { it.ordinal == value }
+        }
+    }
+}

core/logger/src/main/kotlin/dev/meloda/fast/logger/FastLogger.kt

@@ -0,0 +1,108 @@
+package dev.meloda.fast.logger
+
+import android.util.Log
+import kotlin.reflect.KClass
+
+class FastLogger {
+    companion object {
+
+        @Volatile
+        private lateinit var instance: FastLogger
+
+        fun setInstance(logger: FastLogger) {
+            if (::instance.isInitialized) {
+                throw IllegalStateException("FastLogger has already been initialized.")
+            }
+
+            instance = logger
+        }
+
+        fun getInstance(): FastLogger {
+            if (!::instance.isInitialized) {
+                throw UninitializedPropertyAccessException("FastLogger is not initialized.")
+            }
+            return instance
+        }
+    }
+
+    private var logLevel: FastLogLevel = FastLogLevel.ERROR
+
+    fun setLogLevel(logLevel: FastLogLevel) {
+        Log.v(this::class.java.simpleName, "Set LogLevel from ${this.logLevel} to $logLevel")
+        this.logLevel = logLevel
+    }
+
+    fun verbose(clazz: Class<*>, message: String, throwable: Throwable? = null) {
+        verbose(clazz.simpleName, message, throwable)
+    }
+
+    fun verbose(tag: String, message: String, throwable: Throwable? = null) {
+        if (shouldLog(FastLogLevel.VERBOSE)) {
+            Log.v(tag, message, throwable)
+        }
+    }
+
+    fun debug(clazz: KClass<*>, message: String, throwable: Throwable? = null) {
+        debug(clazz.java, message, throwable)
+    }
+
+    fun debug(clazz: Class<*>, message: String, throwable: Throwable? = null) {
+        debug(clazz.simpleName, message, throwable)
+    }
+
+    fun debug(tag: String, message: String, throwable: Throwable? = null) {
+        if (shouldLog(FastLogLevel.DEBUG)) {
+            Log.d(tag, message, throwable)
+        }
+    }
+
+    fun info(clazz: KClass<*>, message: String, throwable: Throwable? = null) {
+        info(clazz.java, message, throwable)
+    }
+
+    fun info(clazz: Class<*>, message: String, throwable: Throwable? = null) {
+        info(clazz.simpleName, message, throwable)
+    }
+
+    fun info(tag: String, message: String, throwable: Throwable? = null) {
+        if (shouldLog(FastLogLevel.INFO)) {
+            Log.i(tag, message, throwable)
+        }
+    }
+
+    fun warning(clazz: Class<*>, message: String, throwable: Throwable? = null) {
+        warning(clazz.simpleName, message, throwable)
+    }
+
+    fun warning(tag: String, message: String, throwable: Throwable? = null) {
+        if (shouldLog(FastLogLevel.WARNING)) {
+            Log.w(tag, message, throwable)
+        }
+    }
+
+    fun error(clazz: KClass<*>, message: String, throwable: Throwable? = null) {
+        error(clazz.java, message, throwable)
+    }
+
+    fun error(clazz: Class<*>, message: String, throwable: Throwable? = null) {
+        error(clazz.simpleName, message, throwable)
+    }
+
+    fun error(tag: String, message: String, throwable: Throwable? = null) {
+        if (shouldLog(FastLogLevel.ERROR)) {
+            Log.e(tag, message, throwable)
+        }
+    }
+
+    fun assert(clazz: Class<*>, message: String, throwable: Throwable? = null) {
+        assert(clazz.simpleName, message, throwable)
+    }
+
+    fun assert(tag: String, message: String, throwable: Throwable? = null) {
+        if (shouldLog(FastLogLevel.ASSERT)) {
+            Log.wtf(tag, message, throwable)
+        }
+    }
+
+    private fun shouldLog(level: FastLogLevel): Boolean = level.ordinal >= logLevel.ordinal
+}

core/logger/src/main/kotlin/dev/meloda/fast/logger/LoggerModule.kt

@@ -0,0 +1,8 @@
+package dev.meloda.fast.logger
+
+import org.koin.core.module.dsl.singleOf
+import org.koin.dsl.module
+
+val loggerModule = module {
+    singleOf(::FastLogger)
+}

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

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

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

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

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

@@ -1,7 +1,5 @@
 package dev.meloda.fast.model.api.data
 
-import android.util.Log
-
 enum class AttachmentType(var value: String) {
     UNKNOWN("unknown"),
     PHOTO("photo"),
@@ -30,7 +28,8 @@ enum class AttachmentType(var value: String) {
     ARTICLE("article"),
     VIDEO_MESSAGE("video_message"),
     GROUP_CHAT_STICKER("ugc_sticker"),
-    STICKER_PACK_PREVIEW("sticker_pack_preview")
+    STICKER_PACK_PREVIEW("sticker_pack_preview"),
+    CHANNEL_MESSAGE("channel_message")
     ;
 
     fun isMultiple(): Boolean = this in listOf(PHOTO, VIDEO, AUDIO, FILE)
@@ -41,10 +40,6 @@ enum class AttachmentType(var value: String) {
                 it.value == value
             } ?: UNKNOWN
 
-            if (parsedValue == UNKNOWN) {
-                Log.e("AttachmentType", "Unknown attachment type: $value")
-            }
-
             return parsedValue
         }
     }

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

@@ -35,7 +35,8 @@ data class VkAttachmentItemData(
     @Json(name = "article") val article: VkArticleData?,
     @Json(name = "video_message") val videoMessage: VkVideoMessageData?,
     @Json(name = "ugc_sticker") val groupSticker: VkGroupStickerData?,
-    @Json(name = "sticker_pack_preview") val stickerPackPreview: VkStickerPackPreviewData?
+    @Json(name = "sticker_pack_preview") val stickerPackPreview: VkStickerPackPreviewData?,
+    @Json(name = "channel_message") val channelMessageData: VkChannelMessageData?
 ) {
     fun toDomain(): VkAttachment = when (AttachmentType.parse(type)) {
         AttachmentType.UNKNOWN -> VkUnknownAttachment
@@ -66,5 +67,6 @@ data class VkAttachmentItemData(
         AttachmentType.VIDEO_MESSAGE -> videoMessage?.toDomain()
         AttachmentType.GROUP_CHAT_STICKER -> groupSticker?.toDomain()
         AttachmentType.STICKER_PACK_PREVIEW -> stickerPackPreview?.toDomain()
+        AttachmentType.CHANNEL_MESSAGE -> channelMessageData?.toDomain()
     } ?: VkUnknownAttachment
 }

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

@@ -0,0 +1,40 @@
+package dev.meloda.fast.model.api.data
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+import dev.meloda.fast.model.api.domain.VkChannelMessage
+
+@JsonClass(generateAdapter = true)
+data class VkChannelMessageData(
+    @Json(name = "channel_id") val channelId: Long,
+    @Json(name = "cmid") val cmId: Long,
+    @Json(name = "author_id") val authorId: Long,
+    @Json(name = "channel_info") val channelInfo: ChannelInfo,
+    @Json(name = "channel_type") val channelType: String,
+    @Json(name = "guid") val guid: String,
+    @Json(name = "text") val text: String?,
+    @Json(name = "time") val time: Long,
+    @Json(name = "attachments") val attachments: List<VkAttachmentItemData> = emptyList(),
+) : VkAttachmentData {
+
+    @JsonClass(generateAdapter = true)
+    data class ChannelInfo(
+        @Json(name = "photo_base") val photoBase: String?,
+        @Json(name = "title") val title: String
+    )
+
+    fun toDomain(): VkChannelMessage = VkChannelMessage(
+        channelId = channelId,
+        cmId = cmId,
+        authorId = authorId,
+        channelInfo = VkChannelMessage.ChannelInfo(
+            title = channelInfo.title,
+            photoBase = channelInfo.photoBase
+        ),
+        channelType = channelType,
+        guid = guid,
+        text = text,
+        time = time,
+        attachments = attachments.map(VkAttachmentItemData::toDomain),
+    )
+}

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

@@ -117,5 +117,6 @@ fun VkMessageData.asDomain(): VkMessage = VkMessage(
     pinnedAt = pinnedAt,
     isPinned = isPinned == true,
     formatData = formatData?.asDomain(),
-    isSpam = false
+    isSpam = false,
+    isDeleted = false
 )

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

@@ -56,5 +56,6 @@ data class VkPinnedMessageData(
         isPinned = true,
         isSpam = false,
         formatData = null,
+        isDeleted = false
     )
 }

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

@@ -5,7 +5,7 @@ import com.squareup.moshi.JsonClass
 
 @JsonClass(generateAdapter = true)
 data class VkWidgetData(
-    val id: Long
+    val id: Long?
 ) : VkAttachmentData {
 
     fun toDomain() = VkWidgetDomain(id)

core/model/src/main/kotlin/dev/meloda/fast/model/api/domain/VkAttachment.kt

@@ -1,7 +1,9 @@
 package dev.meloda.fast.model.api.domain
 
+import androidx.compose.runtime.Immutable
 import dev.meloda.fast.model.api.data.AttachmentType
 
+@Immutable
 interface VkAttachment {
     val type: AttachmentType
 }

core/model/src/main/kotlin/dev/meloda/fast/model/api/domain/VkChannelMessage.kt

@@ -0,0 +1,23 @@
+package dev.meloda.fast.model.api.domain
+
+import dev.meloda.fast.model.api.data.AttachmentType
+
+data class VkChannelMessage(
+    val channelId: Long,
+    val cmId: Long,
+    val authorId: Long,
+    val channelInfo: ChannelInfo,
+    val channelType: String,
+    val guid: String,
+    val text: String?,
+    val time: Long,
+    val attachments: List<VkAttachment>?,
+) : VkAttachment {
+
+    data class ChannelInfo(
+        val title: String,
+        val photoBase: String?
+    )
+
+    override val type: AttachmentType = AttachmentType.CHANNEL_MESSAGE
+}

core/model/src/main/kotlin/dev/meloda/fast/model/api/domain/VkMessage.kt

@@ -36,6 +36,8 @@ data class VkMessage(
     val group: VkGroupDomain?,
     val actionUser: VkUser?,
     val actionGroup: VkGroupDomain?,
+
+    val isDeleted: Boolean
 ) {
 
     fun isPeerChat() = peerId > 2_000_000_000
@@ -111,7 +113,7 @@ fun VkMessage.asEntity(): VkMessageEntity = VkMessageEntity(
     actionCmId = actionCmId,
     actionMessage = actionMessage,
     updateTime = updateTime,
-    important = isImportant,
+    isImportant = isImportant,
     forwardIds = forwards.orEmpty().map(VkMessage::id),
     // TODO: 05/05/2024, Danil Nikolaev: save attachments
     attachments = emptyList(),
@@ -119,4 +121,6 @@ fun VkMessage.asEntity(): VkMessageEntity = VkMessageEntity(
     geoType = geoType,
     pinnedAt = pinnedAt,
     isPinned = isPinned,
+    isDeleted = isDeleted,
+    isSpam = isSpam
 )

core/model/src/main/kotlin/dev/meloda/fast/model/api/domain/VkWidgetDomain.kt

@@ -3,7 +3,7 @@ package dev.meloda.fast.model.api.domain
 import dev.meloda.fast.model.api.data.AttachmentType
 
 data class VkWidgetDomain(
-    val id: Long
+    val id: Long?
 ) : VkAttachment {
 
     override val type: AttachmentType = AttachmentType.WIDGET

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

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

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

@@ -12,7 +12,8 @@ data class AuthDirectRequest(
     val validationCode: String? = null,
     val captchaSid: String? = null,
     val captchaKey: String? = null,
-    val trustedHash: String? = null
+    val trustedHash: String? = null,
+    val successToken: String? = null
 ) {
 
     val map
@@ -31,6 +32,7 @@ data class AuthDirectRequest(
                 captchaSid?.let { this["captcha_sid"] = it }
                 captchaKey?.let { this["captcha_key"] = it }
                 trustedHash?.let { this["trusted_hash"] = it }
+                successToken?.let { this["success_token"] = it }
             }
 }
 

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

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

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

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

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

@@ -21,13 +21,15 @@ data class VkMessageEntity(
     val actionCmId: Long?,
     val actionMessage: String?,
     val updateTime: Int?,
-    val important: Boolean,
+    val isImportant: Boolean,
     val forwardIds: List<Long>?,
     val attachments: List<String>?, // TODO: 01/05/2024, Danil Nikolaev: how to store???
     val replyMessageId: Long?,
     val geoType: String?,
     val pinnedAt: Int?,
-    val isPinned: Boolean
+    val isPinned: Boolean,
+    val isDeleted: Boolean,
+    val isSpam: Boolean
 )
 
 fun VkMessageEntity.asExternalModel(): VkMessage = VkMessage(
@@ -45,7 +47,7 @@ fun VkMessageEntity.asExternalModel(): VkMessage = VkMessage(
     actionCmId = actionCmId,
     actionMessage = actionMessage,
     updateTime = updateTime,
-    isImportant = important,
+    isImportant = isImportant,
     forwards = emptyList(),//forwards.orEmpty().map(VkMessageEntity::asExternalModel),
     // TODO: 05/05/2024, Danil Nikolaev: restore attachments
     attachments = attachments.orEmpty().map { VkUnknownAttachment },
@@ -59,4 +61,5 @@ fun VkMessageEntity.asExternalModel(): VkMessage = VkMessage(
     isPinned = isPinned,
     isSpam = false,
     formatData = null,
+    isDeleted = isDeleted
 )

core/network/build.gradle.kts

@@ -15,6 +15,7 @@ dependencies {
     api(projects.core.common)
     api(projects.core.model)
     api(projects.core.datastore)
+    api(projects.core.logger)
 
     implementation(libs.moshi.kotlin)
     implementation(libs.koin.android)

core/network/src/main/kotlin/dev/meloda/fast/network/OAuthErrorDomain.kt

@@ -16,7 +16,8 @@ sealed class OAuthErrorDomain {
 
     data class CaptchaRequiredError(
         val captchaSid: String,
-        val captchaImageUrl: String
+        val captchaImageUrl: String,
+        val redirectUri: String?
     ) : OAuthErrorDomain()
 
     data class UserBannedError(

core/network/src/main/kotlin/dev/meloda/fast/network/ResponseConverterFactory.kt

@@ -1,10 +1,10 @@
 package dev.meloda.fast.network
 
-import android.util.Log
 import com.slack.eithernet.ApiException
 import com.slack.eithernet.errorType
 import com.slack.eithernet.toType
 import com.squareup.moshi.JsonDataException
+import dev.meloda.fast.logger.FastLogger
 import okhttp3.ResponseBody
 import retrofit2.Converter
 import retrofit2.Retrofit
@@ -16,7 +16,10 @@ import java.lang.reflect.Type
  *
  * допускает Unit как SuccessType в случае невозможности каста ответа в ErrorType
  */
-class ResponseConverterFactory(private val converter: JsonConverter) : Converter.Factory() {
+class ResponseConverterFactory(
+    private val converter: JsonConverter,
+    private val logger: FastLogger
+) : Converter.Factory() {
 
     override fun responseBodyConverter(
         type: Type,
@@ -29,6 +32,7 @@ class ResponseConverterFactory(private val converter: JsonConverter) : Converter
             successType = type,
             errorRaw = errorRaw,
             converter = converter,
+            logger = logger
         )
     }
 
@@ -36,6 +40,7 @@ class ResponseConverterFactory(private val converter: JsonConverter) : Converter
         private val successType: Type,
         private val errorRaw: Class<*>,
         private val converter: JsonConverter,
+        private val logger: FastLogger
     ) : Converter<ResponseBody, Any?> {
         override fun convert(value: ResponseBody): Any? {
             val string = value.string()
@@ -53,6 +58,7 @@ class ResponseConverterFactory(private val converter: JsonConverter) : Converter
                 },
                 onFailure = { failure ->
                     if (failure is JsonDataException) {
+                        logger.error(this::class, "convert(): ERROR", failure)
                         throw ApiException(
                             RestApiError(
                                 errorCode = -1,
@@ -67,10 +73,11 @@ class ResponseConverterFactory(private val converter: JsonConverter) : Converter
                         converter.fromJson(errorRaw, string)
                     }.fold(
                         onSuccess = { errorModel ->
-                            Log.d("ResponseBodyConverter", "convert: $errorModel")
+                            logger.debug(this::class, "convert(): errorModel: $errorModel")
                             throw ApiException(errorModel)
                         },
                         onFailure = { exception ->
+                            logger.error(this::class, "convert(): INNER: ERROR", exception)
                             if (!isUnit) {
                                 throw exception
                             } else {

core/network/src/main/kotlin/dev/meloda/fast/network/ValidationType.kt

@@ -2,7 +2,8 @@ package dev.meloda.fast.network
 
 enum class ValidationType(val value: String) {
     APP("2fa_app"),
-    SMS("2fa_sms");
+    SMS("sms"),
+    SMS2("2fa_sms");
 
     companion object {
         fun parse(value: String): ValidationType =

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

@@ -7,10 +7,12 @@ import com.slack.eithernet.integration.retrofit.ApiResultConverterFactory
 import com.squareup.moshi.Moshi
 import dev.meloda.fast.common.AppConstants
 import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.logger.FastLogger
 import dev.meloda.fast.network.JsonConverter
 import dev.meloda.fast.network.MoshiConverter
 import dev.meloda.fast.network.OAuthResultCallFactory
 import dev.meloda.fast.network.ResponseConverterFactory
+import dev.meloda.fast.network.interceptor.Error14HandlingInterceptor
 import dev.meloda.fast.network.interceptor.LanguageInterceptor
 import dev.meloda.fast.network.interceptor.VersionInterceptor
 import dev.meloda.fast.network.service.account.AccountService
@@ -45,6 +47,7 @@ val networkModule = module {
     single { ChuckerInterceptor.Builder(get()).collector(get()).build() }
     singleOf(::VersionInterceptor)
     singleOf(::LanguageInterceptor)
+    singleOf(::Error14HandlingInterceptor)
 
     single<OkHttpClient>(named("auth")) {
         buildHttpClient(true)
@@ -101,6 +104,7 @@ private fun Scope.buildHttpClient(forAuth: Boolean): OkHttpClient {
                 addInterceptor(get(named("token_interceptor")) as Interceptor)
             }
         }
+        .addInterceptor(get<Error14HandlingInterceptor>())
         .addInterceptor(get<VersionInterceptor>())
         .addInterceptor(get<LanguageInterceptor>())
         .addInterceptor(get<ChuckerInterceptor>())
@@ -120,7 +124,12 @@ private fun Scope.buildRetrofit(client: OkHttpClient): Retrofit {
         .baseUrl("${AppConstants.URL_API}/")
         .addConverterFactory(ApiResultConverterFactory)
         .addCallAdapterFactory(ApiResultCallAdapterFactory)
-        .addConverterFactory(ResponseConverterFactory(get<JsonConverter>()))
+        .addConverterFactory(
+            ResponseConverterFactory(
+                get<JsonConverter>(),
+                get<FastLogger>()
+            )
+        )
         .addConverterFactory(MoshiConverterFactory.create(get()))
         .client(client)
         .build()

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

@@ -0,0 +1,143 @@
+package dev.meloda.fast.network.interceptor
+
+import dev.meloda.fast.common.extensions.listenValue
+import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.datastore.CaptchaTokenResult
+import dev.meloda.fast.logger.FastLogger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import okhttp3.Interceptor
+import okhttp3.Request
+import okhttp3.Response
+import org.json.JSONObject
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicReference
+
+class Error14HandlingInterceptor(private val logger: FastLogger) : Interceptor {
+
+    private companion object {
+        private const val CAPTCHA_ERROR_CODE = 14
+        private const val CAPTCHA_ERROR_KIND = "need_captcha"
+        private val executor = Executors.newSingleThreadExecutor()
+    }
+
+    private val cookie = AtomicReference<String?>(null)
+
+    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 = passCaptchaAndGetToken(redirectUri)
+        return chain.proceed(chain.request().withCookie().withSuccessToken(token))
+    }
+
+    private fun passCaptchaAndGetToken(redirectUri: String): String = synchronized(this) {
+        val tokenResult = AtomicReference<Result<String>>(Result.failure(Exception("No result")))
+
+        executor.submit {
+            AppSettings.setCaptchaRedirectUri(redirectUri)
+            logger.debug(this::class, "passCaptchaAndGetToken: $redirectUri")
+
+            var job: Job? = null
+            job = AppSettings.getCaptchaResultFlow()
+                .listenValue(CoroutineScope(Dispatchers.IO)) {
+                    logger.debug(this::class, "passCaptchaAndGetToken: $it")
+                    if (it != CaptchaTokenResult.Initial) {
+                        synchronized(tokenResult) {
+                            logger.debug(
+                                this::class,
+                                "passCaptchaAndGetToken: SYNCHRONIZED: $it"
+                            )
+                            tokenResult.set(wrapResult(it))
+                            tokenResult.notifyAll()
+                            job?.cancel()
+                            logger.debug(
+                                this::class,
+                                "passCaptchaAndGetToken: NULL RESULT"
+                            )
+                            AppSettings.setCaptchaResult(CaptchaTokenResult.Initial)
+                            AppSettings.setCaptchaRedirectUri(null)
+                        }
+                    }
+                }
+        }
+        synchronized(tokenResult) {
+            if (tokenResult.get().getOrNull() == null) {
+                tokenResult.wait()
+            }
+
+            logger.debug(this::class, "passCaptchaAndGetToken: GET VALUE")
+            tokenResult.get().getOrThrow()
+        }
+    }
+
+    private fun wrapResult(result: CaptchaTokenResult): Result<String> {
+        return when (result) {
+            // TODO: 03/05/2026, Danil Nikolaev: check again?
+            CaptchaTokenResult.Null -> Result.success("")
+
+            CaptchaTokenResult.Cancelled, CaptchaTokenResult.Initial -> Result.success("")
+
+            is CaptchaTokenResult.Success -> Result.success(result.token)
+        }
+    }
+
+    private fun Request.withSuccessToken(token: String): Request {
+        return newBuilder()
+            .url(url.newBuilder().addQueryParameter("success_token", token).build())
+            .build()
+    }
+
+    private fun Response.getRedirectUri(): String? {
+        val responseBody = JSONObject(peekBody(Long.MAX_VALUE).string())
+        return if (responseBody.has("error")) {
+            val stringError = try {
+                responseBody.getString("error")
+            } catch (ignored: Exception) {
+                null
+            }
+
+            if (stringError != null) {
+                if (stringError == CAPTCHA_ERROR_KIND && responseBody.has("redirect_uri")) {
+                    responseBody.getString("redirect_uri")
+                } else {
+                    null
+                }
+            } else {
+                val error = responseBody.getJSONObject("error")
+                if (error.getInt("error_code") == CAPTCHA_ERROR_CODE) {
+                    error.getString("redirect_uri")
+                } else {
+                    null
+                }
+            }
+        } else {
+            null
+        }
+    }
+
+    private fun Request.shouldSkipCaptcha(): Boolean {
+        return false
+//        return !domains.contains(url.toUrl().host) && domains.isNotEmpty()
+    }
+
+    private fun Response.parseCookie() {
+        headers("Set-Cookie").firstOrNull { it.contains("remixstlid") }?.let(cookie::set)
+    }
+
+    private fun Request.withCookie(): Request {
+        return newBuilder().apply { cookie.get()?.let { addHeader("Cookie", it) } }.build()
+    }
+}
+
+@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/ui/build.gradle.kts

@@ -12,6 +12,7 @@ android {
 dependencies {
     api(projects.core.common)
     api(projects.core.model)
+    api(projects.core.logger)
     implementation(projects.core.presentation)
 
     implementation(libs.haze)

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

@@ -0,0 +1,48 @@
+package dev.meloda.fast.ui.common
+
+import androidx.compose.ui.tooling.preview.AndroidUiModes.UI_MODE_NIGHT_YES
+import androidx.compose.ui.tooling.preview.AndroidUiModes.UI_MODE_TYPE_NORMAL
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.Wallpapers.BLUE_DOMINATED_EXAMPLE
+import androidx.compose.ui.tooling.preview.Wallpapers.GREEN_DOMINATED_EXAMPLE
+import androidx.compose.ui.tooling.preview.Wallpapers.RED_DOMINATED_EXAMPLE
+import androidx.compose.ui.tooling.preview.Wallpapers.YELLOW_DOMINATED_EXAMPLE
+
+@Preview(name = "70%", fontScale = 0.70f)
+@Preview(name = "85%", fontScale = 0.85f)
+@Preview(name = "100%", fontScale = 1.0f)
+@Preview(name = "115%", fontScale = 1.15f)
+@Preview(name = "130%", fontScale = 1.3f)
+@Preview(name = "150%", fontScale = 1.5f)
+@Preview(name = "180%", fontScale = 1.8f)
+@Preview(name = "200%", fontScale = 2f)
+
+@Preview(name = "Light")
+@Preview(name = "Red", wallpaper = RED_DOMINATED_EXAMPLE)
+@Preview(name = "Blue", wallpaper = BLUE_DOMINATED_EXAMPLE)
+@Preview(name = "Green", wallpaper = GREEN_DOMINATED_EXAMPLE)
+@Preview(name = "Yellow", wallpaper = YELLOW_DOMINATED_EXAMPLE)
+
+@Preview(name = "Dark", uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL)
+@Preview(
+    name = "Dark Red",
+    uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL,
+    wallpaper = RED_DOMINATED_EXAMPLE
+)
+@Preview(
+    name = "Dark Blue",
+    uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL,
+    wallpaper = BLUE_DOMINATED_EXAMPLE
+)
+@Preview(
+    name = "Dark Green",
+    uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL,
+    wallpaper = GREEN_DOMINATED_EXAMPLE
+)
+@Preview(
+    name = "Dark Yellow",
+    uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL,
+    wallpaper = YELLOW_DOMINATED_EXAMPLE
+)
+
+annotation class FastPreview

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

@@ -0,0 +1,6 @@
+package dev.meloda.fast.ui.common
+
+import androidx.compose.runtime.compositionLocalOf
+import dev.meloda.fast.logger.FastLogger
+
+val LocalLogger = compositionLocalOf { FastLogger.getInstance() }

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

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

core/ui/src/main/kotlin/dev/meloda/fast/ui/components/FastIconButton.kt

@@ -1,6 +1,7 @@
 package dev.meloda.fast.ui.components
 
 import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.Indication
 import androidx.compose.foundation.background
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
@@ -20,6 +21,8 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Shape
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 
 @OptIn(ExperimentalFoundationApi::class, ExperimentalMaterial3ExpressiveApi::class)
@@ -30,27 +33,32 @@ fun FastIconButton(
     onLongClick: (() -> Unit)? = null,
     enabled: Boolean = true,
     colors: IconButtonColors = IconButtonDefaults.iconButtonColors(),
+    containerColor: Color = colors.containerColor(enabled),
+    contentColor: Color = colors.contentColor(enabled),
+    size: Dp = IconButtonTokens.StateLayerSize,
+    shape: Shape = IconButtonTokens.StateLayerShape,
+    alignment: Alignment = Alignment.Center,
     interactionSource: MutableInteractionSource? = null,
+    indication: Indication = ripple(),
     content: @Composable () -> Unit
 ) {
     Box(
         modifier =
             modifier
                 .minimumInteractiveComponentSize()
-                .size(IconButtonTokens.StateLayerSize)
-                .clip(IconButtonTokens.StateLayerShape)
-                .background(color = colors.containerColor(enabled))
+                .size(size)
+                .clip(shape)
+                .background(containerColor)
                 .combinedClickable(
                     onClick = onClick,
                     onLongClick = onLongClick,
                     enabled = enabled,
                     interactionSource = interactionSource,
-                    indication = ripple()
+                    indication = indication
                 ),
-        contentAlignment = Alignment.Center
+        contentAlignment = alignment
     ) {
-        val contentColor = colors.contentColor(enabled)
-        CompositionLocalProvider(LocalContentColor provides contentColor, content = content)
+        CompositionLocalProvider(LocalContentColor provides contentColor) { content() }
     }
 }
 

core/ui/src/main/kotlin/dev/meloda/fast/ui/components/MaterialDialog.kt

@@ -2,6 +2,7 @@ package dev.meloda.fast.ui.components
 
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
@@ -46,9 +47,14 @@ import androidx.compose.ui.layout.onPlaced
 import androidx.compose.ui.res.vectorResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewDynamicColors
+import androidx.compose.ui.tooling.preview.PreviewFontScale
+import androidx.compose.ui.tooling.preview.PreviewLightDark
+import androidx.compose.ui.tooling.preview.PreviewScreenSizes
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.DialogProperties
 import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.common.FastPreview
 import dev.meloda.fast.ui.theme.AppTheme
 import dev.meloda.fast.ui.util.ImmutableList
 import dev.meloda.fast.ui.util.ImmutableList.Companion.toImmutableList
@@ -361,10 +367,10 @@ sealed class SelectionType {
     data object None : SelectionType()
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun MaterialDialogPreview() {
-    AppTheme {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         MaterialDialog(
             onDismissRequest = {},
             title = "Material Dialog",
@@ -376,10 +382,10 @@ private fun MaterialDialogPreview() {
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun MaterialDialogWithListPreview() {
-    AppTheme {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         MaterialDialog(
             onDismissRequest = {},
             title = "Material Dialog",
@@ -393,10 +399,10 @@ private fun MaterialDialogWithListPreview() {
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun MaterialDialogWithCustomContent() {
-    AppTheme {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         MaterialDialog(
             onDismissRequest = {},
             title = "Material Dialog",
@@ -425,10 +431,10 @@ private fun MaterialDialogWithCustomContent() {
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun MaterialDialogWithOnlyCustomContent() {
-    AppTheme {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         MaterialDialog(onDismissRequest = {}) {
             Row(
                 modifier = Modifier

core/ui/src/main/kotlin/dev/meloda/fast/ui/components/NoItemsView.kt

@@ -1,5 +1,6 @@
 package dev.meloda.fast.ui.components
 
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
@@ -8,15 +9,17 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.common.FastPreview
+import dev.meloda.fast.ui.theme.AppTheme
 
 @Composable
 fun NoItemsView(
@@ -49,11 +52,15 @@ fun NoItemsView(
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun NoItemsViewPreview() {
-    NoItemsView(
-        customText = "Nothing here...",
-        buttonText = "Refresh"
-    )
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
+        Surface {
+            NoItemsView(
+                customText = "Nothing here...",
+                buttonText = "Refresh"
+            )
+        }
+    }
 }

core/ui/src/main/kotlin/dev/meloda/fast/ui/components/SegmentedButtons.kt

@@ -0,0 +1,116 @@
+package dev.meloda.fast.ui.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.sizeIn
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.CornerBasedShape
+import androidx.compose.foundation.shape.CornerSize
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.VerticalDivider
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Shape
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import dev.meloda.fast.ui.util.ImmutableList
+
+data class SegmentedButtonItem(
+    val key: String,
+    val iconResId: Int
+)
+
+@Composable
+fun SegmentedButtonsRow(
+    items: ImmutableList<SegmentedButtonItem>,
+    onClick: (index: Int) -> Unit,
+    modifier: Modifier = Modifier,
+    containerShape: CornerBasedShape = RoundedCornerShape(24.dp),
+    containerColor: Color = MaterialTheme.colorScheme.background,
+    borderColor: Color = MaterialTheme.colorScheme.outlineVariant,
+    borderSize: Dp = 1.dp,
+    iconContainerWidth: Dp = 42.dp,
+    iconContainerHeight: Dp = 36.dp,
+    iconSize: Dp = 18.dp,
+    showDividers: Boolean = true
+) {
+    SegmentedButtonsRow(
+        modifier = modifier.sizeIn(maxHeight = iconContainerHeight + borderSize),
+        items = items.mapIndexed { index, item ->
+            {
+                val first = index == 0
+                val last = index == items.lastIndex
+
+                if (showDividers && !first) {
+                    VerticalDivider(modifier = Modifier.padding(vertical = iconContainerHeight / 4))
+                }
+
+                SegmentedButton(
+                    onClick = { onClick(index) },
+                    iconResId = item.iconResId,
+                    modifier = Modifier.size(
+                        iconContainerWidth,
+                        iconContainerHeight
+                    ),
+                    iconSize = iconSize,
+                    shape = containerShape.copy(
+                        topStart = if (!first) CornerSize(0.dp) else containerShape.topStart,
+                        bottomStart = if (!first) CornerSize(0.dp) else containerShape.bottomStart,
+                        topEnd = if (!last) CornerSize(0.dp) else containerShape.topEnd,
+                        bottomEnd = if (!last) CornerSize(0.dp) else containerShape.bottomEnd
+                    )
+                )
+            }
+        },
+        containerShape = containerShape,
+        containerColor = containerColor,
+        borderColor = borderColor,
+        borderSize = borderSize
+    )
+}
+
+@Composable
+fun SegmentedButtonsRow(
+    items: ImmutableList<@Composable () -> Unit>,
+    modifier: Modifier = Modifier,
+    containerShape: CornerBasedShape = RoundedCornerShape(24.dp),
+    containerColor: Color = MaterialTheme.colorScheme.background,
+    borderColor: Color = MaterialTheme.colorScheme.outlineVariant,
+    borderSize: Dp = 1.dp,
+) {
+    Row(
+        modifier = modifier
+            .background(containerColor, containerShape)
+            .border(borderSize, borderColor, containerShape)
+    ) {
+        items.forEach { it.invoke() }
+    }
+}
+
+@Composable
+fun SegmentedButton(
+    onClick: () -> Unit,
+    iconResId: Int,
+    modifier: Modifier = Modifier,
+    iconSize: Dp = 18.dp,
+    shape: Shape = CircleShape
+) {
+    FastIconButton(
+        onClick = onClick,
+        modifier = modifier,
+        shape = shape
+    ) {
+        Icon(
+            modifier = Modifier.size(iconSize),
+            painter = painterResource(iconResId),
+            contentDescription = null
+        )
+    }
+}

core/ui/src/main/kotlin/dev/meloda/fast/ui/extensions/SharedViewModel.kt

@@ -9,6 +9,7 @@ import org.koin.androidx.compose.koinViewModel
 import org.koin.core.parameter.ParametersDefinition
 import org.koin.core.qualifier.Qualifier
 
+@Suppress("ParamsComparedByRef")
 @Composable
 inline fun <reified T : ViewModel> NavBackStackEntry.sharedViewModel(
     navController: NavController,

core/ui/src/main/kotlin/dev/meloda/fast/ui/theme/AppTheme.kt

@@ -58,7 +58,7 @@ fun AppTheme(
 ) {
     val context = LocalContext.current
 
-    val colorScheme: ColorScheme = when {
+    val colorScheme: ColorScheme = predefinedColorScheme ?: when {
         useDynamicColors && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
             if (useDarkTheme) dynamicDarkColorScheme(context)
             else dynamicLightColorScheme(context)
@@ -82,10 +82,6 @@ fun AppTheme(
         }
     }
 
-    val colorPrimary by animateColorAsState(colorScheme.primary)
-    val colorSurface by animateColorAsState(colorScheme.surface)
-    val colorBackground by animateColorAsState(colorScheme.background)
-
     val typography = if (useSystemFont) {
         MaterialTheme.typography
     } else {
@@ -118,12 +114,7 @@ fun AppTheme(
     }
 
     MaterialExpressiveTheme(
-        colorScheme = (predefinedColorScheme ?: colorScheme)
-            .copy(
-                primary = colorPrimary,
-                background = colorBackground,
-                surface = colorSurface
-            ),
+        colorScheme = colorScheme,
         typography = typography,
         content = content
     )

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 =

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

@@ -1,6 +1,7 @@
 package dev.meloda.fast.ui.util
 
 import androidx.compose.runtime.Immutable
+import dev.meloda.fast.ui.util.ImmutableList.Companion.toImmutableList
 
 @Immutable
 class ImmutableList<T>(val values: List<T>) : Collection<T> {
@@ -9,10 +10,6 @@ class ImmutableList<T>(val values: List<T>) : Collection<T> {
 
     operator fun get(index: Int): T = values[index]
 
-    inline fun forEach(action: (T) -> Unit) {
-        for (element in values) action(element)
-    }
-
     inline fun <R> map(transform: (T) -> R): ImmutableList<R> {
         return values.map(transform).toImmutableList()
     }
@@ -49,6 +46,8 @@ class ImmutableList<T>(val values: List<T>) : Collection<T> {
             if (elements.isNotEmpty()) copyOf(elements.asList()) else empty()
 
         fun <T> of(element: T) = ImmutableList(listOf(element))
+
+        fun <T> ImmutableList<T>?.orEmpty(): ImmutableList<T> = this ?: emptyImmutableList()
     }
 
     override fun iterator(): Iterator<T> = values.listIterator()
@@ -60,4 +59,8 @@ fun <T> emptyImmutableList(): ImmutableList<T> = ImmutableList(emptyList())
 
 fun <T> immutableListOf(vararg elements: T) = ImmutableList(listOf(elements = elements))
 
-fun <T> ImmutableList<T>?.orEmpty(): ImmutableList<T> = this ?: emptyImmutableList()
+inline fun <T> buildImmutableList(builderAction: MutableList<T>.() -> Unit): ImmutableList<T> {
+    val mutableList = mutableListOf<T>()
+    mutableList.apply(builderAction)
+    return mutableList.toImmutableList()
+}

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

@@ -232,8 +232,10 @@
     <string name="month_short">М</string>
     <string name="week_short">Н</string>
     <string name="day_short">Д</string>
+    <string name="second_short">С</string>
     <string name="time_now">Сейчас</string>
 
     <string name="confirm_chat_create_with_title">Вы действительно хотите создать чат «%s»?</string>
     <string name="confirm_chat_create_empty_with_title">Вы действительно хотите создать чат «%s» только с собой?</string>
+    <string name="minute_short">М</string>
 </resources>

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

@@ -1,4 +1,4 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
+<resources>
     <string name="app_name" translatable="false">Fast</string>
     <string name="fast_messenger" translatable="false">Fast Messenger</string>
 
@@ -88,6 +88,7 @@
     <string name="message_attachments_video_message">Video message</string>
     <string name="message_attachments_group_sticker">Group sticker</string>
     <string name="message_attachments_sticker_pack_preview">Sticker pack preview</string>
+    <string name="message_attachments_channel_message">Channel message</string>
 
     <string name="chat_interaction_uploading_file">Uploading file</string>
     <string name="chat_interaction_uploading_photo">Uploading photo</string>
@@ -188,6 +189,7 @@
     <string name="title_application_language">Application language</string>
     <string name="action_refresh">Refresh</string>
     <string name="title_loading">Loading&#8230;</string>
+    <string name="title_no_network">No network&#8230;</string>
     <string name="title_convos">Conversations</string>
     <string name="title_archive">Archive</string>
     <string name="title_friends">Friends</string>
@@ -297,8 +299,15 @@
     <string name="month_short">M</string>
     <string name="week_short">W</string>
     <string name="day_short">D</string>
+    <string name="minute_short">M</string>
+    <string name="second_short">S</string>
     <string name="time_now">Now</string>
 
     <string name="confirm_chat_create_with_title">Are you sure you want to create chat «%s»?</string>
     <string name="confirm_chat_create_empty_with_title">Are you sure you want to create chat «%s» only with yourself?</string>
+
+    <string name="title_edit_message">Edit message</string>
+    <string name="action_close">Close</string>
+    <string name="action_hide_stacktrace">Hide stacktrace</string>
+    <string name="action_show_stacktrace">Show stacktrace</string>
 </resources>

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

@@ -2,4 +2,13 @@
 <resources>
 
     <style name="AppTheme" parent="Theme.AppCompat.DayNight.NoActionBar" />
+
+    <style name="CrashDialogTheme" parent="Theme.AppCompat.DayNight.NoActionBar">
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowContentOverlay">@null</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="android:windowIsFloating">true</item>
+        <item name="android:backgroundDimEnabled">false</item>
+    </style>
 </resources>

feature/auth/src/androidTest/kotlin/dev/meloda/fast/auth/login/LogoScreenTest.kt

@@ -3,7 +3,6 @@ package dev.meloda.fast.auth.login
 import androidx.compose.ui.test.assertHasClickAction
 import androidx.compose.ui.test.junit4.createComposeRule
 import androidx.compose.ui.test.onNodeWithTag
-import dev.meloda.fast.auth.login.presentation.LogoScreen
 import org.junit.Rule
 import org.junit.Test
 
@@ -15,7 +14,7 @@ class LogoScreenTest {
     @Test
     fun goNextButton_isClickable() {
         composeTestRule.setContent {
-            LogoScreen()
+
         }
 
         composeTestRule.onNodeWithTag(testTag = "go_next_fab").assertHasClickAction()