From ff2e1639834e85a02f393327e6cbf8e6d45464f9 Mon Sep 17 00:00:00 2001 From: Piotr Dec Date: Thu, 24 Aug 2023 00:23:40 +0200 Subject: [PATCH] State to IntArray mapper --- app/src/main/java/eu/ztsh/garmin/Garmin.kt | 43 ++--- .../java/eu/ztsh/garmin/data/GarminMapper.kt | 151 ++++++++++++++++++ .../ztsh/garmin/{ => data}/ManeuverMapper.kt | 5 +- .../java/eu/ztsh/garmin/{ => data}/Model.kt | 6 +- 4 files changed, 173 insertions(+), 32 deletions(-) create mode 100644 app/src/main/java/eu/ztsh/garmin/data/GarminMapper.kt rename app/src/main/java/eu/ztsh/garmin/{ => data}/ManeuverMapper.kt (94%) rename app/src/main/java/eu/ztsh/garmin/{ => data}/Model.kt (93%) diff --git a/app/src/main/java/eu/ztsh/garmin/Garmin.kt b/app/src/main/java/eu/ztsh/garmin/Garmin.kt index 702a123..d6b3113 100644 --- a/app/src/main/java/eu/ztsh/garmin/Garmin.kt +++ b/app/src/main/java/eu/ztsh/garmin/Garmin.kt @@ -6,6 +6,12 @@ import android.bluetooth.BluetoothDevice import android.bluetooth.BluetoothSocket import android.util.Log import com.mapbox.navigation.ui.maneuver.model.Maneuver +import eu.ztsh.garmin.data.Direction +import eu.ztsh.garmin.data.GarminMapper +import eu.ztsh.garmin.data.ManeuverMapper +import eu.ztsh.garmin.data.OutAngle +import eu.ztsh.garmin.data.OutType +import eu.ztsh.garmin.data.State import java.io.IOException import java.util.* import java.util.concurrent.SynchronousQueue @@ -45,46 +51,29 @@ class Garmin( send(ManeuverMapper.apply(maneuver)) } - fun send(incoming: eu.ztsh.garmin.State) { + fun send(incoming: eu.ztsh.garmin.data.State) { if (stateCache.distance != incoming.distance) { setDistance(incoming) } if (stateCache.direction != incoming.direction) { - setDirection(stateCache.direction) + setDirection(stateCache) } stateCache = incoming } - private fun setDistance(state: eu.ztsh.garmin.State) { - connection.enqueue(intArrayOf( - 0x03, asDigit(state.distance / 1000), asDigit(state.distance / 100), asDigit(state.distance / 10), - 0x00, asDigit(state.distance), state.unit.value - )) + + private fun setLines(state: eu.ztsh.garmin.data.State) { + } - private fun setDirection(direction: Direction) { - val param1: Int = when (direction.angle) { - OutAngle.LeftDown -> 0x10 - OutAngle.RightDown -> 0x20 - else -> direction.out.value - } - val param2: Int = if (direction.out == OutType.RightRoundabout - || direction.out == OutType.LeftRoundabout) { - if (direction.roundabout == OutAngle.AsDirection) direction.angle.value else direction.roundabout.value - } else { - 0x00 - } - val param3: Int = if (direction.angle == OutAngle.LeftDown || direction.angle == OutAngle.RightDown) 0x00 else direction.angle.value - connection.enqueue(intArrayOf(0x01, param1, param2, param3)) + private fun setDistance(state: eu.ztsh.garmin.data.State) { + connection.enqueue(GarminMapper.setDistance(state)) } - private fun asDigit(n: Int): Int { - if (n == 0) { - return 0 - } - val m = n % 10 - return if (m == 0) 10 else m + private fun setDirection(direction: eu.ztsh.garmin.data.State) { + connection.enqueue(GarminMapper.setDirection(direction)) } + } private inner class ConnectThread : Thread() { diff --git a/app/src/main/java/eu/ztsh/garmin/data/GarminMapper.kt b/app/src/main/java/eu/ztsh/garmin/data/GarminMapper.kt new file mode 100644 index 0000000..44182c8 --- /dev/null +++ b/app/src/main/java/eu/ztsh/garmin/data/GarminMapper.kt @@ -0,0 +1,151 @@ +package eu.ztsh.garmin.data + +class GarminMapper { + + companion object { + + fun setLines(state: State): IntArray { + return intArrayOf(0x02, state.lineOutlines.sumOf { it.value }, state.lineArrows.sumOf { it.value }) + } + + fun setDirection(state: State): IntArray { + return setDirection(state.direction.angle, state.direction.out, state.direction.roundabout) + } + + fun setDistance(state: State): IntArray { + return setDistance(state.distance, state.unit) + } + + fun setSpeed(state: State): IntArray { + return setSpeed(state.speed, state.limit, state.speed > state.limit) + } + + fun setSpeedFreeRide(state: State): Pair { + return Pair(setDistance(state.speed), setSpeed(state.limit, limitWarning = state.speed > state.limit)) + } + + fun setTime(hours: Int, minutes: Int, traffic: Boolean = false, flag: Boolean = false): IntArray { + val trafficChar = asChar(traffic) + val flagChar = asChar(flag) + return if (hours > 99) { + intArrayOf( + 0x05, + trafficChar, + asDigit(hours / 1000), + asDigit(hours / 100), + 0x00, + asDigit(hours / 10), + asDigit(hours), + 0xff, + flagChar + ) + } else { + intArrayOf( + 0x05, + trafficChar, + asDigit(hours / 10), + asDigit(hours), + 0xff, + asDigit(minutes / 10), + asDigit(minutes), + 0x00, + flagChar + ) + } + } + + fun setSpeedControl(state: State): IntArray { + return intArrayOf(0x04, if (state.control) 0x01 else 0x02) + } + + fun setCompass(state: State): IntArray { + // TODO: Implement + return setDirection(OutAngle.Straight, OutType.ArrowOnly) + } + + fun cleanDistance(): IntArray { + return intArrayOf(0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00) + } + + private fun setDirection( + angle: OutAngle, + out: OutType = OutType.Lane, + roundabout: OutAngle = OutAngle.AsDirection + ): IntArray { + val param1: Int = when (angle) { + OutAngle.LeftDown -> 0x10 + OutAngle.RightDown -> 0x20 + else -> out.value + } + val param2: Int = if (out == OutType.RightRoundabout + || out == OutType.LeftRoundabout + ) { + if (roundabout == OutAngle.AsDirection) angle.value else roundabout.value + } else { + 0x00 + } + val param3: Int = + if (angle == OutAngle.LeftDown || angle == OutAngle.RightDown) 0x00 else angle.value + return intArrayOf(0x01, param1, param2, param3) + } + + private fun setDistance(distance: Int, unit: Unit = Unit.Any): IntArray { + return intArrayOf( + 0x03, asDigit(distance / 1000), asDigit(distance / 100), asDigit(distance / 10), + 0x00, asDigit(distance), unit.value + ) + } + + private fun setSpeed( + speed: Int, + limit: Int = 0, + limitWarning: Boolean = false, + acc: Boolean = false + ): IntArray { + // TODO: car connection + val accChar = asChar(acc) + val limitWarningChar = asChar(limitWarning) + return if (limit > 0) { + intArrayOf( + 0x06, + asDigit(speed / 100), + asDigit(speed / 10), + asDigit(speed), + 0xff, + asDigit(limit / 100), + asDigit(limit / 10), + asDigit(limit), + limitWarningChar, + accChar + ) + } else { + intArrayOf( + 0x06, + 0x00, + 0x00, + 0x00, + 0x00, + asDigit(speed / 100), + asDigit(speed / 10), + asDigit(speed), + limitWarningChar, + accChar + ) + } + } + + private fun asDigit(n: Int): Int { + if (n == 0) { + return 0 + } + val m = n % 10 + return if (m == 0) 10 else m + } + + private fun asChar(boolean: Boolean): Int { + return if (boolean) 0xff else 0x00 + } + + } + +} \ No newline at end of file diff --git a/app/src/main/java/eu/ztsh/garmin/ManeuverMapper.kt b/app/src/main/java/eu/ztsh/garmin/data/ManeuverMapper.kt similarity index 94% rename from app/src/main/java/eu/ztsh/garmin/ManeuverMapper.kt rename to app/src/main/java/eu/ztsh/garmin/data/ManeuverMapper.kt index 11c7fc3..89f1996 100644 --- a/app/src/main/java/eu/ztsh/garmin/ManeuverMapper.kt +++ b/app/src/main/java/eu/ztsh/garmin/data/ManeuverMapper.kt @@ -1,4 +1,4 @@ -package eu.ztsh.garmin +package eu.ztsh.garmin.data import com.mapbox.navigation.ui.maneuver.model.Maneuver @@ -43,7 +43,8 @@ class ManeuverMapper { state.unit = when (this[1]) { "m" -> Unit.Metres "km" -> Unit.Kilometres - else -> {Unit.Any} + else -> { + Unit.Any} } } diff --git a/app/src/main/java/eu/ztsh/garmin/Model.kt b/app/src/main/java/eu/ztsh/garmin/data/Model.kt similarity index 93% rename from app/src/main/java/eu/ztsh/garmin/Model.kt rename to app/src/main/java/eu/ztsh/garmin/data/Model.kt index 27a46f6..9092bbb 100644 --- a/app/src/main/java/eu/ztsh/garmin/Model.kt +++ b/app/src/main/java/eu/ztsh/garmin/data/Model.kt @@ -1,4 +1,4 @@ -package eu.ztsh.garmin +package eu.ztsh.garmin.data enum class OutType(val value: Int) { @@ -54,8 +54,8 @@ enum class Lane(val value: Int) { class State { - var lineArrows: Int = 0 - var lineOutlines: Int = 0 + var lineArrows: List = listOf() + var lineOutlines: List = listOf() var direction = Direction() var distance: Int = 0 var unit: Unit = Unit.Any