@momo-kits/native-kits 0.162.1-gif.11-debug → 0.162.1-gif.13-debug

package/build.gradle.kts

@@ -9,3 +9,13 @@ plugins {
     alias(libs.plugins.jetbrains.kotlin.serialization) apply false
     alias(libs.plugins.vanniktech.mavenPublish) apply false
 }
+
+subprojects {
+    configurations.configureEach {
+        resolutionStrategy.dependencySubstitution {
+            substitute(module("io.github.panpf.sketch4:sketch-compose-core"))
+                .using(project(":sketch-compose-core"))
+                .because("Patch duplicate Kotlin/Native symbols in sketch-compose-core 4.4.0")
+        }
+    }
+}

package/compose/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.162.1-gif.11-debug"
+        version = "0.162.1-gif.13-debug"
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"
@@ -77,7 +77,8 @@ kotlin {
             implementation(libs.kotlinx.datetime)
             api(libs.native.max.api)
             implementation(libs.compottie)
-            implementation(libs.sketch.core)
+            implementation(libs.sketch.compose)
+            implementation(project(":sketch-compose-core"))
             implementation(libs.sketch.http.core)
             implementation(libs.sketch.animated.gif)
         }

package/compose/build.gradle.kts.backup

@@ -77,7 +77,8 @@ kotlin {
             implementation(libs.kotlinx.datetime)
             api(libs.native.max.api)
             implementation(libs.compottie)
-            implementation(libs.sketch.core)
+            implementation(libs.sketch.compose)
+            implementation(project(":sketch-compose-core"))
             implementation(libs.sketch.http.core)
             implementation(libs.sketch.animated.gif)
         }

package/compose/compose.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |spec|
     spec.name                     = 'compose'
-    spec.version                  = '0.162.1-gif.10'
+    spec.version                  = '0.162.1-gif.12'
     spec.homepage                 = 'https://momo.vn'
     spec.source                   = { :http=> ''}
     spec.authors                  = ''

package/compose/src/commonMain/kotlin/vn/momo/kits/components/Image.kt

@@ -17,11 +17,18 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.unit.dp
+import com.github.panpf.sketch.AsyncImage as SketchAsyncImage
+import com.github.panpf.sketch.LocalPlatformContext
+import com.github.panpf.sketch.PainterState
+import com.github.panpf.sketch.fetch.HttpUriFetcher
+import com.github.panpf.sketch.request.ImageRequest as SketchImageRequest
+import com.github.panpf.sketch.rememberAsyncImageState
 import coil3.compose.AsyncImage as CoilAsyncImage
 import vn.momo.kits.application.IsShowBaseLineDebug
 import vn.momo.kits.const.AppTheme
 import vn.momo.kits.const.Colors
 import vn.momo.kits.modifier.conditional
+import vn.momo.kits.utils.KitsSketchHttpStack
 
 data class Options(
     val alignment: Alignment = Alignment.TopStart,
@@ -116,6 +123,7 @@ fun Image(
             }
             .semantics { contentDescription = "img|$source" },
     ) {
+        val platformContext = LocalPlatformContext.current
         val urlToLoad = remember(source, maxWidth, maxHeight, density) {
             when (source) {
                 is String -> {
@@ -132,20 +140,34 @@ fun Image(
         }
 
         if (isGifUrl(urlToLoad)) {
-            val imageState = remember(urlToLoad) { mutableStateOf(ImageState.Loading) }
+            val asyncImageState = rememberAsyncImageState()
+            val request = remember(platformContext, urlToLoad) {
+                SketchImageRequest(platformContext, urlToLoad) {
+                    components {
+                        add(HttpUriFetcher.Factory(KitsSketchHttpStack))
+                    }
+                }
+            }
 
-            SketchGifImage(
+            SketchAsyncImage(
                 modifier = Modifier.matchParentSize(),
-                url = urlToLoad,
+                request = request,
+                state = asyncImageState,
+                contentDescription = null,
                 contentScale = imageOptions.contentScale,
                 alignment = imageOptions.alignment,
                 colorFilter = imageOptions.colorFilter,
                 alpha = imageOptions.alpha,
-                onStateChanged = { imageState.value = it },
             )
 
+            val imageState = when (asyncImageState.painterState) {
+                is PainterState.Success -> ImageState.Success
+                is PainterState.Error -> ImageState.Error
+                else -> ImageState.Loading
+            }
+
             ImageStateContent(
-                imageState = imageState.value,
+                imageState = imageState,
                 loading = loading,
                 onLoadingChanged = currentOnLoadingChanged.value
             )

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/{GifImageHttpClient.kt → KitsSketchHttpStack.kt}

@@ -14,25 +14,9 @@ import io.ktor.utils.io.ByteReadChannel
 import io.ktor.utils.io.cancel
 import io.ktor.utils.io.readAvailable
 
-object GifImageHttpClient {
-    private val defaultClient by lazy { HttpClient() }
-    private var customClient: HttpClient? = null
+internal object KitsSketchHttpStack : HttpStack {
+    private val client by lazy { HttpClient() }
 
-    internal val client: HttpClient
-        get() = customClient ?: defaultClient
-
-    fun set(client: HttpClient) {
-        customClient = client
-    }
-
-    fun clear() {
-        customClient = null
-    }
-}
-
-internal class KitsKtorHttpStack(
-    private val client: HttpClient,
-) : HttpStack {
     override suspend fun <T> request(
         url: String,
         httpHeaders: HttpHeaders?,
@@ -65,7 +49,7 @@ internal class KitsKtorHttpStack(
         return request(url, httpHeaders, extras) { it }
     }
 
-    override fun toString(): String = "KitsKtorHttpStack"
+    override fun toString(): String = "KitsSketchHttpStack"
 
     private class Response(
         private val response: HttpResponse,

package/gradle/libs.versions.toml

@@ -54,6 +54,7 @@ androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "a
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidx-activity" }
 material = { module = "com.google.android.material:material", version.ref = "material" }
 
+sketch-compose = { module = "io.github.panpf.sketch4:sketch-compose", version.ref = "sketch" }
 sketch-core = { module = "io.github.panpf.sketch4:sketch-core", version.ref = "sketch" }
 sketch-http-core = { module = "io.github.panpf.sketch4:sketch-http-core", version.ref = "sketch" }
 sketch-animated-gif = { module = "io.github.panpf.sketch4:sketch-animated-gif", version.ref = "sketch" }

package/gradle.properties

@@ -18,7 +18,7 @@ kotlin.apple.xcodeCompatibility.nowarn=true
 name="ComposeKits"
 group=vn.momo.kits
 artifact.id=kits
-version=0.162.1-gif.11
+version=0.162.1-gif.13
 
 repo=GitLab
 url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.162.1-gif.11-debug",
+  "version": "0.162.1-gif.13-debug",
   "private": false,
   "dependencies": {},
   "devDependencies": {},

package/publish.sh

@@ -241,6 +241,10 @@ phase_publish_maven() {
     VERSION=$(node -p "require('./package.json').version")
     export VERSION="$VERSION"
 
+    echo "📦 Publishing patched sketch-compose-core to Maven..."
+    ./gradlew :sketch-compose-core:publishAllPublicationsToGitLabPackagesRepository
+    echo "✅ patched sketch-compose-core Maven publishing completed successfully!"
+
     echo "📦 Publishing KMP artifacts to Maven (version ${VERSION})..."
 
     ./gradlew :compose:publishAllPublicationsToGitLabPackagesRepository

package/settings.gradle.kts

@@ -59,6 +59,8 @@ dependencyResolutionManagement {
 }
 
 include(":compose")
+include(":sketch-compose-core")
+project(":sketch-compose-core").projectDir = file("third_party/sketch-compose-core-patched")
 
 include(":sample:androidApp")
 include(":sample:shared")

package/third_party/sketch-compose-core-patched/META-INF/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+

package/third_party/sketch-compose-core-patched/androidMain/com/github/panpf/sketch/LocalPlatformContext.android.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2024 panpf <panpfpanpf@outlook.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.panpf.sketch
+
+import androidx.compose.runtime.ProvidableCompositionLocal
+import androidx.compose.ui.platform.LocalContext
+
+/**
+ * Platform context, used to provide platform-specific context information
+ *
+ * @see com.github.panpf.sketch.compose.core.android.test.LocalPlatformContextAndroidTest.testLocalPlatformContext
+ */
+actual val LocalPlatformContext: ProvidableCompositionLocal<PlatformContext> = LocalContext

package/third_party/sketch-compose-core-patched/androidMain/com/github/panpf/sketch/PainterImage.android.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2024 panpf <panpfpanpf@outlook.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.panpf.sketch
+
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.painter.Painter
+import com.github.panpf.sketch.painter.AnimatedImagePainter
+import com.github.panpf.sketch.painter.asPainter
+
+/**
+ * Convert the Image to a Painter
+ *
+ * @see com.github.panpf.sketch.compose.core.android.test.PainterImageAndroidTest.testImageAsPainterOrNull
+ */
+actual fun Image.asPainterOrNull(filterQuality: FilterQuality): Painter? = when (this) {
+    is PainterImage -> painter
+    is BitmapImage -> bitmap.asImageBitmap().asPainter(filterQuality)
+    is AnimatedImage -> AnimatedImagePainter(this)
+    is DrawableImage -> drawable.asPainter()
+    else -> null
+}

package/third_party/sketch-compose-core-patched/androidMain/com/github/panpf/sketch/painter/DrawableAnimatablePainter.kt

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2024 panpf <panpfpanpf@outlook.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.panpf.sketch.painter
+
+import android.graphics.drawable.Animatable
+import android.graphics.drawable.Drawable
+import androidx.compose.runtime.Stable
+import com.github.panpf.sketch.util.toLogString
+
+/**
+ * Drawable painter that implements the [AnimatablePainter] interface
+ *
+ * @see com.github.panpf.sketch.compose.core.android.test.painter.DrawableAnimatablePainterTest
+ */
+@Stable
+class DrawableAnimatablePainter(
+    drawable: Drawable
+) : DrawablePainter(drawable), AnimatablePainter {
+
+    private val animatable: Animatable
+
+    init {
+        require(drawable is Animatable) {
+            "drawable must be Animatable"
+        }
+        animatable = drawable
+    }
+
+    override fun onFirstRemembered() {
+        super.onFirstRemembered()
+        animatable.start()
+    }
+
+    override fun onLastRemembered() {
+        super.onLastRemembered()
+        animatable.stop()
+    }
+
+    override fun start() {
+        if (rememberedCounter.isRemembered) {
+            animatable.start()
+        }
+    }
+
+    override fun stop() {
+        if (rememberedCounter.isRemembered) {
+            animatable.stop()
+        }
+    }
+
+    override fun isRunning(): Boolean {
+        return animatable.isRunning
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+        other as DrawableAnimatablePainter
+        return drawable == other.drawable
+    }
+
+    override fun hashCode(): Int {
+        return drawable.hashCode()
+    }
+
+    override fun toString(): String {
+        return "DrawableAnimatablePainter(drawable=${drawable.toLogString()})"
+    }
+}

package/third_party/sketch-compose-core-patched/androidMain/com/github/panpf/sketch/painter/DrawablePainter.kt

@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2024 panpf <panpfpanpf@outlook.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.panpf.sketch.painter
+
+import android.graphics.drawable.Animatable
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.ColorDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.Drawable.Callback
+import android.os.Build.VERSION
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.RememberObserver
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.asAndroidColorFilter
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.drawIntoCanvas
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.compose.ui.graphics.painter.BitmapPainter
+import androidx.compose.ui.graphics.painter.ColorPainter
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.graphics.withSave
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.LayoutDirection.Ltr
+import androidx.compose.ui.unit.LayoutDirection.Rtl
+import com.github.panpf.sketch.drawable.EquitableDrawable
+import com.github.panpf.sketch.util.RememberedCounter
+import com.github.panpf.sketch.util.toLogString
+import kotlin.math.ceil
+import kotlin.math.roundToInt
+
+/**
+ * Remembers [Drawable] wrapped up as a [Painter]. This function attempts to un-wrap the
+ * drawable contents and use Compose primitives where possible.
+ *
+ * If the provided [drawable] is `null`, an empty no-op painter is returned.
+ *
+ * This function tries to dispatch lifecycle events to [drawable] as much as possible from
+ * within Compose.
+ *
+ * @see com.github.panpf.sketch.compose.core.android.test.painter.DrawablePainterTest.testRememberDrawablePainter
+ */
+@Composable
+fun rememberDrawablePainter(drawable: EquitableDrawable): Painter =
+    remember(drawable) { drawable.asPainter() }
+
+/**
+ * Converts a [Drawable] to a [Painter]. This function attempts to un-wrap the drawable contents
+ *
+ * @see com.github.panpf.sketch.compose.core.android.test.painter.DrawablePainterTest.testAsPainter
+ */
+fun Drawable?.asPainter(): Painter {
+    return when (this) {
+        null -> EmptyPainter
+        is Animatable -> DrawableAnimatablePainter(this.mutate())
+        is BitmapDrawable -> BitmapPainter(this.bitmap.asImageBitmap())
+        is ColorDrawable -> ColorPainter(Color(this.color))
+        // Since the DrawablePainter will be remembered and it implements RememberObserver, it
+        //  will receive the necessary events
+        else -> DrawablePainter(this.mutate())
+    }
+}
+
+/**
+ * A [Painter] which draws an Android [Drawable] and supports [Animatable] drawables. Instances
+ * should be remembered to be able to start and stop [Animatable] animations.
+ *
+ * Instances are usually retrieved from [rememberDrawablePainter].
+ *
+ * @see com.github.panpf.sketch.compose.core.android.test.painter.DrawablePainterTest
+ */
+@Stable
+// TODO Synchronize from accompanyist-drawablepainter
+open class DrawablePainter(
+    val drawable: Drawable
+) : Painter(), RememberObserver, SketchPainter {
+    private var drawInvalidateTick by mutableIntStateOf(0)
+    private var drawableIntrinsicSize by mutableStateOf(drawable.intrinsicSize)
+
+    private val callback: Callback by lazy {
+        object : Callback {
+            override fun invalidateDrawable(d: Drawable) {
+                // Update the tick so that we get re-drawn
+                drawInvalidateTick++
+                // Update our intrinsic size too
+                drawableIntrinsicSize = drawable.intrinsicSize
+            }
+
+            override fun scheduleDrawable(d: Drawable, what: Runnable, time: Long) {
+                MAIN_HANDLER.postAtTime(what, time)
+            }
+
+            override fun unscheduleDrawable(d: Drawable, what: Runnable) {
+                MAIN_HANDLER.removeCallbacks(what)
+            }
+        }
+    }
+
+    internal val rememberedCounter: RememberedCounter = RememberedCounter()
+
+    override val intrinsicSize: Size get() = drawableIntrinsicSize
+
+    init {
+        if (drawable.intrinsicWidth >= 0 && drawable.intrinsicHeight >= 0) {
+            // Update the drawable's bounds to match the intrinsic size
+            drawable.setBounds(0, 0, drawable.intrinsicWidth, drawable.intrinsicHeight)
+        }
+    }
+
+    override fun onRemembered() {
+        if (!rememberedCounter.remember()) return
+        onFirstRemembered()
+    }
+
+    protected open fun onFirstRemembered() {
+        drawable.callback = callback
+        drawable.setVisible(true, true)
+    }
+
+    override fun onAbandoned() = onForgotten()
+    override fun onForgotten() {
+        if (!rememberedCounter.forget()) return
+        onLastRemembered()
+    }
+
+    protected open fun onLastRemembered() {
+        drawable.setVisible(false, false)
+        drawable.callback = null
+    }
+
+    override fun applyAlpha(alpha: Float): Boolean {
+        drawable.alpha = (alpha * 255).roundToInt().coerceIn(0, 255)
+        return true
+    }
+
+    override fun applyColorFilter(colorFilter: ColorFilter?): Boolean {
+        drawable.colorFilter = colorFilter?.asAndroidColorFilter()
+        return true
+    }
+
+    override fun applyLayoutDirection(layoutDirection: LayoutDirection): Boolean {
+        if (VERSION.SDK_INT >= 23) {
+            return drawable.setLayoutDirection(
+                when (layoutDirection) {
+                    Ltr -> View.LAYOUT_DIRECTION_LTR
+                    Rtl -> View.LAYOUT_DIRECTION_RTL
+                }
+            )
+        }
+        return false
+    }
+
+    override fun DrawScope.onDraw() {
+        drawIntoCanvas { canvas ->
+            // Reading this ensures that we invalidate when invalidateDrawable() is called
+            drawInvalidateTick
+
+            // Update the Drawable's bounds
+            drawable.setBounds(0, 0, ceil(size.width).toInt(), ceil(size.height).toInt())
+
+            canvas.withSave {
+                drawable.draw(canvas.nativeCanvas)
+            }
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+        other as DrawablePainter
+        return drawable == other.drawable
+    }
+
+    override fun hashCode(): Int {
+        return drawable.hashCode()
+    }
+
+    override fun toString(): String {
+        return "DrawablePainter(drawable=${drawable.toLogString()})"
+    }
+}
+
+/**
+ * @see com.github.panpf.sketch.compose.core.android.test.painter.DrawablePainterTest.testMainHandler
+ */
+internal val MAIN_HANDLER by lazy(LazyThreadSafetyMode.NONE) {
+    Handler(Looper.getMainLooper())
+}
+
+/**
+ * Get the intrinsic size of Drawable, if Drawable has no intrinsic size, return [Size.Unspecified]
+ *
+ * @see com.github.panpf.sketch.compose.core.android.test.painter.DrawablePainterTest.testDrawableIntrinsicSize
+ */
+internal val Drawable.intrinsicSize: Size
+    get() = when {
+        // Only return a finite size if the drawable has an intrinsic size
+        intrinsicWidth >= 0 && intrinsicHeight >= 0 -> {
+            Size(width = intrinsicWidth.toFloat(), height = intrinsicHeight.toFloat())
+        }
+
+        else -> Size.Unspecified
+    }
+
+/**
+ * Empty Painter
+ *
+ * @see com.github.panpf.sketch.compose.core.android.test.painter.DrawablePainterTest.testEmptyPainter
+ */
+internal object EmptyPainter : Painter() {
+    override val intrinsicSize: Size get() = Size.Unspecified
+    override fun DrawScope.onDraw() {}
+}