update kritor

xposed/src/main/java/kritor/client/KritorClient.kt

@@ -6,9 +6,9 @@ import io.grpc.ManagedChannel
 import io.grpc.ManagedChannelBuilder
 import io.kritor.ReverseServiceGrpcKt
 import io.kritor.event.*
-import io.kritor.reverse.ReqCode
+import io.kritor.ReqCode
-import io.kritor.reverse.Request
+import io.kritor.Request
-import io.kritor.reverse.Response
+import io.kritor.Response
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope

xposed/src/main/java/kritor/server/KritorServer.kt

@@ -20,15 +20,15 @@ class KritorServer(
         .intercept(AuthInterceptor)
         .addService(Authentication)
         .addService(ContactService)
-        .addService(KritorService)
+        .addService(CoreService)
         .addService(FriendService)
         .addService(GroupService)
         .addService(GroupFileService)
         .addService(MessageService)
         .addService(EventService)
-        .addService(ForwardMessageService)
         .addService(WebService)
         .addService(DeveloperService)
+        .addService(QsignService)
         .build()!!
 
     fun start(block: Boolean = false) {

xposed/src/main/java/kritor/service/Authentication.kt

@@ -5,7 +5,7 @@ import io.grpc.StatusRuntimeException
 import io.kritor.AuthCode
 import io.kritor.AuthReq
 import io.kritor.AuthRsp
-import io.kritor.AuthenticationGrpcKt
+import io.kritor.AuthenticationServiceGrpcKt
 import io.kritor.GetAuthStateReq
 import io.kritor.GetAuthStateRsp
 import kritor.auth.AuthInterceptor
@@ -13,7 +13,7 @@ import moe.fuqiuluo.shamrock.config.ActiveTicket
 import moe.fuqiuluo.shamrock.config.ShamrockConfig
 import qq.service.QQInterfaces
 
-internal object Authentication: AuthenticationGrpcKt.AuthenticationCoroutineImplBase() {
+internal object Authentication: AuthenticationServiceGrpcKt.AuthenticationServiceCoroutineImplBase() {
     @Grpc("Authentication", "Auth")
     override suspend fun auth(request: AuthReq): AuthRsp {
         if (QQInterfaces.app.account != request.account) {

xposed/src/main/java/kritor/service/CoreService.kt

@@ -16,8 +16,8 @@ import qq.service.QQInterfaces.Companion.app
 import qq.service.contact.ContactHelper
 import java.io.File
 
-internal object KritorService : KritorServiceGrpcKt.KritorServiceCoroutineImplBase() {
+internal object CoreService : CoreServiceGrpcKt.CoreServiceCoroutineImplBase() {
-    @Grpc("KritorService", "GetVersion")
+    @Grpc("CoreService", "GetVersion")
     override suspend fun getVersion(request: GetVersionRequest): GetVersionResponse {
         return GetVersionResponse.newBuilder().apply {
             this.version = ShamrockVersion
@@ -25,7 +25,7 @@ internal object KritorService : KritorServiceGrpcKt.KritorServiceCoroutineImplBa
         }.build()
     }
 
-    @Grpc("KritorService", "ClearCache")
+    @Grpc("CoreService", "ClearCache")
     override suspend fun clearCache(request: ClearCacheRequest): ClearCacheResponse {
         FileUtils.clearCache()
         MMKVFetcher.mmkvWithId("audio2silk")
@@ -33,7 +33,7 @@ internal object KritorService : KritorServiceGrpcKt.KritorServiceCoroutineImplBa
         return ClearCacheResponse.newBuilder().build()
     }
 
-    @Grpc("KritorService", "GetCurrentAccount")
+    @Grpc("CoreService", "GetCurrentAccount")
     override suspend fun getCurrentAccount(request: GetCurrentAccountRequest): GetCurrentAccountResponse {
         return GetCurrentAccountResponse.newBuilder().apply {
             this.accountName = if (app is QQAppInterface) app.currentNickname else "unknown"
@@ -42,7 +42,7 @@ internal object KritorService : KritorServiceGrpcKt.KritorServiceCoroutineImplBa
         }.build()
     }
 
-    @Grpc("KritorService", "DownloadFile")
+    @Grpc("CoreService", "DownloadFile")
     override suspend fun downloadFile(request: DownloadFileRequest): DownloadFileResponse {
         val headerMap = mutableMapOf(
             "User-Agent" to "Shamrock"
@@ -88,7 +88,7 @@ internal object KritorService : KritorServiceGrpcKt.KritorServiceCoroutineImplBa
         }.build()
     }
 
-    @Grpc("KritorService", "SwitchAccount")
+    @Grpc("CoreService", "SwitchAccount")
     override suspend fun switchAccount(request: SwitchAccountRequest): SwitchAccountResponse {
         val uin = when (request.accountCase!!) {
             SwitchAccountRequest.AccountCase.ACCOUNT_UID -> ContactHelper.getUinByUidAsync(request.accountUid)
@@ -109,7 +109,7 @@ internal object KritorService : KritorServiceGrpcKt.KritorServiceCoroutineImplBa
         return SwitchAccountResponse.newBuilder().build()
     }
 
-    @Grpc("KritorService", "GetDeviceBattery")
+    @Grpc("CoreService", "GetDeviceBattery")
     override suspend fun getDeviceBattery(request: GetDeviceBatteryRequest): GetDeviceBatteryResponse {
         return GetDeviceBatteryResponse.newBuilder().apply {
             PlatformUtils.getDeviceBattery().let {

xposed/src/main/java/kritor/service/DeveloperService.kt

@@ -1,30 +1,10 @@
 package kritor.service
 
 import com.google.protobuf.ByteString
-import com.tencent.mobileqq.fe.FEKit
-import com.tencent.mobileqq.qsec.qsecdandelionsdk.Dandelion
 import io.kritor.developer.*
 import qq.service.QQInterfaces
 
 internal object DeveloperService: DeveloperServiceGrpcKt.DeveloperServiceCoroutineImplBase() {
-    @Grpc("DeveloperService", "Sign")
-    override suspend fun sign(request: SignRequest): SignResponse {
-        return SignResponse.newBuilder().apply {
-            val result = FEKit.getInstance().getSign(request.command, request.buffer.toByteArray(), request.seq, request.uin)
-            this.sign = ByteString.copyFrom(result.sign)
-            this.token = ByteString.copyFrom(result.token)
-            this.extra = ByteString.copyFrom(result.extra)
-        }.build()
-    }
-
-    @Grpc("DeveloperService", "Energy")
-    override suspend fun energy(request: EnergyRequest): EnergyResponse {
-        return EnergyResponse.newBuilder().apply {
-            this.result = ByteString.copyFrom(Dandelion.getInstance().fly(request.data, request.salt.toByteArray()))
-        }.build()
-    }
-
-
     @Grpc("DeveloperService", "SendPacket")
     override suspend fun sendPacket(request: SendPacketRequest): SendPacketResponse {
         return SendPacketResponse.newBuilder().apply {
@@ -37,5 +17,4 @@ internal object DeveloperService: DeveloperServiceGrpcKt.DeveloperServiceCorouti
             }
         }.build()
     }
-
 }

xposed/src/main/java/kritor/service/ForwardMessageService.kt

@@ -1,85 +0,0 @@
-package kritor.service
-
-import com.tencent.qqnt.kernel.nativeinterface.MsgConstant
-import io.grpc.Status
-import io.grpc.StatusRuntimeException
-import io.kritor.event.MessageEvent
-import io.kritor.message.*
-import qq.service.contact.longPeer
-import qq.service.msg.ForwardMessageHelper
-import qq.service.msg.MessageHelper
-import qq.service.msg.toKritorResponseMessages
-
-internal object ForwardMessageService : ForwardMessageServiceGrpcKt.ForwardMessageServiceCoroutineImplBase() {
-    @Grpc("ForwardMessageService", "UploadForwardMessage")
-    override suspend fun uploadForwardMessage(request: UploadForwardMessageRequest): UploadForwardMessageResponse {
-        val contact = request.contact.let {
-            MessageHelper.generateContact(
-                when (it.scene!!) {
-                    Scene.GROUP -> MsgConstant.KCHATTYPEGROUP
-                    Scene.FRIEND -> MsgConstant.KCHATTYPEC2C
-                    Scene.GUILD -> MsgConstant.KCHATTYPEGUILD
-                    Scene.STRANGER_FROM_GROUP -> MsgConstant.KCHATTYPETEMPC2CFROMGROUP
-                    Scene.NEARBY -> MsgConstant.KCHATTYPETEMPC2CFROMUNKNOWN
-                    Scene.STRANGER -> MsgConstant.KCHATTYPETEMPC2CFROMUNKNOWN
-                    Scene.UNRECOGNIZED -> throw StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription("Unrecognized scene"))
-                }, it.peer, it.subPeer
-            )
-        }
-
-        val forwardMessage = ForwardMessageHelper.uploadMultiMsg(
-            contact.chatType,
-            contact.longPeer().toString(),
-            contact.guildId,
-            request.messagesList
-        ).onFailure {
-            throw StatusRuntimeException(Status.INTERNAL.withCause(it))
-        }.getOrThrow()
-
-        return UploadForwardMessageResponse.newBuilder().apply {
-            this.resId = forwardMessage.resId
-        }.build()
-    }
-
-    @Grpc("ForwardMessageService", "DownloadForwardMessage")
-    override suspend fun downloadForwardMessage(request: DownloadForwardMessageRequest): DownloadForwardMessageResponse {
-        return DownloadForwardMessageResponse.newBuilder().apply {
-            this.addAllMessages(
-                MessageHelper.getForwardMsg(request.resId).onFailure {
-                    throw StatusRuntimeException(Status.INTERNAL.withCause(it))
-                }.getOrThrow().map { detail ->
-                    MessageEvent.newBuilder().apply {
-                        this.time = detail.time
-                        this.messageId = detail.qqMsgId
-                        this.messageSeq = detail.msgSeq
-                        this.contact = Contact.newBuilder().apply {
-                            this.scene = when (detail.msgType) {
-                                MsgConstant.KCHATTYPEC2C -> Scene.FRIEND
-                                MsgConstant.KCHATTYPEGROUP -> Scene.GROUP
-                                MsgConstant.KCHATTYPEGUILD -> Scene.GUILD
-                                MsgConstant.KCHATTYPETEMPC2CFROMGROUP -> Scene.STRANGER_FROM_GROUP
-                                MsgConstant.KCHATTYPETEMPC2CFROMUNKNOWN -> Scene.NEARBY
-                                else -> Scene.STRANGER
-                            }
-                            this.peer = detail.peerId.toString()
-                        }.build()
-                        this.sender = Sender.newBuilder().apply {
-                            this.uin = detail.sender.userId
-                            this.nick = detail.sender.nickName
-                            this.uid = detail.sender.uid
-                        }.build()
-                        detail.message?.elements?.toKritorResponseMessages(
-                            com.tencent.qqnt.kernel.nativeinterface.Contact(
-                                detail.msgType,
-                                detail.peerId.toString(),
-                                null
-                            )
-                        )?.let {
-                            this.addAllElements(it)
-                        }
-                    }.build()
-                }
-            )
-        }.build()
-    }
-}

xposed/src/main/java/kritor/service/MessageService.kt

@@ -9,6 +9,7 @@ import io.grpc.Status
 import io.grpc.StatusRuntimeException
 import io.kritor.event.MessageEvent
 import io.kritor.message.*
+import io.kritor.message.EssenceMessage
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withTimeoutOrNull
 import moe.fuqiuluo.shamrock.helper.Level
@@ -21,9 +22,9 @@ import protobuf.message.routing.Grp
 import qq.service.QQInterfaces
 import qq.service.contact.longPeer
 import qq.service.internals.NTServiceFetcher
+import qq.service.msg.*
+import qq.service.msg.ForwardMessageHelper
 import qq.service.msg.MessageHelper
-import qq.service.msg.NtMsgConvertor
-import qq.service.msg.toKritorReqMessages
 import kotlin.coroutines.resume
 import kotlin.random.Random
 import kotlin.random.nextUInt
@@ -274,6 +275,78 @@ internal object MessageService : MessageServiceGrpcKt.MessageServiceCoroutineImp
         }.build()
     }
 
+    @Grpc("MessageService", "UploadForwardMessage")
+    override suspend fun uploadForwardMessage(request: UploadForwardMessageRequest): UploadForwardMessageResponse {
+        val contact = request.contact.let {
+            MessageHelper.generateContact(
+                when (it.scene!!) {
+                    Scene.GROUP -> MsgConstant.KCHATTYPEGROUP
+                    Scene.FRIEND -> MsgConstant.KCHATTYPEC2C
+                    Scene.GUILD -> MsgConstant.KCHATTYPEGUILD
+                    Scene.STRANGER_FROM_GROUP -> MsgConstant.KCHATTYPETEMPC2CFROMGROUP
+                    Scene.NEARBY -> MsgConstant.KCHATTYPETEMPC2CFROMUNKNOWN
+                    Scene.STRANGER -> MsgConstant.KCHATTYPETEMPC2CFROMUNKNOWN
+                    Scene.UNRECOGNIZED -> throw StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription("Unrecognized scene"))
+                }, it.peer, it.subPeer
+            )
+        }
+
+        val forwardMessage = ForwardMessageHelper.uploadMultiMsg(
+            contact.chatType,
+            contact.longPeer().toString(),
+            contact.guildId,
+            request.messagesList
+        ).onFailure {
+            throw StatusRuntimeException(Status.INTERNAL.withCause(it))
+        }.getOrThrow()
+
+        return UploadForwardMessageResponse.newBuilder().apply {
+            this.resId = forwardMessage.resId
+        }.build()
+    }
+
+    @Grpc("MessageService", "DownloadForwardMessage")
+    override suspend fun downloadForwardMessage(request: DownloadForwardMessageRequest): DownloadForwardMessageResponse {
+        return DownloadForwardMessageResponse.newBuilder().apply {
+            this.addAllMessages(
+                MessageHelper.getForwardMsg(request.resId).onFailure {
+                    throw StatusRuntimeException(Status.INTERNAL.withCause(it))
+                }.getOrThrow().map { detail ->
+                    MessageEvent.newBuilder().apply {
+                        this.time = detail.time
+                        this.messageId = detail.qqMsgId
+                        this.messageSeq = detail.msgSeq
+                        this.contact = io.kritor.message.Contact.newBuilder().apply {
+                            this.scene = when (detail.msgType) {
+                                MsgConstant.KCHATTYPEC2C -> Scene.FRIEND
+                                MsgConstant.KCHATTYPEGROUP -> Scene.GROUP
+                                MsgConstant.KCHATTYPEGUILD -> Scene.GUILD
+                                MsgConstant.KCHATTYPETEMPC2CFROMGROUP -> Scene.STRANGER_FROM_GROUP
+                                MsgConstant.KCHATTYPETEMPC2CFROMUNKNOWN -> Scene.NEARBY
+                                else -> Scene.STRANGER
+                            }
+                            this.peer = detail.peerId.toString()
+                        }.build()
+                        this.sender = Sender.newBuilder().apply {
+                            this.uin = detail.sender.userId
+                            this.nick = detail.sender.nickName
+                            this.uid = detail.sender.uid
+                        }.build()
+                        detail.message?.elements?.toKritorResponseMessages(
+                            com.tencent.qqnt.kernel.nativeinterface.Contact(
+                                detail.msgType,
+                                detail.peerId.toString(),
+                                null
+                            )
+                        )?.let {
+                            this.addAllElements(it)
+                        }
+                    }.build()
+                }
+            )
+        }.build()
+    }
+
     @Grpc("MessageService", "DeleteEssenceMsg")
     override suspend fun deleteEssenceMsg(request: DeleteEssenceMsgRequest): DeleteEssenceMsgResponse {
         val contact = MessageHelper.generateContact(MsgConstant.KCHATTYPEGROUP, request.groupId.toString())

xposed/src/main/java/kritor/service/QsignService.kt

@@ -0,0 +1,26 @@
+package kritor.service
+
+import com.google.protobuf.ByteString
+import com.tencent.mobileqq.fe.FEKit
+import com.tencent.mobileqq.qsec.qsecdandelionsdk.Dandelion
+import io.kritor.developer.*
+
+
+internal object QsignService: QsignServiceGrpcKt.QsignServiceCoroutineImplBase() {
+    @Grpc("QsignService", "Sign")
+    override suspend fun sign(request: SignRequest): SignResponse {
+        return SignResponse.newBuilder().apply {
+            val result = FEKit.getInstance().getSign(request.command, request.buffer.toByteArray(), request.seq, request.uin)
+            this.sign = ByteString.copyFrom(result.sign)
+            this.token = ByteString.copyFrom(result.token)
+            this.extra = ByteString.copyFrom(result.extra)
+        }.build()
+    }
+
+    @Grpc("QsignService", "Energy")
+    override suspend fun energy(request: EnergyRequest): EnergyResponse {
+        return EnergyResponse.newBuilder().apply {
+            this.result = ByteString.copyFrom(Dandelion.getInstance().fly(request.data, request.salt.toByteArray()))
+        }.build()
+    }
+}