Update README.md

- Implement `VkChannelMessage` domain and data models for channel message attachments
- Add `CHANNEL_MESSAGE` to `AttachmentType` and map it to relevant UI resources and strings
- Refactor `Sticker` and `Gift` composables to accept URL strings instead of domain objects for better decoupling
- Simplify `AppTheme` by removing redundant color animations and passing the color scheme directly to `MaterialExpressiveTheme`
- Update `LoginScreen` to include a theme toggle (classic vs. light) and improve back-button behavior by resetting error states
- Bump VK API version from 5.238 to 5.263
- Adjust layout and padding for sticker and gift attachment previews

.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

@@ -1,10 +1,10 @@
 name: Android CI Build
 
 on:
-  push:
-    branches: [ "dev", "release/*", "hotfix/*" ]
-  pull_request:
-    branches: [ "dev", "release/*", "hotfix/*" ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
 
 env:
   KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
@@ -12,15 +12,15 @@ env:
   RELEASE_SIGN_KEY_PASSWORD: ${{ secrets.RELEASE_SIGN_KEY_PASSWORD }}
 
 jobs:
-  build_apk_aab:
+  build_apks:
     runs-on: ubuntu-24.04
     name: Build artifacts
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: set up JDK 21
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           java-version: '21'
           distribution: 'temurin'
@@ -29,20 +29,34 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
 
-      - name: Build and sign debug APK
-        run: ./gradlew assembleDebug
-
-      - name: Upload debug APK
-        uses: actions/upload-artifact@v4
-        with:
-          name: app-debug.apk
-          path: app/build/outputs/apk/debug/app-debug.apk
-
       - name: Build and sign release APK
         run: ./gradlew assembleRelease
 
-      - name: Upload release APK
-        uses: actions/upload-artifact@v4
+      - 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" >> $GITHUB_ENV
+          echo "APK_NAME=$(basename $APK_PATH)" >> $GITHUB_ENV
+
+      - name: Upload APK with original name
+        uses: actions/upload-artifact@v7
         with:
-          name: app-release.apk
-          path: app/build/outputs/apk/release/app-release.apk
+          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" >> $GITHUB_ENV
+            echo "APK_NAME=$(basename $APK_PATH)" >> $GITHUB_ENV
+
+      - name: Upload APK with original name
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ env.APK_NAME }}
+          path: ${{ env.APK_PATH }}

.github/workflows/create_release.yml

@@ -1,8 +1,11 @@
 name: Android CI Release
+permissions:
+  contents: read
 
 on:
-  pull_request:
-    branches: [ "master" ]
+  workflow_dispatch:
+  push:
+    branches: [ "release/*"]
 
 env:
   KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
@@ -15,10 +18,10 @@ jobs:
     name: Build artifacts
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: set up JDK 21
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           java-version: '21'
           distribution: 'temurin'
@@ -27,38 +30,20 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
 
-      - name: Build and sign debug APK
-        run: ./gradlew assembleDebug
-
-      - name: Upload debug APK
-        uses: actions/upload-artifact@v4
-        with:
-          name: app-debug.apk
-          path: app/build/outputs/apk/debug/app-debug.apk
-
       - name: Build and sign release APK
         run: ./gradlew assembleRelease
 
       - name: Upload release APK
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: app-release.apk
           path: app/build/outputs/apk/release/app-release.apk
 
-      - name: Build and sign debug Bundle
-        run: ./gradlew bundleDebug
-
-      - name: Upload debug Bundle
-        uses: actions/upload-artifact@v4
-        with:
-          name: app-debug.aab
-          path: app/build/outputs/bundle/debug/app-debug.aab
-
       - name: Build and sign release Bundle
         run: ./gradlew bundleRelease
 
       - name: Upload release Bundle
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: app-release.aab
           path: app/build/outputs/bundle/release/app-release.aab

README.md

@@ -7,15 +7,17 @@ Unofficial messenger for russian social network VKontakte
     - [x] 2FA support
         - [x] Resend otp
     - [x] Captcha support
-    - [ ] Support for new authorization with service and refresh tokens
+    - [x] Support for new authorization with service and refresh tokens
+    - [ ] Handle token expiration
+    - [x] Ability to export/import tokens
 - [x] Conversations list
     - [x] Pagination
     - [x] Manual refresh
     - [x] Pin & unpin conversations
     - [x] Delete conversations
-    - [ ] Archive
-        - [ ] View archived conversations
-        - [ ] Archive & unarchive conversations
+    - [x] Archive
+        - [x] View archived conversations
+        - [x] Archive & unarchive conversations
 - [x] Friends list
     - [x] Sort alphabetically, by priority or random
     - [x] Separate tab with only friends who are online
@@ -30,17 +32,25 @@ Unofficial messenger for russian social network VKontakte
         - [x] Read status
         - [x] Edit status
         - [x] Sending status
-        - [ ] Message's attachments
-            - [ ] Photo
-            - [ ] Video
-            - [ ] Audio
-            - [ ] File
-            - [ ] Link
+        - [x] Message's attachments
+            - [x] Photo
+            - [x] Video
+            - [x] Audio
+            - [x] File
+            - [x] Link
+            - [x] Sticker
+            - [x] Reply
+            - [ ] Forwarded messages
+            - [ ] Wall post
+            - [ ] Comment in wall post
+            - [ ] Comment in channel
+            - [ ] Poll
             - [ ] TODO
     - [x] Send messages
     - [x] Pinned message
     - [x] Pin & unpin messages
-    - [ ] Reply to message
+    - [x] Reply to message
+    - [x] Swipe to reply to message
     - [x] Delete message
     - [x] Select multiple messages
         - [x] Delete
@@ -55,7 +65,7 @@ Unofficial messenger for russian social network VKontakte
     - [x] View attachments
         - [x] Open photo
             - [x] Internal viewer
-            - [ ] External viewer
+            - [x] External viewer
         - [ ] Open video in external player
         - [ ] TODO
 - [ ] Caching

app/build.gradle.kts

@@ -1,3 +1,4 @@
+import com.android.build.gradle.internal.api.BaseVariantOutputImpl
 import java.util.Properties
 
 plugins {
@@ -12,8 +13,8 @@ android {
     defaultConfig {
         applicationId = "dev.meloda.fastvk"
 
-        versionCode = libs.versions.versionCode.get().toInt()
-        versionName = libs.versions.versionName.get()
+        versionCode = 11
+        versionName = "0.2.3"
     }
 
     signingConfigs {
@@ -46,7 +47,7 @@ android {
             applicationIdSuffix = ".debug"
         }
         named("release") {
-            signingConfig = signingConfigs.getByName("release")
+            signingConfig = signingConfigs.getByName("debugSigning")
 
             isMinifyEnabled = true
             isShrinkResources = true
@@ -58,6 +59,18 @@ android {
         }
     }
 
+//    applicationVariants.all {
+//        outputs.all {
+//            val date = System.currentTimeMillis() / 1000
+//            val buildType = buildType.name
+//            val appVersion = versionName
+//            val appVersionCode = versionCode
+//
+//            val newApkName = "app-$buildType-v$appVersion($appVersionCode)-$date.apk"
+//            (this as? BaseVariantOutputImpl)?.outputFileName = newApkName
+//        }
+//    }
+
     packaging {
         resources {
             excludes += "/META-INF/{AL2.0,LGPL2.1}"
@@ -66,10 +79,13 @@ android {
 }
 
 dependencies {
+    implementation(libs.acra.email)
+    implementation(libs.acra.dialog)
+
     implementation(projects.feature.auth)
 
     implementation(projects.feature.chatmaterials)
-    implementation(projects.feature.conversations)
+    implementation(projects.feature.convos)
     implementation(projects.feature.languagepicker)
     implementation(projects.feature.messageshistory)
     implementation(projects.feature.photoviewer)

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

@@ -4,8 +4,14 @@ import android.app.Application
 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 org.acra.config.dialog
+import org.acra.config.mailSender
+import org.acra.data.StringFormat
+import org.acra.ktx.initAcra
 import org.koin.android.ext.android.get
 import org.koin.android.ext.koin.androidContext
 import org.koin.android.ext.koin.androidLogger
@@ -18,10 +24,14 @@ class AppGlobal : Application(), ImageLoaderFactory {
 
         val preferences = PreferenceManager.getDefaultSharedPreferences(this)
         AppSettings.init(preferences)
+        ComposeStabilityAnalyzer.setEnabled(BuildConfig.DEBUG)
 
         initKoin()
+        initAcra()
     }
 
+    override fun newImageLoader(): ImageLoader = get()
+
     private fun initKoin() {
         startKoin {
             androidLogger()
@@ -30,5 +40,21 @@ class AppGlobal : Application(), ImageLoaderFactory {
         }
     }
 
-    override fun newImageLoader(): ImageLoader = get()
+    private fun initAcra() {
+        initAcra {
+            buildConfigClass = BuildConfig::class.java
+            reportFormat = StringFormat.JSON
+
+            mailSender {
+                mailTo = "lischenkodev@gmail.com"
+                reportAsFile = true
+                reportFileName = "Crash.txt"
+            }
+
+            dialog {
+                text = "App crashed"
+                enabled = true
+            }
+        }
+    }
 }

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

@@ -5,18 +5,17 @@ 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.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.provider.Provider
 import dev.meloda.fast.common.provider.ResourceProvider
 import dev.meloda.fast.common.provider.ResourceProviderImpl
-import dev.meloda.fast.conversations.di.conversationsModule
-import dev.meloda.fast.conversations.di.createChatModule
+import dev.meloda.fast.convos.di.convosModule
+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
@@ -33,13 +32,12 @@ import org.koin.core.qualifier.qualifier
 import org.koin.dsl.bind
 import org.koin.dsl.module
 
+@OptIn(ExperimentalCoilApi::class)
 val applicationModule = module {
     includes(domainModule)
     includes(
-        loginModule,
-        validationModule,
-        captchaModule,
-        conversationsModule,
+        authModule,
+        convosModule,
         settingsModule,
         messagesHistoryModule,
         photoViewModule,
@@ -66,6 +64,7 @@ val applicationModule = module {
         ImageLoader.Builder(get())
             .crossfade(true)
             .build()
+            .also { it.diskCache?.directory?.toFile()?.listFiles() }
     }
 
     singleOf(::LongPollControllerImpl) bind LongPollController::class

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

@@ -2,15 +2,15 @@ package dev.meloda.fast.navigation
 
 import androidx.navigation.NavGraphBuilder
 import androidx.navigation.compose.composable
-import dev.meloda.fast.conversations.navigation.ConversationsGraph
+import dev.meloda.fast.convos.navigation.ConvoGraph
 import dev.meloda.fast.friends.navigation.Friends
 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 as UiR
 
 @Serializable
 object MainGraph
@@ -21,28 +21,28 @@ object Main
 fun NavGraphBuilder.mainScreen(
     onError: (BaseError) -> Unit,
     onSettingsButtonClicked: () -> Unit,
-    onNavigateToMessagesHistory: (conversationId: Long) -> Unit,
+    onNavigateToMessagesHistory: (convoId: Long) -> Unit,
     onPhotoClicked: (url: String) -> Unit,
     onMessageClicked: (userid: Long) -> Unit,
     onNavigateToCreateChat: () -> Unit
 ) {
     val navigationItems = ImmutableList.of(
         BottomNavigationItem(
-            titleResId = UiR.string.title_friends,
-            selectedIconResId = UiR.drawable.baseline_people_alt_24,
-            unselectedIconResId = UiR.drawable.outline_people_alt_24,
+            titleResId = R.string.title_friends,
+            selectedIconResId = R.drawable.ic_group_fill_round_24,
+            unselectedIconResId = R.drawable.ic_group_round_24,
             route = Friends,
         ),
         BottomNavigationItem(
-            titleResId = UiR.string.title_conversations,
-            selectedIconResId = UiR.drawable.baseline_chat_24,
-            unselectedIconResId = UiR.drawable.outline_chat_24,
-            route = ConversationsGraph
+            titleResId = R.string.title_convos,
+            selectedIconResId = R.drawable.ic_mail_fill_round_24,
+            unselectedIconResId = R.drawable.ic_mail_round_24,
+            route = ConvoGraph
         ),
         BottomNavigationItem(
-            titleResId = UiR.string.title_profile,
-            selectedIconResId = UiR.drawable.baseline_account_circle_24,
-            unselectedIconResId = UiR.drawable.outline_account_circle_24,
+            titleResId = R.string.title_profile,
+            selectedIconResId = R.drawable.ic_account_circle_fill_round_24,
+            unselectedIconResId = R.drawable.ic_account_circle_round_24,
             route = Profile
         )
     )

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

@@ -4,7 +4,6 @@ import android.Manifest
 import android.annotation.SuppressLint
 import android.app.NotificationChannel
 import android.app.NotificationManager
-import android.content.Context
 import android.content.Intent
 import android.content.res.Configuration
 import android.os.Build
@@ -15,44 +14,20 @@ import androidx.activity.SystemBarStyle
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.platform.LocalContext
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.compose.LifecycleResumeEffect
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.conena.nanokt.android.content.pxToDp
 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.common.AppConstants
-import dev.meloda.fast.common.LongPollController
-import dev.meloda.fast.common.model.LongPollState
 import dev.meloda.fast.datastore.AppSettings
-import dev.meloda.fast.datastore.UserSettings
-import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.service.OnlineService
 import dev.meloda.fast.service.longpolling.LongPollingService
-import dev.meloda.fast.ui.model.DeviceSize
-import dev.meloda.fast.ui.model.SizeConfig
-import dev.meloda.fast.ui.model.ThemeConfig
-import dev.meloda.fast.ui.theme.AppTheme
-import dev.meloda.fast.ui.theme.LocalSizeConfig
-import dev.meloda.fast.ui.theme.LocalThemeConfig
-import dev.meloda.fast.ui.theme.LocalUser
-import dev.meloda.fast.ui.util.isNeedToEnableDarkMode
+import dev.meloda.fast.ui.R
 import org.koin.androidx.compose.koinViewModel
-import org.koin.compose.KoinContext
-import org.koin.compose.koinInject
-import dev.meloda.fast.ui.R as UiR
 
 class MainActivity : AppCompatActivity() {
 
@@ -89,177 +64,33 @@ class MainActivity : AppCompatActivity() {
         requestNotificationPermissions()
 
         setContent {
-            KoinContext {
-                val context = LocalContext.current
-
-                val userSettings: UserSettings = koinInject()
-                val longPollController: LongPollController = koinInject()
-
-                val longPollCurrentState by longPollController.currentState.collectAsStateWithLifecycle()
-                val longPollStateToApply by longPollController.stateToApply.collectAsStateWithLifecycle()
-
             val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
-
-                val currentUser: VkUser? by viewModel.currentUser.collectAsStateWithLifecycle()
+            LaunchedEffect(viewModel) {
+                Log.d("VM_CREATE", "onCreate: viewModel: $viewModel")
+            }
 
             LifecycleResumeEffect(true) {
                 viewModel.onAppResumed(intent)
                 onPauseOrDispose {}
             }
 
-                val permissionState =
-                    rememberPermissionState(permission = Manifest.permission.POST_NOTIFICATIONS)
-
-                val isNeedToCheckPermission by viewModel.isNeedToCheckNotificationsPermission.collectAsStateWithLifecycle()
-                val isNeedToRequestPermission by viewModel.isNeedToRequestNotifications.collectAsStateWithLifecycle()
-
-                LaunchedEffect(isNeedToCheckPermission) {
-                    if (isNeedToCheckPermission) {
-                        viewModel.onPermissionCheckStatus(permissionState.status)
-
-                        if (permissionState.status.isGranted) {
-                            if (longPollCurrentState == LongPollState.InApp) {
-                                toggleLongPollService(false)
-                            }
-
+            RootScreen(
+                toggleLongPollService = { enable, inBackground ->
                     toggleLongPollService(
-                                enable = true,
-                                inBackground = true
+                        enable = enable,
+                        inBackground = inBackground ?: AppSettings.Experimental.longPollInBackground
                     )
-                        }
-                    }
-                }
-
-                LaunchedEffect(isNeedToRequestPermission) {
-                    if (isNeedToRequestPermission) {
-                        viewModel.onPermissionsRequested()
-                        permissionState.launchPermissionRequest()
-                    }
-                }
-
-                LifecycleResumeEffect(longPollStateToApply) {
-                    Log.d("LongPollMainActivity", "longPollStateToApply: $longPollStateToApply")
-                    if (longPollStateToApply != LongPollState.Background) {
-                        if (longPollStateToApply.isLaunched() && longPollCurrentState.isLaunched()
-                            && longPollCurrentState != longPollStateToApply
-                        ) {
-                            toggleLongPollService(false)
-                            Log.d("LongPoll", "recreate()")
-                        }
-
-                        toggleLongPollService(
-                            enable = longPollStateToApply.isLaunched(),
-                            inBackground = longPollStateToApply == LongPollState.Background
+                },
+                toggleOnlineService = ::toggleOnlineService
             )
         }
-
-                    onPauseOrDispose {}
-                }
-
-                val sendOnline by userSettings.sendOnlineStatus.collectAsStateWithLifecycle()
-                LifecycleResumeEffect(sendOnline) {
-                    toggleOnlineService(sendOnline)
-
-                    onPauseOrDispose {
-                        toggleOnlineService(false)
-                    }
-                }
-
-                val deviceWidthDp = remember(true) {
-                    context.resources.displayMetrics.widthPixels.pxToDp()
-                }
-                val deviceHeightDp = remember(true) {
-                    context.resources.displayMetrics.heightPixels.pxToDp()
-                }
-
-                val deviceWidthSize by remember(deviceWidthDp) {
-                    derivedStateOf {
-                        when {
-                            deviceWidthDp <= 360 -> DeviceSize.Small
-                            deviceWidthDp <= 600 -> DeviceSize.Compact
-                            deviceWidthDp <= 840 -> DeviceSize.Medium
-                            else -> DeviceSize.Expanded
-                        }
-                    }
-                }
-
-                val deviceHeightSize by remember(deviceHeightDp) {
-                    derivedStateOf {
-                        when {
-                            deviceHeightDp <= 480 -> DeviceSize.Small
-                            deviceHeightDp <= 700 -> DeviceSize.Compact
-                            deviceHeightDp <= 900 -> DeviceSize.Medium
-                            else -> DeviceSize.Expanded
-                        }
-                    }
-                }
-
-                val sizeConfig by remember(deviceWidthSize, deviceHeightSize) {
-                    mutableStateOf(
-                        SizeConfig(
-                            widthSize = deviceWidthSize,
-                            heightSize = deviceHeightSize
-                        )
-                    )
-                }
-
-                val darkMode by userSettings.darkMode.collectAsStateWithLifecycle()
-                val dynamicColors by userSettings.enableDynamicColors.collectAsStateWithLifecycle()
-                val amoledDark by userSettings.enableAmoledDark.collectAsStateWithLifecycle()
-                val enableBlur by userSettings.useBlur.collectAsStateWithLifecycle()
-                val enableMultiline by userSettings.enableMultiline.collectAsStateWithLifecycle()
-                val useSystemFont by userSettings.useSystemFont.collectAsStateWithLifecycle()
-                val enableAnimations by userSettings.enableAnimations.collectAsStateWithLifecycle()
-
-                val setDarkMode = isNeedToEnableDarkMode(darkMode = darkMode)
-
-                val themeConfig by remember(
-                    darkMode,
-                    dynamicColors,
-                    amoledDark,
-                    enableBlur,
-                    enableMultiline,
-                    setDarkMode,
-                    useSystemFont
-                ) {
-                    derivedStateOf {
-                        ThemeConfig(
-                            darkMode = setDarkMode,
-                            dynamicColors = dynamicColors,
-                            selectedColorScheme = 0,
-                            amoledDark = amoledDark,
-                            enableBlur = enableBlur,
-                            enableMultiline = enableMultiline,
-                            useSystemFont = useSystemFont,
-                            enableAnimations = enableAnimations
-                        )
-                    }
-                }
-
-                CompositionLocalProvider(
-                    LocalThemeConfig provides themeConfig,
-                    LocalSizeConfig provides sizeConfig,
-                    LocalUser provides currentUser
-                ) {
-                    AppTheme(
-                        useDarkTheme = themeConfig.darkMode,
-                        useDynamicColors = themeConfig.dynamicColors,
-                        selectedColorScheme = themeConfig.selectedColorScheme,
-                        useAmoledBackground = themeConfig.amoledDark,
-                        useSystemFont = themeConfig.useSystemFont
-                    ) {
-                        RootScreen(viewModel = viewModel)
-                    }
-                }
-            }
-        }
     }
 
     private fun createNotificationChannels() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val noCategoryName = getString(UiR.string.notification_channel_no_category_name)
+            val noCategoryName = getString(R.string.notification_channel_no_category_name)
             val noCategoryDescriptionText =
-                getString(UiR.string.notification_channel_no_category_description)
+                getString(R.string.notification_channel_no_category_description)
             val noCategoryChannel =
                 NotificationChannel(
                     AppConstants.NOTIFICATION_CHANNEL_UNCATEGORIZED,
@@ -269,9 +100,9 @@ class MainActivity : AppCompatActivity() {
                     description = noCategoryDescriptionText
                 }
 
-            val longPollName = getString(UiR.string.notification_channel_long_polling_service_name)
+            val longPollName = getString(R.string.notification_channel_long_polling_service_name)
             val longPollDescriptionText =
-                getString(UiR.string.notification_channel_long_polling_service_description)
+                getString(R.string.notification_channel_long_polling_service_description)
             val longPollChannel =
                 NotificationChannel(
                     AppConstants.NOTIFICATION_CHANNEL_LONG_POLLING,
@@ -282,7 +113,7 @@ class MainActivity : AppCompatActivity() {
                 }
 
             val notificationManager: NotificationManager =
-                getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+                getSystemService(NOTIFICATION_SERVICE) as NotificationManager
 
             notificationManager.createNotificationChannels(
                 listOf(

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

@@ -1,5 +1,8 @@
 package dev.meloda.fast.presentation
 
+import androidx.activity.compose.BackHandler
+import androidx.activity.compose.LocalActivity
+import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
@@ -15,7 +18,6 @@ import androidx.compose.material3.NavigationBarItem
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
@@ -36,8 +38,8 @@ 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.conversations.navigation.Conversations
-import dev.meloda.fast.conversations.navigation.conversationsGraph
+import dev.meloda.fast.convos.navigation.ConvoGraph
+import dev.meloda.fast.convos.navigation.convosGraph
 import dev.meloda.fast.friends.navigation.Friends
 import dev.meloda.fast.friends.navigation.friendsScreen
 import dev.meloda.fast.model.BaseError
@@ -58,30 +60,35 @@ fun MainScreen(
     navigationItems: ImmutableList<BottomNavigationItem>,
     onError: (BaseError) -> Unit = {},
     onSettingsButtonClicked: () -> Unit = {},
-    onNavigateToMessagesHistory: (conversationId: Long) -> Unit = {},
+    onNavigateToMessagesHistory: (convoId: Long) -> Unit = {},
     onPhotoClicked: (url: String) -> Unit = {},
     onMessageClicked: (userid: Long) -> Unit = {},
     onNavigateToCreateChat: () -> Unit = {}
 ) {
+    val activity = LocalActivity.current as? AppCompatActivity ?: return
     val theme = LocalThemeConfig.current
-    val hazeState = remember { HazeState() }
+    val hazeState = remember { HazeState(true) }
     val navController = rememberNavController()
 
     var selectedItemIndex by rememberSaveable {
         mutableIntStateOf(1)
     }
 
-    val user = LocalUser.current
-    val profileImageUrl by remember(user) {
-        derivedStateOf { user?.photo100 }
+    BackHandler(enabled = selectedItemIndex != 1) {
+        val currentRoute = navigationItems[selectedItemIndex].route
+
+        selectedItemIndex = 1
+        navController.navigate(navigationItems[selectedItemIndex].route) {
+            popUpTo(route = currentRoute) {
+                inclusive = true
+            }
+        }
     }
 
+    val profileImageUrl = LocalUser.current?.photo100
+
     var tabReselected by remember {
-        mutableStateOf(
-            navigationItems.associate {
-                it.route to false
-            }
-        )
+        mutableStateOf(navigationItems.associate { it.route to false })
     }
 
     Scaffold(
@@ -93,7 +100,7 @@ fun MainScreen(
                         if (theme.enableBlur) {
                             Modifier.hazeEffect(
                                 state = hazeState,
-                                style = HazeMaterials.thick()
+                                style = HazeMaterials.regular(NavigationBarDefaults.containerColor)
                             )
                         } else Modifier
                     ),
@@ -180,6 +187,7 @@ fun MainScreen(
                         exitTransition = { fadeOut(animationSpec = tween(200)) }
                     ) {
                         friendsScreen(
+                            activity = activity,
                             onError = onError,
                             onPhotoClicked = onPhotoClicked,
                             onMessageClicked = onMessageClicked,
@@ -189,17 +197,19 @@ fun MainScreen(
                                 }
                             },
                         )
-                        conversationsGraph(
+                        convosGraph(
+                            activity = activity,
                             onError = onError,
                             onNavigateToMessagesHistory = onNavigateToMessagesHistory,
                             onNavigateToCreateChat = onNavigateToCreateChat,
                             onScrolledToTop = {
                                 tabReselected = tabReselected.toMutableMap().also {
-                                    it[Conversations] = false
+                                    it[ConvoGraph] = false
                                 }
                             }
                         )
                         profileScreen(
+                            activity = activity,
                             onError = onError,
                             onSettingsButtonClicked = onSettingsButtonClicked,
                             onPhotoClicked = onPhotoClicked

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

@@ -1,52 +1,243 @@
 package dev.meloda.fast.presentation
 
+import android.Manifest
 import android.content.Intent
 import android.net.Uri
 import android.provider.Settings
+import android.util.Log
+import androidx.activity.compose.LocalActivity
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalResources
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.window.DialogProperties
+import androidx.lifecycle.compose.LifecycleResumeEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.rememberNavController
+import com.conena.nanokt.android.content.pxToDp
+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.conversations.navigation.createChatScreen
-import dev.meloda.fast.conversations.navigation.navigateToCreateChat
+import dev.meloda.fast.common.LongPollController
+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
 import dev.meloda.fast.messageshistory.navigation.messagesHistoryScreen
 import dev.meloda.fast.messageshistory.navigation.navigateToMessagesHistory
+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.navigation.navigateToPhotoView
-import dev.meloda.fast.photoviewer.navigation.photoViewScreen
+import dev.meloda.fast.photoviewer.presentation.PhotoViewDialog
 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.LocalSizeConfig
+import dev.meloda.fast.ui.model.DeviceSize
+import dev.meloda.fast.ui.model.SizeConfig
+import dev.meloda.fast.ui.model.ThemeConfig
+import dev.meloda.fast.ui.theme.AppTheme
 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.Companion.toImmutableList
+import dev.meloda.fast.ui.util.isNeedToEnableDarkMode
+import org.koin.androidx.compose.koinViewModel
+import org.koin.compose.koinInject
 
+@OptIn(ExperimentalPermissionsApi::class)
 @Composable
 fun RootScreen(
-    navController: NavHostController = rememberNavController(),
-    viewModel: MainViewModel
+    toggleLongPollService: (enable: Boolean, inBackground: Boolean?) -> Unit,
+    toggleOnlineService: (enable: Boolean) -> Unit
 ) {
+    val resources = LocalResources.current
+
+    val userSettings: UserSettings = koinInject()
+    val longPollController: LongPollController = koinInject()
+
+    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 currentUser: VkUser? by viewModel.currentUser.collectAsStateWithLifecycle()
+
+    val permissionState =
+        rememberPermissionState(permission = Manifest.permission.POST_NOTIFICATIONS)
+
+    val isNeedToCheckPermission by viewModel.isNeedToCheckNotificationsPermission.collectAsStateWithLifecycle()
+    val isNeedToRequestPermission by viewModel.isNeedToRequestNotifications.collectAsStateWithLifecycle()
+
+    LaunchedEffect(isNeedToCheckPermission) {
+        if (isNeedToCheckPermission) {
+            viewModel.onPermissionCheckStatus(permissionState.status)
+
+            if (permissionState.status.isGranted) {
+                if (longPollCurrentState == LongPollState.InApp) {
+                    toggleLongPollService(false, null)
+                }
+
+                toggleLongPollService(true, true)
+            }
+        }
+    }
+
+    LaunchedEffect(isNeedToRequestPermission) {
+        if (isNeedToRequestPermission) {
+            viewModel.onPermissionsRequested()
+            permissionState.launchPermissionRequest()
+        }
+    }
+
+    LifecycleResumeEffect(longPollStateToApply) {
+        Log.d("LongPollMainActivity", "longPollStateToApply: $longPollStateToApply")
+        if (longPollStateToApply != LongPollState.Background) {
+            if (longPollStateToApply.isLaunched() && longPollCurrentState.isLaunched()
+                && longPollCurrentState != longPollStateToApply
+            ) {
+                toggleLongPollService(false, null)
+                Log.d("LongPoll", "recreate()")
+            }
+
+            toggleLongPollService(
+                longPollStateToApply.isLaunched(),
+                longPollStateToApply == LongPollState.Background
+            )
+        }
+
+        onPauseOrDispose {}
+    }
+
+    val sendOnline by userSettings.sendOnlineStatus.collectAsStateWithLifecycle()
+    LifecycleResumeEffect(sendOnline) {
+        toggleOnlineService(sendOnline)
+
+        onPauseOrDispose {
+            toggleOnlineService(false)
+        }
+    }
+
+    val deviceWidthDp = remember(true) {
+        resources.displayMetrics.widthPixels.pxToDp()
+    }
+    val deviceHeightDp = remember(true) {
+        resources.displayMetrics.heightPixels.pxToDp()
+    }
+
+    val deviceWidthSize by remember(deviceWidthDp) {
+        derivedStateOf {
+            when {
+                deviceWidthDp <= 360 -> DeviceSize.Small
+                deviceWidthDp <= 600 -> DeviceSize.Compact
+                deviceWidthDp <= 840 -> DeviceSize.Medium
+                else -> DeviceSize.Expanded
+            }
+        }
+    }
+
+    val deviceHeightSize by remember(deviceHeightDp) {
+        derivedStateOf {
+            when {
+                deviceHeightDp <= 480 -> DeviceSize.Small
+                deviceHeightDp <= 700 -> DeviceSize.Compact
+                deviceHeightDp <= 900 -> DeviceSize.Medium
+                else -> DeviceSize.Expanded
+            }
+        }
+    }
+
+    val sizeConfig by remember(deviceWidthSize, deviceHeightSize) {
+        mutableStateOf(
+            SizeConfig(
+                widthSize = deviceWidthSize,
+                heightSize = deviceHeightSize
+            )
+        )
+    }
+
+    val darkMode by userSettings.darkMode.collectAsStateWithLifecycle()
+    val dynamicColors by userSettings.enableDynamicColors.collectAsStateWithLifecycle()
+    val amoledDark by userSettings.enableAmoledDark.collectAsStateWithLifecycle()
+    val enableBlur by userSettings.useBlur.collectAsStateWithLifecycle()
+    val enableMultiline by userSettings.enableMultiline.collectAsStateWithLifecycle()
+    val useSystemFont by userSettings.useSystemFont.collectAsStateWithLifecycle()
+    val enableAnimations by userSettings.enableAnimations.collectAsStateWithLifecycle()
+
+    val setDarkMode = isNeedToEnableDarkMode(darkMode = darkMode)
+
+    val themeConfig by remember(
+        darkMode,
+        dynamicColors,
+        amoledDark,
+        enableBlur,
+        enableMultiline,
+        setDarkMode,
+        useSystemFont
+    ) {
+        derivedStateOf {
+            ThemeConfig(
+                darkMode = setDarkMode,
+                dynamicColors = dynamicColors,
+                selectedColorScheme = 0,
+                amoledDark = amoledDark,
+                enableBlur = enableBlur,
+                enableMultiline = enableMultiline,
+                useSystemFont = useSystemFont,
+                enableAnimations = enableAnimations
+            )
+        }
+    }
+
+    CompositionLocalProvider(
+        LocalThemeConfig provides themeConfig,
+        LocalSizeConfig provides sizeConfig,
+        LocalUser provides currentUser
+    ) {
+        AppTheme(
+            useDarkTheme = themeConfig.darkMode,
+            useDynamicColors = themeConfig.dynamicColors,
+            selectedColorScheme = themeConfig.selectedColorScheme,
+            useAmoledBackground = themeConfig.amoledDark,
+            useSystemFont = themeConfig.useSystemFont
+        ) {
+            val navController: NavHostController = rememberNavController()
+            val activity = LocalActivity.current
             val context = LocalContext.current
             val startDestination by viewModel.startDestination.collectAsStateWithLifecycle()
             val isNeedToOpenAuth by viewModel.isNeedToReplaceWithAuth.collectAsStateWithLifecycle()
@@ -118,6 +309,14 @@ fun RootScreen(
                     LocalNavRootController provides navController,
                     LocalNavController provides navController
                 ) {
+                    var photoViewerInfo by rememberSaveable {
+                        mutableStateOf<Pair<List<String>, Int?>?>(null)
+                    }
+
+                    val captchaRedirectUri by AppSettings.getCaptchaRedirectUriFlow()
+                        .collectAsStateWithLifecycle()
+
+                    Box(modifier = Modifier.fillMaxSize()) {
                         NavHost(
                             navController = navController,
                             startDestination = requireNotNull(startDestination),
@@ -129,6 +328,7 @@ fun RootScreen(
                                     viewModel.onUserAuthenticated()
                                     navController.navigateToMain()
                                 },
+                                onNavigateToSettings = navController::navigateToSettings,
                                 navController = navController
                             )
 
@@ -136,24 +336,31 @@ fun RootScreen(
                                 onError = viewModel::onError,
                                 onSettingsButtonClicked = navController::navigateToSettings,
                                 onNavigateToMessagesHistory = navController::navigateToMessagesHistory,
-                    onPhotoClicked = { url -> navController.navigateToPhotoView(listOf(url)) },
+                                onPhotoClicked = { url ->
+                                    photoViewerInfo = listOf(url) to null
+                                },
                                 onMessageClicked = navController::navigateToMessagesHistory,
-                    onNavigateToCreateChat = navController::navigateToCreateChat
+                                onNavigateToCreateChat = navController::navigateToCreateChat,
                             )
 
                             messagesHistoryScreen(
                                 onError = viewModel::onError,
                                 onBack = navController::navigateUp,
-                    onNavigateToChatMaterials = navController::navigateToChatMaterials
+                                onNavigateToChatMaterials = navController::navigateToChatMaterials,
+                                onNavigateToPhotoViewer = { photos, index ->
+                                    photoViewerInfo = photos to index
+                                }
                             )
                             chatMaterialsScreen(
                                 onBack = navController::navigateUp,
-                    onPhotoClicked = { url -> navController.navigateToPhotoView(listOf(url)) }
+                                onPhotoClicked = { url ->
+                                    photoViewerInfo = listOf(url) to null
+                                }
                             )
                             createChatScreen(
-                    onChatCreated = { conversationId ->
+                                onChatCreated = { convoId ->
                                     navController.popBackStack()
-                        navController.navigateToMessagesHistory(conversationId)
+                                    navController.navigateToMessagesHistory(convoId)
                                 },
                                 navController = navController
                             )
@@ -161,11 +368,39 @@ fun RootScreen(
                             settingsScreen(
                                 onBack = navController::navigateUp,
                                 onLogOutButtonClicked = { navController.navigateToAuth(true) },
-                    onLanguageItemClicked = navController::navigateToLanguagePicker
+                                onLanguageItemClicked = navController::navigateToLanguagePicker,
+                                onRestartRequired = {
+                                    activity?.let {
+                                        val intent = Intent(activity, MainActivity::class.java)
+                                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                                        activity.startActivity(intent)
+                                        activity.finish()
+                                    }
+                                }
                             )
                             languagePickerScreen(onBack = navController::navigateUp)
+                        }
 
-                photoViewScreen(onBack = navController::navigateUp)
+                        PhotoViewDialog(
+                            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/longpolling/LongPollingService.kt

@@ -32,10 +32,10 @@ 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() {
@@ -204,7 +204,7 @@ class LongPollingService : Service() {
         }
     }
 
-    private suspend fun getServerInfo(): VkLongPollData? = suspendCoroutine {
+    private suspend fun getServerInfo(): VkLongPollData? = suspendCancellableCoroutine {
         longPollUseCase.getLongPollServer(
             needPts = true,
             version = VkConstants.LP_VERSION
@@ -224,7 +224,7 @@ class LongPollingService : Service() {
 
     private suspend fun getUpdatesResponse(
         server: VkLongPollData
-    ): LongPollUpdates? = suspendCoroutine {
+    ): LongPollUpdates? = suspendCancellableCoroutine {
         longPollUseCase.getLongPollUpdates(
             serverUrl = "https://${server.server}",
             key = server.key,

app/src/main/kotlin/dev/meloda/fast/util/NotificationsUtils.kt

@@ -6,7 +6,7 @@ import android.content.Context
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import dev.meloda.fast.common.AppConstants
-import dev.meloda.fast.ui.R as UiR
+import dev.meloda.fast.ui.R
 
 object NotificationsUtils {
 
@@ -28,7 +28,7 @@ object NotificationsUtils {
         actions: List<NotificationCompat.Action> = emptyList(),
     ): NotificationCompat.Builder {
         val builder = NotificationCompat.Builder(context, channelId)
-            .setSmallIcon(UiR.drawable.ic_fast_logo)
+            .setSmallIcon(R.drawable.ic_fast_logo)
             .setContentTitle(title)
             .setPriority(priority.value)
             .setContentIntent(contentIntent)

app/src/main/res/xml/network_security_config.xml

@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <network-security-config xmlns:tools="http://schemas.android.com/tools">
-    <!-- Allow cleartext network traffic -->
     <base-config
-        cleartextTrafficPermitted="true"
+        cleartextTrafficPermitted="false"
         tools:ignore="InsecureBaseConfiguration">
         <trust-anchors>
             <!-- Trust pre-installed CAs -->

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,6 +1,6 @@
 import com.android.build.api.dsl.ApplicationExtension
 import dev.meloda.fast.configureKotlinAndroid
-import dev.meloda.fast.libs
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -10,12 +10,18 @@ class AndroidApplicationConventionPlugin : Plugin<Project> {
         with(target) {
             with(pluginManager) {
                 apply("com.android.application")
-                apply("org.jetbrains.kotlin.android")
             }
 
             extensions.configure<ApplicationExtension> {
                 configureKotlinAndroid(this)
-                defaultConfig.targetSdk = libs.findVersion("targetSdk").get().toString().toInt()
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                    targetSdk = getVersionInt("targetSdk")
+                }
+                lint {
+                    abortOnError = false
+                }
             }
         }
     }

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

@@ -1,18 +1,26 @@
-import com.android.build.gradle.LibraryExtension
+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>()
-            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

@@ -1,8 +1,8 @@
+import com.android.build.api.dsl.LibraryExtension
 import com.android.build.api.variant.LibraryAndroidComponentsExtension
-import com.android.build.gradle.LibraryExtension
 import dev.meloda.fast.configureKotlinAndroid
 import dev.meloda.fast.disableUnnecessaryAndroidTests
-import dev.meloda.fast.libs
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -14,15 +14,20 @@ class AndroidLibraryConventionPlugin : Plugin<Project> {
         with(target) {
             with(pluginManager) {
                 apply("com.android.library")
-                apply("org.jetbrains.kotlin.android")
                 apply("org.jetbrains.kotlin.plugin.parcelize")
                 apply("org.jetbrains.kotlin.plugin.serialization")
             }
 
             extensions.configure<LibraryExtension> {
                 configureKotlinAndroid(this)
-                defaultConfig.targetSdk = libs.findVersion("targetSdk").get().toString().toInt()
-                defaultConfig.testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                androidResources.enable = false
+                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,6 +1,6 @@
-import com.android.build.gradle.TestExtension
+import com.android.build.api.dsl.TestExtension
 import dev.meloda.fast.configureKotlinAndroid
-import dev.meloda.fast.libs
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -10,12 +10,15 @@ class AndroidTestConventionPlugin : Plugin<Project> {
         with(target) {
             with(pluginManager) {
                 apply("com.android.test")
-                apply("org.jetbrains.kotlin.android")
             }
 
             extensions.configure<TestExtension> {
                 configureKotlinAndroid(this)
-                defaultConfig.targetSdk = libs.findVersion("targetSdk").get().toString().toInt()
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                    targetSdk = getVersionInt("targetSdk")
+                }
             }
         }
     }

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

@@ -5,12 +5,10 @@ import org.gradle.api.Project
 import org.gradle.kotlin.dsl.dependencies
 
 internal fun Project.configureAndroidCompose(
-    commonExtension: CommonExtension<*, *, *, *, *, *>,
+    commonExtension: CommonExtension,
 ) {
     commonExtension.apply {
-        buildFeatures {
-            compose = true
-        }
+        buildFeatures.compose = true
 
         dependencies {
             val bom = libs.findLibrary("compose-bom").get()

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

@@ -1,6 +1,9 @@
 package dev.meloda.fast
 
+import com.android.build.api.dsl.ApplicationExtension
 import com.android.build.api.dsl.CommonExtension
+import com.android.build.api.dsl.CompileOptions
+import com.android.build.api.dsl.LibraryExtension
 import org.gradle.api.JavaVersion
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
@@ -13,24 +16,25 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinBaseExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 
 internal fun Project.configureKotlinAndroid(
-    commonExtension: CommonExtension<*, *, *, *, *, *>,
+    commonExtension: CommonExtension,
 ) {
+    when (commonExtension) {
+        is ApplicationExtension -> commonExtension.compileOptions(buildCompileOptions())
+        is LibraryExtension -> commonExtension.compileOptions(buildCompileOptions())
+    }
+
     commonExtension.apply {
-        compileSdk = libs.findVersion("compileSdk").get().toString().toInt()
-
-        defaultConfig {
-            minSdk = libs.findVersion("minSdk").get().toString().toInt()
-        }
-
-        compileOptions {
-            sourceCompatibility = JavaVersion.VERSION_21
-            targetCompatibility = JavaVersion.VERSION_21
-        }
+        compileSdk = getVersionInt("compileSdk")
     }
 
     configureKotlin<KotlinAndroidProjectExtension>()
 }
 
+private fun buildCompileOptions(): CompileOptions.() -> Unit = {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+
 internal fun Project.configureKotlinJvm() {
     extensions.configure<JavaPluginExtension> {
         sourceCompatibility = JavaVersion.VERSION_21
@@ -47,7 +51,7 @@ private inline fun <reified T : KotlinBaseExtension> Project.configureKotlin() =
     when (this) {
         is KotlinAndroidProjectExtension -> compilerOptions
         is KotlinJvmProjectExtension -> compilerOptions
-        else -> TODO("Unsupported project extension $this ${T::class}")
+        else -> throw IllegalArgumentException("Unsupported project extension $this ${T::class}")
     }.apply {
         jvmTarget = JvmTarget.JVM_21
         allWarningsAsErrors = warningsAsErrors.toBoolean()
@@ -55,7 +59,9 @@ private inline fun <reified T : KotlinBaseExtension> Project.configureKotlin() =
             "-opt-in=kotlin.RequiresOptIn",
             // Enable experimental coroutines APIs, including Flow
             "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
-            "-opt-in=kotlinx.coroutines.FlowPreview"
+            "-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

@@ -1,7 +1,6 @@
 plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.android.library) apply false
-    alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.parcelize) apply false
     alias(libs.plugins.kotlin.serialization) apply false
     alias(libs.plugins.kotlin.jvm) apply false
@@ -9,4 +8,6 @@ plugins {
     alias(libs.plugins.room) apply false
     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,9 +4,9 @@ object AppConstants {
 
     const val INSTALL_APP_MIME_TYPE = "application/vnd.android.package-archive"
     
-    const val API_VERSION = "5.238"
-    const val URL_OAUTH = "https://oauth.vk.com"
-    const val URL_API = "https://api.vk.com/method"
+    const val API_VERSION = "5.263"
+    const val URL_OAUTH = "https://oauth.vk.ru"
+    const val URL_API = "https://api.vk.ru/method"
 
     const val NOTIFICATION_CHANNEL_UNCATEGORIZED = "uncategorized"
     const val NOTIFICATION_CHANNEL_LONG_POLLING = "long_polling"

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

@@ -1,5 +1,7 @@
 package dev.meloda.fast.common.extensions
 
+import android.os.Build
+import android.os.Bundle
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
@@ -11,6 +13,7 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.update
+import kotlin.reflect.KClass
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
@@ -23,6 +26,20 @@ fun <T> MutableList<T>.addIf(element: T, condition: () -> Boolean) {
     if (condition.invoke()) add(element)
 }
 
+fun <T> MutableList<T>.removeIfCompat(condition: (T) -> Boolean): Boolean {
+    var removed = false
+
+    val each = iterator()
+    while (each.hasNext()) {
+        if (condition(each.next())) {
+            each.remove()
+            removed = true
+        }
+    }
+
+    return removed
+}
+
 fun <T> Flow<T>.listenValue(
     coroutineScope: CoroutineScope,
     action: suspend (T) -> Unit
@@ -103,3 +120,33 @@ fun <T> Any.toList(mapper: (old: Any) -> T): List<T> {
         else -> emptyList()
     }
 }
+
+fun <T> Bundle.getParcelableCompat(key: String, clazz: Class<T>): T? {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        getParcelable(key, clazz)
+    } else {
+        @Suppress("DEPRECATION")
+        getParcelable(key)
+    }
+}
+
+fun <T : Any> Bundle.getParcelableCompat(key: String, clazz: KClass<T>): T? {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        getParcelable(key, clazz.java)
+    } else {
+        @Suppress("DEPRECATION")
+        getParcelable(key)
+    }
+}
+
+infix fun ClosedRange<Int>.collidesWith(other: ClosedRange<Int>): Boolean {
+    return this.start < other.endInclusive && other.start < this.endInclusive
+}
+
+operator fun ClosedRange<Int>.minus(other: ClosedRange<Int>): ClosedRange<Int> {
+    return (this.start - other.start)..(this.endInclusive - other.endInclusive)
+}
+
+operator fun ClosedRange<Int>.minus(other: Int): ClosedRange<Int> {
+    return (this.start - other)..(this.endInclusive - other)
+}

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

@@ -1,19 +1,22 @@
 package dev.meloda.fast.common.util
 
-import android.content.res.Resources
 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
 import com.conena.nanokt.jvm.util.month
 import com.conena.nanokt.jvm.util.second
 import com.conena.nanokt.jvm.util.year
-import dev.meloda.fast.common.R
 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 {
 
@@ -27,7 +30,11 @@ object TimeUtils {
         }.timeInMillis
     }
 
-    fun getLocalizedDate(resources: Resources, date: Long): String {
+    fun getLocalizedDate(
+        date: Long,
+        yesterday: () -> String,
+        today: () -> String
+    ): String {
         val now = Calendar.getInstance()
         val then = Calendar.getInstance().also { it.timeInMillis = date }
 
@@ -36,48 +43,41 @@ object TimeUtils {
             now.month != then.month -> "dd MMMM"
             now.dayOfMonth != then.dayOfMonth -> {
                 if (now.dayOfMonth - then.dayOfMonth == 1) {
-                    return resources.getString(R.string.yesterday)
+                    return yesterday()
                 } else {
                     "dd MMMM"
                 }
             }
 
-            else -> return resources.getString(R.string.today)
+            else -> return today()
         }
 
         return SimpleDateFormat(pattern, Locale.getDefault()).format(date)
     }
 
-    fun getLocalizedTime(resources: Resources, date: Long): String {
-        val now = Calendar.getInstance()
-        val then = Calendar.getInstance().also { it.timeInMillis = date }
+    fun getLocalizedTime(
+        date: Long,
+        yearShort: () -> String,
+        monthShort: () -> String,
+        weekShort: () -> String,
+        dayShort: () -> String,
+        minuteShort: () -> String,
+        secondShort: () -> String,
+        now: () -> String
+    ): String {
+        val now = Clock.System.now()
+        val then = Instant.fromEpochMilliseconds(date)
+        val diff = now - then
 
         return when {
-            now.year != then.year -> {
-                "${now.year - then.year}${resources.getString(R.string.year_short).lowercase()}"
-            }
-
-            now.month != then.month -> {
-                "${now.month - then.month}${resources.getString(R.string.month_short).lowercase()}"
-            }
-
-            now.dayOfMonth != then.dayOfMonth -> {
-                val change = now.dayOfMonth - then.dayOfMonth
-
-                if (change % 7 == 0) {
-                    "${change / 7}${resources.getString(R.string.week_short).lowercase()}"
-                } else {
-                    "$change${resources.getString(R.string.day_short).lowercase()}"
-                }
-            }
-
-            now.hour == then.hour && now.minute == then.minute -> {
-                resources.getString(R.string.time_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

@@ -0,0 +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/common/src/main/res/values-ru/strings.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="yesterday">Вчера</string>
-    <string name="today">Сегодня</string>
-    <string name="year_short">Г</string>
-    <string name="month_short">М</string>
-    <string name="week_short">Н</string>
-    <string name="day_short">Д</string>
-    <string name="time_now">Сейчас</string>
-</resources>

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

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="yesterday">Yesterday</string>
-    <string name="today">Today</string>
-    <string name="year_short">Y</string>
-    <string name="month_short">M</string>
-    <string name="week_short">W</string>
-    <string name="day_short">D</string>
-    <string name="time_now">Now</string>
-</resources>

core/data/build.gradle.kts

@@ -14,7 +14,6 @@ dependencies {
     api(projects.core.network)
     api(projects.core.database)
 
-    // TODO: 11/08/2024, Danil Nikolaev: remove?
     implementation(libs.retrofit)
     implementation(libs.eithernet)
     implementation(libs.koin.android)

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

@@ -1,7 +1,7 @@
 package dev.meloda.fast.data
 
 import dev.meloda.fast.model.api.data.VkMessageData
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import kotlin.math.abs
@@ -16,9 +16,9 @@ class VkGroupsMap(
 
     fun groups(): List<VkGroupDomain> = map.values.toList()
 
-    fun conversationGroup(conversation: VkConversation): VkGroupDomain? =
-        if (!conversation.peerType.isGroup()) null
-        else map[abs(conversation.id)]
+    fun convoGroup(convo: VkConvo): VkGroupDomain? =
+        if (!convo.peerType.isGroup()) null
+        else map[abs(convo.id)]
 
     fun messageActionGroup(message: VkMessage): VkGroupDomain? =
         if (message.actionMemberId == null || message.actionMemberId!! >= 0) null

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

@@ -2,7 +2,7 @@ package dev.meloda.fast.data
 
 import dev.meloda.fast.data.UserConfig.userId
 import dev.meloda.fast.model.api.domain.VkContactDomain
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
@@ -13,7 +13,7 @@ object VkMemoryCache {
     private val users: HashMap<Long, VkUser> = hashMapOf()
     private val groups: HashMap<Long, VkGroupDomain> = hashMapOf()
     private val messages: HashMap<Long, VkMessage> = hashMapOf()
-    private val conversations: HashMap<Long, VkConversation> = hashMapOf()
+    private val convos: HashMap<Long, VkConvo> = hashMapOf()
     private val contacts: HashMap<Long, VkContactDomain> = hashMapOf()
 
     fun appendUsers(users: List<VkUser>) {
@@ -28,9 +28,9 @@ object VkMemoryCache {
         messages.forEach { message -> VkMemoryCache.messages[message.id] = message }
     }
 
-    fun appendConversations(conversations: List<VkConversation>) {
-        conversations.forEach { conversation ->
-            VkMemoryCache.conversations[conversation.id] = conversation
+    fun appendConvos(convos: List<VkConvo>) {
+        convos.forEach { convo ->
+            VkMemoryCache.convos[convo.id] = convo
         }
     }
 
@@ -50,8 +50,8 @@ object VkMemoryCache {
         messages[messageId] = message
     }
 
-    operator fun set(conversationId: Long, conversation: VkConversation) {
-        conversations[conversationId] = conversation
+    operator fun set(convoId: Long, convo: VkConvo) {
+        convos[convoId] = convo
     }
 
     operator fun set(contactId: Long, contact: VkContactDomain) {
@@ -94,16 +94,16 @@ object VkMemoryCache {
         return ids.mapNotNull { id -> messages[id] }
     }
 
-    fun getConversation(id: Long): VkConversation? {
-        return getConversations(id).firstOrNull()
+    fun getConvo(id: Long): VkConvo? {
+        return getConvos(id).firstOrNull()
     }
 
-    fun getConversations(vararg ids: Long): List<VkConversation> {
-        return getConversations(ids.toList())
+    fun getConvos(vararg ids: Long): List<VkConvo> {
+        return getConvos(ids.toList())
     }
 
-    fun getConversations(ids: List<Long>): List<VkConversation> {
-        return ids.mapNotNull { id -> conversations[id] }
+    fun getConvos(ids: List<Long>): List<VkConvo> {
+        return ids.mapNotNull { id -> convos[id] }
     }
 
     fun getContact(id: Long): VkContactDomain? {

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

@@ -1,8 +1,7 @@
 package dev.meloda.fast.data
 
-import dev.meloda.fast.data.UserConfig.userId
 import dev.meloda.fast.model.api.data.VkMessageData
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
 
@@ -16,9 +15,9 @@ class VkUsersMap(
 
     fun users(): List<VkUser> = map.values.toList()
 
-    fun conversationUser(conversation: VkConversation): VkUser? =
-        if (!conversation.peerType.isUser()) null
-        else map[conversation.id]
+    fun convoUser(convo: VkConvo): VkUser? =
+        if (!convo.peerType.isUser()) null
+        else map[convo.id]
 
     fun messageActionUser(message: VkMessage): VkUser? =
         if (message.actionMemberId == null || message.actionMemberId!! <= 0) null
@@ -36,7 +35,7 @@ class VkUsersMap(
         if (message.fromId > 0) map[message.fromId]
         else null
 
-    fun user(userid: Long): VkUser? = map[userId]
+    fun user(userId: Long): VkUser? = map[userId]
 
     companion object {
 

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

@@ -1,25 +1,25 @@
-package dev.meloda.fast.data.api.conversations
+package dev.meloda.fast.data.api.convos
 
 import com.slack.eithernet.ApiResult
-import dev.meloda.fast.model.ConversationsFilter
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.ConvosFilter
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.network.RestApiErrorDomain
 
-interface ConversationsRepository {
+interface ConvosRepository {
 
-    suspend fun storeConversations(conversations: List<VkConversation>)
+    suspend fun storeConvos(convos: List<VkConvo>)
 
-    suspend fun getConversations(
+    suspend fun getConvos(
         count: Int?,
         offset: Int?,
-        filter: ConversationsFilter
-    ): ApiResult<List<VkConversation>, RestApiErrorDomain>
+        filter: ConvosFilter
+    ): ApiResult<List<VkConvo>, RestApiErrorDomain>
 
-    suspend fun getConversationsById(
+    suspend fun getConvosById(
         peerIds: List<Long>,
         extended: Boolean? = null,
         fields: String? = null
-    ): ApiResult<List<VkConversation>, RestApiErrorDomain>
+    ): ApiResult<List<VkConvo>, RestApiErrorDomain>
 
     suspend fun delete(peerId: Long): ApiResult<Long, RestApiErrorDomain>
     suspend fun pin(peerId: Long): ApiResult<Int, RestApiErrorDomain>

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

@@ -1,51 +1,51 @@
-package dev.meloda.fast.data.api.conversations
+package dev.meloda.fast.data.api.convos
 
 import com.slack.eithernet.ApiResult
 import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.data.VkGroupsMap
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.data.VkUsersMap
-import dev.meloda.fast.database.dao.ConversationDao
+import dev.meloda.fast.database.dao.ConvoDao
 import dev.meloda.fast.database.dao.GroupDao
 import dev.meloda.fast.database.dao.MessageDao
 import dev.meloda.fast.database.dao.UserDao
-import dev.meloda.fast.model.ConversationsFilter
+import dev.meloda.fast.model.ConvosFilter
 import dev.meloda.fast.model.api.data.VkContactData
 import dev.meloda.fast.model.api.data.VkGroupData
 import dev.meloda.fast.model.api.data.VkUserData
 import dev.meloda.fast.model.api.data.asDomain
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.model.api.domain.asEntity
-import dev.meloda.fast.model.api.requests.ConversationsGetRequest
+import dev.meloda.fast.model.api.requests.ConvosGetRequest
 import dev.meloda.fast.network.RestApiErrorDomain
 import dev.meloda.fast.network.mapApiDefault
 import dev.meloda.fast.network.mapApiResult
-import dev.meloda.fast.network.service.conversations.ConversationsService
+import dev.meloda.fast.network.service.convos.ConvosService
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
-class ConversationsRepositoryImpl(
-    private val conversationsService: ConversationsService,
+class ConvosRepositoryImpl(
+    private val convosService: ConvosService,
     private val messageDao: MessageDao,
     private val userDao: UserDao,
     private val groupDao: GroupDao,
-    private val conversationDao: ConversationDao
-) : ConversationsRepository {
+    private val convoDao: ConvoDao
+) : ConvosRepository {
 
-    override suspend fun storeConversations(conversations: List<VkConversation>) {
-        conversationDao.insertAll(conversations.map(VkConversation::asEntity))
+    override suspend fun storeConvos(convos: List<VkConvo>) {
+        convoDao.insertAll(convos.map(VkConvo::asEntity))
     }
 
-    override suspend fun getConversations(
+    override suspend fun getConvos(
         count: Int?,
         offset: Int?,
-        filter: ConversationsFilter
-    ): ApiResult<List<VkConversation>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        val requestModel = ConversationsGetRequest(
+        filter: ConvosFilter
+    ): ApiResult<List<VkConvo>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+        val requestModel = ConvosGetRequest(
             count = count,
             offset = offset,
             fields = VkConstants.ALL_FIELDS,
@@ -54,7 +54,7 @@ class ConversationsRepositoryImpl(
             startMessageId = null
         )
 
-        conversationsService.getConversations(requestModel.map).mapApiResult(
+        convosService.getConvos(requestModel.map).mapApiResult(
             successMapper = { apiResponse ->
                 val response = apiResponse.requireResponse()
 
@@ -69,33 +69,39 @@ class ConversationsRepositoryImpl(
                 VkMemoryCache.appendGroups(groupsList)
                 VkMemoryCache.appendContacts(contactsList)
 
-                val conversations = response.items.map { item ->
+                val convos = response.items.map { item ->
                     val lastMessage = item.lastMessage?.asDomain()?.let { message ->
                         message.copy(
                             user = usersMap.messageUser(message),
                             group = groupsMap.messageGroup(message),
                             actionUser = usersMap.messageActionUser(message),
-                            actionGroup = groupsMap.messageActionGroup(message)
+                            actionGroup = groupsMap.messageActionGroup(message),
+                            replyMessage = message.replyMessage?.copy(
+                                user = usersMap.messageUser(message),
+                                group = groupsMap.messageGroup(message),
+                                actionUser = usersMap.messageActionUser(message),
+                                actionGroup = groupsMap.messageActionGroup(message),
+                            )
                         ).also { VkMemoryCache[message.id] = it }
                     }
-                    item.conversation.asDomain(lastMessage).let { conversation ->
-                        conversation.copy(
-                            user = usersMap.conversationUser(conversation),
-                            group = groupsMap.conversationGroup(conversation)
-                        ).also { VkMemoryCache[conversation.id] = it }
+                    item.convo.asDomain(lastMessage).let { convo ->
+                        convo.copy(
+                            user = usersMap.convoUser(convo),
+                            group = groupsMap.convoGroup(convo)
+                        ).also { VkMemoryCache[convo.id] = it }
                     }
                 }
 
-                val messages = conversations.mapNotNull(VkConversation::lastMessage)
+                val messages = convos.mapNotNull(VkConvo::lastMessage)
 
                 launch(Dispatchers.IO) {
-                    conversationDao.insertAll(conversations.map(VkConversation::asEntity))
+                    convoDao.insertAll(convos.map(VkConvo::asEntity))
                     messageDao.insertAll(messages.map(VkMessage::asEntity))
                     userDao.insertAll(profilesList.map(VkUser::asEntity))
                     groupDao.insertAll(groupsList.map(VkGroupDomain::asEntity))
                 }
 
-                conversations
+                convos
             },
             errorMapper = { error ->
                 error?.toDomain()
@@ -103,11 +109,11 @@ class ConversationsRepositoryImpl(
         )
     }
 
-    override suspend fun getConversationsById(
+    override suspend fun getConvosById(
         peerIds: List<Long>,
         extended: Boolean?,
         fields: String?
-    ): ApiResult<List<VkConversation>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+    ): ApiResult<List<VkConvo>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
         val requestParams = mutableMapOf(
             "peer_ids" to peerIds.joinToString(separator = ",")
         ).apply {
@@ -115,7 +121,7 @@ class ConversationsRepositoryImpl(
             fields?.let { this["fields"] = it }
         }
 
-        conversationsService.getConversationsById(requestParams).mapApiResult(
+        convosService.getConvosById(requestParams).mapApiResult(
             successMapper = { apiResponse ->
                 val response = apiResponse.requireResponse()
 
@@ -126,17 +132,17 @@ class ConversationsRepositoryImpl(
                 val usersMap = VkUsersMap.forUsers(profilesList)
                 val groupsMap = VkGroupsMap.forGroups(groupsList)
 
-                val conversations = response.items.map { item ->
-                    item.asDomain().let { conversation ->
-                        conversation.copy(
-                            user = usersMap.conversationUser(conversation),
-                            group = groupsMap.conversationGroup(conversation)
-                        ).also { VkMemoryCache[conversation.id] = it }
+                val convos = response.items.map { item ->
+                    item.asDomain().let { convo ->
+                        convo.copy(
+                            user = usersMap.convoUser(convo),
+                            group = groupsMap.convoGroup(convo)
+                        ).also { VkMemoryCache[convo.id] = it }
                     }
                 }
 
                 launch(Dispatchers.IO) {
-                    conversationDao.insertAll(conversations.map(VkConversation::asEntity))
+                    convoDao.insertAll(convos.map(VkConvo::asEntity))
                     userDao.insertAll(profilesList.map(VkUser::asEntity))
                     groupDao.insertAll(groupsList.map(VkGroupDomain::asEntity))
                 }
@@ -145,7 +151,7 @@ class ConversationsRepositoryImpl(
                 VkMemoryCache.appendGroups(groupsList)
                 VkMemoryCache.appendContacts(contactsList)
 
-                conversations
+                convos
             },
             errorMapper = { error ->
                 error?.toDomain()
@@ -155,7 +161,7 @@ class ConversationsRepositoryImpl(
 
     override suspend fun delete(peerId: Long): ApiResult<Long, RestApiErrorDomain> =
         withContext(Dispatchers.IO) {
-            conversationsService.delete(mapOf("peer_id" to peerId.toString())).mapApiResult(
+            convosService.delete(mapOf("peer_id" to peerId.toString())).mapApiResult(
                 successMapper = { response -> response.requireResponse().lastDeletedId },
                 errorMapper = { error -> error?.toDomain() }
             )
@@ -164,19 +170,19 @@ class ConversationsRepositoryImpl(
     override suspend fun pin(
         peerId: Long
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService.pin(mapOf("peer_id" to peerId.toString())).mapApiDefault()
+        convosService.pin(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
 
     override suspend fun unpin(
         peerId: Long
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService.unpin(mapOf("peer_id" to peerId.toString())).mapApiDefault()
+        convosService.unpin(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
 
     override suspend fun reorderPinned(
         peerIds: List<Long>
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService
+        convosService
             .reorderPinned(mapOf("peer_ids" to peerIds.joinToString(",")))
             .mapApiDefault()
     }
@@ -184,12 +190,12 @@ class ConversationsRepositoryImpl(
     override suspend fun archive(
         peerId: Long
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService.archive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
+        convosService.archive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
 
     override suspend fun unarchive(
         peerId: Long
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService.unarchive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
+        convosService.unarchive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
 }

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

@@ -1,9 +1,9 @@
 package dev.meloda.fast.data.api.messages
 
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 
 data class MessagesHistoryInfo(
     val messages: List<VkMessage>,
-    val conversations: List<VkConversation>
+    val convos: List<VkConvo>
 )

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

@@ -5,7 +5,8 @@ import dev.meloda.fast.model.api.data.VkChatData
 import dev.meloda.fast.model.api.domain.VkAttachment
 import dev.meloda.fast.model.api.domain.VkAttachmentHistoryMessage
 import dev.meloda.fast.model.api.domain.VkMessage
-import dev.meloda.fast.model.api.responses.MessagesGetConversationMembersResponse
+import dev.meloda.fast.model.api.responses.MessagesGetConvoMembersResponse
+import dev.meloda.fast.model.api.responses.MessagesGetReadPeersResponse
 import dev.meloda.fast.model.api.responses.MessagesSendResponse
 import dev.meloda.fast.network.RestApiErrorDomain
 
@@ -14,7 +15,7 @@ interface MessagesRepository {
     suspend fun storeMessages(messages: List<VkMessage>)
 
     suspend fun getHistory(
-        conversationId: Long,
+        convoId: Long,
         offset: Int?,
         count: Int?
     ): ApiResult<MessagesHistoryInfo, RestApiErrorDomain>
@@ -32,8 +33,9 @@ interface MessagesRepository {
         peerId: Long,
         randomId: Long,
         message: String?,
-        replyTo: Long?,
-        attachments: List<VkAttachment>?
+        forward: String?,
+        attachments: List<VkAttachment>?,
+        formatData: VkMessage.FormatData?
     ): ApiResult<MessagesSendResponse, RestApiErrorDomain>
 
     suspend fun markAsRead(
@@ -97,16 +99,21 @@ interface MessagesRepository {
         fields: String? = null
     ): ApiResult<VkChatData, RestApiErrorDomain>
 
-    suspend fun getConversationMembers(
+    suspend fun getConvoMembers(
         peerId: Long,
         offset: Int? = null,
         count: Int? = null,
         extended: Boolean? = null,
         fields: String? = null
-    ): ApiResult<MessagesGetConversationMembersResponse, RestApiErrorDomain>
+    ): ApiResult<MessagesGetConvoMembersResponse, RestApiErrorDomain>
 
     suspend fun removeChatUser(
         chatId: Long,
         memberId: Long
     ): ApiResult<Int, RestApiErrorDomain>
+
+    suspend fun getMessageReadPeers(
+        peerId: Long,
+        cmId: Long
+    ): ApiResult<MessagesGetReadPeersResponse, RestApiErrorDomain>
 }

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

@@ -5,7 +5,7 @@ import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.data.VkGroupsMap
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.data.VkUsersMap
-import dev.meloda.fast.database.dao.ConversationDao
+import dev.meloda.fast.database.dao.ConvoDao
 import dev.meloda.fast.database.dao.GroupDao
 import dev.meloda.fast.database.dao.MessageDao
 import dev.meloda.fast.database.dao.UserDao
@@ -17,7 +17,7 @@ import dev.meloda.fast.model.api.data.VkUserData
 import dev.meloda.fast.model.api.data.asDomain
 import dev.meloda.fast.model.api.domain.VkAttachment
 import dev.meloda.fast.model.api.domain.VkAttachmentHistoryMessage
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
@@ -27,7 +27,7 @@ import dev.meloda.fast.model.api.requests.MessagesDeleteRequest
 import dev.meloda.fast.model.api.requests.MessagesEditRequest
 import dev.meloda.fast.model.api.requests.MessagesGetByIdRequest
 import dev.meloda.fast.model.api.requests.MessagesGetChatRequest
-import dev.meloda.fast.model.api.requests.MessagesGetConversationMembersRequest
+import dev.meloda.fast.model.api.requests.MessagesGetConvoMembersRequest
 import dev.meloda.fast.model.api.requests.MessagesGetHistoryAttachmentsRequest
 import dev.meloda.fast.model.api.requests.MessagesGetHistoryRequest
 import dev.meloda.fast.model.api.requests.MessagesMarkAsImportantRequest
@@ -36,7 +36,8 @@ import dev.meloda.fast.model.api.requests.MessagesPinMessageRequest
 import dev.meloda.fast.model.api.requests.MessagesRemoveChatUserRequest
 import dev.meloda.fast.model.api.requests.MessagesSendRequest
 import dev.meloda.fast.model.api.requests.MessagesUnpinMessageRequest
-import dev.meloda.fast.model.api.responses.MessagesGetConversationMembersResponse
+import dev.meloda.fast.model.api.responses.MessagesGetConvoMembersResponse
+import dev.meloda.fast.model.api.responses.MessagesGetReadPeersResponse
 import dev.meloda.fast.model.api.responses.MessagesSendResponse
 import dev.meloda.fast.network.RestApiErrorDomain
 import dev.meloda.fast.network.mapApiDefault
@@ -51,18 +52,18 @@ class MessagesRepositoryImpl(
     private val messageDao: MessageDao,
     private val userDao: UserDao,
     private val groupDao: GroupDao,
-    private val conversationDao: ConversationDao
+    private val convoDao: ConvoDao
 ) : MessagesRepository {
 
     override suspend fun getHistory(
-        conversationId: Long,
+        convoId: Long,
         offset: Int?,
         count: Int?
     ): ApiResult<MessagesHistoryInfo, RestApiErrorDomain> = withContext(Dispatchers.IO) {
         val requestModel = MessagesGetHistoryRequest(
             count = count,
             offset = offset,
-            peerId = conversationId,
+            peerId = convoId,
             extended = true,
             startMessageId = null,
             rev = null,
@@ -90,24 +91,32 @@ class MessagesRepositoryImpl(
                             user = usersMap.messageUser(message),
                             group = groupsMap.messageGroup(message),
                             actionUser = usersMap.messageActionUser(message),
-                            actionGroup = groupsMap.messageActionGroup(message)
+                            actionGroup = groupsMap.messageActionGroup(message),
+                            replyMessage = message.replyMessage.let { replyMessage ->
+                                replyMessage?.copy(
+                                    user = usersMap.messageUser(replyMessage),
+                                    group = groupsMap.messageGroup(replyMessage),
+                                    actionUser = usersMap.messageActionUser(replyMessage),
+                                    actionGroup = groupsMap.messageActionGroup(replyMessage),
+                                )
+                            }
                         ).also { VkMemoryCache[message.id] = it }
                     }
                 }
 
-                val conversations = response.conversations.orEmpty().map { item ->
+                val convos = response.convos.orEmpty().map { item ->
                     val message = messages.firstOrNull { it.id == item.lastMessageId }
                     item.asDomain(message)
-                        .let { conversation ->
-                            conversation.copy(
-                                user = usersMap.conversationUser(conversation),
-                                group = groupsMap.conversationGroup(conversation)
-                            ).also { VkMemoryCache[conversation.id] = it }
+                        .let { convo ->
+                            convo.copy(
+                                user = usersMap.convoUser(convo),
+                                group = groupsMap.convoGroup(convo)
+                            ).also { VkMemoryCache[convo.id] = it }
                         }
                 }
 
                 launch(Dispatchers.IO) {
-                    conversationDao.insertAll(conversations.map(VkConversation::asEntity))
+                    convoDao.insertAll(convos.map(VkConvo::asEntity))
                     messageDao.insertAll(messages.map(VkMessage::asEntity))
                     userDao.insertAll(profilesList.map(VkUser::asEntity))
                     groupDao.insertAll(groupsList.map(VkGroupDomain::asEntity))
@@ -115,7 +124,7 @@ class MessagesRepositoryImpl(
 
                 MessagesHistoryInfo(
                     messages = messages,
-                    conversations = conversations
+                    convos = convos
                 )
             },
             errorMapper = { error ->
@@ -159,7 +168,15 @@ class MessagesRepositoryImpl(
                         user = usersMap.messageUser(message),
                         group = groupsMap.messageGroup(message),
                         actionUser = usersMap.messageActionUser(message),
-                        actionGroup = groupsMap.messageActionGroup(message)
+                        actionGroup = groupsMap.messageActionGroup(message),
+                        replyMessage = message.replyMessage?.asDomain().let { replyMessage ->
+                            replyMessage?.copy(
+                                user = usersMap.messageUser(replyMessage),
+                                group = groupsMap.messageGroup(replyMessage),
+                                actionUser = usersMap.messageActionUser(replyMessage),
+                                actionGroup = groupsMap.messageActionGroup(replyMessage),
+                            )
+                        }
                     )
                 }
 
@@ -183,15 +200,17 @@ class MessagesRepositoryImpl(
         peerId: Long,
         randomId: Long,
         message: String?,
-        replyTo: Long?,
-        attachments: List<VkAttachment>?
+        forward: String?,
+        attachments: List<VkAttachment>?,
+        formatData: VkMessage.FormatData?
     ): ApiResult<MessagesSendResponse, RestApiErrorDomain> = withContext(Dispatchers.IO) {
         val requestModel = MessagesSendRequest(
             peerId = peerId,
             randomId = randomId,
             message = message,
-            replyTo = replyTo,
-            attachments = attachments
+            forward = forward,
+            attachments = attachments,
+            formatData = formatData
         )
 
         messagesService.send(requestModel.map).mapApiDefault()
@@ -224,7 +243,7 @@ class MessagesRepositoryImpl(
                 offset = offset,
                 preserveOrder = true,
                 attachmentTypes = attachmentTypes,
-                conversationMessageId = cmId,
+                cmId = cmId,
                 fields = VkConstants.ALL_FIELDS
             )
 
@@ -278,7 +297,7 @@ class MessagesRepositoryImpl(
         val requestModel = MessagesPinMessageRequest(
             peerId = peerId,
             messageId = messageId,
-            conversationMessageId = cmId
+            cmId = cmId
         )
 
         messagesService.pin(requestModel.map).mapApiResult(
@@ -306,7 +325,12 @@ class MessagesRepositoryImpl(
             messagesIds = messageIds.orEmpty(),
             important = important
         )
-        messagesService.markAsImportant(requestModel.map).mapApiDefault()
+        messagesService.markAsImportant(requestModel.map).mapApiResult(
+            successMapper = { apiResponse ->
+                apiResponse.requireResponse().marked.map { it.cmId }
+            },
+            errorMapper = { error -> error?.toDomain() }
+        )
     }
 
     override suspend fun delete(
@@ -319,7 +343,7 @@ class MessagesRepositoryImpl(
         val requestModel = MessagesDeleteRequest(
             peerId = peerId,
             messagesIds = messageIds,
-            conversationsMessagesIds = cmIds,
+            cmIds = cmIds,
             isSpam = spam,
             deleteForAll = deleteForAll
         )
@@ -370,15 +394,15 @@ class MessagesRepositoryImpl(
         messagesService.getChat(requestModel.map).mapApiDefault()
     }
 
-    override suspend fun getConversationMembers(
+    override suspend fun getConvoMembers(
         peerId: Long,
         offset: Int?,
         count: Int?,
         extended: Boolean?,
         fields: String?
-    ): ApiResult<MessagesGetConversationMembersResponse, RestApiErrorDomain> =
+    ): ApiResult<MessagesGetConvoMembersResponse, RestApiErrorDomain> =
         withContext(Dispatchers.IO) {
-            val requestModel = MessagesGetConversationMembersRequest(
+            val requestModel = MessagesGetConvoMembersRequest(
                 peerId = peerId,
                 offset = offset,
                 count = count,
@@ -386,7 +410,7 @@ class MessagesRepositoryImpl(
                 fields = fields
             )
 
-            messagesService.getConversationMembers(requestModel.map).mapApiDefault()
+            messagesService.getConvoMembers(requestModel.map).mapApiDefault()
         }
 
     override suspend fun removeChatUser(
@@ -400,4 +424,18 @@ class MessagesRepositoryImpl(
 
         messagesService.removeChatUser(requestModel.map).mapApiDefault()
     }
+
+    override suspend fun getMessageReadPeers(
+        peerId: Long,
+        cmId: Long
+    ): ApiResult<MessagesGetReadPeersResponse, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+        messagesService.getMessageReadPeers(
+            mapOf(
+                "peer_id" to peerId.toString(),
+                "cmid" to cmId.toString(),
+                "extended" to "1",
+                "fields" to VkConstants.USER_FIELDS
+            )
+        ).mapApiDefault()
+    }
 }

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/data/src/main/kotlin/dev/meloda/fast/data/di/DataModule.kt

@@ -6,8 +6,8 @@ import dev.meloda.fast.data.api.account.AccountRepositoryImpl
 import dev.meloda.fast.data.api.audios.AudiosRepository
 import dev.meloda.fast.data.api.auth.AuthRepository
 import dev.meloda.fast.data.api.auth.AuthRepositoryImpl
-import dev.meloda.fast.data.api.conversations.ConversationsRepository
-import dev.meloda.fast.data.api.conversations.ConversationsRepositoryImpl
+import dev.meloda.fast.data.api.convos.ConvosRepository
+import dev.meloda.fast.data.api.convos.ConvosRepositoryImpl
 import dev.meloda.fast.data.api.files.FilesRepository
 import dev.meloda.fast.data.api.friends.FriendsRepository
 import dev.meloda.fast.data.api.friends.FriendsRepositoryImpl
@@ -45,7 +45,7 @@ val dataModule = module {
 
     singleOf(::AuthRepositoryImpl) bind AuthRepository::class
 
-    singleOf(::ConversationsRepositoryImpl) bind ConversationsRepository::class
+    singleOf(::ConvosRepositoryImpl) bind ConvosRepository::class
 
     singleOf(::FilesRepository)
 

core/database/schemas/dev.meloda.fast.database.AccountsDatabase/3.json

@@ -0,0 +1,58 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 3,
+    "identityHash": "ca007bca2ab4a9b901662792042770ad",
+    "entities": [
+      {
+        "tableName": "accounts",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`userId` INTEGER NOT NULL, `accessToken` TEXT NOT NULL, `fastToken` TEXT, `trustedHash` TEXT, `exchangeToken` TEXT, PRIMARY KEY(`userId`))",
+        "fields": [
+          {
+            "fieldPath": "userId",
+            "columnName": "userId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "accessToken",
+            "columnName": "accessToken",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fastToken",
+            "columnName": "fastToken",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "trustedHash",
+            "columnName": "trustedHash",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "exchangeToken",
+            "columnName": "exchangeToken",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "userId"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "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, 'ca007bca2ab4a9b901662792042770ad')"
+    ]
+  }
+}

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

@@ -0,0 +1,413 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 10,
+    "identityHash": "6c315b7f800694f635318d86032746ec",
+    "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, `important` INTEGER NOT NULL, `forwardIds` TEXT, `attachments` TEXT, `replyMessageId` INTEGER, `geoType` TEXT, `pinnedAt` INTEGER, `isPinned` 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": "important",
+            "columnName": "important",
+            "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
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "conversations",
+        "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, '6c315b7f800694f635318d86032746ec')"
+    ]
+  }
+}

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

@@ -0,0 +1,413 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 11,
+    "identityHash": "a746865995959331f8a1b512c049dacb",
+    "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, `important` INTEGER NOT NULL, `forwardIds` TEXT, `attachments` TEXT, `replyMessageId` INTEGER, `geoType` TEXT, `pinnedAt` INTEGER, `isPinned` 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": "important",
+            "columnName": "important",
+            "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
+          }
+        ],
+        "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, 'a746865995959331f8a1b512c049dacb')"
+    ]
+  }
+}

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

@@ -3,12 +3,12 @@ package dev.meloda.fast.database
 import androidx.room.Database
 import androidx.room.RoomDatabase
 import androidx.room.TypeConverters
-import dev.meloda.fast.database.dao.ConversationDao
+import dev.meloda.fast.database.dao.ConvoDao
 import dev.meloda.fast.database.dao.GroupDao
 import dev.meloda.fast.database.dao.MessageDao
 import dev.meloda.fast.database.dao.UserDao
 import dev.meloda.fast.database.typeconverters.Converters
-import dev.meloda.fast.model.database.VkConversationEntity
+import dev.meloda.fast.model.database.VkConvoEntity
 import dev.meloda.fast.model.database.VkGroupEntity
 import dev.meloda.fast.model.database.VkMessageEntity
 import dev.meloda.fast.model.database.VkUserEntity
@@ -18,15 +18,15 @@ import dev.meloda.fast.model.database.VkUserEntity
         VkUserEntity::class,
         VkGroupEntity::class,
         VkMessageEntity::class,
-        VkConversationEntity::class
+        VkConvoEntity::class
     ],
 
-    version = 10
+    version = 11
 )
 @TypeConverters(Converters::class)
 abstract class CacheDatabase : RoomDatabase() {
     abstract fun userDao(): UserDao
     abstract fun groupDao(): GroupDao
     abstract fun messageDao(): MessageDao
-    abstract fun conversationDao(): ConversationDao
+    abstract fun convoDao(): ConvoDao
 }

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

@@ -1,30 +0,0 @@
-package dev.meloda.fast.database.dao
-
-import androidx.room.Dao
-import androidx.room.Query
-import androidx.room.Transaction
-import dev.meloda.fast.model.database.ConversationWithMessage
-import dev.meloda.fast.model.database.VkConversationEntity
-
-@Dao
-abstract class ConversationDao : EntityDao<VkConversationEntity> {
-
-    @Query("SELECT * FROM conversations")
-    abstract suspend fun getAll(): List<VkConversationEntity>
-
-    @Query("SELECT * FROM conversations WHERE id IN (:ids)")
-    abstract suspend fun getAllByIds(ids: List<Int>): List<VkConversationEntity>
-
-    @Query("SELECT * FROM conversations WHERE id IS (:id)")
-    abstract suspend fun getById(id: Long): VkConversationEntity?
-
-    @Transaction
-    @Query("SELECT * FROM conversations WHERE id IS (:id)")
-    abstract suspend fun getByIdWithMessage(id: Long): ConversationWithMessage?
-
-    @Query("DELETE FROM conversations WHERE rowid IN (:ids)")
-    abstract suspend fun deleteByIds(ids: List<Int>): Int
-}
-
-
-

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

@@ -0,0 +1,30 @@
+package dev.meloda.fast.database.dao
+
+import androidx.room.Dao
+import androidx.room.Query
+import androidx.room.Transaction
+import dev.meloda.fast.model.database.ConvoWithMessage
+import dev.meloda.fast.model.database.VkConvoEntity
+
+@Dao
+abstract class ConvoDao : EntityDao<VkConvoEntity> {
+
+    @Query("SELECT * FROM convos")
+    abstract suspend fun getAll(): List<VkConvoEntity>
+
+    @Query("SELECT * FROM convos WHERE id IN (:ids)")
+    abstract suspend fun getAllByIds(ids: List<Int>): List<VkConvoEntity>
+
+    @Query("SELECT * FROM convos WHERE id IS (:id)")
+    abstract suspend fun getById(id: Long): VkConvoEntity?
+
+    @Transaction
+    @Query("SELECT * FROM convos WHERE id IS (:id)")
+    abstract suspend fun getByIdWithMessage(id: Long): ConvoWithMessage?
+
+    @Query("DELETE FROM convos WHERE rowid IN (:ids)")
+    abstract suspend fun deleteByIds(ids: List<Int>): Int
+}
+
+
+

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

@@ -10,8 +10,8 @@ abstract class MessageDao : EntityDao<VkMessageEntity> {
     @Query("SELECT * FROM messages")
     abstract suspend fun getAll(): List<VkMessageEntity>
 
-    @Query("SELECT * FROM messages WHERE peerId IS (:conversationId)")
-    abstract suspend fun getAll(conversationId: Long): List<VkMessageEntity>
+    @Query("SELECT * FROM messages WHERE peerId IS (:convoId)")
+    abstract suspend fun getAll(convoId: Long): List<VkMessageEntity>
 
     @Query("SELECT * FROM messages WHERE id IN (:ids)")
     abstract suspend fun getAllByIds(ids: List<Int>): List<VkMessageEntity>

core/database/src/main/kotlin/dev/meloda/fast/database/di/DatabaseModule.kt

@@ -17,13 +17,13 @@ val databaseModule = module {
 
     single {
         Room.databaseBuilder(get(), CacheDatabase::class.java, "cache")
-            .fallbackToDestructiveMigration()
+            .fallbackToDestructiveMigration(true)
             .build()
     }
     single { cacheDB().userDao() }
     single { cacheDB().groupDao() }
     single { cacheDB().messageDao() }
-    single { cacheDB().conversationDao() }
+    single { cacheDB().convoDao() }
 }
 
 private fun Scope.cacheDB(): CacheDatabase = get()

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

@@ -4,13 +4,32 @@ import android.content.SharedPreferences
 import androidx.core.content.edit
 import dev.meloda.fast.common.model.DarkMode
 import dev.meloda.fast.common.model.LogLevel
+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
     }
@@ -96,6 +115,20 @@ object AppSettings {
             )
             set(value) = put(SettingsKeys.KEY_SHOW_EMOJI_BUTTON, value)
 
+        var showAttachmentButton: Boolean
+            get() = get(
+                SettingsKeys.KEY_SHOW_ATTACHMENT_BUTTON,
+                SettingsKeys.DEFAULT_VALUE_SHOW_ATTACHMENT_BUTTON
+            )
+            set(value) = put(SettingsKeys.KEY_SHOW_ATTACHMENT_BUTTON, value)
+
+        var showManualRefreshOptions: Boolean
+            get() = get(
+                SettingsKeys.KEY_SHOW_MANUAL_REFRESH_OPTIONS,
+                SettingsKeys.DEFAULT_VALUE_SHOW_MANUAL_REFRESH_OPTIONS
+            )
+            set(value) = put(SettingsKeys.KEY_SHOW_MANUAL_REFRESH_OPTIONS, value)
+
         var enableHaptic: Boolean
             get() = get(
                 SettingsKeys.KEY_ENABLE_HAPTIC,

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

@@ -11,6 +11,10 @@ object SettingsKeys {
     const val DEFAULT_VALUE_USE_CONTACT_NAMES = false
     const val KEY_SHOW_EMOJI_BUTTON = "show_emoji_button"
     const val DEFAULT_VALUE_KEY_SHOW_EMOJI_BUTTON = false
+    const val KEY_SHOW_ATTACHMENT_BUTTON = "show_attachment_button"
+    const val DEFAULT_VALUE_SHOW_ATTACHMENT_BUTTON = false
+    const val KEY_SHOW_MANUAL_REFRESH_OPTIONS = "show_manual_refresh_options"
+    const val DEFAULT_VALUE_SHOW_MANUAL_REFRESH_OPTIONS = false
 
     const val KEY_APPEARANCE = "appearance"
     const val KEY_APPEARANCE_MULTILINE = "appearance_multiline"
@@ -46,6 +50,9 @@ object SettingsKeys {
     const val DEFAULT_ENABLE_HAPTIC = true
     const val KEY_DEBUG_NETWORK_LOG_LEVEL = "debug_network_log_level"
     const val DEFAULT_NETWORK_LOG_LEVEL = 3
+    const val KEY_DEBUG_IMPORT_AUTH_DATA = "debug_import_auth_data"
+    const val KEY_DEBUG_EXPORT_AUTH_DATA = "debug_export_auth_data"
+
     const val KEY_USE_SYSTEM_FONT = "use_system_font"
     const val DEFAULT_USE_SYSTEM_FONT = false
     const val KEY_MORE_ANIMATIONS = "more_animations"

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

@@ -14,15 +14,10 @@ interface UserSettings {
     val enableDynamicColors: StateFlow<Boolean>
     val appLanguage: StateFlow<String>
 
-    val fastText: StateFlow<String>
-
     val sendOnlineStatus: StateFlow<Boolean>
 
-    val showAlertAfterCrash: StateFlow<Boolean>
     val longPollInBackground: StateFlow<Boolean>
     val useBlur: StateFlow<Boolean>
-    val showEmojiButton: StateFlow<Boolean>
-    val showTimeInActionMessages: StateFlow<Boolean>
     val useSystemFont: StateFlow<Boolean>
     val enableAnimations: StateFlow<Boolean>
     val showDebugCategory: StateFlow<Boolean>
@@ -35,15 +30,10 @@ interface UserSettings {
     fun onEnableDynamicColorsChanged(enable: Boolean)
     fun onAppLanguageChanged(language: String)
 
-    fun onFastTextChanged(text: String)
-
     fun onSendOnlineStatusChanged(send: Boolean)
 
-    fun onShowAlertAfterCrashChanged(show: Boolean)
     fun onLongPollInBackgroundChanged(inBackground: Boolean)
     fun onUseBlurChanged(use: Boolean)
-    fun onShowEmojiButtonChanged(show: Boolean)
-    fun onShowTimeInActionMessagesChanged(show: Boolean)
     fun onUseSystemFontChanged(use: Boolean)
     fun onShowDebugCategoryChanged(show: Boolean)
 }
@@ -58,16 +48,11 @@ class UserSettingsImpl : UserSettings {
     override val enableDynamicColors = MutableStateFlow(AppSettings.Appearance.enableDynamicColors)
     override val appLanguage = MutableStateFlow(AppSettings.Appearance.appLanguage)
 
-    override val fastText = MutableStateFlow(AppSettings.Features.fastText)
-
     override val sendOnlineStatus = MutableStateFlow(AppSettings.Activity.sendOnlineStatus)
 
-    override val showAlertAfterCrash = MutableStateFlow(AppSettings.Debug.showAlertAfterCrash)
-    override val longPollInBackground = MutableStateFlow(AppSettings.Experimental.longPollInBackground)
+    override val longPollInBackground =
+        MutableStateFlow(AppSettings.Experimental.longPollInBackground)
     override val useBlur = MutableStateFlow(AppSettings.Experimental.useBlur)
-    override val showEmojiButton = MutableStateFlow(AppSettings.General.showEmojiButton)
-    override val showTimeInActionMessages =
-        MutableStateFlow(AppSettings.Experimental.showTimeInActionMessages)
     override val useSystemFont = MutableStateFlow(AppSettings.Appearance.useSystemFont)
     override val enableAnimations = MutableStateFlow(AppSettings.Experimental.moreAnimations)
     override val showDebugCategory = MutableStateFlow(AppSettings.Debug.showDebugCategory)
@@ -96,18 +81,10 @@ class UserSettingsImpl : UserSettings {
         appLanguage.value = language
     }
 
-    override fun onFastTextChanged(text: String) {
-        fastText.value = text
-    }
-
     override fun onSendOnlineStatusChanged(send: Boolean) {
         sendOnlineStatus.value = send
     }
 
-    override fun onShowAlertAfterCrashChanged(show: Boolean) {
-        showAlertAfterCrash.value = show
-    }
-
     override fun onLongPollInBackgroundChanged(inBackground: Boolean) {
         longPollInBackground.value = inBackground
     }
@@ -116,14 +93,6 @@ class UserSettingsImpl : UserSettings {
         useBlur.value = use
     }
 
-    override fun onShowEmojiButtonChanged(show: Boolean) {
-        showEmojiButton.value = show
-    }
-
-    override fun onShowTimeInActionMessagesChanged(show: Boolean) {
-        showTimeInActionMessages.value = show
-    }
-
     override fun onUseSystemFontChanged(use: Boolean) {
         useSystemFont.value = use
     }

core/domain/build.gradle.kts

@@ -8,11 +8,16 @@ android {
 }
 
 dependencies {
+    api(projects.core.common)
     api(projects.core.data)
     api(projects.core.model)
 
-    // TODO: 11/08/2024, Danil Nikolaev: remove?
     implementation(libs.kotlinx.coroutines.core)
     implementation(libs.koin.core)
     implementation(libs.eithernet)
+
+    implementation(libs.bundles.nanokt)
+
+    implementation(platform(libs.compose.bom))
+    implementation(libs.compose.ui)
 }

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

@@ -1,25 +1,25 @@
 package dev.meloda.fast.domain
 
 import dev.meloda.fast.data.State
-import dev.meloda.fast.model.ConversationsFilter
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.ConvosFilter
+import dev.meloda.fast.model.api.domain.VkConvo
 import kotlinx.coroutines.flow.Flow
 
-interface ConversationsUseCase : BaseUseCase {
+interface ConvoUseCase : BaseUseCase {
 
-    suspend fun storeConversations(conversations: List<VkConversation>)
+    suspend fun storeConvos(convos: List<VkConvo>)
 
-    fun getConversations(
+    fun getConvos(
         count: Int? = null,
         offset: Int? = null,
-        filter: ConversationsFilter
-    ): Flow<State<List<VkConversation>>>
+        filter: ConvosFilter
+    ): Flow<State<List<VkConvo>>>
 
     fun getById(
         peerIds: List<Long>,
         extended: Boolean? = null,
         fields: String? = null
-    ): Flow<State<List<VkConversation>>>
+    ): Flow<State<List<VkConvo>>>
 
     fun delete(peerId: Long): Flow<State<Long>>
 

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

@@ -1,30 +1,30 @@
 package dev.meloda.fast.domain
 
 import dev.meloda.fast.data.State
-import dev.meloda.fast.data.api.conversations.ConversationsRepository
+import dev.meloda.fast.data.api.convos.ConvosRepository
 import dev.meloda.fast.data.mapToState
-import dev.meloda.fast.model.ConversationsFilter
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.ConvosFilter
+import dev.meloda.fast.model.api.domain.VkConvo
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.withContext
 
-class ConversationsUseCaseImpl(
-    private val repository: ConversationsRepository,
-) : ConversationsUseCase {
+class ConvoUseCaseImpl(
+    private val repository: ConvosRepository,
+) : ConvoUseCase {
 
-    override suspend fun storeConversations(
-        conversations: List<VkConversation>
+    override suspend fun storeConvos(
+        convos: List<VkConvo>
     ) = withContext(Dispatchers.IO) {
-        repository.storeConversations(conversations)
+        repository.storeConvos(convos)
     }
 
-    override fun getConversations(
+    override fun getConvos(
         count: Int?,
         offset: Int?,
-        filter: ConversationsFilter
-    ): Flow<State<List<VkConversation>>> = flowNewState {
-        repository.getConversations(
+        filter: ConvosFilter
+    ): Flow<State<List<VkConvo>>> = flowNewState {
+        repository.getConvos(
             count = count,
             offset = offset,
             filter = filter
@@ -35,8 +35,8 @@ class ConversationsUseCaseImpl(
         peerIds: List<Long>,
         extended: Boolean?,
         fields: String?
-    ): Flow<State<List<VkConversation>>> = flowNewState {
-        repository.getConversationsById(
+    ): Flow<State<List<VkConvo>>> = flowNewState {
+        repository.getConvosById(
             peerIds = peerIds,
             extended = extended,
             fields = fields

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

@@ -0,0 +1,21 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.messages.MessagesRepository
+import dev.meloda.fast.data.mapToState
+import kotlinx.coroutines.flow.Flow
+
+class GetMessageReadPeersUseCase(
+    private val repository: MessagesRepository
+) : BaseUseCase {
+
+    operator fun invoke(
+        peerId: Long,
+        cmId: Long
+    ): Flow<State<Int>> = flowNewState {
+        repository.getMessageReadPeers(
+            peerId = peerId,
+            cmId = cmId
+        ).mapToState(successMapper = { it.totalCount })
+    }
+}

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

@@ -1,22 +1,22 @@
 package dev.meloda.fast.domain
 
 import dev.meloda.fast.data.State
-import dev.meloda.fast.data.api.conversations.ConversationsRepository
+import dev.meloda.fast.data.api.convos.ConvosRepository
 import dev.meloda.fast.data.mapToState
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import kotlinx.coroutines.flow.Flow
 
-class LoadConversationsByIdUseCase(
-    private val conversationsRepository: ConversationsRepository
+class LoadConvosByIdUseCase(
+    private val convosRepository: ConvosRepository
 ) : BaseUseCase {
 
     operator fun invoke(
         peerIds: List<Long>,
         extended: Boolean? = null,
         fields: String? = null
-    ): Flow<State<List<VkConversation>>> = flowNewState {
-        conversationsRepository
-            .getConversationsById(
+    ): Flow<State<List<VkConvo>>> = flowNewState {
+        convosRepository
+            .getConvosById(
                 peerIds = peerIds,
                 extended = extended,
                 fields = fields,

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

@@ -9,12 +9,12 @@ import dev.meloda.fast.common.extensions.toList
 import dev.meloda.fast.data.UserConfig
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.model.ApiEvent
-import dev.meloda.fast.model.ConversationFlags
+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.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
@@ -28,7 +28,7 @@ import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
 class LongPollUpdatesParser(
-    private val conversationsUseCase: ConversationsUseCase,
+    private val convoUseCase: ConvoUseCase,
     private val messagesUseCase: MessagesUseCase
 ) {
     private val job = SupervisorJob()
@@ -271,9 +271,9 @@ class LongPollUpdatesParser(
             val message =
                 async { loadMessage(peerId = peerId, cmId = cmId) }.await()
 
-            val conversation =
+            val convo =
                 async {
-                    loadConversation(
+                    loadConvo(
                         peerId = peerId,
                         extended = true,
                         fields = VkConstants.ALL_FIELDS
@@ -287,7 +287,7 @@ class LongPollUpdatesParser(
                             .onEvent(
                                 LongPollParsedEvent.NewMessage(
                                     message = message,
-                                    inArchive = conversation?.isArchived == true
+                                    inArchive = convo?.isArchived == true
                                     // TODO: 03-Apr-25, Danil Nikolaev:
                                     // load user settings about restoring chats with
                                     // enabled notifications from archive
@@ -368,13 +368,13 @@ class LongPollUpdatesParser(
 
         val eventsToSend = mutableListOf<LongPollParsedEvent>()
 
-        val parsedFlags = ConversationFlags.parse(flags)
+        val parsedFlags = ConvoFlags.parse(flags)
 
         coroutineScope.launch(Dispatchers.IO) {
             parsedFlags.forEach { flag ->
                 when (flag) {
-                    ConversationFlags.ARCHIVED -> {
-                        val conversation = loadConversation(
+                    ConvoFlags.ARCHIVED -> {
+                        val convo = loadConvo(
                             peerId = peerId,
                             extended = true,
                             fields = VkConstants.ALL_FIELDS
@@ -382,11 +382,11 @@ class LongPollUpdatesParser(
 
                         val message = loadMessage(
                             peerId = peerId,
-                            cmId = conversation.lastCmId
+                            cmId = convo.lastCmId
                         )
 
                         val eventToSend = LongPollParsedEvent.ChatArchived(
-                            conversation = conversation.copy(lastMessage = message),
+                            convo = convo.copy(lastMessage = message),
                             archived = false
                         )
                         eventsToSend += eventToSend
@@ -423,13 +423,13 @@ class LongPollUpdatesParser(
 
         val eventsToSend = mutableListOf<LongPollParsedEvent>()
 
-        val parsedFlags = ConversationFlags.parse(flags)
+        val parsedFlags = ConvoFlags.parse(flags)
 
         coroutineScope.launch(Dispatchers.IO) {
             parsedFlags.forEach { flag ->
                 when (flag) {
-                    ConversationFlags.ARCHIVED -> {
-                        val conversation = loadConversation(
+                    ConvoFlags.ARCHIVED -> {
+                        val convo = loadConvo(
                             peerId = peerId,
                             extended = true,
                             fields = VkConstants.ALL_FIELDS
@@ -437,11 +437,11 @@ class LongPollUpdatesParser(
 
                         val message = loadMessage(
                             peerId = peerId,
-                            cmId = conversation.lastCmId
+                            cmId = convo.lastCmId
                         )
 
                         val eventToSend = LongPollParsedEvent.ChatArchived(
-                            conversation = conversation.copy(lastMessage = message),
+                            convo = convo.copy(lastMessage = message),
                             archived = true
                         )
                         eventsToSend += eventToSend
@@ -673,29 +673,29 @@ class LongPollUpdatesParser(
         }
     }
 
-    private suspend fun loadConversation(
+    private suspend fun loadConvo(
         peerId: Long,
         extended: Boolean = false,
         fields: String? = null
-    ): VkConversation? = suspendCoroutine { continuation ->
+    ): VkConvo? = suspendCoroutine { continuation ->
         coroutineScope.launch(Dispatchers.IO) {
-            conversationsUseCase.getById(
+            convoUseCase.getById(
                 peerIds = listOf(peerId),
                 extended = extended,
                 fields = fields
             ).listenValue(coroutineScope) { state ->
                 state.processState(
                     error = { error ->
-                        Log.e("LongPollUpdatesParser", "loadConversation: error: $error")
+                        Log.e("LongPollUpdatesParser", "loadConvo: error: $error")
                         continuation.resume(null)
                     },
                     success = { response ->
-                        val conversation = response.singleOrNull() ?: run {
+                        val convo = response.singleOrNull() ?: run {
                             continuation.resume(null)
                             return@listenValue
                         }
 
-                        continuation.resume(conversation)
+                        continuation.resume(convo)
                     }
                 )
             }

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

@@ -14,7 +14,7 @@ interface MessagesUseCase : BaseUseCase {
     suspend fun storeMessages(messages: List<VkMessage>)
 
     fun getMessagesHistory(
-        conversationId: Long,
+        convoId: Long,
         count: Int?,
         offset: Int?
     ): Flow<State<MessagesHistoryInfo>>
@@ -32,8 +32,9 @@ interface MessagesUseCase : BaseUseCase {
         peerId: Long,
         randomId: Long,
         message: String?,
-        replyTo: Long?,
-        attachments: List<VkAttachment>?
+        forward: String?,
+        attachments: List<VkAttachment>?,
+        formatData: VkMessage.FormatData?
     ): Flow<State<MessagesSendResponse>>
 
     fun markAsRead(

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

@@ -23,12 +23,12 @@ class MessagesUseCaseImpl(
     }
 
     override fun getMessagesHistory(
-        conversationId: Long,
+        convoId: Long,
         count: Int?,
         offset: Int?
     ): Flow<State<MessagesHistoryInfo>> = flowNewState {
         repository.getHistory(
-            conversationId = conversationId,
+            convoId = convoId,
             offset = offset,
             count = count
         ).mapToState()
@@ -56,15 +56,17 @@ class MessagesUseCaseImpl(
         peerId: Long,
         randomId: Long,
         message: String?,
-        replyTo: Long?,
-        attachments: List<VkAttachment>?
+        forward: String?,
+        attachments: List<VkAttachment>?,
+        formatData: VkMessage.FormatData?
     ): Flow<State<MessagesSendResponse>> = flowNewState {
         repository.send(
             peerId = peerId,
             randomId = randomId,
             message = message,
-            replyTo = replyTo,
-            attachments = attachments
+            forward = forward,
+            attachments = attachments,
+            formatData = formatData
         ).mapToState()
     }
 

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

@@ -6,7 +6,8 @@ import dev.meloda.fast.domain.AccountUseCaseImpl
 import dev.meloda.fast.domain.GetCurrentAccountUseCase
 import dev.meloda.fast.domain.GetLocalUserByIdUseCase
 import dev.meloda.fast.domain.GetLocalUsersByIdsUseCase
-import dev.meloda.fast.domain.LoadConversationsByIdUseCase
+import dev.meloda.fast.domain.GetMessageReadPeersUseCase
+import dev.meloda.fast.domain.LoadConvosByIdUseCase
 import dev.meloda.fast.domain.LoadUserByIdUseCase
 import dev.meloda.fast.domain.LoadUsersByIdsUseCase
 import dev.meloda.fast.domain.StoreUsersUseCase
@@ -26,5 +27,7 @@ val domainModule = module {
     singleOf(::AccountUseCaseImpl) bind AccountUseCase::class
     singleOf(::GetCurrentAccountUseCase)
 
-    singleOf(::LoadConversationsByIdUseCase)
+    singleOf(::LoadConvosByIdUseCase)
+
+    singleOf(::GetMessageReadPeersUseCase)
 }

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

@@ -1,7 +1,6 @@
-package dev.meloda.fast.conversations.util
+package dev.meloda.fast.domain.util
 
 import android.content.res.Resources
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.buildAnnotatedString
@@ -13,56 +12,22 @@ import dev.meloda.fast.common.extensions.orDots
 import dev.meloda.fast.common.model.UiImage
 import dev.meloda.fast.common.model.UiText
 import dev.meloda.fast.common.model.parseString
-import dev.meloda.fast.common.util.TimeUtils
 import dev.meloda.fast.data.UserConfig
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.model.InteractionType
 import dev.meloda.fast.model.api.PeerType
 import dev.meloda.fast.model.api.data.AttachmentType
 import dev.meloda.fast.model.api.domain.VkAttachment
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
-import dev.meloda.fast.ui.model.api.ActionState
-import dev.meloda.fast.ui.model.api.ConversationOption
-import dev.meloda.fast.ui.model.api.UiConversation
-import dev.meloda.fast.ui.util.ImmutableList
-import dev.meloda.fast.ui.util.emptyImmutableList
+import dev.meloda.fast.model.api.domain.VkVideoDomain
+import dev.meloda.fast.ui.R
 import java.util.Calendar
 import java.util.Locale
 import kotlin.math.ln
 import kotlin.math.pow
-import dev.meloda.fast.ui.R as UiR
 
-fun VkConversation.asPresentation(
-    resources: Resources,
-    useContactName: Boolean,
-    isExpanded: Boolean = false,
-    options: ImmutableList<ConversationOption> = emptyImmutableList()
-): UiConversation = UiConversation(
-    id = id,
-    lastMessageId = lastMessageId,
-    avatar = extractAvatar(),
-    title = extractTitle(this, useContactName, resources),
-    unreadCount = extractUnreadCount(lastMessage, this),
-    date = TimeUtils.getLocalizedTime(resources, (lastMessage?.date ?: -1) * 1000L),
-    message = extractMessage(resources, lastMessage, id, peerType),
-    attachmentImage = if (lastMessage?.text == null) null
-    else getAttachmentConversationIcon(lastMessage),
-    isPinned = majorId > 0,
-    actionImageId = ActionState.parse(isPhantom, isCallInProgress).getResourceId(),
-    isBirthday = extractBirthday(this),
-    isUnread = !isRead(),
-    isAccount = isAccount(id),
-    isOnline = !isAccount(id) && user?.onlineStatus?.isOnline() == true,
-    lastMessage = lastMessage,
-    peerType = peerType,
-    interactionText = extractInteractionText(resources, this),
-    isExpanded = isExpanded,
-    isArchived = isArchived,
-    options = options
-)
-
-fun VkConversation.extractAvatar() = when (peerType) {
+fun VkConvo.extractAvatar(): UiImage = when (peerType) {
     PeerType.USER -> {
         if (isAccount(id)) null
         else user?.photo200
@@ -75,20 +40,19 @@ fun VkConversation.extractAvatar() = when (peerType) {
     PeerType.CHAT -> {
         photo200
     }
-}?.let(UiImage::Url) ?: UiImage.Resource(UiR.drawable.ic_account_circle_cut)
+}?.let(UiImage::Url) ?: UiImage.Resource(R.drawable.ic_account_circle_fill_round_24)
 
-private fun extractTitle(
-    conversation: VkConversation,
+fun VkConvo.extractTitle(
     useContactName: Boolean,
     resources: Resources
-) = when (conversation.peerType) {
+) = when (peerType) {
     PeerType.USER -> {
-        if (isAccount(conversation.id)) {
-            UiText.Resource(UiR.string.favorites)
+        if (isAccount(id)) {
+            UiText.Resource(R.string.favorites)
         } else {
-            val userName = conversation.user?.let { user ->
+            val userName = user?.let { user ->
                 if (useContactName) {
-                    VkMemoryCache.getContact(user.id)?.name ?: user.fullName
+                    VkMemoryCache.getContact(user.id)?.name
                 } else {
                     user.fullName
                 }
@@ -98,22 +62,22 @@ private fun extractTitle(
         }
     }
 
-    PeerType.GROUP -> UiText.Simple(conversation.group?.name.orDots())
-    PeerType.CHAT -> UiText.Simple(conversation.title.orDots())
+    PeerType.GROUP -> UiText.Simple(group?.name.orDots())
+    PeerType.CHAT -> UiText.Simple(title.orDots())
 }.parseString(resources).orDots()
 
-private fun extractUnreadCount(
+fun extractUnreadCount(
     lastMessage: VkMessage?,
-    conversation: VkConversation
+    convo: VkConvo
 ): String? = when {
-    lastMessage?.isOut == false && conversation.isInRead() -> null
-    conversation.unreadCount == 0 -> null
-    conversation.unreadCount < 1000 -> conversation.unreadCount.toString()
+    lastMessage?.isOut == false && convo.isInRead() -> null
+    convo.unreadCount == 0 -> null
+    convo.unreadCount < 1000 -> convo.unreadCount.toString()
     else -> {
-        val exp = (ln(conversation.unreadCount.toDouble()) / ln(1000.0)).toInt()
+        val exp = (ln(convo.unreadCount.toDouble()) / ln(1000.0)).toInt()
         val suffix = "KMBT"[exp - 1]
 
-        val result = conversation.unreadCount / 1000.0.pow(exp.toDouble())
+        val result = convo.unreadCount / 1000.0.pow(exp.toDouble())
 
         if (result.toLong().toDouble() == result) {
             String.format(Locale.getDefault(), "%.0f%s", result, suffix)
@@ -123,13 +87,14 @@ private fun extractUnreadCount(
     }
 }
 
-private fun extractMessage(
+fun extractMessage(
     resources: Resources,
     lastMessage: VkMessage?,
     peerId: Long,
-    peerType: PeerType
+    peerType: PeerType,
+    showPeer: Boolean = true
 ): AnnotatedString {
-    val youPrefix = UiText.Resource(UiR.string.you_message_prefix)
+    val youPrefix = UiText.Resource(R.string.you_message_prefix)
         .parseString(resources)
         .orDots()
 
@@ -152,6 +117,8 @@ private fun extractMessage(
     val messageText = lastMessage?.text.orEmpty()
 
     val prefixText: AnnotatedString? = when {
+        !showPeer -> null
+
         actionMessage != null -> null
 
         lastMessage == null -> null
@@ -218,16 +185,17 @@ private fun extractMessage(
                 .let { text ->
                     extractTextWithVisualizedMentions(
                         isOut = lastMessage?.isOut == true,
-                        originalText = text
+                        originalText = text,
+                        formatData = null
                     )
                 }
-                .let { text -> prefix + text }
+                .let { text -> prefix + text.orEmpty() }
     }
 
     return finalText
 }
 
-private fun extractActionText(
+fun extractActionText(
     lastMessage: VkMessage?,
     resources: Resources,
     youPrefix: String
@@ -264,7 +232,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_CREATE -> {
                 val string = UiText.ResourceParams(
-                    UiR.string.message_action_chat_created,
+                    R.string.message_action_chat_created,
                     listOf(prefix, text)
                 ).parseString(resources).orEmpty()
 
@@ -287,7 +255,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_TITLE_UPDATE -> {
                 val string = UiText.ResourceParams(
-                    UiR.string.message_action_chat_renamed,
+                    R.string.message_action_chat_renamed,
                     listOf(prefix, text)
                 ).parseString(resources).orEmpty()
 
@@ -310,7 +278,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_PHOTO_UPDATE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_photo_update,
+                    R.string.message_action_chat_photo_update,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -323,7 +291,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_PHOTO_REMOVE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_photo_remove,
+                    R.string.message_action_chat_photo_remove,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -337,7 +305,7 @@ private fun extractActionText(
             VkMessage.Action.CHAT_KICK_USER -> {
                 if (memberId == fromId) {
                     UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_left,
+                        R.string.message_action_chat_user_left,
                         listOf(memberPrefix)
                     ).parseString(resources).orEmpty().let(::append)
 
@@ -352,7 +320,7 @@ private fun extractActionText(
                         else lastMessage.actionUser.toString()
 
                     val string = UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_kicked,
+                        R.string.message_action_chat_user_kicked,
                         listOf(prefix, postfix)
                     ).parseString(resources).orEmpty()
 
@@ -377,7 +345,7 @@ private fun extractActionText(
             VkMessage.Action.CHAT_INVITE_USER -> {
                 if (memberId == lastMessage.fromId) {
                     UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_returned,
+                        R.string.message_action_chat_user_returned,
                         listOf(memberPrefix)
                     ).parseString(resources).orEmpty().let(::append)
 
@@ -392,7 +360,7 @@ private fun extractActionText(
                         else lastMessage.actionUser.toString()
 
                     val string = UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_invited,
+                        R.string.message_action_chat_user_invited,
                         listOf(memberPrefix, postfix)
                     ).parseString(resources).orEmpty()
 
@@ -410,7 +378,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_LINK -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_link,
+                    R.string.message_action_chat_user_joined_by_link,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -423,7 +391,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_CALL -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_call,
+                    R.string.message_action_chat_user_joined_by_call,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -436,7 +404,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_CALL_LINK -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_call_link,
+                    R.string.message_action_chat_user_joined_by_call_link,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -449,7 +417,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_PIN_MESSAGE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_pin_message,
+                    R.string.message_action_chat_pin_message,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -462,7 +430,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_UNPIN_MESSAGE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_unpin_message,
+                    R.string.message_action_chat_unpin_message,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -475,7 +443,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_SCREENSHOT -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_screenshot,
+                    R.string.message_action_chat_screenshot,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -488,7 +456,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_STYLE_UPDATE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_style_update,
+                    R.string.message_action_chat_style_update,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -502,16 +470,25 @@ private fun extractActionText(
     }
 }
 
-private fun extractAttachmentIcon(
+fun extractAttachmentIcon(
     lastMessage: VkMessage?
 ): UiImage? = when {
     lastMessage == null -> null
     lastMessage.text == null -> null
+    lastMessage.geoType != null -> {
+        val geoType = lastMessage.geoType
+        if (geoType == "point") {
+            UiImage.Resource(R.drawable.ic_pin_drop_fill_round_24)
+        } else {
+            UiImage.Resource(R.drawable.ic_map_fill_round_24)
+        }
+    }
+
     !lastMessage.forwards.isNullOrEmpty() -> {
         if (lastMessage.forwards.orEmpty().size == 1) {
-            UiImage.Resource(UiR.drawable.ic_attachment_forwarded_message)
+            UiImage.Resource(R.drawable.ic_reply_round_24)
         } else {
-            UiImage.Resource(UiR.drawable.ic_attachment_forwarded_messages)
+            UiImage.Resource(R.drawable.ic_reply_all_round_24)
         }
     }
 
@@ -519,19 +496,15 @@ private fun extractAttachmentIcon(
         lastMessage.attachments?.let { attachments ->
             if (attachments.isEmpty()) return null
             if (attachments.size == 1 || isAttachmentsHaveOneType(attachments)) {
-                lastMessage.geoType?.let {
-                    return UiImage.Resource(UiR.drawable.ic_map_marker)
-                }
-
                 getAttachmentIconByType(attachments.first().type)
             } else {
-                UiImage.Resource(UiR.drawable.ic_baseline_attach_file_24)
+                UiImage.Resource(R.drawable.ic_attach_file_round_24)
             }
         }
     }
 }
 
-private fun extractAttachmentText(
+fun extractAttachmentText(
     resources: Resources,
     lastMessage: VkMessage?
 ): AnnotatedString? = when {
@@ -541,13 +514,13 @@ private fun extractAttachmentText(
             withStyle(style = SpanStyle(fontWeight = FontWeight.SemiBold)) {
                 when (lastMessage.geoType) {
                     "point" -> {
-                        UiText.Resource(UiR.string.message_geo_point)
+                        UiText.Resource(R.string.message_geo_point)
                             .parseString(resources)
                             .let(::append)
                     }
 
                     else -> {
-                        UiText.Resource(UiR.string.message_geo)
+                        UiText.Resource(R.string.message_geo)
                             .parseString(resources)
                             .let(::append)
                     }
@@ -582,7 +555,7 @@ private fun extractAttachmentText(
                         }
 
                         else -> {
-                            UiText.Resource(UiR.string.message_attachments_many)
+                            UiText.Resource(R.string.message_attachments_many)
                                 .parseString(resources)
                                 .let(::append)
                         }
@@ -597,22 +570,22 @@ private fun extractAttachmentText(
 
 private fun getAttachmentIconByType(attachmentType: AttachmentType): UiImage? {
     return when (attachmentType) {
-        AttachmentType.PHOTO -> UiR.drawable.ic_attachment_photo
-        AttachmentType.VIDEO -> UiR.drawable.ic_attachment_video
-        AttachmentType.AUDIO -> UiR.drawable.ic_attachment_audio
-        AttachmentType.FILE -> UiR.drawable.ic_attachment_file
-        AttachmentType.LINK -> UiR.drawable.ic_attachment_link
-        AttachmentType.AUDIO_MESSAGE -> UiR.drawable.ic_attachment_voice
-        AttachmentType.MINI_APP -> UiR.drawable.ic_attachment_mini_app
-        AttachmentType.STICKER -> UiR.drawable.ic_attachment_sticker
-        AttachmentType.GIFT -> UiR.drawable.ic_attachment_gift
-        AttachmentType.WALL -> UiR.drawable.ic_attachment_wall
-        AttachmentType.GRAFFITI -> UiR.drawable.ic_attachment_graffiti
-        AttachmentType.POLL -> UiR.drawable.ic_attachment_poll
-        AttachmentType.WALL_REPLY -> UiR.drawable.ic_attachment_wall_reply
-        AttachmentType.CALL -> UiR.drawable.ic_attachment_call
-        AttachmentType.GROUP_CALL_IN_PROGRESS -> UiR.drawable.ic_attachment_group_call
-        AttachmentType.STORY -> UiR.drawable.ic_attachment_story
+        AttachmentType.PHOTO -> R.drawable.ic_image_fill_round_24
+        AttachmentType.VIDEO -> R.drawable.ic_video_fill_round_24
+        AttachmentType.AUDIO -> R.drawable.ic_music_note_round_24
+        AttachmentType.FILE -> R.drawable.ic_draft_fill_round_24
+        AttachmentType.LINK -> R.drawable.ic_language_round_24
+        AttachmentType.AUDIO_MESSAGE -> R.drawable.ic_mic_fill_round_24
+        AttachmentType.MINI_APP -> R.drawable.ic_widgets_fill_round_24
+        AttachmentType.STICKER -> R.drawable.ic_sticker_fill_round_24
+        AttachmentType.GIFT -> R.drawable.ic_attachment_gift_old
+        AttachmentType.WALL -> R.drawable.ic_brick_fill_round_24
+        AttachmentType.GRAFFITI -> R.drawable.ic_fragrance_fill_round_24
+        AttachmentType.POLL -> R.drawable.ic_insert_chart_fill_round_24
+        AttachmentType.WALL_REPLY -> R.drawable.ic_comment_fill_round_24
+        AttachmentType.CALL -> R.drawable.ic_call_round_24
+        AttachmentType.GROUP_CALL_IN_PROGRESS -> R.drawable.ic_perm_phone_msg_fill_round_24
+        AttachmentType.STORY -> R.drawable.ic_history_toggle_off_round_24
         AttachmentType.UNKNOWN -> null
         AttachmentType.CURATOR -> null
         AttachmentType.EVENT -> null
@@ -623,8 +596,9 @@ private fun getAttachmentIconByType(attachmentType: AttachmentType): UiImage? {
         AttachmentType.NARRATIVE -> null
         AttachmentType.ARTICLE -> null
         AttachmentType.VIDEO_MESSAGE -> null
-        AttachmentType.GROUP_CHAT_STICKER -> UiR.drawable.ic_attachment_sticker
+        AttachmentType.GROUP_CHAT_STICKER -> R.drawable.ic_sticker_fill_round_24
         AttachmentType.STICKER_PACK_PREVIEW -> null
+        AttachmentType.CHANNEL_MESSAGE -> null
     }?.let(UiImage::Resource)
 }
 
@@ -641,7 +615,7 @@ private fun isAttachmentsHaveOneType(attachments: List<VkAttachment>): Boolean {
     return true
 }
 
-private fun extractForwardsText(
+fun extractForwardsText(
     resources: Resources,
     lastMessage: VkMessage?
 ): AnnotatedString? = when {
@@ -652,8 +626,8 @@ private fun extractForwardsText(
         withStyle(style = SpanStyle(fontWeight = FontWeight.SemiBold)) {
             append(
                 UiText.Resource(
-                    if (forwards.size == 1) UiR.string.forwarded_message
-                    else UiR.string.forwarded_messages
+                    if (forwards.size == 1) R.string.forwarded_message
+                    else R.string.forwarded_messages
                 ).parseString(resources)
             )
         }
@@ -662,78 +636,22 @@ private fun extractForwardsText(
     else -> null
 }
 
-fun extractTextWithVisualizedMentions(
-    isOut: Boolean,
-    originalText: String
-): AnnotatedString = buildAnnotatedString {
-    val regex = """\[(id|club)(\d+)\|([^]]+)]""".toRegex()
-
-    val mentions = mutableListOf<MentionIndex>()
-
-    var currentIndex = 0
-    val replacements = mutableListOf<Pair<IntRange, String>>()
-
-    val result = regex.replace(originalText) { matchResult ->
-        val idPrefix = matchResult.groups[1]?.value.orEmpty()
-        val startIndex = matchResult.range.first
-        val endIndex = matchResult.range.last
-
-        val id = matchResult.groups[2]?.value ?: ""
-
-        val replaced = matchResult.groups[3]?.value.orEmpty()
-
-        val indexRange =
-            (startIndex + currentIndex)..startIndex + currentIndex + replaced.length
-
-        replacements.add(indexRange to replaced)
-
-        mentions += MentionIndex(
-            id = id.toLongOrNull() ?: -1,
-            idPrefix = idPrefix,
-            indexRange = indexRange
-        )
-
-        currentIndex += replaced.length - (endIndex - startIndex + 1)
-
-        replaced
-    }
-
-    append(result)
-
-    mentions.forEach { mention ->
-        val startIndex = mention.indexRange.first
-        val endIndex = mention.indexRange.last
-
-        addStyle(
-            style = SpanStyle(color = Color.Red),
-            start = startIndex,
-            end = endIndex
-        )
-        addStringAnnotation(
-            tag = mention.idPrefix,
-            annotation = mention.id.toString(),
-            start = startIndex,
-            end = endIndex
-        )
-    }
-}
-
-data class MentionIndex(
-    val id: Long,
-    val idPrefix: String,
-    val indexRange: IntRange
-)
-
-private fun getAttachmentUiText(
+fun getAttachmentUiText(
     attachment: VkAttachment,
     size: Int = 1,
 ): UiText {
+    if (attachment.type == AttachmentType.VIDEO &&
+        (attachment as? VkVideoDomain)?.isShortVideo == true
+    ) {
+        return UiText.Resource(R.string.message_attachments_clip)
+    }
+
     if (attachment.type.isMultiple()) {
         return when (attachment.type) {
-            AttachmentType.PHOTO -> UiR.plurals.attachment_photos
-            AttachmentType.VIDEO -> UiR.plurals.attachment_videos
-            AttachmentType.AUDIO -> UiR.plurals.attachment_audios
-            AttachmentType.FILE -> UiR.plurals.attachment_files
+            AttachmentType.PHOTO -> R.plurals.attachment_photos
+            AttachmentType.VIDEO -> R.plurals.attachment_videos
+            AttachmentType.AUDIO -> R.plurals.attachment_audios
+            AttachmentType.FILE -> R.plurals.attachment_files
             else -> throw IllegalArgumentException("Unknown multiple type: ${attachment.type}")
         }.let { resId -> UiText.QuantityResource(resId, size) }
     }
@@ -747,48 +665,35 @@ private fun getAttachmentUiText(
             throw IllegalArgumentException("Unknown multiple type: ${attachment.type}")
         }
 
-        AttachmentType.LINK -> UiR.string.message_attachments_link
-        AttachmentType.AUDIO_MESSAGE -> UiR.string.message_attachments_audio_message
-        AttachmentType.MINI_APP -> UiR.string.message_attachments_mini_app
-        AttachmentType.STICKER -> UiR.string.message_attachments_sticker
-        AttachmentType.GIFT -> UiR.string.message_attachments_gift
-        AttachmentType.WALL -> UiR.string.message_attachments_wall
-        AttachmentType.GRAFFITI -> UiR.string.message_attachments_graffiti
-        AttachmentType.POLL -> UiR.string.message_attachments_poll
-        AttachmentType.WALL_REPLY -> UiR.string.message_attachments_wall_reply
-        AttachmentType.CALL -> UiR.string.message_attachments_call
-        AttachmentType.GROUP_CALL_IN_PROGRESS -> UiR.string.message_attachments_call_in_progress
-        AttachmentType.CURATOR -> UiR.string.message_attachments_curator
-        AttachmentType.EVENT -> UiR.string.message_attachments_event
-        AttachmentType.STORY -> UiR.string.message_attachments_story
-        AttachmentType.WIDGET -> UiR.string.message_attachments_widget
-        AttachmentType.ARTIST -> UiR.string.message_attachments_artist
-        AttachmentType.AUDIO_PLAYLIST -> UiR.string.message_attachments_audio_playlist
-        AttachmentType.PODCAST -> UiR.string.message_attachments_podcast
-        AttachmentType.NARRATIVE -> UiR.string.message_attachments_narrative
-        AttachmentType.ARTICLE -> UiR.string.message_attachments_article
-        AttachmentType.VIDEO_MESSAGE -> UiR.string.message_attachments_video_message
-        AttachmentType.GROUP_CHAT_STICKER -> UiR.string.message_attachments_group_sticker
-        AttachmentType.STICKER_PACK_PREVIEW -> UiR.string.message_attachments_sticker_pack_preview
+        AttachmentType.LINK -> R.string.message_attachments_link
+        AttachmentType.AUDIO_MESSAGE -> R.string.message_attachments_audio_message
+        AttachmentType.MINI_APP -> R.string.message_attachments_mini_app
+        AttachmentType.STICKER -> R.string.message_attachments_sticker
+        AttachmentType.GIFT -> R.string.message_attachments_gift
+        AttachmentType.WALL -> R.string.message_attachments_wall
+        AttachmentType.GRAFFITI -> R.string.message_attachments_graffiti
+        AttachmentType.POLL -> R.string.message_attachments_poll
+        AttachmentType.WALL_REPLY -> R.string.message_attachments_wall_reply
+        AttachmentType.CALL -> R.string.message_attachments_call
+        AttachmentType.GROUP_CALL_IN_PROGRESS -> R.string.message_attachments_call_in_progress
+        AttachmentType.CURATOR -> R.string.message_attachments_curator
+        AttachmentType.EVENT -> R.string.message_attachments_event
+        AttachmentType.STORY -> R.string.message_attachments_story
+        AttachmentType.WIDGET -> R.string.message_attachments_widget
+        AttachmentType.ARTIST -> R.string.message_attachments_artist
+        AttachmentType.AUDIO_PLAYLIST -> R.string.message_attachments_audio_playlist
+        AttachmentType.PODCAST -> R.string.message_attachments_podcast
+        AttachmentType.NARRATIVE -> R.string.message_attachments_narrative
+        AttachmentType.ARTICLE -> R.string.message_attachments_article
+        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)
 }
 
-private fun getAttachmentConversationIcon(message: VkMessage?): UiImage? {
-    return message?.attachments?.let { attachments ->
-        if (attachments.isEmpty()) return null
-        if (attachments.size == 1 || isAttachmentsHaveOneType(attachments)) {
-            message.geoType?.let {
-                return UiImage.Resource(UiR.drawable.ic_map_marker)
-            }
-            getAttachmentIconByType(attachments.first().type)
-        } else {
-            UiImage.Resource(UiR.drawable.ic_baseline_attach_file_24)
-        }
-    }
-}
-
-private fun extractBirthday(conversation: VkConversation): Boolean {
-    val birthday = conversation.user?.birthday ?: return false
+fun extractBirthday(convo: VkConvo): Boolean {
+    val birthday = convo.user?.birthday ?: return false
     val splitBirthday = birthday.split(".").mapNotNull(String::toIntOrNull)
 
     if (splitBirthday.isEmpty()) return false
@@ -808,37 +713,35 @@ private fun extractBirthday(conversation: VkConversation): Boolean {
     } else false
 }
 
-private fun extractReadCondition(
-    conversation: VkConversation,
+fun extractReadCondition(
+    convo: VkConvo,
     lastMessage: VkMessage?
-): Boolean = !conversation.isRead(lastMessage)
+): Boolean = !convo.isRead(lastMessage)
 
-private fun isAccount(peerId: Long) = peerId == UserConfig.userId
-
-private fun extractInteractionText(
+fun extractInteractionText(
     resources: Resources,
-    conversation: VkConversation
+    convo: VkConvo
 ): String? {
-    val interactionType = InteractionType.parse(conversation.interactionType)
-    val interactiveUsers = extractInteractionUsers(conversation)
+    val interactionType = InteractionType.parse(convo.interactionType)
+    val interactiveUsers = extractInteractionUsers(convo)
 
     val typingText =
         if (interactionType == null) {
             null
         } else {
-            if (!conversation.peerType.isChat() && interactiveUsers.size == 1) {
+            if (!convo.peerType.isChat() && interactiveUsers.size == 1) {
                 when (interactionType) {
-                    InteractionType.File -> UiR.string.chat_interaction_uploading_file
-                    InteractionType.Photo -> UiR.string.chat_interaction_uploading_photo
-                    InteractionType.Typing -> UiR.string.chat_interaction_typing
-                    InteractionType.Video -> UiR.string.chat_interaction_uploading_video
-                    InteractionType.VoiceMessage -> UiR.string.chat_interaction_recording_audio_message
+                    InteractionType.File -> R.string.chat_interaction_uploading_file
+                    InteractionType.Photo -> R.string.chat_interaction_uploading_photo
+                    InteractionType.Typing -> R.string.chat_interaction_typing
+                    InteractionType.Video -> R.string.chat_interaction_uploading_video
+                    InteractionType.VoiceMessage -> R.string.chat_interaction_recording_audio_message
                 }.let(UiText::Resource)
             } else {
                 if (interactiveUsers.size == 1) {
-                    UiR.string.chat_interaction_chat_single_typing
+                    R.string.chat_interaction_chat_single_typing
                 } else {
-                    UiR.string.chat_interaction_chat_typing
+                    R.string.chat_interaction_chat_typing
                 }.let { resId ->
                     UiText.ResourceParams(
                         resId,
@@ -851,8 +754,8 @@ private fun extractInteractionText(
     return typingText
 }
 
-private fun extractInteractionUsers(conversation: VkConversation): List<String> {
-    return conversation.interactionIds.mapNotNull { id ->
+fun extractInteractionUsers(convo: VkConvo): List<String> {
+    return convo.interactionIds.mapNotNull { id ->
         when {
             id > 0 -> VkMemoryCache.getUser(id)?.fullName
             id < 0 -> VkMemoryCache.getGroup(id)?.name

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

@@ -0,0 +1,49 @@
+package dev.meloda.fast.domain.util
+
+import android.content.res.Resources
+import dev.meloda.fast.common.util.TimeUtils
+import dev.meloda.fast.model.api.domain.VkConvo
+import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.model.vk.ActionState
+import dev.meloda.fast.ui.model.vk.ConvoOption
+import dev.meloda.fast.ui.model.vk.UiConvo
+import dev.meloda.fast.ui.util.ImmutableList
+import dev.meloda.fast.ui.util.emptyImmutableList
+
+fun VkConvo.asPresentation(
+    resources: Resources,
+    useContactName: Boolean,
+    isExpanded: Boolean = false,
+    options: ImmutableList<ConvoOption> = emptyImmutableList()
+): UiConvo = UiConvo(
+    id = id,
+    lastMessageId = lastMessageId,
+    avatar = extractAvatar(),
+    title = extractTitle(useContactName, resources),
+    unreadCount = extractUnreadCount(lastMessage, this),
+    date = TimeUtils.getLocalizedTime(
+        date = (lastMessage?.date ?: -1) * 1000L,
+        yearShort = { resources.getString(R.string.year_short) },
+        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),
+    attachmentImage = if (lastMessage?.text == null) null
+    else extractAttachmentIcon(lastMessage),
+    isPinned = majorId > 0,
+    actionImageId = ActionState.parse(isPhantom, isCallInProgress).getResourceId(),
+    isBirthday = extractBirthday(this),
+    isUnread = !isRead(),
+    isAccount = isAccount(id),
+    isOnline = !isAccount(id) && user?.onlineStatus?.isOnline() == true,
+    lastMessage = lastMessage,
+    peerType = peerType,
+    interactionText = extractInteractionText(resources, this),
+    isExpanded = isExpanded,
+    isArchived = isArchived,
+    options = options
+)

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

@@ -3,7 +3,7 @@ package dev.meloda.fast.domain.util
 import dev.meloda.fast.common.model.UiImage
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.model.api.domain.VkUser
-import dev.meloda.fast.ui.model.api.UiFriend
+import dev.meloda.fast.ui.model.vk.UiFriend
 
 fun VkUser.asPresentation(
     useContactNames: Boolean = false

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

@@ -1,34 +1,20 @@
-package dev.meloda.fast.messageshistory.util
+package dev.meloda.fast.domain.util
 
 import android.content.res.Resources
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.AnnotatedString.Annotation
 import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.StringAnnotation
 import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextDecoration
 import dev.meloda.fast.common.extensions.orDots
 import dev.meloda.fast.common.model.UiImage
 import dev.meloda.fast.common.model.UiText
 import dev.meloda.fast.common.model.parseString
-import dev.meloda.fast.common.provider.ResourceProvider
 import dev.meloda.fast.data.UserConfig
-import dev.meloda.fast.data.VkMemoryCache
-import dev.meloda.fast.messageshistory.model.SendingStatus
-import dev.meloda.fast.messageshistory.model.UiItem
-import dev.meloda.fast.model.api.PeerType
-import dev.meloda.fast.model.api.domain.FormatDataType
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.PeerType.Companion.getPeerType
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.ui.R
 import java.text.SimpleDateFormat
 import java.util.Locale
-import dev.meloda.fast.ui.R as UiR
-
-private fun isAccount(fromId: Long) = fromId == UserConfig.userId
 
 fun VkMessage.extractAvatar() = when {
     isUser() -> {
@@ -41,7 +27,7 @@ fun VkMessage.extractAvatar() = when {
     }
 
     else -> null
-}?.let(UiImage::Url) ?: UiImage.Resource(UiR.drawable.ic_account_circle_cut)
+}?.let(UiImage::Url) ?: UiImage.Resource(R.drawable.ic_account_circle_fill_round_24)
 
 fun VkMessage.extractDate(): String =
     SimpleDateFormat("HH:mm", Locale.getDefault()).format(date * 1000L)
@@ -57,96 +43,17 @@ fun VkMessage.extractTitle(): String = when {
     else -> throw IllegalStateException("Message is not from user nor group. fromId: $fromId")
 }
 
-fun VkConversation.extractAvatar(): UiImage = when (peerType) {
-    PeerType.USER -> {
-        if (isAccount(id)) null
-        else user?.photo200
-    }
+fun VkMessage.extractReplyTitle(): String? = replyMessage?.extractTitle()
 
-    PeerType.GROUP -> {
-        group?.photo200
-    }
-
-    PeerType.CHAT -> {
-        photo200
-    }
-}?.let(UiImage::Url) ?: UiImage.Resource(R.drawable.ic_account_circle_cut)
-
-fun VkConversation.extractTitle(
-    useContactName: Boolean,
-    resources: Resources
-) = when (peerType) {
-    PeerType.USER -> {
-        if (isAccount(id)) {
-            UiText.Resource(UiR.string.favorites)
-        } else {
-            val userName = user?.let { user ->
-                if (useContactName) {
-                    VkMemoryCache.getContact(user.id)?.name
-                } else {
-                    user.fullName
-                }
-            }
-
-            UiText.Simple(userName.orDots())
-        }
-    }
-
-    PeerType.GROUP -> UiText.Simple(group?.name.orDots())
-    PeerType.CHAT -> UiText.Simple(title.orDots())
-}.parseString(resources).orDots()
-
-fun VkMessage.asPresentation(
-    conversation: VkConversation,
-    resourceProvider: ResourceProvider,
-    showName: Boolean,
-    prevMessage: VkMessage?,
-    nextMessage: VkMessage?,
-    showTimeInActionMessages: Boolean,
-    isSelected: Boolean
-): UiItem = when {
-    action != null -> UiItem.ActionMessage(
-        id = id,
-        conversationMessageId = cmId,
-        text = extractActionText(
-            resources = resourceProvider.resources,
-            youPrefix = resourceProvider.getString(R.string.you_message_prefix),
-            showTime = showTimeInActionMessages
-        ) ?: buildAnnotatedString { },
-        actionCmId = actionConversationMessageId
+fun VkMessage.extractReplySummary(resources: Resources): AnnotatedString? =
+    extractMessage(
+        resources = resources,
+        lastMessage = this,
+        peerId = peerId,
+        peerType = getPeerType(),
+        showPeer = false
     )
 
-    else -> UiItem.Message(
-        id = id,
-        conversationMessageId = cmId,
-        text = extractTextWithVisualizedMentions(
-            isOut = isOut,
-            originalText = text,
-            formatData = formatData
-        ),
-        isOut = isOut,
-        fromId = fromId,
-        date = extractDate(),
-        randomId = randomId,
-        isInChat = isPeerChat(),
-        name = extractTitle(),
-        showDate = true,
-        showAvatar = extractShowAvatar(nextMessage),
-        showName = showName && extractShowName(prevMessage),
-        avatar = extractAvatar(),
-        isEdited = updateTime != null,
-        isRead = isRead(conversation),
-        sendingStatus = when {
-            isFailed() -> SendingStatus.FAILED
-            id <= 0 -> SendingStatus.SENDING
-            else -> SendingStatus.SENT
-        },
-        isSelected = isSelected,
-        isPinned = isPinned,
-        isImportant = isImportant
-    )
-}
-
 fun VkMessage.extractShowAvatar(nextMessage: VkMessage?): Boolean {
     if (isOut) return false
     return nextMessage == null || nextMessage.fromId != fromId
@@ -197,7 +104,7 @@ fun VkMessage.extractActionText(
         when (action) {
             VkMessage.Action.CHAT_CREATE -> {
                 val string = UiText.ResourceParams(
-                    UiR.string.message_action_chat_created,
+                    R.string.message_action_chat_created,
                     listOf(prefix, text)
                 ).parseString(resources)
                     .orEmpty()
@@ -225,7 +132,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_TITLE_UPDATE -> {
                 val string = UiText.ResourceParams(
-                    UiR.string.message_action_chat_renamed,
+                    R.string.message_action_chat_renamed,
                     listOf(prefix, text)
                 ).parseString(resources)
                     .orEmpty()
@@ -253,7 +160,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_PHOTO_UPDATE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_photo_update,
+                    R.string.message_action_chat_photo_update,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -273,7 +180,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_PHOTO_REMOVE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_photo_remove,
+                    R.string.message_action_chat_photo_remove,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -294,7 +201,7 @@ fun VkMessage.extractActionText(
             VkMessage.Action.CHAT_KICK_USER -> {
                 if (memberId == fromId) {
                     UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_left,
+                        R.string.message_action_chat_user_left,
                         listOf(memberPrefix)
                     ).parseString(resources)
                         .orEmpty()
@@ -316,7 +223,7 @@ fun VkMessage.extractActionText(
                         else lastMessage.actionUser.toString()
 
                     val string = UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_kicked,
+                        R.string.message_action_chat_user_kicked,
                         listOf(prefix, postfix)
                     ).parseString(resources)
                         .orEmpty()
@@ -346,7 +253,7 @@ fun VkMessage.extractActionText(
             VkMessage.Action.CHAT_INVITE_USER -> {
                 if (memberId == lastMessage.fromId) {
                     UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_returned,
+                        R.string.message_action_chat_user_returned,
                         listOf(memberPrefix)
                     ).parseString(resources)
                         .orEmpty()
@@ -368,7 +275,7 @@ fun VkMessage.extractActionText(
                         else lastMessage.actionUser.toString()
 
                     val string = UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_invited,
+                        R.string.message_action_chat_user_invited,
                         listOf(memberPrefix, postfix)
                     ).parseString(resources)
                         .orEmpty()
@@ -391,7 +298,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_LINK -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_link,
+                    R.string.message_action_chat_user_joined_by_link,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -411,7 +318,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_CALL -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_call,
+                    R.string.message_action_chat_user_joined_by_call,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -431,7 +338,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_CALL_LINK -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_call_link,
+                    R.string.message_action_chat_user_joined_by_call_link,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -456,7 +363,7 @@ fun VkMessage.extractActionText(
 //                val hasMessageText = messageText.isNotEmpty()
 
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_pin_message,
+                    R.string.message_action_chat_pin_message,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -492,7 +399,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_UNPIN_MESSAGE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_unpin_message,
+                    R.string.message_action_chat_unpin_message,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -512,7 +419,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_SCREENSHOT -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_screenshot,
+                    R.string.message_action_chat_screenshot,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -532,7 +439,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_STYLE_UPDATE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_style_update,
+                    R.string.message_action_chat_style_update,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -552,144 +459,3 @@ fun VkMessage.extractActionText(
         }
     }
 }
-
-// TODO: 04-Apr-25, Danil Nikolaev: get rid of method duplication
-fun extractTextWithVisualizedMentions(
-    isOut: Boolean,
-    originalText: String?,
-    formatData: VkMessage.FormatData?
-): AnnotatedString? {
-    if (originalText == null) return null
-
-    val annotations =
-        mutableListOf<AnnotatedString.Range<out Annotation>>()
-
-    val regex = """\[(id|club)(\d+)\|([^]]+)]""".toRegex()
-
-    val mentions = mutableListOf<MentionIndex>()
-
-    var currentIndex = 0
-    val replacements = mutableListOf<Pair<IntRange, String>>()
-
-    val newText = regex.replace(originalText) { matchResult ->
-        val idPrefix = matchResult.groups[1]?.value.orEmpty()
-        val startIndex = matchResult.range.first
-        val endIndex = matchResult.range.last
-
-        val id = matchResult.groups[2]?.value ?: ""
-
-        val replaced = matchResult.groups[3]?.value.orEmpty()
-
-        val indexRange =
-            (startIndex + currentIndex)..startIndex + currentIndex + replaced.length
-
-        replacements.add(indexRange to replaced)
-
-        mentions += MentionIndex(
-            id = id.toLongOrNull() ?: -1,
-            idPrefix = idPrefix,
-            indexRange = indexRange
-        )
-
-        currentIndex += replaced.length - (endIndex - startIndex + 1)
-
-        replaced
-    }
-
-    mentions.forEach { mention ->
-        val startIndex = mention.indexRange.first
-        val endIndex = mention.indexRange.last
-
-        annotations += AnnotatedString.Range(
-            item = SpanStyle(color = Color.Red),
-            start = startIndex,
-            end = endIndex
-        )
-        annotations += AnnotatedString.Range(
-            item = StringAnnotation(mention.id.toString()),
-            tag = mention.idPrefix,
-            start = startIndex,
-            end = endIndex
-        )
-    }
-
-    if (formatData == null) return AnnotatedString(text = newText, annotations = annotations)
-
-    var current = 0
-
-    val newOffsets = formatData.items.map { (offset, length) ->
-        val r = replacements.filter { (range, _) ->
-            (range - current) collidesWith (offset..<offset + length) || offset > range.first
-        }
-
-        current = r.sumOf { (range, _) -> range.last - range.first - 1 }
-
-        offset + current
-    }
-
-    formatData.items.forEachIndexed { index, item ->
-        val offset = newOffsets[index]
-
-        val spanStyle = when (item.type) {
-            FormatDataType.BOLD -> {
-                SpanStyle(fontWeight = FontWeight.SemiBold)
-            }
-
-            FormatDataType.ITALIC -> {
-                SpanStyle(fontStyle = FontStyle.Italic)
-            }
-
-            FormatDataType.UNDERLINE -> {
-                SpanStyle(textDecoration = TextDecoration.Underline)
-            }
-
-            FormatDataType.URL -> {
-                annotations += AnnotatedString.Range(
-                    item = StringAnnotation(item.url.orEmpty()),
-                    start = offset,
-                    end = offset + item.length,
-                    tag = newText.substring(offset, offset + item.length)
-                )
-
-                if (isOut) {
-                    SpanStyle(
-                        fontWeight = FontWeight.SemiBold,
-                        textDecoration = TextDecoration.Underline
-                    )
-
-                } else {
-                    SpanStyle(
-                        fontWeight = FontWeight.SemiBold,
-                        color = Color.Red
-                    )
-                }
-            }
-        }
-
-        annotations += AnnotatedString.Range(
-            item = spanStyle,
-            start = offset,
-            end = offset + item.length
-        )
-    }
-
-    return AnnotatedString(text = newText, annotations = annotations)
-}
-
-data class MentionIndex(
-    val id: Long,
-    val idPrefix: String,
-    val indexRange: IntRange
-)
-
-infix fun ClosedRange<Int>.collidesWith(other: ClosedRange<Int>): Boolean {
-    return this.start < other.endInclusive && other.start < this.endInclusive
-}
-
-operator fun ClosedRange<Int>.minus(other: ClosedRange<Int>): ClosedRange<Int> {
-    return (this.start - other.start)..(this.endInclusive - other.endInclusive)
-}
-
-operator fun ClosedRange<Int>.minus(other: Int): ClosedRange<Int> {
-    return (this.start - other)..(this.endInclusive - other)
-}

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

@@ -0,0 +1,65 @@
+package dev.meloda.fast.domain.util
+
+import androidx.compose.ui.text.buildAnnotatedString
+import dev.meloda.fast.common.provider.ResourceProvider
+import dev.meloda.fast.model.api.domain.VkConvo
+import dev.meloda.fast.model.api.domain.VkMessage
+import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.model.vk.MessageUiItem
+import dev.meloda.fast.ui.model.vk.SendingStatus
+import dev.meloda.fast.ui.util.ImmutableList.Companion.toImmutableList
+
+fun VkMessage.asPresentation(
+    convo: VkConvo,
+    resourceProvider: ResourceProvider,
+    showName: Boolean,
+    prevMessage: VkMessage?,
+    nextMessage: VkMessage?,
+    showTimeInActionMessages: Boolean,
+    isSelected: Boolean
+): MessageUiItem = when {
+    action != null -> MessageUiItem.ActionMessage(
+        id = id,
+        cmId = cmId,
+        text = extractActionText(
+            resources = resourceProvider.resources,
+            youPrefix = resourceProvider.getString(R.string.you_message_prefix),
+            showTime = showTimeInActionMessages
+        ) ?: buildAnnotatedString { },
+        actionCmId = actionCmId
+    )
+
+    else -> MessageUiItem.Message(
+        id = id,
+        cmId = cmId,
+        text = extractTextWithVisualizedMentions(
+            isOut = isOut,
+            originalText = text,
+            formatData = formatData
+        ),
+        isOut = isOut,
+        fromId = fromId,
+        date = extractDate(),
+        randomId = randomId,
+        isInChat = isPeerChat(),
+        name = extractTitle(),
+        showDate = true,
+        showAvatar = extractShowAvatar(nextMessage),
+        showName = showName && extractShowName(prevMessage),
+        avatar = extractAvatar(),
+        isEdited = updateTime != null,
+        isRead = isRead(convo),
+        sendingStatus = when {
+            isFailed() -> SendingStatus.FAILED
+            id <= 0 -> SendingStatus.SENDING
+            else -> SendingStatus.SENT
+        },
+        isSelected = isSelected,
+        isPinned = isPinned,
+        isImportant = isImportant,
+        attachments = attachments?.ifEmpty { null }?.toImmutableList(),
+        replyCmId = replyMessage?.cmId,
+        replyTitle = extractReplyTitle(),
+        replySummary = replyMessage?.extractReplySummary(resourceProvider.resources)
+    )
+}

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

@@ -0,0 +1,177 @@
+package dev.meloda.fast.domain.util
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.StringAnnotation
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextDecoration
+import com.conena.nanokt.collections.indexOfFirstOrNull
+import dev.meloda.fast.common.extensions.collidesWith
+import dev.meloda.fast.common.extensions.minus
+import dev.meloda.fast.data.UserConfig
+import dev.meloda.fast.model.api.domain.FormatDataType
+import dev.meloda.fast.model.api.domain.VkMessage
+import dev.meloda.fast.ui.model.vk.MentionIndex
+import dev.meloda.fast.ui.model.vk.MessageUiItem
+
+fun emptyAnnotatedString(): AnnotatedString = AnnotatedString(text = "")
+
+fun AnnotatedString?.orEmpty(): AnnotatedString = this ?: emptyAnnotatedString()
+
+fun String.annotated(): AnnotatedString = AnnotatedString(text = this)
+
+fun isAccount(id: Long) = id == UserConfig.userId
+
+fun extractTextWithVisualizedMentions(
+    isOut: Boolean,
+    originalText: String?,
+    formatData: VkMessage.FormatData?
+): AnnotatedString? {
+    if (originalText == null) return null
+
+    val annotations =
+        mutableListOf<AnnotatedString.Range<out androidx.compose.ui.text.AnnotatedString.Annotation>>()
+
+    val regex = """\[(id|club)(\d+)\|([^]]+)]""".toRegex()
+
+    val mentions = mutableListOf<MentionIndex>()
+
+    var currentIndex = 0
+    val replacements = mutableListOf<Pair<IntRange, String>>()
+
+    val newText = regex.replace(originalText) { matchResult ->
+        val idPrefix = matchResult.groups[1]?.value.orEmpty()
+        val startIndex = matchResult.range.first
+        val endIndex = matchResult.range.last
+
+        val id = matchResult.groups[2]?.value ?: ""
+
+        val replaced = matchResult.groups[3]?.value.orEmpty()
+
+        val indexRange =
+            (startIndex + currentIndex)..startIndex + currentIndex + replaced.length
+
+        replacements.add(indexRange to replaced)
+
+        mentions += MentionIndex(
+            id = id.toLongOrNull() ?: -1,
+            idPrefix = idPrefix,
+            indexRange = indexRange
+        )
+
+        currentIndex += replaced.length - (endIndex - startIndex + 1)
+
+        replaced
+    }
+
+    mentions.forEach { mention ->
+        val startIndex = mention.indexRange.first
+        val endIndex = mention.indexRange.last
+
+        annotations += if (isOut) {
+            AnnotatedString.Range(
+                item = SpanStyle(textDecoration = TextDecoration.Underline),
+                start = startIndex,
+                end = endIndex
+            )
+        } else {
+            AnnotatedString.Range(
+                item = SpanStyle(color = Color.Red),
+                start = startIndex,
+                end = endIndex
+            )
+        }
+
+        annotations += AnnotatedString.Range(
+            item = StringAnnotation(mention.id.toString()),
+            tag = mention.idPrefix,
+            start = startIndex,
+            end = endIndex
+        )
+    }
+
+    if (formatData == null) {
+        return AnnotatedString(text = newText, annotations = annotations)
+    }
+
+    var current = 0
+
+    val newOffsets = formatData.items.map { (offset, length) ->
+        val r = replacements.filter { (range, _) ->
+            (range - current) collidesWith (offset..<offset + length) || offset > range.first
+        }
+
+        current = r.sumOf { (range, _) -> range.last - range.first - 1 }
+
+        offset + current
+    }
+
+    formatData.items.forEachIndexed { index, item ->
+        val offset = newOffsets[index]
+
+        val spanStyle = when (item.type) {
+            FormatDataType.BOLD -> {
+                SpanStyle(fontWeight = FontWeight.SemiBold)
+            }
+
+            FormatDataType.ITALIC -> {
+                SpanStyle(fontStyle = FontStyle.Italic)
+            }
+
+            FormatDataType.UNDERLINE -> {
+                SpanStyle(textDecoration = TextDecoration.Underline)
+            }
+
+            FormatDataType.URL -> {
+                annotations += AnnotatedString.Range(
+                    item = StringAnnotation(item.url.orEmpty()),
+                    start = offset,
+                    end = offset + item.length,
+                    tag = newText.substring(offset, offset + item.length)
+                )
+
+                if (isOut) {
+                    SpanStyle(
+                        fontWeight = FontWeight.SemiBold,
+                        textDecoration = TextDecoration.Underline
+                    )
+
+                } else {
+                    SpanStyle(
+                        fontWeight = FontWeight.SemiBold,
+                        color = Color.Red
+                    )
+                }
+            }
+        }
+
+        annotations += AnnotatedString.Range(
+            item = spanStyle,
+            start = offset,
+            end = offset + item.length
+        )
+    }
+
+    return AnnotatedString(text = newText, annotations = annotations)
+}
+
+
+fun List<MessageUiItem>.firstMessage(): MessageUiItem.Message =
+    filterIsInstance<MessageUiItem.Message>().first()
+
+fun List<MessageUiItem>.firstMessageOrNull(): MessageUiItem.Message? =
+    filterIsInstance<MessageUiItem.Message>().firstOrNull()
+
+fun List<MessageUiItem>.indexOfMessageById(messageId: Long): Int =
+    indexOfFirst { it.id == messageId }
+
+fun List<MessageUiItem>.findMessageById(messageId: Long): MessageUiItem.Message? =
+    firstOrNull { it.id == messageId } as MessageUiItem.Message?
+
+fun List<MessageUiItem>.indexOfMessageByCmId(cmId: Long): Int? =
+    indexOfFirstOrNull { it.cmId == cmId }
+
+fun List<MessageUiItem>.findMessageByCmId(cmId: Long): MessageUiItem.Message =
+    first { it.cmId == cmId } as MessageUiItem.Message

core/model/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 android {
-    namespace = "dev.meloda.fast.datastore"
+    namespace = "dev.meloda.fast.model"
 }
 
 dependencies {
@@ -12,7 +12,7 @@ dependencies {
     ksp(libs.moshi.kotlin.codegen)
 
     implementation(platform(libs.compose.bom))
-    implementation(libs.bundles.compose)
+    implementation(libs.compose.ui)
 
     implementation(libs.room.ktx)
     implementation(libs.room.runtime)

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

@@ -1,6 +1,6 @@
 package dev.meloda.fast.model
 
-enum class ConversationFlags(val value: Int) {
+enum class ConvoFlags(val value: Int) {
     DISABLE_PUSH(16),
     DISABLE_SOUND(32),
     INCOMING_CHAT_REQUEST(256),
@@ -17,10 +17,10 @@ enum class ConversationFlags(val value: Int) {
 
     companion object {
 
-        fun parse(mask: Int): List<ConversationFlags> {
-            val flags = mutableListOf<ConversationFlags>()
+        fun parse(mask: Int): List<ConvoFlags> {
+            val flags = mutableListOf<ConvoFlags>()
 
-            ConversationFlags.entries.forEach { flag ->
+            ConvoFlags.entries.forEach { flag ->
                 if (mask and flag.value > 0) {
                     flags.add(flag)
                 }

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

@@ -1,5 +1,5 @@
 package dev.meloda.fast.model
 
-enum class ConversationsFilter {
+enum class ConvosFilter {
     ALL, UNREAD, ARCHIVE, BUSINESS_NOTIFY
 }

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

@@ -1,6 +1,6 @@
 package dev.meloda.fast.model
 
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 
 sealed interface LongPollParsedEvent {
@@ -92,7 +92,7 @@ sealed interface LongPollParsedEvent {
     ) : LongPollParsedEvent
 
     data class ChatArchived(
-        val conversation: VkConversation,
+        val convo: VkConvo,
         val archived: Boolean
     ) : LongPollParsedEvent
 }

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

@@ -0,0 +1,8 @@
+package dev.meloda.fast.model
+
+data class PhotoSize(
+    val height: Int,
+    val width: Int,
+    val type: String,
+    val url: String
+)

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

@@ -1,5 +1,7 @@
 package dev.meloda.fast.model.api
 
+import dev.meloda.fast.model.api.domain.VkMessage
+
 enum class PeerType(val value: String) {
     USER("user"),
     GROUP("group"),
@@ -13,5 +15,14 @@ enum class PeerType(val value: String) {
         fun parse(type: String): PeerType {
             return entries.first { it.value == type }
         }
+
+        fun VkMessage.getPeerType(): PeerType {
+            return when {
+                peerId > 2_000_000_000 -> CHAT
+                peerId > 0 -> USER
+                peerId < 0 -> GROUP
+                else -> throw IllegalArgumentException("Unknown peer type for peerId: 0")
+            }
+        }
     }
 }

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

@@ -6,8 +6,8 @@ enum class AttachmentType(var value: String) {
     UNKNOWN("unknown"),
     PHOTO("photo"),
     VIDEO("video"),
-    AUDIO("audio"),
     FILE("doc"),
+    AUDIO("audio"),
     LINK("link"),
     AUDIO_MESSAGE("audio_message"),
     MINI_APP("mini_app"),
@@ -30,7 +30,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)

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

@@ -8,7 +8,7 @@ import dev.meloda.fast.model.api.domain.VkAttachmentHistoryMessage
 data class VkAttachmentHistoryMessageData(
     @Json(name = "message_id") val messageId: Long,
     @Json(name = "date") val date: Int,
-    @Json(name = "cmid") val conversationMessageId: Long,
+    @Json(name = "cmid") val cmId: Long,
     @Json(name = "from_id") val fromId: Long,
     @Json(name = "position") val position: Int,
     @Json(name = "attachment") val attachment: VkAttachmentItemData
@@ -16,7 +16,7 @@ data class VkAttachmentHistoryMessageData(
 
     fun toDomain(): VkAttachmentHistoryMessage = VkAttachmentHistoryMessage(
         messageId = messageId,
-        conversationMessageId = conversationMessageId,
+        cmId = cmId,
         date = date,
         fromId = fromId,
         position = position,

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

@@ -3,19 +3,19 @@ package dev.meloda.fast.model.api.data
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
 import dev.meloda.fast.model.api.PeerType
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 
 @JsonClass(generateAdapter = true)
-data class VkConversationData(
+data class VkConvoData(
     @Json(name = "peer") val peer: Peer,
     @Json(name = "last_message_id") val lastMessageId: Long?,
     @Json(name = "in_read") val inRead: Long,
     @Json(name = "out_read") val outRead: Long,
-    @Json(name = "in_read_cmid") val inReadConversationMessageId: Long,
-    @Json(name = "out_read_cmid") val outReadConversationMessageId: Long,
+    @Json(name = "in_read_cmid") val inReadCmId: Long,
+    @Json(name = "out_read_cmid") val outReadCmId: Long,
     @Json(name = "sort_id") val sortId: SortId,
-    @Json(name = "last_conversation_message_id") val lastConversationMessageId: Long,
+    @Json(name = "last_conversation_message_id") val lastCmId: Long,
     @Json(name = "is_marked_unread") val isMarkedUnread: Boolean,
     @Json(name = "important") val important: Boolean,
     @Json(name = "push_settings") val pushSettings: PushSettings?,
@@ -111,7 +111,7 @@ data class VkConversationData(
 
     fun asDomain(
         lastMessage: VkMessage? = null,
-    ): VkConversation = VkConversation(
+    ): VkConvo = VkConvo(
         id = peer.id,
         localId = peer.localId,
         title = chatSettings?.title,
@@ -120,7 +120,7 @@ data class VkConversationData(
         photo200 = chatSettings?.photo?.photo200,
         isCallInProgress = callInProgress != null,
         isPhantom = chatSettings?.isDisappearing == true,
-        lastCmId = lastConversationMessageId,
+        lastCmId = lastCmId,
         inRead = inRead,
         outRead = outRead,
         lastMessageId = lastMessageId,
@@ -132,8 +132,8 @@ data class VkConversationData(
         canChangePin = chatSettings?.acl?.canChangePin == true,
         canChangeInfo = chatSettings?.acl?.canChangeInfo == true,
         pinnedMessageId = chatSettings?.pinnedMessage?.id,
-        inReadCmId = inReadConversationMessageId,
-        outReadCmId = outReadConversationMessageId,
+        inReadCmId = inReadCmId,
+        outReadCmId = outReadCmId,
         interactionType = -1,
         interactionIds = emptyList(),
         peerType = PeerType.parse(peer.type),

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

@@ -27,7 +27,9 @@ data class VkFileData(
     ) {
 
         @JsonClass(generateAdapter = true)
-        data class Photo(val sizes: List<Size>) {
+        data class Photo(
+            val sizes: List<Size>
+        ) {
 
             @JsonClass(generateAdapter = true)
             data class Size(

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

@@ -1,12 +1,13 @@
 package dev.meloda.fast.model.api.data
 
-import dev.meloda.fast.model.api.domain.VkGiftDomain
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
+import dev.meloda.fast.model.api.domain.VkGiftDomain
 
 @JsonClass(generateAdapter = true)
 data class VkGiftData(
     @Json(name = "id") val id: Long,
+    @Json(name = "thumb_512") val thumb512: String?,
     @Json(name = "thumb_256") val thumb256: String?,
     @Json(name = "thumb_96") val thumb96: String?,
     @Json(name = "thumb_48") val thumb48: String
@@ -14,6 +15,7 @@ data class VkGiftData(
 
     fun toDomain() = VkGiftDomain(
         id = id,
+        thumb512 = thumb512,
         thumb256 = thumb256,
         thumb96 = thumb96,
         thumb48 = thumb48

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

@@ -56,7 +56,7 @@ data class VkMessageData(
         @Json(name = "type") val type: String,
         @Json(name = "member_id") val memberId: Long?,
         @Json(name = "text") val text: String?,
-        @Json(name = "conversation_message_id") val conversationMessageId: Long?,
+        @Json(name = "conversation_message_id") val cmId: Long?,
         @Json(name = "message") val message: String?
     )
 
@@ -102,10 +102,10 @@ fun VkMessageData.asDomain(): VkMessage = VkMessage(
     action = VkMessage.Action.parse(action?.type),
     actionMemberId = action?.memberId,
     actionText = action?.text,
-    actionConversationMessageId = action?.conversationMessageId,
+    actionCmId = action?.cmId,
     actionMessage = action?.message,
     geoType = geo?.type,
-    isImportant = important ?: false,
+    isImportant = important == true,
     updateTime = updateTime,
     forwards = fwdMessages.orEmpty().map(VkMessageData::asDomain),
     attachments = attachments.map(VkAttachmentItemData::toDomain),

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

@@ -2,6 +2,7 @@ package dev.meloda.fast.model.api.data
 
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
+import dev.meloda.fast.model.PhotoSize
 import dev.meloda.fast.model.api.domain.VkPhotoDomain
 
 @JsonClass(generateAdapter = true)
@@ -35,7 +36,14 @@ data class VkPhotoData(
         ownerId = ownerId,
         hasTags = hasTags == true,
         accessKey = accessKey,
-        sizes = sizes,
+        sizes = sizes.map { size ->
+            PhotoSize(
+                height = size.height,
+                width = size.width,
+                type = size.type,
+                url = size.url
+            )
+        },
         text = text,
         userId = userId
     )

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

@@ -12,7 +12,7 @@ data class VkPinnedMessageData(
     @Json(name = "from_id") val fromId: Long,
     @Json(name = "out") val out: Boolean?,
     @Json(name = "text") val text: String,
-    @Json(name = "conversation_message_id") val conversationMessageId: Long,
+    @Json(name = "conversation_message_id") val cmId: Long,
     @Json(name = "fwd_messages") val forwards: List<VkMessageData>?,
     @Json(name = "important") val important: Boolean = false,
     @Json(name = "random_id") val randomId: Long = 0,
@@ -28,7 +28,7 @@ data class VkPinnedMessageData(
 
     fun mapToDomain(): VkMessage = VkMessage(
         id = id ?: -1,
-        cmId = conversationMessageId,
+        cmId = cmId,
         text = text.ifBlank { null },
         isOut = out == true,
         peerId = peerId ?: -1,
@@ -38,7 +38,7 @@ data class VkPinnedMessageData(
         action = VkMessage.Action.parse(action?.type),
         actionMemberId = action?.memberId,
         actionText = action?.text,
-        actionConversationMessageId = action?.conversationMessageId,
+        actionCmId = action?.cmId,
         actionMessage = action?.message,
         geoType = geo?.type,
         isImportant = important,

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

@@ -37,7 +37,7 @@ data class VkUserData(
 
     @JsonClass(generateAdapter = true)
     data class LastSeen(
-        @Json(name = "platform") val platform: Int,
+        @Json(name = "platform") val platform: Int?,
         @Json(name = "time") val time: Int
     )
 

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

@@ -23,7 +23,7 @@ data class VkVideoData(
     @Json(name = "is_favorite") val isFavorite: Boolean?,
     @Json(name = "image") val image: List<Image>?,
     @Json(name = "first_frame") val firstFrame: List<FirstFrame>?,
-    @Json(name = "files") val files: File?
+    @Json(name = "files") val files: File?,
 ) : VkAttachmentData {
 
     @JsonClass(generateAdapter = true)
@@ -73,6 +73,7 @@ data class VkVideoData(
         accessKey = accessKey,
         title = title,
         views = views,
-        duration = duration
+        duration = duration,
+        isShortVideo = type == "short_video"
     )
 }

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

@@ -54,9 +54,9 @@ data class VkVideoMessageData(
 
     @JsonClass(generateAdapter = true)
     data class Image(
-        val height: Int?,
-        val url: String?,
-        val width: Int?,
+        val height: Int,
+        val url: String,
+        val width: Int,
         val with_padding: Int?,
     )
 
@@ -73,6 +73,7 @@ data class VkVideoMessageData(
     )
 
     fun toDomain(): VkVideoMessageDomain = VkVideoMessageDomain(
-        id = id
+        id = id,
+        image = image.orEmpty().filter { it.width / it.height == 1 }.maxByOrNull { it.width }?.url
     )
 }

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

@@ -9,10 +9,10 @@ data class VkWallReplyData(
     val from_id: Long,
     val date: Int,
     val text: String,
-    val post_id: Long,
-    val owner_id: Long,
-    val parents_stack: List<Int>,
-    val likes: Likes,
+    val post_id: Long?,
+    val owner_id: Long?,
+    val parents_stack: List<Int>?,
+    val likes: Likes?,
     val reply_to_user: Int?,
     val reply_to_comment: Int?
 ) {

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

@@ -3,6 +3,10 @@ package dev.meloda.fast.model.api.domain
 enum class FormatDataType {
     BOLD, ITALIC, UNDERLINE, URL;
 
+    override fun toString(): String {
+        return super.toString().lowercase()
+    }
+
     companion object {
         fun parse(value: String): FormatDataType? =
             entries.firstOrNull { it.name.lowercase() == value }

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

@@ -2,7 +2,7 @@ package dev.meloda.fast.model.api.domain
 
 data class VkAttachmentHistoryMessage(
     val messageId: Long,
-    val conversationMessageId: Long,
+    val cmId: Long,
     val date: Int,
     val fromId: Long,
     val position: Int,

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

@@ -1,9 +1,9 @@
 package dev.meloda.fast.model.api.domain
 
 import dev.meloda.fast.model.api.PeerType
-import dev.meloda.fast.model.database.VkConversationEntity
+import dev.meloda.fast.model.database.VkConvoEntity
 
-data class VkConversation(
+data class VkConvo(
     val id: Long,
     val localId: Long,
     val ownerId: Long?,
@@ -54,7 +54,7 @@ data class VkConversation(
     }
 
     companion object {
-        val EMPTY: VkConversation = VkConversation(
+        val EMPTY: VkConvo = VkConvo(
             id = -1,
             localId = -1,
             ownerId = null,
@@ -90,7 +90,7 @@ data class VkConversation(
     }
 }
 
-fun VkConversation.asEntity(): VkConversationEntity = VkConversationEntity(
+fun VkConvo.asEntity(): VkConvoEntity = VkConvoEntity(
     id = id,
     localId = localId,
     ownerId = ownerId,
@@ -99,7 +99,7 @@ fun VkConversation.asEntity(): VkConversationEntity = VkConversationEntity(
     photo100 = photo100,
     photo200 = photo200,
     isPhantom = isPhantom,
-    lastConversationMessageId = lastCmId,
+    lastCmId = lastCmId,
     inReadCmId = inReadCmId,
     outReadCmId = outReadCmId,
     inRead = inRead,

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

@@ -4,10 +4,14 @@ import dev.meloda.fast.model.api.data.AttachmentType
 
 data class VkGiftDomain(
     val id: Long,
+    val thumb512: String?,
     val thumb256: String?,
     val thumb96: String?,
     val thumb48: String
 ) : VkAttachment {
 
     override val type: AttachmentType = AttachmentType.GIFT
+
+    fun getMaxSizeThumb(): String = thumb512 ?: thumb256 ?: thumb96 ?: thumb48
+    fun getDefaultThumbSizeOrLess(): String = thumb256 ?: thumb96 ?: thumb48
 }

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

@@ -16,7 +16,7 @@ data class VkMessage(
     val action: Action?,
     val actionMemberId: Long?,
     val actionText: String?,
-    val actionConversationMessageId: Long?,
+    val actionCmId: Long?,
     val actionMessage: String?,
 
     val updateTime: Int?,
@@ -35,7 +35,7 @@ data class VkMessage(
     val user: VkUser?,
     val group: VkGroupDomain?,
     val actionUser: VkUser?,
-    val actionGroup: VkGroupDomain?
+    val actionGroup: VkGroupDomain?,
 ) {
 
     fun isPeerChat() = peerId > 2_000_000_000
@@ -44,9 +44,9 @@ data class VkMessage(
 
     fun isGroup() = fromId < 0
 
-    fun isRead(conversation: VkConversation): Boolean = when {
+    fun isRead(convo: VkConvo): Boolean = when {
         id <= 0 -> false
-        else -> conversation.isRead(this)
+        else -> convo.isRead(this)
     }
 
     fun hasAttachments(): Boolean = attachments.orEmpty().isNotEmpty()
@@ -98,7 +98,7 @@ data class VkMessage(
 
 fun VkMessage.asEntity(): VkMessageEntity = VkMessageEntity(
     id = id,
-    conversationMessageId = cmId,
+    cmId = cmId,
     text = text,
     isOut = isOut,
     peerId = peerId,
@@ -108,7 +108,7 @@ fun VkMessage.asEntity(): VkMessageEntity = VkMessageEntity(
     action = action?.value,
     actionMemberId = actionMemberId,
     actionText = actionText,
-    actionConversationMessageId = actionConversationMessageId,
+    actionCmId = actionCmId,
     actionMessage = actionMessage,
     updateTime = updateTime,
     important = isImportant,

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

@@ -1,7 +1,7 @@
 package dev.meloda.fast.model.api.domain
 
+import dev.meloda.fast.model.PhotoSize
 import dev.meloda.fast.model.api.data.AttachmentType
-import dev.meloda.fast.model.api.data.VkPhotoData
 import java.util.Stack
 
 
@@ -13,7 +13,7 @@ data class VkPhotoDomain(
     val ownerId: Long,
     val hasTags: Boolean,
     val accessKey: String?,
-    val sizes: List<VkPhotoData.Size>,
+    val sizes: List<PhotoSize>,
     val text: String?,
     val userId: Long?
 ) : VkAttachment {
@@ -35,11 +35,15 @@ data class VkPhotoDomain(
         sizesChars.push(SIZE_TYPE_2560_2048)
     }
 
-    fun getMaxSize(): VkPhotoData.Size? {
+    fun getMaxSize(): PhotoSize? {
         return getSizeOrSmaller(sizesChars.peek())
     }
 
-    fun getSizeOrNull(type: Char): VkPhotoData.Size? {
+    fun getDefault(): PhotoSize? {
+        return getSizeOrSmaller(SIZE_TYPE_1080_1024)
+    }
+
+    fun getSizeOrNull(type: Char): PhotoSize? {
         for (size in sizes) {
             if (size.type == type.toString()) return size
         }
@@ -47,7 +51,7 @@ data class VkPhotoDomain(
         return null
     }
 
-    fun getSizeOrSmaller(type: Char): VkPhotoData.Size? {
+    fun getSizeOrSmaller(type: Char): PhotoSize? {
         val photoStack = sizesChars.clone() as Stack<*>
 
         val sizeIndex = photoStack.search(type)