State to IntArray mapper

2023-08-24 00:23:40 +02:00 · 2023-08-24 00:23:40 +02:00 · ff2e163983
commit ff2e163983
parent 2b0746f6c4
4 changed files with 173 additions and 32 deletions
--- a/app/src/main/java/eu/ztsh/garmin/data/GarminMapper.kt
+++ 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<IntArray, IntArray> {
+            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
+        }
+
+    }
+
+}