@momo-kits/native-kits 0.162.1-beta.7 → 0.162.1-gif.1-debug

package/build.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+    // this is necessary to avoid the plugins to be loaded multiple times
+    // in each subproject's classloader
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.android.library) apply false
+    alias(libs.plugins.compose) apply false
+    alias(libs.plugins.kotlin.compose.compiler) apply false
+    alias(libs.plugins.jetbrains.kotlin.multiplatform) apply false
+    alias(libs.plugins.jetbrains.kotlin.serialization) apply false
+    alias(libs.plugins.vanniktech.mavenPublish) apply false
+}

package/compose/build.gradle.kts

@@ -0,0 +1,190 @@
+// import com.vanniktech.maven.publish.JavadocJar
+// import com.vanniktech.maven.publish.KotlinMultiplatform
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    alias(libs.plugins.jetbrains.kotlin.multiplatform)
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.compose)
+    alias(libs.plugins.kotlin.compose.compiler)
+//         alias(libs.plugins.vanniktech.mavenPublish)
+    id(libs.plugins.jetbrains.kotlin.cocoapods.get().pluginId)
+    kotlin("plugin.serialization")
+}
+
+val gitlabName: String? = findProperty("name") as String? ?: ""
+val gitlabRepo: String? = findProperty("repo") as String? ?: ""
+val gitlabUrl: String? = findProperty("url") as String? ?: ""
+val gitlabGroup: String? = findProperty("group") as String? ?: ""
+val gitlabArtifactId: String = findProperty("artifact.id") as String? ?: ""
+val gitlabVersion: String? = findProperty("version") as String? ?: ""
+val gitlabUser: String? = findProperty("gitlab.user") as String? ?: ""
+val gitlabKey: String? = findProperty("gitlab.password") as String? ?: ""
+
+kotlin {
+    androidTarget {
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_17)
+        }
+        publishLibraryVariants("release")
+    }
+
+    val fwName = gitlabArtifactId
+    val iosTargets = listOf(iosArm64(), iosSimulatorArm64())
+    iosTargets.forEach {
+        it.binaries.framework {
+            baseName = fwName
+            binaryOption("bundleId", "$gitlabGroup.$fwName")
+            isStatic = true
+        }
+    }
+
+    cocoapods {
+        version = "0.162.1-gif.1-debug"
+        summary = "IOS Shared module"
+        homepage = "https://momo.vn"
+        ios.deploymentTarget = "15.0"
+
+        framework {
+            baseName = fwName
+            isStatic = true
+        }
+
+        pod("lottie-ios") {
+            moduleName = "Lottie"
+            version = "4.4.3"
+            extraOpts += listOf("-compiler-option", "-fmodules")
+        }
+    }
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(compose.runtime)
+            implementation(compose.material)
+            implementation(compose.material3)
+            implementation(compose.components.resources)
+            implementation(libs.compose.ui.backhandler)
+            implementation(libs.ktor.client.core)
+            implementation(libs.jetbrains.coroutines.core)
+            implementation(libs.navigation.multiplatform)
+            implementation(libs.coil.multiplatform.compose)
+            implementation(libs.coil.multiplatform.core)
+            implementation(libs.coil.multiplatform.network.ktor)
+            implementation(libs.jetbrains.serialization.json)
+            implementation(libs.kotlinx.datetime)
+            api(libs.native.max.api)
+            implementation(libs.compottie)
+            implementation(libs.sketch.compose)
+            implementation(libs.sketch.http)
+            implementation(libs.sketch.animated.core)
+            implementation(libs.sketch.animated.gif)
+        }
+        androidMain.dependencies {
+            implementation(libs.ktor.client.okhttp)
+            implementation(libs.airbnb.lottie)
+        }
+        iosMain.dependencies {
+            implementation(libs.ktor.client.darwin)
+        }
+    }
+}
+
+android {
+    namespace = "vn.momo.kits.kits"
+    compileSdk = 35
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    defaultConfig {
+        minSdk = 24
+    }
+}
+
+dependencies {
+}
+
+repositories {
+    google {
+        mavenContent {
+            includeGroupAndSubgroups("androidx")
+            includeGroupAndSubgroups("com.android")
+            includeGroupAndSubgroups("com.google")
+        }
+    }
+    mavenCentral()
+    maven { url = uri("https://maven.pkg.jetbrains.space/public/p/compose/dev") }
+    maven {
+        url = uri("https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven")
+        credentials {username = "download_packages"; password = "gldt-bjDqLpU_sPcHDuXau2ws" }
+    }
+    maven {
+        url = uri("https://artifacts.mservice.com.vn/repository/maven-momo-app/")
+        credentials {
+            username = "viewer"
+            password = "viewer"
+        }
+        isAllowInsecureProtocol = true
+    }
+}
+
+compose {
+    resources {
+        publicResClass = true
+        packageOfResClass = "vn.momo.uikits.resources"
+        generateResClass = always
+    }
+}
+
+// publishing {
+//     repositories {
+//         maven {
+//             name = "${gitlabRepo}Packages"
+//             credentials {
+//                 username = gitlabUser
+//                 password = gitlabKey
+//             }
+//             url = uri("$gitlabUrl")
+//         }
+//     }
+// }
+
+// mavenPublishing {
+//     configure(
+//         KotlinMultiplatform(
+//             javadocJar = JavadocJar.Empty(),
+//             sourcesJar = true,
+//             androidVariantsToPublish = listOf("release")
+//         )
+//     )
+// 
+//     repositories {
+//         maven {
+//             name = "${gitlabRepo}Packages"
+//             credentials { username = gitlabUser; password = gitlabKey }
+//             url = uri("$gitlabUrl")
+//         }
+//     }
+// 
+//     coordinates(gitlabGroup.toString(), gitlabArtifactId, gitlabVersion.toString())
+// 
+//     pom {
+//         name = "$gitlabName Klib"
+//         description = "$gitlabName"
+//         url = "https://gitlab.mservice.com.vn"
+//         licenses {
+//             license {
+//                 name = "The Apache License, Version 2.0"
+//                 url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
+//                 distribution = "https://www.apache.org/licenses/LICENSE-2.0.txt"
+//             }
+//         }
+//         developers {
+//             developer {
+//                 id = "kotlin-hands-on"
+//                 name = "Kotlin Developer Advocate"
+//                 url = "https://github.com/kotlin-hands-on/"
+//             }
+//         }
+//     }
+// }

package/compose/build.gradle.kts.backup

@@ -0,0 +1,190 @@
+import com.vanniktech.maven.publish.JavadocJar
+import com.vanniktech.maven.publish.KotlinMultiplatform
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    alias(libs.plugins.jetbrains.kotlin.multiplatform)
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.compose)
+    alias(libs.plugins.kotlin.compose.compiler)
+    alias(libs.plugins.vanniktech.mavenPublish)
+    id(libs.plugins.jetbrains.kotlin.cocoapods.get().pluginId)
+    kotlin("plugin.serialization")
+}
+
+val gitlabName: String? = findProperty("name") as String? ?: ""
+val gitlabRepo: String? = findProperty("repo") as String? ?: ""
+val gitlabUrl: String? = findProperty("url") as String? ?: ""
+val gitlabGroup: String? = findProperty("group") as String? ?: ""
+val gitlabArtifactId: String = findProperty("artifact.id") as String? ?: ""
+val gitlabVersion: String? = findProperty("version") as String? ?: ""
+val gitlabUser: String? = findProperty("gitlab.user") as String? ?: ""
+val gitlabKey: String? = findProperty("gitlab.password") as String? ?: ""
+
+kotlin {
+    androidTarget {
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_17)
+        }
+        publishLibraryVariants("release")
+    }
+
+    val fwName = gitlabArtifactId
+    val iosTargets = listOf(iosArm64(), iosSimulatorArm64())
+    iosTargets.forEach {
+        it.binaries.framework {
+            baseName = fwName
+            binaryOption("bundleId", "$gitlabGroup.$fwName")
+            isStatic = true
+        }
+    }
+
+    cocoapods {
+        version = gitlabVersion
+        summary = "IOS Shared module"
+        homepage = "https://momo.vn"
+        ios.deploymentTarget = "15.0"
+
+        framework {
+            baseName = fwName
+            isStatic = true
+        }
+
+        pod("lottie-ios") {
+            moduleName = "Lottie"
+            version = "4.4.3"
+            extraOpts += listOf("-compiler-option", "-fmodules")
+        }
+    }
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(compose.runtime)
+            implementation(compose.material)
+            implementation(compose.material3)
+            implementation(compose.components.resources)
+            implementation(libs.compose.ui.backhandler)
+            implementation(libs.ktor.client.core)
+            implementation(libs.jetbrains.coroutines.core)
+            implementation(libs.navigation.multiplatform)
+            implementation(libs.coil.multiplatform.compose)
+            implementation(libs.coil.multiplatform.core)
+            implementation(libs.coil.multiplatform.network.ktor)
+            implementation(libs.jetbrains.serialization.json)
+            implementation(libs.kotlinx.datetime)
+            api(libs.native.max.api)
+            implementation(libs.compottie)
+            implementation(libs.sketch.compose)
+            implementation(libs.sketch.http)
+            implementation(libs.sketch.animated.core)
+            implementation(libs.sketch.animated.gif)
+        }
+        androidMain.dependencies {
+            implementation(libs.ktor.client.okhttp)
+            implementation(libs.airbnb.lottie)
+        }
+        iosMain.dependencies {
+            implementation(libs.ktor.client.darwin)
+        }
+    }
+}
+
+android {
+    namespace = "$gitlabGroup.$gitlabArtifactId"
+    compileSdk = libs.versions.android.compileSdk.get().toInt()
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    defaultConfig {
+        minSdk = libs.versions.android.minSdk.get().toInt()
+    }
+}
+
+dependencies {
+}
+
+repositories {
+    google {
+        mavenContent {
+            includeGroupAndSubgroups("androidx")
+            includeGroupAndSubgroups("com.android")
+            includeGroupAndSubgroups("com.google")
+        }
+    }
+    mavenCentral()
+    maven { url = uri("https://maven.pkg.jetbrains.space/public/p/compose/dev") }
+    maven {
+        url = uri("https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven")
+        credentials {username = "download_packages"; password = "gldt-bjDqLpU_sPcHDuXau2ws" }
+    }
+    maven {
+        url = uri("https://artifacts.mservice.com.vn/repository/maven-momo-app/")
+        credentials {
+            username = "viewer"
+            password = "viewer"
+        }
+        isAllowInsecureProtocol = true
+    }
+}
+
+compose {
+    resources {
+        publicResClass = true
+        packageOfResClass = "vn.momo.uikits.resources"
+        generateResClass = always
+    }
+}
+
+publishing {
+    repositories {
+        maven {
+            name = "${gitlabRepo}Packages"
+            credentials {
+                username = gitlabUser
+                password = gitlabKey
+            }
+            url = uri("$gitlabUrl")
+        }
+    }
+}
+
+mavenPublishing {
+    configure(
+        KotlinMultiplatform(
+            javadocJar = JavadocJar.Empty(),
+            sourcesJar = true,
+            androidVariantsToPublish = listOf("release")
+        )
+    )
+
+    repositories {
+        maven {
+            name = "${gitlabRepo}Packages"
+            credentials { username = gitlabUser; password = gitlabKey }
+            url = uri("$gitlabUrl")
+        }
+    }
+
+    coordinates(gitlabGroup.toString(), gitlabArtifactId, gitlabVersion.toString())
+
+    pom {
+        name = "$gitlabName Klib"
+        description = "$gitlabName"
+        url = "https://gitlab.mservice.com.vn"
+        licenses {
+            license {
+                name = "The Apache License, Version 2.0"
+                url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
+                distribution = "https://www.apache.org/licenses/LICENSE-2.0.txt"
+            }
+        }
+        developers {
+            developer {
+                id = "kotlin-hands-on"
+                name = "Kotlin Developer Advocate"
+                url = "https://github.com/kotlin-hands-on/"
+            }
+        }
+    }
+}

package/compose/compose.podspec

@@ -0,0 +1,47 @@
+Pod::Spec.new do |spec|
+    spec.name                     = 'compose'
+    spec.version                  = '0.161.2-beta.15'
+    spec.homepage                 = 'https://momo.vn'
+    spec.source                   = { :http=> ''}
+    spec.authors                  = ''
+    spec.license                  = ''
+    spec.summary                  = 'IOS Shared module'
+    spec.vendored_frameworks      = 'build/cocoapods/framework/kits.framework'
+    spec.libraries                = 'c++'
+    spec.ios.deployment_target    = '15.0'
+    spec.dependency 'lottie-ios', '4.4.3'
+    if !Dir.exist?('build/cocoapods/framework/kits.framework') || Dir.empty?('build/cocoapods/framework/kits.framework')
+        raise "
+        Kotlin framework 'kits' doesn't exist yet, so a proper Xcode project can't be generated.
+        'pod install' should be executed after running ':generateDummyFramework' Gradle task:
+            ./gradlew :compose:generateDummyFramework
+        Alternatively, proper pod installation is performed during Gradle sync in the IDE (if Podfile location is set)"
+    end
+    spec.xcconfig = {
+        'ENABLE_USER_SCRIPT_SANDBOXING' => 'NO',
+    }
+    spec.pod_target_xcconfig = {
+        'KOTLIN_PROJECT_PATH' => ':compose',
+        'PRODUCT_MODULE_NAME' => 'kits',
+    }
+    spec.script_phases = [
+        {
+            :name => 'Build compose',
+            :execution_position => :before_compile,
+            :shell_path => '/bin/sh',
+            :script => <<-SCRIPT
+                if [ "YES" = "$OVERRIDE_KOTLIN_BUILD_IDE_SUPPORTED" ]; then
+                    echo "Skipping Gradle build task invocation due to OVERRIDE_KOTLIN_BUILD_IDE_SUPPORTED environment variable set to \"YES\""
+                    exit 0
+                fi
+                set -ev
+                REPO_ROOT="$PODS_TARGET_SRCROOT"
+                "$REPO_ROOT/../gradlew" -p "$REPO_ROOT" $KOTLIN_PROJECT_PATH:syncFramework \
+                    -Pkotlin.native.cocoapods.platform=$PLATFORM_NAME \
+                    -Pkotlin.native.cocoapods.archs="$ARCHS" \
+                    -Pkotlin.native.cocoapods.configuration="$CONFIGURATION"
+            SCRIPT
+        }
+    ]
+    spec.resources = ['build/compose/cocoapods/compose-resources']
+end

package/compose/src/androidMain/kotlin/vn/momo/kits/fpsmonitor/FPSGraphView.kt

@@ -0,0 +1,250 @@
+package vn.momo.kits.fpsmonitor
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Rect
+import android.graphics.RectF
+import android.view.View
+import kotlin.math.max
+import kotlin.math.min
+
+class FPSGraphView(context: Context) : View(context) {
+    private val fpsValues = mutableListOf<Float>()
+    private val cpuTimeValues = mutableListOf<Float>()
+    private val gpuTimeValues = mutableListOf<Float>()
+    private val maxPoints = 100
+
+    private var currentMetrics: FPSMetrics? = null
+    private var collapsed = false
+    private val density = resources.displayMetrics.density
+    private val scaledDensity = resources.displayMetrics.density * resources.configuration.fontScale
+
+    private val fpsColor = Color.rgb(0, 255, 0)
+    private val cpuColor = Color.rgb(255, 165, 0)
+    private val gpuColor = Color.rgb(0, 191, 255)
+    private val memColor = Color.rgb(255, 105, 180)
+    private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = Color.argb(153, 0, 0, 0)
+    }
+    private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = Color.WHITE
+        textSize = 12.sp
+    }
+    private val linePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        strokeWidth = 1.25f.dp
+        style = Paint.Style.STROKE
+    }
+    private val gridPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = Color.argb(25, 255, 255, 255)
+        strokeWidth = 0.5f.dp
+        style = Paint.Style.STROKE
+    }
+
+    init {
+        setLayerType(LAYER_TYPE_SOFTWARE, null)
+    }
+
+    fun toggleCollapse() {
+        collapsed = !collapsed
+        requestLayout()
+        invalidate()
+    }
+
+    fun updateMetrics(metrics: FPSMetrics) {
+        currentMetrics = metrics
+        append(fpsValues, metrics.fps)
+        append(cpuTimeValues, metrics.estCPUTimePerFrameMs)
+        append(gpuTimeValues, metrics.estGPUTimePerFrameMs)
+        requestLayout()
+        invalidate()
+    }
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        if (collapsed) {
+            setMeasuredDimension(72.dp.toInt(), 44.dp.toInt())
+            return
+        }
+
+        textPaint.textSize = 12.sp
+        val metrics = currentMetrics
+        val deviceInfo = metrics?.deviceInfo
+        val lines = listOf(
+            "${deviceInfo?.deviceName ?: "Device"} [${deviceInfo?.resolution ?: "0x0"}]",
+            "${String.format("%.1f", deviceInfo?.density ?: 1f)}x ${deviceInfo?.refreshRate?.toInt() ?: 60}Hz",
+            "Pre: 99.99ms [99.99 99.99]",
+            "GPU: 99.99ms [99.99 99.99]",
+            "Mem: 999.9MB",
+            "FPS: 99.99 [99.99 99.99]",
+        )
+        val desiredWidth = max(220.dp, lines.maxOf { textPaint.measureText(it) } + 16.dp).toInt()
+        val desiredHeight = 156.dp.toInt()
+
+        setMeasuredDimension(
+            resolveSize(desiredWidth, widthMeasureSpec),
+            resolveSize(desiredHeight, heightMeasureSpec),
+        )
+    }
+
+    override fun onDraw(canvas: Canvas) {
+        super.onDraw(canvas)
+        canvas.drawRoundRect(RectF(0f, 0f, width.toFloat(), height.toFloat()), 8.dp, 8.dp, backgroundPaint)
+
+        if (collapsed) {
+            drawCollapsed(canvas)
+        } else {
+            drawExpanded(canvas)
+        }
+    }
+
+    private fun drawCollapsed(canvas: Canvas) {
+        val fpsText = String.format("%.0f", currentMetrics?.fps ?: 0f)
+        textPaint.color = Color.WHITE
+        textPaint.textSize = 18.sp
+        val bounds = Rect()
+        textPaint.getTextBounds(fpsText, 0, fpsText.length, bounds)
+        canvas.drawText(
+            fpsText,
+            (width - bounds.width()) / 2f,
+            (height + bounds.height()) / 2f,
+            textPaint,
+        )
+    }
+
+    private fun drawExpanded(canvas: Canvas) {
+        val metrics = currentMetrics
+        val margin = 8.dp
+        var y = margin + 12.sp
+
+        textPaint.textSize = 12.sp
+        textPaint.color = Color.WHITE
+
+        val deviceInfo = metrics?.deviceInfo
+        drawSplit(canvas, deviceInfo?.deviceName ?: "Device", "[${deviceInfo?.resolution ?: "0x0"}]", y, Color.WHITE)
+        y += 15.sp
+        drawSplit(
+            canvas,
+            "${String.format("%.1f", deviceInfo?.density ?: 1f)}x",
+            "${deviceInfo?.refreshRate?.toInt() ?: 60}Hz",
+            y,
+            Color.WHITE,
+        )
+        y += 18.sp
+
+        val cpuMinMax = minMax(cpuTimeValues, metrics?.estCPUTimePerFrameMs ?: 0f)
+        val gpuMinMax = minMax(gpuTimeValues, metrics?.estGPUTimePerFrameMs ?: 0f)
+        val fpsMinMax = minMax(fpsValues, metrics?.fps ?: 0f)
+
+        drawSplit(
+            canvas,
+            "Pre: ${String.format("%.2f", metrics?.estCPUTimePerFrameMs ?: 0f)}ms",
+            "[${String.format("%.2f", cpuMinMax.first)} ${String.format("%.2f", cpuMinMax.second)}]",
+            y,
+            cpuColor,
+        )
+        y += 15.sp
+
+        drawSplit(
+            canvas,
+            "GPU: ${String.format("%.2f", metrics?.estGPUTimePerFrameMs ?: 0f)}ms",
+            "[${String.format("%.2f", gpuMinMax.first)} ${String.format("%.2f", gpuMinMax.second)}]",
+            y,
+            gpuColor,
+        )
+        y += 15.sp
+
+        drawText(canvas, "Mem: ${String.format("%.1f", metrics?.appMemoryMB ?: 0f)}MB", margin, y, memColor)
+        y += 15.sp
+
+        drawSplit(
+            canvas,
+            "FPS: ${String.format("%.2f", metrics?.fps ?: 0f)}",
+            "[${String.format("%.2f", fpsMinMax.first)} ${String.format("%.2f", fpsMinMax.second)}]",
+            y,
+            fpsColor,
+        )
+        y += 17.sp
+
+        val graphHeight = height - y - margin
+        if (graphHeight > 24.dp) {
+            drawGraph(canvas, margin, y, width - margin * 2, graphHeight)
+        }
+    }
+
+    private fun drawSplit(canvas: Canvas, left: String, right: String, y: Float, color: Int) {
+        val margin = 8.dp
+        drawText(canvas, left, margin, y, color)
+        textPaint.color = color
+        canvas.drawText(right, width - margin - textPaint.measureText(right), y, textPaint)
+    }
+
+    private fun drawText(canvas: Canvas, text: String, x: Float, y: Float, color: Int) {
+        textPaint.color = color
+        canvas.drawText(text, x, y, textPaint)
+    }
+
+    private fun drawGraph(canvas: Canvas, x: Float, y: Float, graphWidth: Float, graphHeight: Float) {
+        canvas.drawRect(x, y, x + graphWidth, y + graphHeight, gridPaint)
+        for (index in 1..3) {
+            val gridY = y + index * (graphHeight / 4f)
+            canvas.drawLine(x + 2.dp, gridY, x + graphWidth - 2.dp, gridY, gridPaint)
+        }
+
+        var gridX = x + 16.dp
+        while (gridX < x + graphWidth) {
+            canvas.drawLine(gridX, y, gridX, y + graphHeight, gridPaint)
+            gridX += 16.dp
+        }
+
+        linePaint.color = fpsColor
+        drawDataLine(canvas, fpsValues, x, y, graphWidth, graphHeight, 60f)
+        linePaint.color = cpuColor
+        drawDataLine(canvas, cpuTimeValues, x, y, graphWidth, graphHeight, 50f)
+    }
+
+    private fun drawDataLine(
+        canvas: Canvas,
+        values: List<Float>,
+        x: Float,
+        y: Float,
+        graphWidth: Float,
+        graphHeight: Float,
+        maxScale: Float,
+    ) {
+        if (values.size < 2) return
+        val visibleValues = values.takeLast(max((graphWidth / 2.dp).toInt(), 2))
+        val step = (graphWidth - 4.dp) / (visibleValues.size - 1).coerceAtLeast(1)
+        var previousX = x + 2.dp
+        var previousY = y + graphHeight * (1f - visibleValues.first().coerceIn(0f, maxScale) / maxScale)
+
+        visibleValues.drop(1).forEachIndexed { index, value ->
+            val pointX = x + 2.dp + (index + 1) * step
+            val pointY = y + graphHeight * (1f - min(max(value / maxScale, 0f), 1f))
+            canvas.drawLine(previousX, previousY, pointX, pointY, linePaint)
+            previousX = pointX
+            previousY = pointY
+        }
+    }
+
+    private fun append(values: MutableList<Float>, value: Float) {
+        if (values.size >= maxPoints) values.removeAt(0)
+        values.add(value)
+    }
+
+    private fun minMax(values: List<Float>, fallback: Float): Pair<Float, Float> {
+        return Pair(values.minOrNull() ?: fallback, values.maxOrNull() ?: fallback)
+    }
+
+    private val Int.dp: Float
+        get() = toFloat().dp
+
+    private val Float.dp: Float
+        get() = this * density
+
+    private val Int.sp: Float
+        get() = toFloat().sp
+
+    private val Float.sp: Float
+        get() = this * scaledDensity
+}