cilly/Neon
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: Event -> Payload, Payload -> Event

Browse source 
A bit more consistent with official terminology ^^
This commit is contained in:
Cilly Leang 2026-01-27 16:41:09 +11:00
parent f0c0be0dd2
commit 214efd7417
Signed by: cilly
GPG key ID: 6500251E087653C9
5 changed files with 49 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

38
core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/Gateway.kt
View file

@ -71,9 +71,9 @@ class Gateway(
// if (frame !is Frame.Text && frame !is Frame.Binary)
return@onEach
logger.d { "Received event ${frame.readText()}" }
logger.d { "Received payload ${frame.readText()}" }
val raw = json.decodeFromString<Event.Unknown>(frame.readText())
val raw = json.decodeFromString<Payload.Unknown>(frame.readText())
val seq = this.seq ?: 0
if (seq + 1 == raw.s) {
this.seq = raw.s
@ -82,33 +82,33 @@ class Gateway(
return@onEach
}
when (val msg = raw.asIncoming()) {
is Event.Incoming<*> -> scope.launch { handleEvent(msg) }
is Event.Unknown -> scope.launch { handleUnknownEvent(msg) }
when (val payload = raw.asIncoming()) {
is Payload.Incoming<*> -> scope.launch { handlePayload(payload) }
is Payload.Unknown -> scope.launch { handleUnknownPayload(payload) }
}
}
.launchIn(scope)
}
suspend fun handleEvent(e: Event.Incoming<*>) {
suspend fun handlePayload(e: Payload.Incoming<*>) {
logger.d { e.toString() }
when (val payload = e.d) {
is Payload.Hello -> handleHello(payload)
is Payload.Ready -> handlers.ready.handle(payload)
is Payload.Heartbeat -> {}
is Payload.HeartbeatAck -> { missedBeats -= 1 }
when (val event = e.d) {
is Event.Hello -> handleHello(event)
is Event.Ready -> handlers.ready.handle(event)
is Event.Heartbeat -> {}
is Event.HeartbeatAck -> { missedBeats -= 1 }
}
}
suspend fun handleUnknownEvent(e: Event.Unknown) {
logger.w { "Unknown event $e" }
suspend fun handleUnknownPayload(e: Payload.Unknown) {
logger.w { "Unknown payload $e" }
}
suspend fun handleHello(e: Payload.Hello) {
suspend fun handleHello(e: Event.Hello) {
val token = auth.token
?: throw IllegalStateException("Token missing between connection and hello, cannot send Identify")
Payload.Identify(token = token).pack().send()
Event.Identify(token = token).pack().send()
val interval = e.heartbeatInterval.milliseconds
scope.launch {
@ -127,7 +127,7 @@ class Gateway(
resume(ResumeReason.MissedHeartbeat)
break
}
Payload.QoSHeartbeat(this@Gateway.seq).pack().send()
Event.QoSHeartbeat(this@Gateway.seq).pack().send()
missedBeats += 1
delay(interval)
}
@ -160,7 +160,7 @@ class Gateway(
is ResumeReason.MissedHeartbeat ->
"heartbeat missed"
is ResumeReason.SkippedSequence ->
"events skipped one sequence (expected: $seq, actual: ${reason.next})"
"payloads skipped one sequence (expected: $seq, actual: ${reason.next})"
is ResumeReason.CloseCode ->
"closed with code ${reason.code}"
null ->
@ -171,10 +171,10 @@ class Gateway(
// TODO
}
private suspend inline fun <reified T : Payload.Outgoing> Event.Outgoing<T>.send() {
private suspend inline fun <reified T : Event.Outgoing> Payload.Outgoing<T>.send() {
val ws = ws
?: throw IllegalStateException("Tried to send with no connection")
logger.d { "Sending event $this" }
logger.d { "Sending payload $this" }
logger.d { "Raw: ${json.encodeToString(this)}" }
ws.send(json.encodeToString(this))
}

16
core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/Payloads.kt
View file

@ -6,17 +6,17 @@ import kotlinx.serialization.json.JsonElement
import moe.lava.neon.core.api.ApiConstants
import moe.lava.neon.core.api.structures.User
sealed interface Event {
sealed interface Payload {
val op: Int
val d: Any?
sealed interface WithSequence : Event {
sealed interface WithSequence : Payload {
val s: Int?
val t: String?
}
@Serializable
data class Incoming<T : Payload.Incoming>(
data class Incoming<T : Event.Incoming>(
override val op: Int,
override val d: T,
override val s: Int?,
@ -24,10 +24,10 @@ sealed interface Event {
) : WithSequence
@Serializable
data class Outgoing<T : Payload.Outgoing>(
data class Outgoing<T : Event.Outgoing>(
override val op: Int,
override val d: T,
) : Event
) : Payload
@Serializable
data class Unknown(
@ -39,9 +39,9 @@ sealed interface Event {
}
@Serializable
sealed interface Payload {
sealed interface Incoming : Payload
sealed interface Outgoing : Payload
sealed interface Event {
sealed interface Incoming : Event
sealed interface Outgoing : Event
sealed class Dispatch : Incoming
// 1

30
core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/SerializingExtensions.kt
View file

@ -6,36 +6,36 @@ import moe.lava.neon.core.api.ApiConstants
private val json = ApiConstants.json
fun <T : Payload.Outgoing> T.pack(): Event.Outgoing<T> {
fun <T : Event.Outgoing> T.pack(): Payload.Outgoing<T> {
val opcode: Int = when (this) {
is Payload.Heartbeat -> 1
is Payload.Identify -> 2
is Payload.HeartbeatAck -> 11
is Payload.QoSHeartbeat -> 40
is Event.Heartbeat -> 1
is Event.Identify -> 2
is Event.HeartbeatAck -> 11
is Event.QoSHeartbeat -> 40
}
return Event.Outgoing(op = opcode, d = this)
return Payload.Outgoing(op = opcode, d = this)
}
fun Event.Unknown.asIncoming() : Event.WithSequence {
fun Payload.Unknown.asIncoming() : Payload.WithSequence {
return when (op) {
0 -> when (t) {
"READY" -> decode<Payload.Ready>()
"READY" -> decode<Event.Ready>()
else -> this
}
1 -> decode<Payload.Heartbeat>()
10 -> decode<Payload.Hello>()
11 -> decode<Payload.HeartbeatAck>()
1 -> decode<Event.Heartbeat>()
10 -> decode<Event.Hello>()
11 -> decode<Event.HeartbeatAck>()
else -> this
}
}
private inline fun <reified T : Payload.Incoming> Event.Unknown.decode(): Event.Incoming<T> =
Event.Incoming(
private inline fun <reified T : Event.Incoming> Payload.Unknown.decode(): Payload.Incoming<T> =
Payload.Incoming(
op = op,
d = json.decodeFromJsonElement<T>(d!!),
s = s,
t = t,
)
private inline fun <reified T : Payload.Incoming> KSerializer<T>.wrap(): KSerializer<Event.Incoming<T>> =
Event.Incoming.serializer(this)
private inline fun <reified T : Event.Incoming> KSerializer<T>.wrap(): KSerializer<Payload.Incoming<T>> =
Payload.Incoming.serializer(this)

6
core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/handlers/Handler.kt
View file

@ -1,7 +1,7 @@
package moe.lava.neon.core.api.gateway.handlers
import moe.lava.neon.core.api.gateway.Payload
import moe.lava.neon.core.api.gateway.Event
sealed interface Handler<T: Payload.Incoming> {
fun handle(payload: T)
sealed interface Handler<T: Event.Incoming> {
fun handle(event: T)
}

8
core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/handlers/ReadyHandler.kt
View file

@ -2,13 +2,13 @@ package moe.lava.neon.core.api.gateway.handlers
import co.touchlab.kermit.Logger
import dev.zacsweers.metro.Inject
import moe.lava.neon.core.api.gateway.Payload
import moe.lava.neon.core.api.gateway.Event
private val logger = Logger.withTag("neon.core.api.events/ready")
@Inject
class ReadyHandler : Handler<Payload.Ready> {
override fun handle(payload: Payload.Ready) {
logger.i { "Received payload $payload" }
class ReadyHandler : Handler<Event.Ready> {
override fun handle(event: Event.Ready) {
logger.i { "Received payload $event" }
}
}