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

package/compose/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.161.0-debug"
+        version = "0.162.1-gif.1-debug"
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"
@@ -74,6 +74,10 @@ kotlin {
             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)

package/compose/build.gradle.kts.backup

@@ -1,5 +1,5 @@
-// import com.vanniktech.maven.publish.JavadocJar
-// import com.vanniktech.maven.publish.KotlinMultiplatform
+import com.vanniktech.maven.publish.JavadocJar
+import com.vanniktech.maven.publish.KotlinMultiplatform
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
@@ -7,7 +7,7 @@ plugins {
     alias(libs.plugins.android.library)
     alias(libs.plugins.compose)
     alias(libs.plugins.kotlin.compose.compiler)
-//         alias(libs.plugins.vanniktech.mavenPublish)
+    alias(libs.plugins.vanniktech.mavenPublish)
     id(libs.plugins.jetbrains.kotlin.cocoapods.get().pluginId)
     kotlin("plugin.serialization")
 }
@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.161.0-debug"
+        version = gitlabVersion
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"
@@ -74,6 +74,10 @@ kotlin {
             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)
@@ -86,14 +90,14 @@ kotlin {
 }
 
 android {
-    namespace = "vn.momo.kits.kits"
-    compileSdk = 35
+    namespace = "$gitlabGroup.$gitlabArtifactId"
+    compileSdk = libs.versions.android.compileSdk.get().toInt()
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
     }
     defaultConfig {
-        minSdk = 24
+        minSdk = libs.versions.android.minSdk.get().toInt()
     }
 }
 
@@ -132,55 +136,55 @@ compose {
     }
 }
 
-// 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/"
-//             }
-//         }
-//     }
-// }
+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/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
+}

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

@@ -0,0 +1,249 @@
+package vn.momo.kits.fpsmonitor
+
+import android.app.Activity
+import android.content.Context
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.DisplayMetrics
+import android.view.Choreographer
+import android.view.ViewGroup
+import java.io.BufferedReader
+import java.io.FileReader
+
+data class FPSMetrics(
+    val fps: Float,
+    val avgFrameTimeMs: Float,
+    val estCPUTimePerFrameMs: Float,
+    val estGPUTimePerFrameMs: Float,
+    val appMemoryMB: Float,
+    val cpuUsagePercent: Float,
+    val deviceInfo: FPSDeviceInfo,
+)
+
+data class FPSDeviceInfo(
+    val deviceName: String,
+    val resolution: String,
+    val density: Float,
+    val refreshRate: Float,
+)
+
+object FPSMonitor {
+    var updateIntervalMs: Long = 200L
+    var fpsThreshold: Float = 30f
+    var ramThresholdMB: Float = 500f
+    var onFPSLow: ((Float) -> Unit)? = null
+    var onRamOverload: ((Float) -> Unit)? = null
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var appContext: Context? = null
+    private var choreographer: Choreographer? = null
+    private var frameCallback: Choreographer.FrameCallback? = null
+    private var overlayView: FPSOverlayView? = null
+    private var overlayParent: ViewGroup? = null
+    private var initialized = false
+    private var running = false
+    private var visible = false
+    private var lastTimestampMs = 0L
+    private var frameCount = 0
+    private var lastFPSAlertMs = 0L
+    private var cachedDeviceInfo: FPSDeviceInfo? = null
+    private var latestMetrics: FPSMetrics? = null
+
+    @JvmStatic
+    fun init(context: Context) {
+        if (initialized) return
+        appContext = context.applicationContext
+        ramThresholdMB = if (isEmulator()) 1500f else 500f
+        cachedDeviceInfo = readDeviceInfo(context)
+        initialized = true
+    }
+
+    @JvmStatic
+    fun startOverlay(activity: Activity) {
+        init(activity)
+        start()
+        showUI(activity)
+    }
+
+    @JvmStatic
+    fun start() {
+        ensureInit()
+        if (running) return
+        running = true
+        runOnMain { startChoreographer() }
+    }
+
+    @JvmStatic
+    fun stop() {
+        runOnMain {
+            hideUI()
+            frameCallback?.let { choreographer?.removeFrameCallback(it) }
+            frameCallback = null
+            choreographer = null
+            lastTimestampMs = 0L
+            frameCount = 0
+            latestMetrics = null
+            lastFPSAlertMs = 0L
+            running = false
+        }
+    }
+
+    @JvmStatic
+    fun showUI(activity: Activity) {
+        init(activity)
+        runOnMain {
+            val parent = activity.findViewById<ViewGroup>(android.R.id.content) ?: return@runOnMain
+            val view = overlayView ?: FPSOverlayView(activity).also { overlayView = it }
+
+            if (view.parent !== parent) {
+                (view.parent as? ViewGroup)?.removeView(view)
+                parent.addView(view, FPSOverlayView.defaultLayoutParams())
+            }
+
+            overlayParent = parent
+            view.visibility = android.view.View.VISIBLE
+            latestMetrics?.let { view.updateMetrics(it) }
+            visible = true
+        }
+    }
+
+    @JvmStatic
+    fun hideUI() {
+        runOnMain {
+            overlayView?.let { view ->
+                (view.parent as? ViewGroup)?.removeView(view)
+                view.visibility = android.view.View.GONE
+            }
+            overlayParent = null
+            visible = false
+        }
+    }
+
+    @JvmStatic
+    fun metricsSnapshot(): FPSMetrics? = latestMetrics
+
+    @JvmStatic
+    fun isRunning(): Boolean = running
+
+    private fun startChoreographer() {
+        choreographer = Choreographer.getInstance()
+        frameCallback = object : Choreographer.FrameCallback {
+            override fun doFrame(frameTimeNanos: Long) {
+                val now = System.currentTimeMillis()
+                if (lastTimestampMs == 0L) {
+                    lastTimestampMs = now
+                    choreographer?.postFrameCallback(this)
+                    return
+                }
+
+                frameCount++
+                val delta = now - lastTimestampMs
+                if (delta >= updateIntervalMs) {
+                    publishMetrics(now, delta)
+                    lastTimestampMs = now
+                    frameCount = 0
+                }
+
+                choreographer?.postFrameCallback(this)
+            }
+        }
+        choreographer?.postFrameCallback(frameCallback!!)
+    }
+
+    private fun publishMetrics(now: Long, delta: Long) {
+        val fps = frameCount * 1000f / delta.coerceAtLeast(1)
+        val frameTimeMs = delta.toFloat() / frameCount.coerceAtLeast(1)
+        val fpsVariation = (60f - fps.coerceAtMost(60f)) / 60f
+        val gpuRatio = 0.4f + fpsVariation * 0.3f
+        val cpuPercent = getCPUUsagePercent()
+        val memoryMB = getAppMemoryUsageMB()
+
+        val metrics = FPSMetrics(
+            fps = fps,
+            avgFrameTimeMs = frameTimeMs,
+            estCPUTimePerFrameMs = frameTimeMs * cpuPercent.coerceIn(0f, 100f) / 100f,
+            estGPUTimePerFrameMs = frameTimeMs * gpuRatio,
+            appMemoryMB = memoryMB,
+            cpuUsagePercent = cpuPercent,
+            deviceInfo = cachedDeviceInfo ?: readDeviceInfo(appContext ?: return),
+        )
+        latestMetrics = metrics
+
+        if (visible) overlayView?.updateMetrics(metrics)
+
+        if (memoryMB > ramThresholdMB) {
+            ramThresholdMB += 100f
+            onRamOverload?.invoke(memoryMB)
+        }
+        if (fps < fpsThreshold && now - lastFPSAlertMs >= 1000L) {
+            onFPSLow?.invoke(fps)
+            lastFPSAlertMs = now
+        }
+    }
+
+    private fun getAppMemoryUsageMB(): Float {
+        val runtime = Runtime.getRuntime()
+        val used = runtime.totalMemory() - runtime.freeMemory()
+        return used / (1024f * 1024f)
+    }
+
+    private fun getCPUUsagePercent(): Float {
+        return try {
+            BufferedReader(FileReader("/proc/stat")).use { reader ->
+                val parts = reader.readLine()
+                    ?.split(Regex("\\s+"))
+                    ?.filter { it.isNotBlank() }
+                    ?: return 0f
+                val idle = parts.getOrNull(4)?.toLongOrNull() ?: return 0f
+                val total = parts.drop(1).take(7).sumOf { it.toLongOrNull() ?: 0L }
+                if (total <= 0) 0f else ((total - idle) * 100f) / total
+            }
+        } catch (_: Exception) {
+            0f
+        }
+    }
+
+    private fun readDeviceInfo(context: Context): FPSDeviceInfo {
+        val displayMetrics = context.resources.displayMetrics
+        val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as? android.view.WindowManager
+        val metrics = DisplayMetrics()
+        @Suppress("DEPRECATION")
+        windowManager?.defaultDisplay?.getMetrics(metrics)
+
+        val width = if (metrics.widthPixels > 0) metrics.widthPixels else displayMetrics.widthPixels
+        val height = if (metrics.heightPixels > 0) metrics.heightPixels else displayMetrics.heightPixels
+        @Suppress("DEPRECATION")
+        val refreshRate = windowManager?.defaultDisplay?.refreshRate ?: 60f
+
+        return FPSDeviceInfo(
+            deviceName = "${Build.MANUFACTURER} ${Build.MODEL}",
+            resolution = "${width}x${height}",
+            density = displayMetrics.density,
+            refreshRate = refreshRate,
+        )
+    }
+
+    private fun isEmulator(): Boolean {
+        return Build.FINGERPRINT.startsWith("generic") ||
+            Build.FINGERPRINT.startsWith("unknown") ||
+            Build.MODEL.contains("google_sdk", ignoreCase = true) ||
+            Build.MODEL.contains("Emulator", ignoreCase = true) ||
+            Build.MODEL.contains("Android SDK built for x86", ignoreCase = true) ||
+            Build.MANUFACTURER.contains("Genymotion", ignoreCase = true) ||
+            (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic")) ||
+            Build.PRODUCT == "google_sdk"
+    }
+
+    private fun ensureInit() {
+        check(initialized) { "FPSMonitor.init(context) must be called before use." }
+    }
+
+    private fun runOnMain(block: () -> Unit) {
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            block()
+        } else {
+            mainHandler.post(block)
+        }
+    }
+}