refactor: split message event handlers

2026-05-14 18:06:54 +03:00
parent 2bf81c60d6
commit c380c1a73d
4 changed files with 251 additions and 236 deletions
@@ -0,0 +1,36 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.model.LongPollEvent
+import dev.meloda.fast.model.LongPollParsedEvent
+
+internal class LongPollEventDispatcher {
+    private val listenersMap: MutableMap<LongPollEvent, MutableList<VkEventCallback<LongPollParsedEvent>>> =
+        mutableMapOf()
+
+    @Suppress("UNCHECKED_CAST")
+    fun <T : LongPollParsedEvent> dispatch(eventType: LongPollEvent, event: T) {
+        listenersMap[eventType]?.forEach { callback ->
+            (callback as? VkEventCallback<T>)?.onEvent(event)
+        }
+    }
+
+    fun dispatchAll(eventType: LongPollEvent, events: List<LongPollParsedEvent>) {
+        events.forEach { event -> dispatch(eventType, event) }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    fun <T : LongPollParsedEvent> registerListener(
+        eventType: LongPollEvent,
+        listener: VkEventCallback<T>
+    ) {
+        listenersMap[eventType] = (listenersMap[eventType] ?: mutableListOf())
+            .also { it.add(listener as VkEventCallback<LongPollParsedEvent>) }
+    }
+
+    fun <T : LongPollParsedEvent> registerListeners(
+        eventTypes: List<LongPollEvent>,
+        listener: VkEventCallback<T>
+    ) {
+        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
+    }
+}
@@ -43,20 +43,7 @@ class LongPollUpdatesParser(
        get() = Dispatchers.Default + job + exceptionHandler

    private val coroutineScope = CoroutineScope(coroutineContext)
-
-    private val listenersMap: MutableMap<LongPollEvent, MutableList<VkEventCallback<LongPollParsedEvent>>> =
-        mutableMapOf()
-
-    @Suppress("UNCHECKED_CAST")
-    private fun <T : LongPollParsedEvent> dispatch(eventType: LongPollEvent, event: T) {
-        listenersMap[eventType]?.forEach { callback ->
-            (callback as? VkEventCallback<T>)?.onEvent(event)
-        }
-    }
-
-    private fun dispatchAll(eventType: LongPollEvent, events: List<LongPollParsedEvent>) {
-        events.forEach { event -> dispatch(eventType, event) }
-    }
+    private val eventDispatcher = LongPollEventDispatcher()

    fun parseNextUpdate(event: List<Any>) {
        val eventId = event.first().asInt()
@@ -107,7 +94,7 @@ class LongPollUpdatesParser(
                        marked = true
                    )
                    eventsToSend += eventToSend
-                    dispatch(LongPollEvent.MARKED_AS_IMPORTANT, eventToSend)
+                    eventDispatcher.dispatch(LongPollEvent.MARKED_AS_IMPORTANT, eventToSend)
                }

                MessageFlags.SPAM -> {
@@ -116,7 +103,7 @@ class LongPollUpdatesParser(
                        cmId = cmId
                    )
                    eventsToSend += eventToSend
-                    dispatch(LongPollEvent.MARKED_AS_SPAM, eventToSend)
+                    eventDispatcher.dispatch(LongPollEvent.MARKED_AS_SPAM, eventToSend)
                }

                MessageFlags.DELETED -> {
@@ -135,7 +122,7 @@ class LongPollUpdatesParser(
                            )
                    }
                    eventsToSend += eventToSend
-                    dispatch(LongPollEvent.MESSAGE_DELETED, eventToSend)
+                    eventDispatcher.dispatch(LongPollEvent.MESSAGE_DELETED, eventToSend)
                }

                MessageFlags.AUDIO_LISTENED -> {
@@ -144,14 +131,14 @@ class LongPollUpdatesParser(
                        cmId = cmId
                    )
                    eventsToSend += eventToSend
-                    dispatch(LongPollEvent.AUDIO_MESSAGE_LISTENED, eventToSend)
+                    eventDispatcher.dispatch(LongPollEvent.AUDIO_MESSAGE_LISTENED, eventToSend)
                }

                else -> Unit
            }
        }

-        dispatchAll(LongPollEvent.MESSAGE_SET_FLAGS, eventsToSend)
+        eventDispatcher.dispatchAll(LongPollEvent.MESSAGE_SET_FLAGS, eventsToSend)
    }

    private fun parseMessageClearFlags(eventType: ApiEvent, event: List<Any>) {
@@ -175,7 +162,7 @@ class LongPollUpdatesParser(
                            marked = false
                        )
                        eventsToSend += eventToSend
-                        dispatch(LongPollEvent.MARKED_AS_IMPORTANT, eventToSend)
+                        eventDispatcher.dispatch(LongPollEvent.MARKED_AS_IMPORTANT, eventToSend)
                    }

                    MessageFlags.SPAM -> {
@@ -189,7 +176,7 @@ class LongPollUpdatesParser(
                                    val eventToSend =
                                        LongPollParsedEvent.MessageMarkedAsNotSpam(message = message)
                                    eventsToSend += eventToSend
-                                    dispatch(LongPollEvent.MARKED_AS_NOT_SPAM, eventToSend)
+                                    eventDispatcher.dispatch(LongPollEvent.MARKED_AS_NOT_SPAM, eventToSend)
                                }
                            }
                        }
@@ -205,7 +192,7 @@ class LongPollUpdatesParser(
                                val eventToSend =
                                    LongPollParsedEvent.MessageRestored(message = message)
                                eventsToSend += eventToSend
-                                dispatch(LongPollEvent.MESSAGE_RESTORED, eventToSend)
+                                eventDispatcher.dispatch(LongPollEvent.MESSAGE_RESTORED, eventToSend)
                            }
                        }
                    }
@@ -214,7 +201,7 @@ class LongPollUpdatesParser(
                }
            }

-            dispatchAll(LongPollEvent.MESSAGE_CLEAR_FLAGS, eventsToSend)
+            eventDispatcher.dispatchAll(LongPollEvent.MESSAGE_CLEAR_FLAGS, eventsToSend)
        }
    }

@@ -238,7 +225,7 @@ class LongPollUpdatesParser(
                }.await()

            message?.let {
-                dispatch(
+                eventDispatcher.dispatch(
                    LongPollEvent.MESSAGE_NEW,
                    LongPollParsedEvent.NewMessage(
                        message = message,
@@ -263,7 +250,7 @@ class LongPollUpdatesParser(
                peerId = peerId,
                cmId = cmId
            )?.let { message ->
-                dispatch(LongPollEvent.MESSAGE_EDITED, LongPollParsedEvent.MessageEdited(message))
+                eventDispatcher.dispatch(LongPollEvent.MESSAGE_EDITED, LongPollParsedEvent.MessageEdited(message))
            }
        }
    }
@@ -274,7 +261,7 @@ class LongPollUpdatesParser(
        val cmId = event[2].asLong()
        val unreadCount = event[3].asInt()

-        dispatch(
+        eventDispatcher.dispatch(
            LongPollEvent.INCOMING_MESSAGE_READ,
            LongPollParsedEvent.IncomingMessageRead(
                peerId = peerId,
@@ -290,7 +277,7 @@ class LongPollUpdatesParser(
        val cmId = event[2].asLong()
        val unreadCount = event[3].asInt()

-        dispatch(
+        eventDispatcher.dispatch(
            LongPollEvent.OUTGOING_MESSAGE_READ,
            LongPollParsedEvent.OutgoingMessageRead(
                peerId = peerId,
@@ -330,14 +317,14 @@ class LongPollUpdatesParser(
                            archived = false
                        )
                        eventsToSend += eventToSend
-                        dispatch(LongPollEvent.CHAT_ARCHIVED, eventToSend)
+                        eventDispatcher.dispatch(LongPollEvent.CHAT_ARCHIVED, eventToSend)
                    }

                    else -> Unit
                }
            }

-            dispatchAll(LongPollEvent.CHAT_CLEAR_FLAGS, eventsToSend)
+            eventDispatcher.dispatchAll(LongPollEvent.CHAT_CLEAR_FLAGS, eventsToSend)
        }
    }

@@ -371,14 +358,14 @@ class LongPollUpdatesParser(
                            archived = true
                        )
                        eventsToSend += eventToSend
-                        dispatch(LongPollEvent.CHAT_ARCHIVED, eventToSend)
+                        eventDispatcher.dispatch(LongPollEvent.CHAT_ARCHIVED, eventToSend)
                    }

                    else -> Unit
                }
            }

-            dispatchAll(LongPollEvent.CHAT_SET_FLAGS, eventsToSend)
+            eventDispatcher.dispatchAll(LongPollEvent.CHAT_SET_FLAGS, eventsToSend)
        }
    }

@@ -388,7 +375,7 @@ class LongPollUpdatesParser(
        val peerId = event[1].asLong()
        val cmId = event[2].asLong()

-        dispatch(
+        eventDispatcher.dispatch(
            LongPollEvent.CHAT_CLEARED,
            LongPollParsedEvent.ChatCleared(
                peerId = peerId,
@@ -403,7 +390,7 @@ class LongPollUpdatesParser(
        val peerId = event[1].asLong()
        val majorId = event[2].asInt()

-        dispatch(
+        eventDispatcher.dispatch(
            LongPollEvent.CHAT_MAJOR_CHANGED,
            LongPollParsedEvent.ChatMajorChanged(
                peerId = peerId,
@@ -418,7 +405,7 @@ class LongPollUpdatesParser(
        val peerId = event[1].asLong()
        val minorId = event[2].asInt()

-        dispatch(
+        eventDispatcher.dispatch(
            LongPollEvent.CHAT_MINOR_CHANGED,
            LongPollParsedEvent.ChatMinorChanged(
                peerId = peerId,
@@ -456,7 +443,7 @@ class LongPollUpdatesParser(
        // if userIds contains only account's id, then we don't need to show our status
        if (userIds.isEmpty()) return

-        dispatch(
+        eventDispatcher.dispatch(
            longPollEvent,
            LongPollParsedEvent.Interaction(
                interactionType = interactionType,
@@ -479,7 +466,7 @@ class LongPollUpdatesParser(
        val archiveUnreadUnmutedCount = event[8].asInt()
        val archiveMentionsCount = event[9].asInt()

-        dispatch(
+        eventDispatcher.dispatch(
            LongPollEvent.UNREAD_COUNTER_UPDATE,
            LongPollParsedEvent.UnreadCounter(
                unread = unreadCount,
@@ -504,7 +491,7 @@ class LongPollUpdatesParser(
                peerId = peerId,
                cmId = cmId
            )?.let { message ->
-                dispatch(LongPollEvent.MESSAGE_UPDATED, LongPollParsedEvent.MessageUpdated(message))
+                eventDispatcher.dispatch(LongPollEvent.MESSAGE_UPDATED, LongPollParsedEvent.MessageUpdated(message))
            }
        }
    }
@@ -516,7 +503,7 @@ class LongPollUpdatesParser(

        coroutineScope.launch(Dispatchers.IO) {
            loadMessage(messageId = messageId)?.let { message ->
-                dispatch(
+                eventDispatcher.dispatch(
                    LongPollEvent.MESSAGE_CACHE_CLEAR,
                    LongPollParsedEvent.MessageCacheClear(message)
                )
@@ -587,88 +574,68 @@ class LongPollUpdatesParser(
        }
    }

-    @Suppress("UNCHECKED_CAST")
-    private fun <T : LongPollParsedEvent> registerListener(
-        eventType: LongPollEvent,
-        listener: VkEventCallback<T>
-    ) {
-        listenersMap.let { map ->
-            map[eventType] = (map[eventType] ?: mutableListOf())
-                .also {
-                    it.add(listener as VkEventCallback<LongPollParsedEvent>)
-                }
-        }
-    }
-
-    private fun <T : LongPollParsedEvent> registerListeners(
-        eventTypes: List<LongPollEvent>,
-        listener: VkEventCallback<T>
-    ) {
-        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
-    }
-
    fun onMessageSetFlags(block: (LongPollParsedEvent) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_SET_FLAGS, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_SET_FLAGS, assembleEventCallback(block))
    }

    fun onMessageMarkedAsImportant(block: (LongPollParsedEvent.MessageMarkedAsImportant) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_IMPORTANT, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_IMPORTANT, assembleEventCallback(block))
    }

    fun onMessageMarkedAsSpam(block: (LongPollParsedEvent.MessageMarkedAsSpam) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_SPAM, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_SPAM, assembleEventCallback(block))
    }

    fun onMessageDeleted(block: (LongPollParsedEvent.MessageDeleted) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_DELETED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_DELETED, assembleEventCallback(block))
    }

    fun onMessageClearFlags(block: (LongPollParsedEvent) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, assembleEventCallback(block))
    }

    fun onMessageMarkedAsNotSpam(block: (LongPollParsedEvent.MessageMarkedAsNotSpam) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, assembleEventCallback(block))
    }

    fun onMessageRestored(block: (LongPollParsedEvent.MessageRestored) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_RESTORED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_RESTORED, assembleEventCallback(block))
    }

    fun onNewMessage(block: (LongPollParsedEvent.NewMessage) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_NEW, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_NEW, assembleEventCallback(block))
    }

    fun onMessageEdited(block: (LongPollParsedEvent.MessageEdited) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_EDITED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_EDITED, assembleEventCallback(block))
    }

    fun onMessageIncomingRead(block: (LongPollParsedEvent.IncomingMessageRead) -> Unit) {
-        registerListener(LongPollEvent.INCOMING_MESSAGE_READ, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.INCOMING_MESSAGE_READ, assembleEventCallback(block))
    }

    fun onMessageOutgoingRead(block: (LongPollParsedEvent.OutgoingMessageRead) -> Unit) {
-        registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, assembleEventCallback(block))
    }

    fun onChatCleared(block: (LongPollParsedEvent.ChatCleared) -> Unit) {
-        registerListener(LongPollEvent.CHAT_CLEARED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.CHAT_CLEARED, assembleEventCallback(block))
    }

    fun onChatMajorChanged(block: (LongPollParsedEvent.ChatMajorChanged) -> Unit) {
-        registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, assembleEventCallback(block))
    }

    fun onChatMinorChanged(block: (LongPollParsedEvent.ChatMinorChanged) -> Unit) {
-        registerListener(LongPollEvent.CHAT_MINOR_CHANGED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.CHAT_MINOR_CHANGED, assembleEventCallback(block))
    }

    fun onChatArchived(block: (LongPollParsedEvent.ChatArchived) -> Unit) {
-        registerListener(LongPollEvent.CHAT_ARCHIVED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.CHAT_ARCHIVED, assembleEventCallback(block))
    }

    fun onInteractions(block: (LongPollParsedEvent.Interaction) -> Unit) {
-        registerListeners(
+        eventDispatcher.registerListeners(
            eventTypes = listOf(
                LongPollEvent.TYPING,
                LongPollEvent.AUDIO_MESSAGE_RECORDING,