Feat/gauge drawings improvement

app/src/main/java/org/obd/graphs/ui/performance/PerformanceFragment.kt

@@ -35,6 +35,8 @@ import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
 import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.query.QueryStrategyType
+import org.obd.graphs.preferences.Prefs
+import org.obd.graphs.preferences.getS
 import org.obd.graphs.registerReceiver
 import org.obd.graphs.renderer.Fps
 import org.obd.graphs.renderer.SurfaceRenderer
@@ -128,7 +130,7 @@ open class PerformanceFragment : Fragment() {
                 metricsCollector,
                 fps,
                 surfaceRendererType = SurfaceRendererType.PERFORMANCE,
-                viewSettings = ViewSettings(marginTop = 20),
+                viewSettings = ViewSettings(marginTop =  settings.getMarginTop()),
             )
 
         surfaceController = SurfaceController(renderer)

app/src/main/java/org/obd/graphs/ui/performance/PerformanceSettings.kt

@@ -41,4 +41,6 @@ class PerformanceSettings : ScreenSettings {
     override fun isStatusPanelEnabled(): Boolean = false
 
     override fun getMaxAllowedItemsInColumn(): Int = 8
+
+    fun getMarginTop(): Int = Prefs.getS("pref.performance.screen_top_margin", "20").toInt()
 }

app/src/main/res/values/strings.xml

@@ -3,6 +3,7 @@
     <string name="nav_close">Close</string>
 
     <string name="pref.performance.screen_label_y_padding"><b><i>Gauge</i></b> label top offset</string>
+    <string name="pref.performance.screen_top_margin">Top margin</string>
 
     <string name="dialog.screen.lock.message">Please wait. This may take a while....</string>
     <string name="pref.experimental_switch_network_enabled">This is an EXPERIMENTAL feature, controlled by the FF_SWITCH_NETWORK_ENABLED feature flag</string>

app/src/main/res/xml/preferences.xml

@@ -733,12 +733,24 @@
                     android:defaultValue="22"
                     android:dialogTitle="@string/pref.performance.screen_label_y_padding"
                     android:key="pref.performance.screen_label_y_padding"
-                    android:max="30"
+                    android:max="34"
                     android:title="@string/pref.performance.screen_label_y_padding"
-                    app:min="-100"
+                    app:min="-60"
+                    app:showSeekBarValue="true"
+                    app:singleLineTitle="false"
+                    app:useSimpleSummaryProvider="true" />
+
+                <org.obd.graphs.preferences.components.ExtendedSeekBar
+                    android:defaultValue="20"
+                    android:dialogTitle="@string/pref.performance.screen_top_margin"
+                    android:key="pref.performance.screen_top_margin"
+                    android:max="30"
+                    android:title="@string/pref.performance.screen_top_margin"
+                    app:min="0"
                     app:showSeekBarValue="true"
                     app:singleLineTitle="false"
                     app:useSimpleSummaryProvider="true" />
+
             </PreferenceScreen>
 
             <PreferenceScreen

common/src/main/java/org/obd/graphs/Formatter.kt

@@ -20,7 +20,7 @@ import org.obd.metrics.api.model.ObdMetric
 import org.obd.metrics.pid.PidDefinition
 import org.obd.metrics.pid.ValueType
 
-private const val NO_DATA = "No data"
+private const val NO_DATA = "--"
 
 fun ObdMetric.format(
     castToInt: Boolean = false,

screen_renderer/src/main/java/org/obd/graphs/renderer/gauge/GaugeDrawer.kt

@@ -24,7 +24,6 @@ import android.graphics.Paint
 import android.graphics.Rect
 import android.graphics.RectF
 import android.graphics.SweepGradient
-import android.util.Log
 import org.obd.graphs.bl.collector.Metric
 import org.obd.graphs.commons.R
 import org.obd.graphs.format
@@ -58,11 +57,26 @@ data class DrawerSettings(
     val dividerWidth: Float = 1f,
     val lineOffset: Float = 8f,
     val valueTextSize: Float = 46f,
-    val labelTextSize: Float = 16f,
+    val labelTextSize: Float = 12f,
     val scaleNumbersTextSize: Float = 12f,
     val dividerHighlightStart: Int = 9,
 )
 
+private data class CachedScaleNumber(
+    val x: Float,
+    val y: Float,
+    val text: String,
+    val color: Int,
+)
+
+private data class ScaleCacheEntry(
+    val min: Double,
+    val max: Double,
+    val radius: Float,
+    val dividerCount: Int,
+    val numbers: List<CachedScaleNumber>,
+)
+
 @Suppress("NOTHING_TO_INLINE")
 internal class GaugeDrawer(
     settings: ScreenSettings,
@@ -88,7 +102,7 @@ internal class GaugeDrawer(
 
     private val progressPaint =
         Paint(Paint.ANTI_ALIAS_FLAG).apply {
-            strokeCap = Paint.Cap.BUTT
+            strokeCap = Paint.Cap.ROUND
             style = Paint.Style.STROKE
             color = COLOR_WHITE
         }
@@ -98,6 +112,8 @@ internal class GaugeDrawer(
             strokeCap = Paint.Cap.BUTT
         }
 
+    private val scaleNumbersCache = mutableMapOf<Long, ScaleCacheEntry>()
+
     fun drawGauge(
         canvas: Canvas,
         metric: Metric,
@@ -214,7 +230,9 @@ internal class GaugeDrawer(
             val startValue = metric.pid().min.toFloat()
             val endValue = metric.pid().max.toFloat()
 
-            if (value == startValue) {
+            val clampedValue = value.coerceIn(startValue, endValue)
+
+            if (clampedValue == startValue) {
                 canvas.drawArc(
                     progressRect,
                     drawerSettings.startAngle,
@@ -224,7 +242,7 @@ internal class GaugeDrawer(
                 )
             } else {
                 val pointAngle = abs(drawerSettings.sweepAngle).toDouble() / (endValue - startValue)
-                val point = (drawerSettings.startAngle + (value - startValue) * pointAngle).toInt()
+                val point = (drawerSettings.startAngle + (clampedValue - startValue) * pointAngle).toInt()
                 when (drawerSettings.gaugeProgressBarType) {
                     GaugeProgressBarType.SHORT -> {
                         progressPaint.strokeWidth = strokeWidth
@@ -274,10 +292,17 @@ internal class GaugeDrawer(
     }
 
     private fun setProgressGradient(rect: RectF) {
-        val colors = intArrayOf(COLOR_WHITE, settings.getColorTheme().progressColor)
-        val gradient = SweepGradient(rect.centerY(), rect.centerX(), colors, null)
+        val colors =
+            intArrayOf(
+                color(R.color.gray),
+                settings.getColorTheme().progressColor,
+                Color.RED,
+            )
+        val positions = floatArrayOf(0.0f, 0.75f, 1.0f)
+
+        val gradient = SweepGradient(rect.centerY(), rect.centerX(), colors, positions)
         val matrix = Matrix()
-        matrix.postRotate(90f, rect.centerY(), rect.centerX())
+        matrix.postRotate(drawerSettings.startAngle - 5, rect.centerY(), rect.centerX())
         gradient.setLocalMatrix(matrix)
         paint.shader = gradient
     }
@@ -303,7 +328,6 @@ internal class GaugeDrawer(
 
         var centerY =
             (area.centerY() + labelCenterYPadding - (if (settings.isStatisticsEnabled()) 8 else 1) * scaleRationBasedOnScreenSize(area))
-        Log.e("WWWWWWWWWw","centerY = $centerY ")
 
         val valueHeight = max(textRect.height(), MIN_TEXT_VALUE_HEIGHT) + settings.getGaugeRendererSetting().topOffset
         val valueY = centerY - valueHeight
@@ -319,7 +343,7 @@ internal class GaugeDrawer(
 
         pid.units?.let {
             valuePaint.getTextBounds(it, 0, it.length, unitRect)
-            canvas.drawText(it, area.centerX() + textRect.width() / 2 + 4, unitY, valuePaint)
+            canvas.drawText(it, area.centerX() + textRect.width() / 2 + 10, unitY, valuePaint)
             centerY += unitRect.height() / 2
         }
 
@@ -349,6 +373,9 @@ internal class GaugeDrawer(
             labelPaint.getTextBounds(label, 0, label.length, labelRect)
 
             labelY = unitY + labelRect.height()
+            if (labelY > area.bottom - 5) {
+                labelY = area.bottom - 5f
+            }
             canvas.drawText(label, area.centerX() - (labelRect.width() / 2), labelY, labelPaint)
         }
 
@@ -470,38 +497,79 @@ internal class GaugeDrawer(
     ) {
         if (metric.source.isNumber()) {
             val pid = metric.pid()
-            val startValue = pid.min.toDouble()
-            val endValue = pid.max.toDouble()
 
-            val numberOfItems = (drawerSettings.dividersCount / drawerSettings.scaleStep)
+            val cachedEntry = scaleNumbersCache[pid.id]
+
+            val isCacheValid =
+                cachedEntry != null &&
+                    cachedEntry.radius == radius &&
+                    cachedEntry.min == pid.min.toDouble() &&
+                    cachedEntry.max == pid.max.toDouble() &&
+                    cachedEntry.dividerCount == drawerSettings.dividersCount
+
+            val scaleNumbers =
+                if (isCacheValid) {
+                    cachedEntry!!.numbers
+                } else {
+                    val newNumbers = calculateScaleNumbers(metric, radius, area)
+                    scaleNumbersCache[pid.id] =
+                        ScaleCacheEntry(
+                            min = pid.min.toDouble(),
+                            max = pid.max.toDouble(),
+                            radius = radius,
+                            dividerCount = drawerSettings.dividersCount,
+                            numbers = newNumbers,
+                        )
+                    newNumbers
+                }
 
-            val scaleRation = scaleRationBasedOnScreenSize(area, targetMin = 0.4f, targetMax = 1.9f)
-            val stepValue = (endValue - startValue) / numberOfItems
-            val baseRadius = radius * NUMERALS_RADIUS_SCALE_FACTOR
+            scaleNumbers.forEach { item ->
+                numbersPaint.color = item.color
+                canvas.drawText(item.text, item.x, item.y, numbersPaint)
+            }
+        }
+    }
 
-            val start = 0
-            val end = drawerSettings.dividersCount + 1
+    private fun calculateScaleNumbers(
+        metric: Metric,
+        radius: Float,
+        area: RectF,
+    ): List<CachedScaleNumber> {
+        val result = mutableListOf<CachedScaleNumber>()
+        val pid = metric.pid()
+        val startValue = pid.min.toDouble()
+        val endValue = pid.max.toDouble()
 
-            for (j in start..end step drawerSettings.scaleStep) {
-                val angle = (drawerSettings.startAngle + j * drawerSettings.dividersStepAngle) * (Math.PI / 180)
-                val text = valueAsString(metric, value = (startValue + stepValue * j / drawerSettings.scaleStep).round(1))
-                val rect = Rect()
-                numbersPaint.getTextBounds(text, 0, text.length, rect)
-                numbersPaint.textSize = drawerSettings.scaleNumbersTextSize * scaleRation
+        val numberOfItems = (drawerSettings.dividersCount / drawerSettings.scaleStep)
+        val scaleRation = scaleRationBasedOnScreenSize(area, targetMin = 0.4f, targetMax = 1.9f)
+        val stepValue = (endValue - startValue) / numberOfItems
+        val baseRadius = radius * NUMERALS_RADIUS_SCALE_FACTOR
 
-                val x = area.left + (area.width() / 2.0f + cos(angle) * baseRadius - rect.width() / 2).toFloat()
-                val y = area.top + (area.height() / 2.0f + sin(angle) * baseRadius + rect.height() / 2).toFloat()
+        val start = 0
+        val end = drawerSettings.dividersCount + 1
 
-                numbersPaint.color =
-                    if (j == (numberOfItems - 1) * drawerSettings.scaleStep || j == numberOfItems * drawerSettings.scaleStep) {
-                        settings.getColorTheme().progressColor
-                    } else {
-                        color(R.color.gray)
-                    }
+        for (j in start..end step drawerSettings.scaleStep) {
+            val angle = (drawerSettings.startAngle + j * drawerSettings.dividersStepAngle) * (Math.PI / 180)
+            val value = (startValue + stepValue * j / drawerSettings.scaleStep).round(1)
+            val text = valueAsString(metric, value)
+
+            numbersPaint.textSize = drawerSettings.scaleNumbersTextSize * scaleRation
+            val rect = Rect()
+            numbersPaint.getTextBounds(text, 0, text.length, rect)
+
+            val x = area.left + (area.width() / 2.0f + cos(angle) * baseRadius - rect.width() / 2).toFloat()
+            val y = area.top + (area.height() / 2.0f + sin(angle) * baseRadius + rect.height() / 2).toFloat()
+
+            val color =
+                if (j == (numberOfItems - 1) * drawerSettings.scaleStep || j == numberOfItems * drawerSettings.scaleStep) {
+                    settings.getColorTheme().progressColor
+                } else {
+                    color(R.color.gray)
+                }
 
-                canvas.drawText(text, x, y, numbersPaint)
-            }
+            result.add(CachedScaleNumber(x, y, text, color))
         }
+        return result
     }
 
     private inline fun valueAsString(