domain module

2024-08-11 17:40:13 +03:00
parent 648850f1c8
commit 0500969d81
77 changed files with 282 additions and 267 deletions
@@ -0,0 +1 @@
+/build
@@ -0,0 +1,18 @@
+plugins {
+    alias(libs.plugins.fast.android.library)
+//    alias(libs.plugins.fast.android.koin)
+}
+
+android {
+    namespace = "dev.meloda.fast.domain"
+}
+
+dependencies {
+    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)
+}
@@ -0,0 +1,16 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import kotlinx.coroutines.flow.Flow
+
+interface AccountUseCase {
+
+    suspend fun setOnline(
+        voip: Boolean,
+        accessToken: String
+    ): Flow<State<Int>>
+
+    suspend fun setOffline(
+        accessToken: String
+    ): Flow<State<Int>>
+}
@@ -0,0 +1,31 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.account.AccountRepository
+import dev.meloda.fast.data.mapToState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+class AccountUseCaseImpl(
+    private val repository: AccountRepository
+) : AccountUseCase {
+
+    override suspend fun setOnline(
+        voip: Boolean,
+        accessToken: String
+    ): Flow<State<Int>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.setOnline(voip = voip).mapToState()
+        emit(newState)
+    }
+
+    override suspend fun setOffline(
+        accessToken: String
+    ): Flow<State<Int>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.setOffline().mapToState()
+        emit(newState)
+    }
+}
@@ -0,0 +1,12 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.model.api.responses.ValidatePhoneResponse
+import kotlinx.coroutines.flow.Flow
+
+interface AuthUseCase {
+
+    fun validatePhone(
+        validationSid: String
+    ): Flow<State<ValidatePhoneResponse>>
+}
@@ -0,0 +1,18 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.auth.AuthRepository
+import dev.meloda.fast.data.mapToState
+import dev.meloda.fast.model.api.responses.ValidatePhoneResponse
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+class AuthUseCaseImpl(private val repository: AuthRepository) : AuthUseCase {
+
+    override fun validatePhone(validationSid: String): Flow<State<ValidatePhoneResponse>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.validatePhone(validationSid).mapToState()
+        emit(newState)
+    }
+}
@@ -0,0 +1,19 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.model.api.domain.VkConversation
+import kotlinx.coroutines.flow.Flow
+
+interface ConversationsUseCase {
+
+    fun getConversations(
+        count: Int?,
+        offset: Int?,
+    ): Flow<State<List<VkConversation>>>
+
+    fun delete(peerId: Int): Flow<State<Int>>
+
+    fun changePinState(peerId: Int, pin: Boolean): Flow<State<Int>>
+
+    suspend fun storeConversations(conversations: List<VkConversation>)
+}
@@ -0,0 +1,118 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.conversations.ConversationsRepository
+import dev.meloda.fast.data.mapToState
+import dev.meloda.fast.model.api.domain.VkConversation
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.withContext
+
+class ConversationsUseCaseImpl(
+    private val repository: ConversationsRepository,
+) : ConversationsUseCase {
+
+    //    override fun getConversations(
+//        count: Int?,
+//        offset: Int?,
+//        fields: String,
+//        filter: String,
+//        extended: Boolean?,
+//        startMessageId: Int?
+//    ): Flow<dev.meloda.fast.network.State<ConversationsResponseDomain>> = flow {
+//        emit(dev.meloda.fast.network.State.Loading)
+//
+//        val newState = conversationsRepository.getConversations(
+//            params = ConversationsGetRequest(
+//                count = count,
+//                offset = offset,
+//                fields = fields,
+//                filter = filter,
+//                extended = extended,
+//                startMessageId = startMessageId
+//            )
+//        ).fold(
+//            onSuccess = { response -> dev.meloda.fast.network.State.Success(response.toDomain()) },
+//            onNetworkFailure = { dev.meloda.fast.network.State.Error.ConnectionError },
+//            onUnknownFailure = { dev.meloda.fast.network.State.UNKNOWN_ERROR },
+//            onHttpFailure = { result -> result.error.toStateApiError() },
+//            onApiFailure = { result -> result.error.toStateApiError() }
+//        )
+//        emit(newState)
+//    }
+//
+
+    //
+//    override fun pin(peerId: Int): Flow<dev.meloda.fast.network.State<Unit>> = flow {
+//        emit(dev.meloda.fast.network.State.Loading)
+//
+//        val newState = conversationsRepository.pin(
+//            ConversationsPinRequest(peerId = peerId)
+//        ).fold(
+//            onSuccess = { dev.meloda.fast.network.State.Success(Unit) },
+//            onNetworkFailure = { dev.meloda.fast.network.State.Error.ConnectionError },
+//            onUnknownFailure = { dev.meloda.fast.network.State.UNKNOWN_ERROR },
+//            onHttpFailure = { result -> result.error.toStateApiError() },
+//            onApiFailure = { result -> result.error.toStateApiError() }
+//        )
+//        emit(newState)
+//    }
+//
+//    override fun unpin(peerId: Int): Flow<dev.meloda.fast.network.State<Unit>> = flow {
+//        emit(dev.meloda.fast.network.State.Loading)
+//
+//        val newState = conversationsRepository.unpin(
+//            ConversationsUnpinRequest(peerId = peerId)
+//        ).fold(
+//            onSuccess = { dev.meloda.fast.network.State.Success(Unit) },
+//            onNetworkFailure = { dev.meloda.fast.network.State.Error.ConnectionError },
+//            onUnknownFailure = { dev.meloda.fast.network.State.UNKNOWN_ERROR },
+//            onHttpFailure = { result -> result.error.toStateApiError() },
+//            onApiFailure = { result -> result.error.toStateApiError() }
+//        )
+//        emit(newState)
+//    }
+//
+//    override suspend fun storeConversations(conversations: List<VkConversationDomain>) {
+//        conversationsDao.insertAll(conversations.map(VkConversationDomain::mapToDb))
+//    }
+//
+//    override suspend fun storeGroups(groups: List<VkGroupDomain>) {
+//        groupsDao.insertAll(groups.map(VkGroupDomain::mapToDB))
+//    }
+    override fun getConversations(
+        count: Int?,
+        offset: Int?
+    ): Flow<State<List<VkConversation>>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getConversations(count, offset).mapToState()
+        emit(newState)
+    }
+
+    override suspend fun storeConversations(
+        conversations: List<VkConversation>
+    ) = withContext(Dispatchers.IO) {
+        repository.storeConversations(conversations)
+    }
+
+    override fun delete(peerId: Int): Flow<State<Int>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.delete(peerId = peerId).mapToState()
+        emit(newState)
+    }
+
+    override fun changePinState(peerId: Int, pin: Boolean): Flow<State<Int>> = flow {
+        emit(State.Loading)
+
+        val newState = if (pin) {
+            repository.pin(peerId)
+        } else {
+            repository.unpin(peerId)
+        }.mapToState()
+
+        emit(newState)
+    }
+}
@@ -0,0 +1,26 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.model.FriendsInfo
+import dev.meloda.fast.model.api.domain.VkUser
+import kotlinx.coroutines.flow.Flow
+
+interface FriendsUseCase {
+
+    fun getAllFriends(
+        count: Int?,
+        offset: Int?
+    ): Flow<State<FriendsInfo>>
+
+    fun getFriends(
+        count: Int?,
+        offset: Int?
+    ): Flow<State<List<VkUser>>>
+
+    fun getOnlineFriends(
+        count: Int?,
+        offset: Int?
+    ): Flow<State<List<Int>>>
+
+    suspend fun storeUsers(users: List<VkUser>)
+}
@@ -0,0 +1,42 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.friends.FriendsRepository
+import dev.meloda.fast.data.mapToState
+import dev.meloda.fast.model.FriendsInfo
+import dev.meloda.fast.model.api.domain.VkUser
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+class FriendsUseCaseImpl(private val repository: FriendsRepository) :
+    FriendsUseCase {
+
+    override fun getAllFriends(count: Int?, offset: Int?): Flow<State<FriendsInfo>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getAllFriends(count, offset).mapToState()
+        emit(newState)
+    }
+
+    override fun getFriends(
+        count: Int?, offset: Int?
+    ): Flow<State<List<VkUser>>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getFriends(count, offset).mapToState()
+        emit(newState)
+    }
+
+    override fun getOnlineFriends(
+        count: Int?, offset: Int?
+    ): Flow<State<List<Int>>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getOnlineFriends(count, offset).mapToState()
+        emit(newState)
+    }
+
+    override suspend fun storeUsers(users: List<VkUser>) {
+        repository.storeUsers(users)
+    }
+}
@@ -0,0 +1,16 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.UserConfig
+import dev.meloda.fast.data.db.AccountsRepository
+import dev.meloda.fast.model.database.AccountEntity
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class GetCurrentAccountUseCase(
+    private val accountsRepository: AccountsRepository
+) {
+
+    suspend operator fun invoke(): AccountEntity? = withContext(Dispatchers.IO) {
+        accountsRepository.getAccountById(UserConfig.currentUserId)
+    }
+}
@@ -0,0 +1,361 @@
+package dev.meloda.fast.domain
+
+import android.util.Log
+import dev.meloda.fast.common.VkConstants
+import dev.meloda.fast.common.extensions.asInt
+import dev.meloda.fast.common.extensions.listenValue
+import dev.meloda.fast.common.extensions.toList
+import dev.meloda.fast.data.UserConfig
+import dev.meloda.fast.data.VkMemoryCache
+import dev.meloda.fast.data.processState
+import dev.meloda.fast.model.ApiEvent
+import dev.meloda.fast.model.InteractionType
+import dev.meloda.fast.model.LongPollEvent
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+class LongPollUpdatesParser(
+    private val messagesUseCase: MessagesUseCase
+) {
+    private val job = SupervisorJob()
+
+    private val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
+        Log.d("LongPollUpdatesParser", "error: $throwable")
+        throwable.printStackTrace()
+    }
+
+    private val coroutineContext: CoroutineContext
+        get() = Dispatchers.Default + job + exceptionHandler
+
+    private val coroutineScope = CoroutineScope(coroutineContext)
+
+    private val listenersMap: MutableMap<ApiEvent, MutableCollection<VkEventCallback<*>>> =
+        mutableMapOf()
+
+    fun parseNextUpdate(event: List<Any>) {
+        val eventId = event.first().asInt()
+
+        val eventType: ApiEvent = try {
+            ApiEvent.parse(eventId)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            Log.d("LongPollUpdatesParser", "parseNextUpdate: unknownEvent: $event")
+            return
+        }
+
+        when (eventType) {
+            ApiEvent.MESSAGE_SET_FLAGS -> parseMessageSetFlags(eventType, event)
+            ApiEvent.MESSAGE_CLEAR_FLAGS -> parseMessageClearFlags(eventType, event)
+            ApiEvent.MESSAGE_NEW -> parseMessageNew(eventType, event)
+            ApiEvent.MESSAGE_EDIT -> parseMessageEdit(eventType, event)
+            ApiEvent.MESSAGE_READ_INCOMING -> parseMessageReadIncoming(eventType, event)
+            ApiEvent.MESSAGE_READ_OUTGOING -> parseMessageReadOutgoing(eventType, event)
+            ApiEvent.MESSAGES_DELETED -> parseMessagesDeleted(eventType, event)
+            ApiEvent.PIN_UNPIN_CONVERSATION -> parseConversationPinStateChanged(eventType, event)
+
+            ApiEvent.TYPING,
+            ApiEvent.AUDIO_MESSAGE_RECORDING,
+            ApiEvent.PHOTO_UPLOADING,
+            ApiEvent.VIDEO_UPLOADING,
+            ApiEvent.FILE_UPLOADING -> parseInteraction(eventType, event)
+
+            ApiEvent.UNREAD_COUNT_UPDATE -> onNewEvent(eventType, event)
+        }
+    }
+
+    private fun onNewEvent(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "newEvent: $eventType: $event")
+    }
+
+    private fun parseInteraction(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val interactionType = when (eventType) {
+            ApiEvent.TYPING -> InteractionType.Typing
+            ApiEvent.AUDIO_MESSAGE_RECORDING -> InteractionType.VoiceMessage
+            ApiEvent.PHOTO_UPLOADING -> InteractionType.Photo
+            ApiEvent.VIDEO_UPLOADING -> InteractionType.Video
+            ApiEvent.FILE_UPLOADING -> InteractionType.File
+            else -> return
+        }
+
+        val peerId = event[1].asInt()
+        val userIds = event[2].toList(Any::asInt).filter { it != UserConfig.userId }
+        val totalCount = event[3].asInt()
+        val timestamp = event[4].asInt()
+
+        // if userIds contains only account's id, then we don't need to show our status
+        if (userIds.isEmpty()) return
+
+        coroutineScope.launch {
+            listenersMap[eventType]?.let { listeners ->
+                listeners.forEach { vkEventCallback ->
+                    (vkEventCallback as VkEventCallback<LongPollEvent.Interaction>)
+                        .onEvent(
+                            LongPollEvent.Interaction(
+                                interactionType = interactionType,
+                                peerId = peerId,
+                                userIds = userIds,
+                                totalCount = totalCount,
+                                timestamp = timestamp
+                            )
+                        )
+                }
+            }
+        }
+    }
+
+    private fun parseConversationPinStateChanged(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+
+        val peerId = event[1].asInt()
+        val majorId = event[2].asInt()
+
+        coroutineScope.launch {
+            listenersMap[ApiEvent.PIN_UNPIN_CONVERSATION]?.let { listeners ->
+                listeners.forEach { vkEventCallback ->
+                    (vkEventCallback as VkEventCallback<LongPollEvent.VkConversationPinStateChangedEvent>)
+                        .onEvent(
+                            LongPollEvent.VkConversationPinStateChangedEvent(
+                                peerId = peerId,
+                                majorId = majorId
+                            )
+                        )
+                }
+            }
+        }
+    }
+
+    private fun parseMessageSetFlags(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    }
+
+    private fun parseMessageClearFlags(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    }
+
+    private fun parseMessageNew(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+        val messageId = event[1].asInt()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            val newMessageEvent: LongPollEvent.VkMessageNewEvent? =
+                loadNormalMessage(
+                    eventType,
+                    messageId
+                )
+
+            newMessageEvent?.let { event ->
+                listenersMap[ApiEvent.MESSAGE_NEW]?.let {
+                    it.map { vkEventCallback ->
+                        (vkEventCallback as VkEventCallback<LongPollEvent.VkMessageNewEvent>)
+                            .onEvent(event)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun parseMessageEdit(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+        val messageId = event[1].asInt()
+
+        coroutineScope.launch {
+            val editedMessageEvent: LongPollEvent.VkMessageEditEvent? =
+                loadNormalMessage(
+                    eventType,
+                    messageId
+                )
+
+            editedMessageEvent?.let { event ->
+                listenersMap[ApiEvent.MESSAGE_EDIT]?.let {
+                    it.map { vkEventCallback ->
+                        (vkEventCallback as VkEventCallback<LongPollEvent.VkMessageEditEvent>)
+                            .onEvent(event)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun parseMessageReadIncoming(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+        val peerId = event[1].asInt()
+        val messageId = event[2].asInt()
+        val unreadCount = event[3].asInt()
+
+        coroutineScope.launch {
+            listenersMap[ApiEvent.MESSAGE_READ_INCOMING]?.let { listeners ->
+                listeners.map { vkEventCallback ->
+                    (vkEventCallback as VkEventCallback<LongPollEvent.VkMessageReadIncomingEvent>)
+                        .onEvent(
+                            LongPollEvent.VkMessageReadIncomingEvent(
+                                peerId = peerId,
+                                messageId = messageId,
+                                unreadCount = unreadCount
+                            )
+                        )
+                }
+            }
+        }
+    }
+
+    private fun parseMessageReadOutgoing(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+        val peerId = event[1].asInt()
+        val messageId = event[2].asInt()
+        val unreadCount = event[3].asInt()
+
+        coroutineScope.launch {
+            listenersMap[ApiEvent.MESSAGE_READ_OUTGOING]?.let { listeners ->
+                listeners.map { vkEventCallback ->
+                    (vkEventCallback as VkEventCallback<LongPollEvent.VkMessageReadOutgoingEvent>)
+                        .onEvent(
+                            LongPollEvent.VkMessageReadOutgoingEvent(
+                                peerId = peerId,
+                                messageId = messageId,
+                                unreadCount = unreadCount
+                            )
+                        )
+                }
+            }
+        }
+    }
+
+    private fun parseMessagesDeleted(eventType: ApiEvent, event: List<Any>) {
+        Log.d("LongPollUpdatesParser", "$eventType: $event")
+    }
+
+    private suspend inline fun <reified T : LongPollEvent> loadNormalMessage(
+        eventType: ApiEvent,
+        messageId: Int
+    ): T? = suspendCoroutine { continuation ->
+        coroutineScope.launch(Dispatchers.IO) {
+            messagesUseCase.getById(
+                messageIds = listOf(messageId),
+                extended = true,
+                fields = VkConstants.ALL_FIELDS
+            ).listenValue(this) { state ->
+                state.processState(
+                    error = { error ->
+                        Log.e("LongPollUpdatesParser", "loadNormalMessage: error: $error")
+                    },
+                    success = { messages ->
+                        val message = messages.singleOrNull() ?: run {
+                            continuation.resume(null)
+                            return@listenValue
+                        }
+
+                        VkMemoryCache[message.id] = message
+                        messagesUseCase.storeMessage(message)
+
+                        val resumeValue: LongPollEvent? = when (eventType) {
+                            ApiEvent.MESSAGE_NEW -> LongPollEvent.VkMessageNewEvent(message)
+                            ApiEvent.MESSAGE_EDIT -> LongPollEvent.VkMessageEditEvent(message)
+
+                            else -> {
+                                continuation.resume(null)
+                                null
+                            }
+                        }
+
+                        resumeValue?.let { value -> continuation.resume(value as T) }
+                    }
+                )
+            }
+        }
+    }
+
+    private fun <T : Any> registerListener(
+        eventType: ApiEvent,
+        listener: VkEventCallback<T>
+    ) {
+        listenersMap.let { map ->
+            map[eventType] = (map[eventType] ?: mutableListOf()).also { it.add(listener) }
+        }
+    }
+
+    private fun <T : Any> registerListeners(
+        eventTypes: List<ApiEvent>,
+        listener: VkEventCallback<T>
+    ) {
+        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
+    }
+
+    fun onConversationPinStateChanged(listener: VkEventCallback<LongPollEvent.VkConversationPinStateChangedEvent>) {
+        registerListener(ApiEvent.PIN_UNPIN_CONVERSATION, listener)
+    }
+
+    fun onConversationPinStateChanged(block: (LongPollEvent.VkConversationPinStateChangedEvent) -> Unit) {
+        onConversationPinStateChanged(assembleEventCallback(block))
+    }
+
+    fun onMessageIncomingRead(listener: VkEventCallback<LongPollEvent.VkMessageReadIncomingEvent>) {
+        registerListener(ApiEvent.MESSAGE_READ_INCOMING, listener)
+    }
+
+    fun onMessageIncomingRead(block: (LongPollEvent.VkMessageReadIncomingEvent) -> Unit) {
+        onMessageIncomingRead(assembleEventCallback(block))
+    }
+
+    fun onMessageOutgoingRead(listener: VkEventCallback<LongPollEvent.VkMessageReadOutgoingEvent>) {
+        registerListener(ApiEvent.MESSAGE_READ_OUTGOING, listener)
+    }
+
+    fun onMessageOutgoingRead(block: (LongPollEvent.VkMessageReadOutgoingEvent) -> Unit) {
+        onMessageOutgoingRead(assembleEventCallback(block))
+    }
+
+    fun onNewMessage(listener: VkEventCallback<LongPollEvent.VkMessageNewEvent>) {
+        registerListener(ApiEvent.MESSAGE_NEW, listener)
+    }
+
+    fun onNewMessage(block: (LongPollEvent.VkMessageNewEvent) -> Unit) {
+        onNewMessage(assembleEventCallback(block))
+    }
+
+    fun onMessageEdited(listener: VkEventCallback<LongPollEvent.VkMessageEditEvent>) {
+        registerListener(ApiEvent.MESSAGE_EDIT, listener)
+    }
+
+    fun onMessageEdited(block: (LongPollEvent.VkMessageEditEvent) -> Unit) {
+        onMessageEdited(assembleEventCallback(block))
+    }
+
+    fun onInteractions(listener: VkEventCallback<LongPollEvent.Interaction>) {
+        registerListeners(
+            eventTypes = listOf(
+                ApiEvent.TYPING,
+                ApiEvent.AUDIO_MESSAGE_RECORDING,
+                ApiEvent.PHOTO_UPLOADING,
+                ApiEvent.VIDEO_UPLOADING,
+                ApiEvent.FILE_UPLOADING
+            ),
+            listener = listener
+        )
+    }
+
+    fun onInteractions(block: (LongPollEvent.Interaction) -> Unit) {
+        onInteractions(assembleEventCallback(block))
+    }
+
+    fun clearListeners() {
+        listenersMap.clear()
+    }
+}
+
+internal inline fun <R : Any> assembleEventCallback(
+    crossinline block: (R) -> Unit,
+): VkEventCallback<R> {
+    return VkEventCallback { event -> block.invoke(event) }
+}
+
+fun interface VkEventCallback<in T : Any> {
+    fun onEvent(event: T)
+}
@@ -0,0 +1,24 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.model.api.data.LongPollUpdates
+import dev.meloda.fast.model.api.data.VkLongPollData
+import kotlinx.coroutines.flow.Flow
+
+interface LongPollUseCase {
+
+    fun getLongPollServer(
+        needPts: Boolean,
+        version: Int
+    ): Flow<State<VkLongPollData>>
+
+    fun getLongPollUpdates(
+        serverUrl: String,
+        act: String = "a_check",
+        key: String,
+        ts: Int,
+        wait: Int,
+        mode: Int,
+        version: Int
+    ): Flow<State<LongPollUpdates>>
+}
@@ -0,0 +1,51 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.longpoll.LongPollRepository
+import dev.meloda.fast.data.mapToState
+import dev.meloda.fast.model.api.data.LongPollUpdates
+import dev.meloda.fast.model.api.data.VkLongPollData
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+class LongPollUseCaseImpl(
+    private val repository: LongPollRepository
+) : LongPollUseCase {
+
+    override fun getLongPollServer(
+        needPts: Boolean,
+        version: Int
+    ): Flow<State<VkLongPollData>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getLongPollServer(
+            needPts = needPts,
+            version = version
+        ).mapToState()
+
+        emit(newState)
+    }
+
+    override fun getLongPollUpdates(
+        serverUrl: String,
+        act: String,
+        key: String,
+        ts: Int,
+        wait: Int,
+        mode: Int,
+        version: Int
+    ): Flow<State<LongPollUpdates>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getLongPollUpdates(
+            serverUrl,
+            act = act,
+            key = key,
+            ts = ts,
+            wait = wait,
+            mode = mode,
+            version = version
+        ).mapToState()
+        emit(newState)
+    }
+}
@@ -0,0 +1,47 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.messages.MessagesHistoryInfo
+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 kotlinx.coroutines.flow.Flow
+
+interface MessagesUseCase {
+
+    fun getMessagesHistory(
+        conversationId: Int,
+        count: Int?,
+        offset: Int?
+    ): Flow<State<MessagesHistoryInfo>>
+
+    fun getById(
+        messageIds: List<Int>,
+        extended: Boolean?,
+        fields: String?
+    ): Flow<State<List<VkMessage>>>
+
+    fun sendMessage(
+        peerId: Int,
+        randomId: Int,
+        message: String?,
+        replyTo: Int?,
+        attachments: List<VkAttachment>?
+    ): Flow<State<Int>>
+
+    fun markAsRead(
+        peerId: Int,
+        startMessageId: Int
+    ): Flow<State<Int>>
+
+    fun getHistoryAttachments(
+        peerId: Int,
+        count: Int?,
+        offset: Int?,
+        attachmentTypes: List<String>,
+        conversationMessageId: Int
+    ): Flow<State<List<VkAttachmentHistoryMessage>>>
+
+    suspend fun storeMessage(message: VkMessage)
+    suspend fun storeMessages(messages: List<VkMessage>)
+}
@@ -0,0 +1,110 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.messages.MessagesHistoryInfo
+import dev.meloda.fast.data.api.messages.MessagesRepository
+import dev.meloda.fast.data.mapToState
+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 kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+class MessagesUseCaseImpl(
+    private val repository: MessagesRepository
+) : MessagesUseCase {
+
+    override fun getMessagesHistory(
+        conversationId: Int,
+        count: Int?,
+        offset: Int?
+    ): Flow<State<MessagesHistoryInfo>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getHistory(
+            conversationId = conversationId,
+            offset = offset,
+            count = count
+        ).mapToState()
+
+        emit(newState)
+    }
+
+    override fun getById(
+        messageIds: List<Int>,
+        extended: Boolean?,
+        fields: String?
+    ): Flow<State<List<VkMessage>>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getById(
+            messagesIds = messageIds,
+            extended = extended,
+            fields = fields
+        ).mapToState()
+
+        emit(newState)
+    }
+
+    override fun sendMessage(
+        peerId: Int,
+        randomId: Int,
+        message: String?,
+        replyTo: Int?,
+        attachments: List<VkAttachment>?
+    ): Flow<State<Int>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.send(
+            peerId = peerId,
+            randomId = randomId,
+            message = message,
+            replyTo = replyTo,
+            attachments = attachments
+        ).mapToState()
+
+        emit(newState)
+    }
+
+    override fun markAsRead(
+        peerId: Int,
+        startMessageId: Int
+    ): Flow<State<Int>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.markAsRead(
+            peerId = peerId,
+            startMessageId = startMessageId
+        ).mapToState()
+
+        emit(newState)
+    }
+
+    override fun getHistoryAttachments(
+        peerId: Int,
+        count: Int?,
+        offset: Int?,
+        attachmentTypes: List<String>,
+        conversationMessageId: Int
+    ): Flow<State<List<VkAttachmentHistoryMessage>>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getHistoryAttachments(
+            peerId = peerId,
+            count = count,
+            offset = offset,
+            attachmentTypes = attachmentTypes,
+            conversationMessageId = conversationMessageId
+        ).mapToState()
+
+        emit(newState)
+    }
+
+    override suspend fun storeMessage(message: VkMessage) {
+        repository.storeMessages(listOf(message))
+    }
+
+    override suspend fun storeMessages(messages: List<VkMessage>) {
+        repository.storeMessages(messages)
+    }
+}
@@ -0,0 +1,17 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.model.AuthInfo
+import kotlinx.coroutines.flow.Flow
+
+interface OAuthUseCase {
+
+    fun auth(
+        login: String,
+        password: String,
+        forceSms: Boolean,
+        validationCode: String?,
+        captchaSid: String?,
+        captchaKey: String?
+    ): Flow<State<AuthInfo>>
+}
@@ -0,0 +1,124 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.oauth.OAuthRepository
+import dev.meloda.fast.model.AuthInfo
+import dev.meloda.fast.network.OAuthErrorDomain
+import dev.meloda.fast.network.ValidationType
+import dev.meloda.fast.network.VkOAuthError
+import dev.meloda.fast.network.VkOAuthErrorType
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+class OAuthUseCaseImpl(
+    private val oAuthRepository: OAuthRepository
+) : OAuthUseCase {
+
+    override fun auth(
+        login: String,
+        password: String,
+        forceSms: Boolean,
+        validationCode: String?,
+        captchaSid: String?,
+        captchaKey: String?
+    ): Flow<State<AuthInfo>> = flow {
+        emit(State.Loading)
+
+        val response = oAuthRepository.auth(
+            login = login,
+            password = password,
+            validationCode = validationCode,
+            captchaSid = captchaSid,
+            captchaKey = captchaKey,
+            forceSms = forceSms
+        )
+
+        val error = response.error?.let(VkOAuthError::parse)
+        val errorType = response.errorType?.let(VkOAuthErrorType::parse)
+
+        val newState = when (error) {
+            null -> {
+                State.Success(
+                    AuthInfo(
+                        userId = response.userId,
+                        accessToken = response.accessToken,
+                        validationHash = response.validationHash
+                    )
+                )
+            }
+
+            VkOAuthError.FLOOD_CONTROL -> {
+                State.Error.OAuthError(OAuthErrorDomain.TooManyTriesError)
+            }
+
+            VkOAuthError.NEED_VALIDATION -> {
+                if (response.banInfo != null) {
+                    val info = requireNotNull(response.banInfo)
+
+                    State.Error.OAuthError(
+                        OAuthErrorDomain.UserBannedError(
+                            memberName = info.memberName,
+                            message = info.message,
+                            accessToken = info.accessToken,
+                            restoreUrl = info.restoreUrl
+                        )
+                    )
+                } else {
+                    State.Error.OAuthError(
+                        OAuthErrorDomain.ValidationRequiredError(
+                            description = response.errorDescription.orEmpty(),
+                            validationType = response.validationType.orEmpty()
+                                .let(ValidationType::parse),
+                            validationSid = response.validationSid.orEmpty(),
+                            phoneMask = response.phoneMask.orEmpty(),
+                            redirectUri = response.redirectUri.orEmpty(),
+                            validationResend = response.validationResend,
+                            restoreIfCannotGetCode = response.restoreIfCannotGetCode
+                        )
+                    )
+                }
+            }
+
+            VkOAuthError.NEED_CAPTCHA -> {
+                State.Error.OAuthError(
+                    OAuthErrorDomain.CaptchaRequiredError(
+                        captchaSid = response.captchaSid.orEmpty(),
+                        captchaImageUrl = response.captchaImage.orEmpty()
+                    )
+                )
+            }
+
+            VkOAuthError.INVALID_CLIENT -> {
+                State.Error.OAuthError(OAuthErrorDomain.InvalidCredentialsError)
+            }
+
+            VkOAuthError.INVALID_REQUEST -> {
+                when (errorType) {
+                    null -> State.Error.OAuthError(OAuthErrorDomain.UnknownError)
+
+                    VkOAuthErrorType.WRONG_OTP -> {
+                        State.Error.OAuthError(OAuthErrorDomain.WrongValidationCode)
+                    }
+
+                    VkOAuthErrorType.WRONG_OTP_FORMAT -> {
+                        State.Error.OAuthError(OAuthErrorDomain.WrongValidationCodeFormat)
+                    }
+
+                    VkOAuthErrorType.PASSWORD_BRUTEFORCE_ATTEMPT -> {
+                        State.Error.OAuthError(OAuthErrorDomain.TooManyTriesError)
+                    }
+
+                    VkOAuthErrorType.USERNAME_OR_PASSWORD_IS_INCORRECT -> {
+                        State.Error.OAuthError(OAuthErrorDomain.InvalidCredentialsError)
+                    }
+                }
+            }
+
+            VkOAuthError.UNKNOWN -> {
+                State.Error.OAuthError(OAuthErrorDomain.UnknownError)
+            }
+        }
+
+        emit(newState)
+    }
+}
@@ -0,0 +1,19 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.model.api.domain.VkUser
+import kotlinx.coroutines.flow.Flow
+
+interface UsersUseCase {
+
+    fun get(
+        userIds: List<Int>?,
+        fields: String?,
+        nomCase: String?
+    ): Flow<State<List<VkUser>>>
+
+    fun getLocalUser(userId: Int): Flow<State<VkUser?>>
+
+    suspend fun storeUser(user: VkUser)
+    suspend fun storeUsers(users: List<VkUser>)
+}
@@ -0,0 +1,40 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.users.UsersRepository
+import dev.meloda.fast.data.mapToState
+import dev.meloda.fast.model.api.domain.VkUser
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+class UsersUseCaseImpl(
+    private val repository: UsersRepository,
+) : UsersUseCase {
+
+    override fun get(
+        userIds: List<Int>?,
+        fields: String?,
+        nomCase: String?
+    ): Flow<State<List<VkUser>>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.get(userIds, fields, nomCase).mapToState()
+        emit(newState)
+    }
+
+    override fun getLocalUser(userId: Int): Flow<State<VkUser?>> = flow {
+        emit(State.Loading)
+
+        val newState = kotlin.runCatching {
+            repository.getLocalUsers(listOf(userId)).singleOrNull()
+        }.fold(
+            onSuccess = { user -> State.Success(user) },
+            onFailure = { State.Error.InternalError }
+        )
+
+        emit(newState)
+    }
+
+    override suspend fun storeUser(user: VkUser) = repository.storeUsers(listOf(user))
+    override suspend fun storeUsers(users: List<VkUser>) = repository.storeUsers(users)
+}
@@ -0,0 +1,19 @@
+package dev.meloda.fast.domain.di
+
+import dev.meloda.fast.data.di.dataModule
+import dev.meloda.fast.domain.AccountUseCase
+import dev.meloda.fast.domain.AccountUseCaseImpl
+import dev.meloda.fast.domain.GetCurrentAccountUseCase
+import dev.meloda.fast.domain.UsersUseCase
+import dev.meloda.fast.domain.UsersUseCaseImpl
+import org.koin.core.module.dsl.singleOf
+import org.koin.dsl.bind
+import org.koin.dsl.module
+
+val domainModule = module {
+    includes(dataModule)
+
+    singleOf(::UsersUseCaseImpl) bind UsersUseCase::class
+    singleOf(::AccountUseCaseImpl) bind AccountUseCase::class
+    singleOf(::GetCurrentAccountUseCase)
+}