feat: add current session duration command and implement duration serialization

Author: twisti-dev

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/netty/network/codec/kotlinx/SurfCloudBufSerializer.kt

@@ -11,6 +11,7 @@ import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.java.URISerial
 import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.java.UUIDSerializer
 import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.java.UtfStringSerializer
 import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.java.ZonedDateTimeSerializer
+import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.kotlin.DurationSerializer
 import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.nbt.CompoundTagSerializer
 import kotlinx.serialization.modules.SerializersModule
 import kotlinx.serialization.modules.contextual
@@ -31,6 +32,9 @@ object SurfCloudBufSerializer {
         contextual(ZonedDateTimeSerializer)
         contextual(Inet4AddressSerializer)
 
+        // Kotlin
+        contextual(DurationSerializer)
+
         // NBT
         contextual(CompoundTagSerializer)
     }

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/netty/network/codec/kotlinx/kotlin/DurationSerializer.kt

@@ -0,0 +1,25 @@
+package dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.kotlin
+
+import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.CloudBufSerializer
+import dev.slne.surf.cloud.api.common.netty.protocol.buffer.SurfByteBuf
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlin.time.Duration
+
+typealias SerializableDuration = @Serializable(with = DurationSerializer::class) Duration
+
+object DurationSerializer : CloudBufSerializer<Duration>() {
+    override val descriptor = PrimitiveSerialDescriptor("Duration", PrimitiveKind.LONG)
+
+    override fun serialize0(
+        buf: SurfByteBuf,
+        value: Duration
+    ) {
+        buf.writeDuration(value)
+    }
+
+    override fun deserialize0(buf: SurfByteBuf): Duration {
+        return buf.readDuration()
+    }
+}

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/netty/protocol/buffer/SurfByteBuf.kt

@@ -38,6 +38,8 @@ import java.util.function.Consumer
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 import kotlin.reflect.KClass
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
 
 private const val NUMBER_BYTE: Byte = 0
 private const val NUMBER_SHORT: Byte = 1
@@ -660,6 +662,14 @@ open class SurfByteBuf(source: ByteBuf) : WrappedByteBuf(source) {
             return Class.forName(className, true, classLoader).kotlin.objectInstance
                 ?: throw DecoderException("Failed to read singleton: $className")
         }
+
+        fun <B: ByteBuf> writeDuration(buf: B, duration: Duration) {
+            buf.writeLong(duration.inWholeMilliseconds)
+        }
+
+        fun <B: ByteBuf> readDuration(buf: B): Duration {
+            return buf.readLong().milliseconds
+        }
     }
 
 
@@ -835,6 +845,8 @@ open class SurfByteBuf(source: ByteBuf) : WrappedByteBuf(source) {
     fun readInet4Address() = readInet4Address(this)
     fun writeSingleton(singleton: Any) = writeSingleton(this, singleton)
     fun readSingleton(classLoader: ClassLoader) = readSingleton(this, classLoader)
+    fun writeDuration(duration: Duration) = writeDuration(this, duration)
+    fun readDuration() = readDuration(this)
     // @formatter:on
 // endregion
 
@@ -1067,6 +1079,9 @@ fun <B : ByteBuf> B.writeInet4Address(address: Inet4Address) = SurfByteBuf.write
 fun <B : ByteBuf> B.readSingleton(classLoader: ClassLoader) = SurfByteBuf.readSingleton(this, classLoader)
 fun <B : ByteBuf> B.writeSingleton(singleton: Any) = SurfByteBuf.writeSingleton(this, singleton)
 
+fun <B : ByteBuf> B.writeDuration(duration: Duration) = SurfByteBuf.writeDuration(this, duration)
+fun <B : ByteBuf> B.readDuration() = SurfByteBuf.readDuration(this)
+
 fun ByteBuf.wrap() = SurfByteBuf(this)
 // endregion
 

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/player/CloudPlayer.kt

@@ -9,6 +9,7 @@ import net.kyori.adventure.audience.Audience
 import net.kyori.adventure.text.Component
 import java.net.Inet4Address
 import java.util.*
+import kotlin.time.Duration
 
 /**
  * Represents a player connected to the cloud infrastructure.
@@ -36,6 +37,7 @@ interface CloudPlayer : Audience, OfflineCloudPlayer { // TODO: conversation but
     val connected get() = connectedToProxy || connectedToServer
 
     suspend fun isAfk(): Boolean
+    suspend fun currentSessionDuration(): Duration
 
     /**
      * Performs modifications on the player's persistent data container.

surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/BukkitMain.kt

@@ -343,6 +343,26 @@ class BukkitMain : SuspendingJavaPlugin() {
                 }
             }
         }
+
+        commandAPICommand("currentSessionDuration") {
+            entitySelectorArgumentOnePlayer("player")
+            anyExecutor { sender, args ->
+                val player: Player by args
+                val cloudPlayer = player.toCloudPlayer()
+                launch {
+                    val currentSessionDuration = cloudPlayer?.currentSessionDuration()
+                    sender.sendText {
+                        appendPrefix()
+                        info("Current session duration for player ${player.name} (${player.uniqueId})")
+                        appendNewPrefixedLine {
+                            variableKey("Current Session Duration")
+                            spacer(": ")
+                            variableValue(currentSessionDuration?.toString() ?: "#Unknown")
+                        }
+                    }
+                }
+            }
+        }
     }
 
     @OptIn(ExperimentalContracts::class)

surf-cloud-core/surf-cloud-core-client/src/main/kotlin/dev/slne/surf/cloud/core/client/player/ClientCloudPlayerImpl.kt

@@ -77,6 +77,10 @@ abstract class ClientCloudPlayerImpl<PlatformPlayer : Audience>(uuid: UUID) :
         return request<IsAFK>(DataRequestType.IS_AFK).isAfk
     }
 
+    override suspend fun currentSessionDuration(): Duration {
+        return request<PlaytimeSession>(DataRequestType.PLAYTIME_SESSION).playtime
+    }
+
     override suspend fun <R> withPersistentData(block: PersistentPlayerDataContainer.() -> R): R {
         val response = ServerboundRequestPlayerPersistentDataContainer(uuid).fireAndAwaitOrThrow()
 

surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/ServerboundRequestPlayerDataPacket.kt

@@ -16,6 +16,7 @@ import net.kyori.adventure.text.Component
 import java.net.Inet4Address
 import java.time.ZonedDateTime
 import java.util.*
+import kotlin.time.Duration
 import dev.slne.surf.cloud.api.common.player.name.NameHistory as ApiNameHistory
 import dev.slne.surf.cloud.api.common.player.playtime.Playtime as ApiPlaytime
 
@@ -87,6 +88,12 @@ class ServerboundRequestPlayerDataPacket(val uuid: UUID, val type: DataRequestTy
                 val player= player.player ?: error("Player is not online")
                 return IsAFK(player.isAfk())
             }
+        },
+        PLAYTIME_SESSION(::PlaytimeSession) {
+            override suspend fun readData(player: OfflineCloudPlayer): DataResponse {
+                val player= player.player ?: error("Player is not online")
+                return PlaytimeSession(player.currentSessionDuration())
+            }
         };
 
         abstract suspend fun readData(player: OfflineCloudPlayer): DataResponse
@@ -188,6 +195,14 @@ class ServerboundRequestPlayerDataResponse(val data: DataResponse) : ResponseNet
             buf.writeBoolean(isAfk)
         }
     }
+
+    class PlaytimeSession(val playtime: Duration) : DataResponse(DataRequestType.PLAYTIME_SESSION) {
+        constructor(buf: SurfByteBuf) : this(buf.readDuration())
+
+        override fun write(buf: SurfByteBuf) {
+            buf.writeDuration(playtime)
+        }
+    }
 }
 
 inline fun <reified T> DataResponse.getGenericValue(): T = when (this) {
@@ -200,5 +215,6 @@ inline fun <reified T> DataResponse.getGenericValue(): T = when (this) {
     is NameHistory -> check(T::class == ApiNameHistory::class) { "Expected ApiNameHistory" }.let { history as T }
     is Playtime -> check(T::class == ApiPlaytime::class) { "Expected ApiPlaytime" }.let { playtime as T }
     is IsAFK -> check(T::class == Boolean::class) { "Expected Boolean" }.let { isAfk as T }
+    is PlaytimeSession -> check(T::class == Duration::class) { "Expected Duration" }.let { playtime as T }
     else -> error("Unknown DataResponse type: ${this::class.simpleName}")
 }

surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/player/StandaloneCloudPlayerImpl.kt

@@ -44,9 +44,11 @@ import net.kyori.adventure.title.TitlePart
 import net.querz.nbt.tag.CompoundTag
 import java.net.Inet4Address
 import java.time.ZonedDateTime
+import java.time.temporal.ChronoUnit
 import java.util.*
 import java.util.concurrent.TimeUnit
 import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
 
 class StandaloneCloudPlayerImpl(uuid: UUID, val name: String, val ip: Inet4Address) :
     CommonCloudPlayerImpl(uuid) {
@@ -87,6 +89,8 @@ class StandaloneCloudPlayerImpl(uuid: UUID, val name: String, val ip: Inet4Addre
     var afk = false
         private set
 
+    var sessionStartTime: ZonedDateTime = ZonedDateTime.now()
+
     fun savePlayerData(tag: CompoundTag) {
         if (!ppdc.empty) {
             tag.put("ppdc", ppdc.toTagCompound())
@@ -104,6 +108,11 @@ class StandaloneCloudPlayerImpl(uuid: UUID, val name: String, val ip: Inet4Addre
         return afk
     }
 
+    override suspend fun currentSessionDuration(): Duration {
+        val duration = sessionStartTime.until(ZonedDateTime.now(), ChronoUnit.SECONDS)
+        return duration.seconds
+    }
+
     fun updateAfkStatus(newValue: Boolean) {
         if (newValue == afk) return
         afk = newValue

surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/player/StandaloneCloudPlayerManagerImpl.kt

@@ -19,6 +19,7 @@ import dev.slne.surf.cloud.standalone.server.serverManagerImpl
 import dev.slne.surf.surfapi.core.api.util.logger
 import kotlinx.coroutines.*
 import java.net.Inet4Address
+import java.time.ZonedDateTime
 import java.util.*
 import kotlin.time.Duration.Companion.minutes
 
@@ -149,6 +150,7 @@ class StandaloneCloudPlayerManagerImpl : CloudPlayerManagerImpl<StandaloneCloudP
             )
         }
 
+        player.sessionStartTime = ZonedDateTime.now()
         super.onNetworkConnect(uuid, player)
     }