Merge pull request #13 from matejdro/music

Music control packets

src/androidMain/kotlin/util/DataBuffer.kt

@@ -9,18 +9,33 @@ actual class DataBuffer {
     actual constructor(size: Int) {
         actualBuf = ByteBuffer.allocate(size)
     }
+
     actual constructor(bytes: UByteArray) {
         actualBuf = ByteBuffer.wrap(bytes.toByteArray())
     }
 
+    /**
+     * Total length of the buffer
+     */
+    actual val length: Int
+        get() = actualBuf.capacity()
+
+    /**
+     * Current position in the buffer
+     */
+    actual val readPosition: Int
+        get() = actualBuf.position()
+
     actual fun putUShort(short: UShort) {
         actualBuf.putShort(short.toShort())
     }
+
     actual fun getUShort(): UShort = actualBuf.short.toUShort()
 
     actual fun putShort(short: Short) {
         actualBuf.putShort(short)
     }
+
     actual fun getShort(): Short = actualBuf.short
 
     actual fun putUByte(byte: UByte) {

src/commonMain/kotlin/io/rebble/libpebblecommon/exceptions/packet.kt

@@ -1,4 +1,4 @@
 package io.rebble.libpebblecommon.exceptions
 
-class PacketEncodeException(message: String?): Exception(message)
-class PacketDecodeException(message: String?): Exception(message)
+class PacketEncodeException(message: String?) : Exception(message)
+class PacketDecodeException(message: String?, cause: Exception? = null) : Exception(message, cause)

src/commonMain/kotlin/io/rebble/libpebblecommon/packets/Music.kt

@@ -0,0 +1,168 @@
+package io.rebble.libpebblecommon.packets
+
+import io.rebble.libpebblecommon.protocolhelpers.PacketRegistry
+import io.rebble.libpebblecommon.protocolhelpers.PebblePacket
+import io.rebble.libpebblecommon.protocolhelpers.ProtocolEndpoint
+import io.rebble.libpebblecommon.structmapper.*
+
+open class MusicControl(val message: Message) : PebblePacket(ProtocolEndpoint.MUSIC_CONTROL) {
+    val command = SUByte(m, message.value)
+
+    init {
+        type = command.get()
+    }
+
+    enum class Message(val value: UByte) {
+        PlayPause(0x01u),
+        Pause(0x02u),
+        Play(0x03u),
+        NextTrack(0x04u),
+        PreviousTrack(0x05u),
+        VolumeUp(0x06u),
+        VolumeDown(0x07u),
+        GetCurrentTrack(0x08u),
+        UpdateCurrentTrack(0x10u),
+        UpdatePlayStateInfo(0x11u),
+        UpdateVolumeInfo(0x12u),
+        UpdatePlayerInfo(0x13u)
+    }
+
+    class UpdateCurrentTrack(
+        artist: String = "",
+        album: String = "",
+        title: String = "",
+        trackLength: Int? = null,
+        trackCount: Int? = null,
+        currentTrack: Int? = null
+    ) : MusicControl(Message.UpdateCurrentTrack) {
+        val artist = SString(m, artist)
+        val album = SString(m, album)
+        val title = SString(m, title)
+        val trackLength = SOptional(
+            m,
+            SUInt(StructMapper(), trackLength?.toUInt() ?: 0u, '<'),
+            trackLength != null
+        )
+        val trackCount = SOptional(
+            m,
+            SUInt(StructMapper(), trackCount?.toUInt() ?: 0u, '<'),
+            trackCount != null
+        )
+        val currentTrack = SOptional(
+            m,
+            SUInt(StructMapper(), currentTrack?.toUInt() ?: 0u, '<'),
+            currentTrack != null
+        )
+    }
+
+    class UpdatePlayStateInfo(
+        playbackState: PlaybackState = PlaybackState.Unknown,
+        trackPosition: UInt = 0u,
+        playRate: UInt = 0u,
+        shuffle: ShuffleState = ShuffleState.Unknown,
+        repeat: RepeatState = RepeatState.Unknown
+    ) : MusicControl(Message.UpdatePlayStateInfo) {
+        val state = SUByte(m, playbackState.value)
+        val trackPosition = SUInt(m, trackPosition, '<')
+        val playRate = SUInt(m, playRate, '<')
+        val shuffle = SUByte(m, shuffle.value)
+        val repeat = SUByte(m, repeat.value)
+    }
+
+    class UpdateVolumeInfo(
+        volumePercent: UByte = 0u,
+    ) : MusicControl(Message.UpdateVolumeInfo) {
+        val volumePercent = SUByte(m, volumePercent)
+    }
+
+    class UpdatePlayerInfo(
+        pkg: String = "",
+        name: String = ""
+    ) : MusicControl(Message.UpdatePlayerInfo) {
+        val pkg = SString(m, pkg)
+        val name = SString(m, name)
+    }
+
+    enum class PlaybackState(val value: UByte) {
+        Paused(0x00u),
+        Playing(0x01u),
+        Rewinding(0x02u),
+        FastForwarding(0x03u),
+        Unknown(0x04u),
+    }
+
+    enum class ShuffleState(val value: UByte) {
+        Unknown(0x00u),
+        Off(0x01u),
+        On(0x02u),
+    }
+
+    enum class RepeatState(val value: UByte) {
+        Unknown(0x00u),
+        Off(0x01u),
+        One(0x02u),
+        All(0x03u),
+    }
+}
+
+fun musicPacketsRegister() {
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.PlayPause.value
+    ) { MusicControl(MusicControl.Message.PlayPause) }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.Pause.value
+    ) { MusicControl(MusicControl.Message.Pause) }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.Play.value
+    ) { MusicControl(MusicControl.Message.Play) }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.NextTrack.value
+    ) { MusicControl(MusicControl.Message.NextTrack) }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.PreviousTrack.value
+    ) { MusicControl(MusicControl.Message.PreviousTrack) }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.VolumeUp.value
+    ) { MusicControl(MusicControl.Message.VolumeUp) }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.VolumeDown.value
+    ) { MusicControl(MusicControl.Message.VolumeDown) }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.GetCurrentTrack.value
+    ) { MusicControl(MusicControl.Message.GetCurrentTrack) }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.UpdateCurrentTrack.value
+    ) { MusicControl.UpdateCurrentTrack() }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.UpdatePlayStateInfo.value
+    ) { MusicControl.UpdatePlayStateInfo() }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.UpdateVolumeInfo.value
+    ) { MusicControl.UpdateVolumeInfo() }
+
+    PacketRegistry.register(
+        ProtocolEndpoint.MUSIC_CONTROL,
+        MusicControl.Message.UpdatePlayerInfo.value
+    ) { MusicControl.UpdatePlayerInfo() }
+}

src/commonMain/kotlin/io/rebble/libpebblecommon/protocolhelpers/PacketRegistry.kt

@@ -1,12 +1,9 @@
 package io.rebble.libpebblecommon.protocolhelpers
 
 import io.rebble.libpebblecommon.exceptions.PacketDecodeException
-import io.rebble.libpebblecommon.packets.appRunStatePacketsRegister
-import io.rebble.libpebblecommon.packets.appmessagePacketsRegister
+import io.rebble.libpebblecommon.packets.*
 import io.rebble.libpebblecommon.packets.blobdb.blobDBPacketsRegister
 import io.rebble.libpebblecommon.packets.blobdb.timelinePacketsRegister
-import io.rebble.libpebblecommon.packets.systemPacketsRegister
-import io.rebble.libpebblecommon.packets.timePacketsRegister
 
 /**
  * Singleton to track endpoint / type discriminators for deserialization
@@ -22,6 +19,7 @@ object PacketRegistry {
         blobDBPacketsRegister()
         appmessagePacketsRegister()
         appRunStatePacketsRegister()
+        musicPacketsRegister()
     }
 
     /**
@@ -46,7 +44,7 @@ object PacketRegistry {
 
         val typeOffset = if (typeOffsets[endpoint] != null) typeOffsets[endpoint]!! else 4
         val decoder = epdecoders[packet[typeOffset]]
-            ?: throw PacketDecodeException("No packet class registered for endpoint $endpoint")
+            ?: throw PacketDecodeException("No packet class registered for type ${packet[typeOffset]} of $endpoint")
         return decoder(packet)
     }
 }

src/commonMain/kotlin/io/rebble/libpebblecommon/protocolhelpers/PebblePacket.kt

@@ -58,15 +58,19 @@ open class PebblePacket{
             val length = SUShort(meta)
             val ep = SUShort(meta)
             meta.fromBytes(buf)
-            if (packet.size <= (2*UShort.SIZE_BYTES))
+            if (packet.size <= (2 * UShort.SIZE_BYTES))
                 throw PacketDecodeException("Malformed packet: contents empty")
-            if (length.get().toInt() != (packet.size - (2*UShort.SIZE_BYTES)))
+            if (length.get().toInt() != (packet.size - (2 * UShort.SIZE_BYTES)))
                 throw PacketDecodeException("Malformed packet: bad length")
             val ret = PacketRegistry.get(
                 ProtocolEndpoint.getByValue(ep.get()),
                 packet
             )
-            ret.m.fromBytes(buf)
+            try {
+                ret.m.fromBytes(buf)
+            } catch (e: Exception) {
+                throw PacketDecodeException("Failed to decode packet $ret", e)
+            }
             return ret
         }
     }

src/commonMain/kotlin/io/rebble/libpebblecommon/services/MusicService.kt

@@ -0,0 +1,28 @@
+package io.rebble.libpebblecommon.services
+
+import io.rebble.libpebblecommon.ProtocolHandler
+import io.rebble.libpebblecommon.packets.MusicControl
+import io.rebble.libpebblecommon.protocolhelpers.PebblePacket
+import io.rebble.libpebblecommon.protocolhelpers.ProtocolEndpoint
+import kotlinx.coroutines.channels.Channel
+
+class MusicService(private val protocolHandler: ProtocolHandler) : ProtocolService {
+    val receivedMessages = Channel<MusicControl>(Channel.BUFFERED)
+
+    init {
+        protocolHandler.registerReceiveCallback(ProtocolEndpoint.MUSIC_CONTROL, this::receive)
+    }
+
+    suspend fun send(packet: MusicControl) {
+        protocolHandler.send(packet)
+    }
+
+    fun receive(packet: PebblePacket) {
+        if (packet !is MusicControl) {
+            throw IllegalStateException("Received invalid packet type: $packet")
+        }
+
+        receivedMessages.offer(packet)
+    }
+
+}

src/commonMain/kotlin/io/rebble/libpebblecommon/services/SystemService.kt

@@ -86,7 +86,8 @@ class SystemService(private val protocolHandler: ProtocolHandler) : ProtocolServ
                     2u,
                     ProtocolCapsFlag.makeFlags(
                         listOf(
-                            ProtocolCapsFlag.Supports8kAppMessage
+                            ProtocolCapsFlag.Supports8kAppMessage,
+                            ProtocolCapsFlag.SupportsExtendedMusicProtocol
                         )
                     )
 

src/commonMain/kotlin/io/rebble/libpebblecommon/structmapper/types.kt

@@ -377,4 +377,41 @@ class SFixedList<T : Mappable>(
     override fun hashCode(): Int {
         return list.hashCode()
     }
+}
+
+class SOptional<T>(
+    mapper: StructMapper,
+    val value: StructElement<T>,
+    var present: Boolean
+) : Mappable {
+    init {
+        mapper.register(this)
+    }
+
+    override fun toBytes(): UByteArray {
+        return if (present) value.toBytes() else UByteArray(0)
+    }
+
+    override fun fromBytes(bytes: DataBuffer) {
+        val leftBytes = bytes.length - bytes.readPosition
+        if (leftBytes < value.size) {
+            present = false
+        } else {
+            present = true
+            value.fromBytes(bytes)
+        }
+    }
+
+    fun get(): T? {
+        return if (present) value.get() else null
+    }
+
+    fun set(value: T?) {
+        if (value != null) {
+            present = true
+            this.value.set(value)
+        } else {
+            present = false
+        }
+    }
 }

src/commonMain/kotlin/io/rebble/libpebblecommon/util/DataBuffer.kt

@@ -34,4 +34,14 @@ expect class DataBuffer {
     fun array(): UByteArray
 
     fun setEndian(endian: Char)
+
+    /**
+     * Total length of the buffer
+     */
+    val length: Int
+
+    /**
+     * Current position in the buffer
+     */
+    val readPosition: Int
 }