fix: add onError dispatcher

RTAkland · Aug 29, 2024 · 64f3e77 · 64f3e77
1 parent fc65ff2
commit 64f3e77
Show file tree

Hide file tree

Showing 6 changed files with 132 additions and 88 deletions.
diff --git a/gradle.properties b/gradle.properties
@@ -1,3 +1,3 @@
 kotlin.code.style=official
 
-libVersion=1.2.1
+libVersion=1.2.2
diff --git a/src/main/kotlin/cn/rtast/rob/util/ob/MessageHandler.kt b/src/main/kotlin/cn/rtast/rob/util/ob/MessageHandler.kt
@@ -35,92 +35,123 @@ import org.java_websocket.WebSocket
 object MessageHandler {
 
     suspend fun onMessage(listener: OBMessage, websocket: WebSocket, message: String) {
-        listener.onMessage(websocket, message)
-        val serializedMessage = message.fromJson<BaseMessage>()
-        if (serializedMessage.metaEventType != null) {
-            when (serializedMessage.metaEventType) {
-                MetaEventType.heartbeat -> listener.onHeartBeatMessage(websocket, message.fromJson<HeartBeatEvent>())
-                MetaEventType.lifecycle -> listener.onConnectEvent(websocket, message.fromJson<ConnectEvent>())
+        try {
+            listener.onMessage(websocket, message)
+            val serializedMessage = message.fromJson<BaseMessage>()
+            if (serializedMessage.metaEventType != null) {
+                when (serializedMessage.metaEventType) {
+                    MetaEventType.heartbeat -> listener.onHeartBeatMessage(
+                        websocket,
+                        message.fromJson<HeartBeatEvent>()
+                    )
+
+                    MetaEventType.lifecycle -> listener.onConnectEvent(websocket, message.fromJson<ConnectEvent>())
+                }
+                return
             }
-            return
-        }
 
-        if (serializedMessage.postType == PostType.message) {
-            when (serializedMessage.messageType) {
-                MessageType.group -> {
-                    val msg = message.fromJson<GroupMessage>()
-                    commandManager.handleGroup(listener, msg)
-                    listener.onGroupMessage(websocket, msg, message)
+            if (serializedMessage.postType == PostType.message) {
+                when (serializedMessage.messageType) {
+                    MessageType.group -> {
+                        val msg = message.fromJson<GroupMessage>()
+                        commandManager.handleGroup(listener, msg)
+                        listener.onGroupMessage(websocket, msg, message)
+                    }
+
+                    MessageType.private -> {
+                        val msg = message.fromJson<PrivateMessage>()
+                        commandManager.handlePrivate(listener, msg)
+                        listener.onPrivateMessage(websocket, msg, message)
+                    }
+
+                    null -> listener.onMessage(websocket, message)
                 }
+                return
+            }
 
-                MessageType.private -> {
-                    val msg = message.fromJson<PrivateMessage>()
-                    commandManager.handlePrivate(listener, msg)
-                    listener.onPrivateMessage(websocket, msg, message)
+            if (serializedMessage.postType == PostType.notice) {
+                val time = serializedMessage.time
+                val msg = message.fromJson<NoticeEvent>()
+                when (serializedMessage.subType) {
+                    SubType.kick -> listener.onMemberKick(websocket, time)
+                    SubType.kick_me -> listener.onBeKicked(websocket, time)
+                    SubType.unset -> listener.onUnsetOperator(websocket, time)
+                    SubType.set -> listener.onSetOperator(websocket, time)
+                    SubType.ban -> listener.onBan(websocket, time)
+                    SubType.lift_ban -> listener.onPardon(websocket, time)
+                    SubType.leave -> listener.onLeaveMessage(websocket, msg.groupId, msg.userId, msg.operatorId, time)
+                    SubType.invite -> listener.onInviteMessage(websocket, msg.groupId, msg.userId, msg.operatorId, time)
+                    SubType.approve -> listener.onApproveMessage(
+                        websocket,
+                        msg.groupId,
+                        msg.userId,
+                        msg.operatorId,
+                        time
+                    )
+
+                    SubType.add -> listener.onJoinRequest(websocket, msg.groupId, msg.userId, msg.comment!!, time)
                 }
-
-                null -> listener.onMessage(websocket, message)
+                return
             }
-            return
-        }
 
-        if (serializedMessage.postType == PostType.notice) {
-            val time = serializedMessage.time
-            val msg = message.fromJson<NoticeEvent>()
-            when (serializedMessage.subType) {
-                SubType.kick -> listener.onMemberKick(websocket, time)
-                SubType.kick_me -> listener.onBeKicked(websocket, time)
-                SubType.unset -> listener.onUnsetOperator(websocket, time)
-                SubType.set -> listener.onSetOperator(websocket, time)
-                SubType.ban -> listener.onBan(websocket, time)
-                SubType.lift_ban -> listener.onPardon(websocket, time)
-                SubType.leave -> listener.onLeaveMessage(websocket, msg.groupId, msg.userId, msg.operatorId, time)
-                SubType.invite -> listener.onInviteMessage(websocket, msg.groupId, msg.userId, msg.operatorId, time)
-                SubType.approve -> listener.onApproveMessage(websocket, msg.groupId, msg.userId, msg.operatorId, time)
-                SubType.add -> listener.onJoinRequest(websocket, msg.groupId, msg.userId, msg.comment!!, time)
+            val messageSign = message.fromJson<ResponseMessage>().echo
+            when (messageSign) {
+                MessageEchoType.CanSendImage -> listener.onCanSendImageResponse(
+                    websocket,
+                    message.fromJson<CanSend>().data.yes
+                )
+
+                MessageEchoType.CanSendRecord -> listener.onCanSendRecordResponse(
+                    websocket,
+                    message.fromJson<CanSend>().data.yes
+                )
+
+                MessageEchoType.GetForwardMessage -> listener.onGetForwardMessageResponse(websocket, message)
+                MessageEchoType.GetFriendList -> listener.onGetFriendListResponse(
+                    websocket,
+                    message.fromJson<FriendList>()
+                )
+
+                MessageEchoType.GetGroupInfo -> listener.onGetGroupInfoResponse(
+                    websocket,
+                    message.fromJson<GroupInfo>()
+                )
+
+                MessageEchoType.GetGroupList -> listener.onGetGroupListResponse(
+                    websocket,
+                    message.fromJson<GroupList>()
+                )
+
+                MessageEchoType.GetGroupMemberList -> listener.onGetGroupMemberListResponse(
+                    websocket,
+                    message.fromJson<GroupMemberList>()
+                )
+
+                MessageEchoType.GetGroupMemberInfo -> listener.onGetGroupMemberInfoResponse(
+                    websocket,
+                    message.fromJson<GroupMemberInfo>()
+                )
+
+                MessageEchoType.GetLoginInfo -> listener.onGetLoginInfoResponse(
+                    websocket,
+                    message.fromJson<LoginInfo>()
+                )
+
+                MessageEchoType.GetMessage -> listener.onGetMessageResponse(websocket, message)
+                MessageEchoType.GetStrangerInfo -> listener.onGetStrangerInfoResponse(
+                    websocket,
+                    message.fromJson<StrangerInfo>()
+                )
+
+                MessageEchoType.GetVersionInfo -> listener.onGetOneBotVersionInfoResponse(
+                    websocket,
+                    message.fromJson<OneBotVersionInfo>()
+                )
+
+                null -> {}
             }
-            return
-        }
-
-        val messageSign = message.fromJson<ResponseMessage>().echo
-        when (messageSign) {
-            MessageEchoType.CanSendImage -> listener.onCanSendImageResponse(
-                websocket,
-                message.fromJson<CanSend>().data.yes
-            )
-
-            MessageEchoType.CanSendRecord -> listener.onCanSendRecordResponse(
-                websocket,
-                message.fromJson<CanSend>().data.yes
-            )
-
-            MessageEchoType.GetForwardMessage -> listener.onGetForwardMessageResponse(websocket, message)
-            MessageEchoType.GetFriendList -> listener.onGetFriendListResponse(websocket, message.fromJson<FriendList>())
-            MessageEchoType.GetGroupInfo -> listener.onGetGroupInfoResponse(websocket, message.fromJson<GroupInfo>())
-            MessageEchoType.GetGroupList -> listener.onGetGroupListResponse(websocket, message.fromJson<GroupList>())
-            MessageEchoType.GetGroupMemberList -> listener.onGetGroupMemberListResponse(
-                websocket,
-                message.fromJson<GroupMemberList>()
-            )
-
-            MessageEchoType.GetGroupMemberInfo -> listener.onGetGroupMemberInfoResponse(
-                websocket,
-                message.fromJson<GroupMemberInfo>()
-            )
-
-            MessageEchoType.GetLoginInfo -> listener.onGetLoginInfoResponse(websocket, message.fromJson<LoginInfo>())
-            MessageEchoType.GetMessage -> listener.onGetMessageResponse(websocket, message)
-            MessageEchoType.GetStrangerInfo -> listener.onGetStrangerInfoResponse(
-                websocket,
-                message.fromJson<StrangerInfo>()
-            )
-
-            MessageEchoType.GetVersionInfo -> listener.onGetOneBotVersionInfoResponse(
-                websocket,
-                message.fromJson<OneBotVersionInfo>()
-            )
-
-            null -> {}
+        } catch (ex: Exception) {
+            this.onError(listener, websocket, ex)
         }
     }
 
@@ -136,4 +167,8 @@ object MessageHandler {
     suspend fun onStart(listener: OBMessage) {
         listener.onWebsocketServerStart()
     }
+
+    suspend fun onError(listener: OBMessage, websocket: WebSocket, ex: Exception) {
+        listener.onError(websocket, ex)
+    }
 }
diff --git a/src/main/kotlin/cn/rtast/rob/util/ob/OBMessage.kt b/src/main/kotlin/cn/rtast/rob/util/ob/OBMessage.kt
@@ -22,6 +22,9 @@ import cn.rtast.rob.entity.StrangerInfo
 import org.java_websocket.WebSocket
 
 interface OBMessage : OBAction {
+    suspend fun onError(webSocket: WebSocket?, ex: Exception) {}
+    suspend fun onWebsocketOpen(websocket: WebSocket) {}
+    suspend fun onWebsocketClose(code: Int, reason: String, remote: Boolean) {}
     suspend fun onWebsocketServerStart() {}
     suspend fun onConnectEvent(websocket: WebSocket, event: ConnectEvent) {}
     suspend fun onHeartBeatMessage(websocket: WebSocket, event: HeartBeatEvent) {}
@@ -33,8 +36,6 @@ interface OBMessage : OBAction {
     suspend fun onLeaveMessage(webSocket: WebSocket, groupId: Long, userId: Long, operator: Long, time: Long) {}
     suspend fun onMemberKick(webSocket: WebSocket, time: Long) {}
     suspend fun onBeKicked(webSocket: WebSocket, time: Long) {}
-    suspend fun onWebsocketOpen(websocket: WebSocket) {}
-    suspend fun onWebsocketClose(code: Int, reason: String, remote: Boolean) {}
     suspend fun onSetOperator(webSocket: WebSocket, time: Long) {}
     suspend fun onUnsetOperator(webSocket: WebSocket, time: Long) {}
     suspend fun onBan(webSocket: WebSocket, time: Long) {}

diff --git a/src/main/kotlin/cn/rtast/rob/util/ws/WsClient.kt b/src/main/kotlin/cn/rtast/rob/util/ws/WsClient.kt
@@ -44,5 +44,9 @@ internal class WsClient(
         }
     }
 
-    override fun onError(ex: Exception) {}
+    override fun onError(ex: Exception) {
+        coroutineScope.launch {
+            MessageHandler.onError(listener, websocket, ex)
+        }
+    }
 }
diff --git a/src/main/kotlin/cn/rtast/rob/util/ws/WsServer.kt b/src/main/kotlin/cn/rtast/rob/util/ws/WsServer.kt
@@ -54,7 +54,11 @@ internal class WsServer(
         }
     }
 
-    override fun onError(conn: WebSocket, ex: Exception) {}
+    override fun onError(conn: WebSocket, ex: Exception) {
+        coroutineScope.launch {
+            MessageHandler.onError(listener, conn, ex)
+        }
+    }
 
     override fun onStart() {
         coroutineScope.launch {

diff --git a/src/test/kotlin/TestServer.kt b/src/test/kotlin/TestServer.kt
@@ -1,14 +1,14 @@
-import cn.rtast.rob.ROneBotFactory
-import cn.rtast.rob.entity.GroupMessage
-import cn.rtast.rob.util.ob.OBMessage
-import org.java_websocket.WebSocket
-
 /*
  * Copyright © 2024 RTAkland
  * Author: RTAkland
  * Date: 2024/8/29
  */
 
+import cn.rtast.rob.ROneBotFactory
+import cn.rtast.rob.entity.GroupMessage
+import cn.rtast.rob.util.ob.OBMessage
+import org.java_websocket.WebSocket
+
 
 fun main() {
     val rob = ROneBotFactory.createServer(6760, "114514", object : OBMessage {