@amazon-devices/lottie-react-native 2.0.1758683737

package/android/build.gradle

@@ -0,0 +1,120 @@
+buildscript {
+    def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['lottiereactnative_kotlinVersion']
+
+    repositories {
+        google()
+        gradlePluginPortal()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath("com.android.tools.build:gradle:7.2.2")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
+    }
+}
+
+def getExtOrDefault(name, defaultValue) {
+    rootProject.ext.has(name) ? rootProject.ext.get(name) : defaultValue
+}
+
+def isNewArchitectureEnabled() {
+    // To opt-in for the New Architecture, you can either:
+    // - Set `newArchEnabled` to true inside the `gradle.properties` file
+    // - Invoke gradle with `-newArchEnabled=true`
+    // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+
+android {
+    compileSdk getExtOrDefault('compileSdkVersion', 31)
+
+    // Used to override the NDK path/version on internal CI or by allowing
+    // users to customize the NDK path/version from their root project (e.g. for M1 support)
+    if (rootProject.hasProperty("ndkPath")) {
+        ndkPath rootProject.ext.ndkPath
+    }
+    if (rootProject.hasProperty("ndkVersion")) {
+        ndkVersion rootProject.ext.ndkVersion
+    }
+
+    defaultConfig {
+        minSdkVersion getExtOrDefault('minSdkVersion', 21)
+        targetSdkVersion getExtOrDefault('targetSdkVersion', 31)
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+        ndk {
+            abiFilters(*reactNativeArchitectures())
+        }
+    }
+
+    packagingOptions {
+        exclude "**/libreact_render*.so"
+    }
+
+    packagingOptions {
+        excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfabricjni.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libreact_codegen_rncore.so",
+            "**/libreact_debug.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libreact_render_componentregistry.so",
+            "**/libreact_render_core.so",
+            "**/libreact_render_debug.so",
+            "**/libreact_render_graphics.so",
+            "**/librrc_view.so",
+            "**/libruntimeexecutor.so",
+            "**/libturbomodulejsijni.so",
+            "**/libyoga.so",
+        ]
+    }
+
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ['src/newarch', "${project.buildDir}/generated/source/codegen/java"]
+            } else {
+                java.srcDirs += ['src/oldarch']
+            }
+        }
+    }
+}
+
+def reactNativeArchitectures() {
+    def value = project.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+repositories {
+    google()
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url "$projectDir/../node_modules/react-native/android"
+    }
+    mavenCentral()
+}
+
+def kotlin_version = getExtOrDefault('kotlinVersion', project.properties['lottiereactnative_kotlinVersion'])
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    //noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-native:+' // From node_modules
+
+    implementation "com.airbnb.android:lottie:5.2.0"
+}

package/android/gradle.properties

@@ -0,0 +1,27 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx512m -XX:MaxMetaspaceSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app's APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Automatically convert third-party libraries to use AndroidX
+android.enableJetifier=true
+
+lottiereactnative_kotlinVersion=1.7.10

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.airbnb.android.react.lottie"
+          xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>

package/android/src/main/java/com/airbnb/android/react/lottie/LottieAnimationViewManagerImpl.kt

@@ -0,0 +1,260 @@
+package com.airbnb.android.react.lottie
+
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.view.View.OnAttachStateChangeListener
+import android.widget.ImageView
+import androidx.core.view.ViewCompat
+import com.airbnb.lottie.LottieAnimationView
+import com.airbnb.lottie.RenderMode
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.net.URL
+import kotlin.concurrent.thread
+
+internal object LottieAnimationViewManagerImpl {
+    const val REACT_CLASS = "LottieAnimationView"
+
+    @JvmStatic
+    val exportedViewConstants: Map<String, Any>
+        get() = MapBuilder.builder<String, Any>()
+            .put("VERSION", 1)
+            .build()
+
+    @JvmStatic
+    fun createViewInstance(context: ThemedReactContext): LottieAnimationView {
+        return LottieAnimationView(context).apply {
+            scaleType = ImageView.ScaleType.CENTER_INSIDE
+        }
+    }
+
+    @JvmStatic
+    fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
+        return MapBuilder.of(
+            "animationFinish",
+            MapBuilder.of("phasedRegistrationNames", MapBuilder.of("bubbled", "onAnimationFinish"))
+        )
+    }
+
+    @JvmStatic
+    fun play(view: LottieAnimationView, startFrame: Int, endFrame: Int) {
+        Handler(Looper.getMainLooper()).post {
+            if (startFrame != -1 && endFrame != -1) {
+                if (startFrame > endFrame) {
+                    view.setMinAndMaxFrame(endFrame, startFrame)
+                    if (view.speed > 0) {
+                        view.reverseAnimationSpeed()
+                    }
+                } else {
+                    view.setMinAndMaxFrame(startFrame, endFrame)
+                    if (view.speed < 0) {
+                        view.reverseAnimationSpeed()
+                    }
+                }
+            }
+            if (ViewCompat.isAttachedToWindow(view)) {
+                view.progress = 0f
+                view.playAnimation()
+            } else {
+                view.addOnAttachStateChangeListener(object : OnAttachStateChangeListener {
+                    override fun onViewAttachedToWindow(v: View) {
+                        val listenerView = v as LottieAnimationView
+                        listenerView.progress = 0f
+                        listenerView.playAnimation()
+                        listenerView.removeOnAttachStateChangeListener(this)
+                    }
+
+                    override fun onViewDetachedFromWindow(v: View) {
+                        val listenerView = v as LottieAnimationView
+                        listenerView.removeOnAttachStateChangeListener(this)
+                    }
+                })
+            }
+        }
+    }
+
+    @JvmStatic
+    fun reset(view: LottieAnimationView) {
+        Handler(Looper.getMainLooper()).post {
+            if (ViewCompat.isAttachedToWindow(view)) {
+                view.cancelAnimation()
+                view.progress = 0f
+            }
+        }
+    }
+
+    @JvmStatic
+    fun pause(view: LottieAnimationView) {
+        Handler(Looper.getMainLooper()).post {
+            if (ViewCompat.isAttachedToWindow(view)) {
+                view.pauseAnimation()
+            }
+        }
+    }
+
+    @JvmStatic
+    fun resume(view: LottieAnimationView) {
+        Handler(Looper.getMainLooper()).post {
+            if (ViewCompat.isAttachedToWindow(view)) {
+                view.resumeAnimation()
+            }
+        }
+    }
+
+    @JvmStatic
+    fun setSourceName(
+        name: String?,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        // To match the behaviour on iOS we expect the source name to be
+        // extensionless. This means "myAnimation" corresponds to a file
+        // named `myAnimation.json` in `main/assets`. To maintain backwards
+        // compatibility we only add the .json extension if no extension is
+        // passed.
+        var resultSourceName = name
+        if (resultSourceName?.contains(".") == false) {
+            resultSourceName = "$resultSourceName.json"
+        }
+        viewManager.animationName = resultSourceName
+    }
+
+    @JvmStatic
+    fun setSourceJson(
+        json: String?,
+        propManagersMap: LottieAnimationViewPropertyManager
+    ) {
+        propManagersMap.animationJson = json
+    }
+
+    @JvmStatic
+    fun setSourceURL(
+        urlString: String?,
+        propManagersMap: LottieAnimationViewPropertyManager
+    ) {
+        thread {
+            BufferedReader(InputStreamReader(URL(urlString).openStream())).useLines {
+                Handler(Looper.getMainLooper()).post {
+                    propManagersMap.animationJson = it.toString()
+                    propManagersMap.commitChanges()
+                }
+            }
+        }
+    }
+
+    @JvmStatic
+    fun setCacheComposition(view: LottieAnimationView, cacheComposition: Boolean) {
+        view.setCacheComposition(cacheComposition)
+    }
+
+    @JvmStatic
+    fun setResizeMode(
+        resizeMode: String?,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        var mode: ImageView.ScaleType? = null
+        when (resizeMode) {
+            "cover" -> {
+                mode = ImageView.ScaleType.CENTER_CROP
+            }
+            "contain" -> {
+                mode = ImageView.ScaleType.CENTER_INSIDE
+            }
+            "center" -> {
+                mode = ImageView.ScaleType.CENTER
+            }
+        }
+        viewManager.scaleType = mode
+    }
+
+    @JvmStatic
+    fun setRenderMode(
+        renderMode: String?,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        var mode: RenderMode? = null
+        when (renderMode) {
+            "AUTOMATIC" -> {
+                mode = RenderMode.AUTOMATIC
+            }
+            "HARDWARE" -> {
+                mode = RenderMode.HARDWARE
+            }
+            "SOFTWARE" -> {
+                mode = RenderMode.SOFTWARE
+            }
+        }
+        viewManager.renderMode = mode
+    }
+
+    @JvmStatic
+    fun setHardwareAcceleration(
+        hardwareAccelerationAndroid: Boolean,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        var layerType: Int? = View.LAYER_TYPE_SOFTWARE
+        if (hardwareAccelerationAndroid) {
+            layerType = View.LAYER_TYPE_HARDWARE
+        }
+        viewManager.layerType = layerType
+    }
+
+    @JvmStatic
+    fun setProgress(
+        progress: Float,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        viewManager.progress = progress
+    }
+
+    @JvmStatic
+    fun setSpeed(
+        speed: Double,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        viewManager.speed = speed.toFloat()
+    }
+
+    @JvmStatic
+    fun setLoop(
+        loop: Boolean,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        viewManager.loop = loop
+    }
+
+    @JvmStatic
+    fun setEnableMergePaths(
+        enableMergePaths: Boolean,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        viewManager.enableMergePaths = enableMergePaths
+    }
+
+    @JvmStatic
+    fun setImageAssetsFolder(
+        imageAssetsFolder: String?,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        viewManager.imageAssetsFolder = imageAssetsFolder
+    }
+
+    @JvmStatic
+    fun setColorFilters(
+        colorFilters: ReadableArray?,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        viewManager.colorFilters = colorFilters
+    }
+
+    @JvmStatic
+    fun setTextFilters(
+        textFilters: ReadableArray?,
+        viewManager: LottieAnimationViewPropertyManager
+    ) {
+        viewManager.textFilters = textFilters
+    }
+}

package/android/src/main/java/com/airbnb/android/react/lottie/LottieAnimationViewPropertyManager.kt

@@ -0,0 +1,156 @@
+package com.airbnb.android.react.lottie
+
+import com.airbnb.lottie.LottieAnimationView
+import java.lang.ref.WeakReference
+import android.widget.ImageView
+import com.facebook.react.bridge.ReadableArray
+import com.airbnb.lottie.RenderMode
+import com.airbnb.lottie.TextDelegate
+import com.airbnb.lottie.LottieDrawable
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.ColorPropConverter
+import android.graphics.ColorFilter
+import com.airbnb.lottie.SimpleColorFilter
+import com.airbnb.lottie.model.KeyPath
+import com.airbnb.lottie.value.LottieValueCallback
+import com.airbnb.lottie.LottieProperty
+import java.util.regex.Pattern
+
+/**
+ * Class responsible for applying the properties to the LottieView.
+ * The way react-native works makes it impossible to predict in which order properties will be set,
+ * also some of the properties of the LottieView needs to be set simultaneously.
+ *
+ * To solve this, instance of this class accumulates all changes to the view and applies them at
+ * the end of react transaction, so it could control how changes are applied.
+ */
+class LottieAnimationViewPropertyManager(view: LottieAnimationView) {
+    private val viewWeakReference: WeakReference<LottieAnimationView>
+
+    /**
+     * Should be set to true if one of the animationName related parameters has changed as a result
+     * of last reconciliation. We need to update the animation in this case.
+     */
+    private var animationNameDirty = false
+
+    var animationName: String? = null
+        set(value) {
+            field = value
+            this.animationNameDirty = true
+        }
+    var scaleType: ImageView.ScaleType? = null
+    var imageAssetsFolder: String? = null
+    var enableMergePaths: Boolean? = null
+    var colorFilters: ReadableArray? = null
+    var textFilters: ReadableArray? = null
+    var renderMode: RenderMode? = null
+    var layerType: Int? = null
+    var animationJson: String? = null
+    var progress: Float? = null
+    var loop: Boolean? = null
+    var speed: Float? = null
+
+    init {
+        viewWeakReference = WeakReference(view)
+    }
+
+    /**
+     * Updates the view with changed fields.
+     * Majority of the properties here are independent so they are has to be reset to null
+     * as soon as view is updated with the value.
+     *
+     * The only exception from this rule is the group of the properties for the animation.
+     * For now this is animationName and cacheStrategy. These two properties are should be set
+     * simultaneously if the dirty flag is set.
+     */
+    fun commitChanges() {
+        val view = viewWeakReference.get() ?: return
+
+        textFilters?.let {
+            if(it.size() > 0) {
+                val textDelegate = TextDelegate(view)
+                for (i in 0 until textFilters!!.size()) {
+                    val current = textFilters!!.getMap(i)
+                    val searchText = current.getString("find")
+                    val replacementText = current.getString("replace")
+                    textDelegate.setText(searchText, replacementText)
+                }
+                view.setTextDelegate(textDelegate)
+            }
+        }
+
+        animationJson?.let {
+            view.setAnimationFromJson(it, it.hashCode().toString())
+            animationJson = null
+        }
+
+        if (animationNameDirty) {
+            view.setAnimation(animationName)
+            animationNameDirty = false
+        }
+
+        progress?.let {
+            view.progress = it
+            progress = null
+        }
+
+        loop?.let {
+            view.repeatCount = if (it) LottieDrawable.INFINITE else 0
+            loop = null
+        }
+
+        speed?.let {
+            view.speed = it
+            speed = null
+        }
+
+        scaleType?.let {
+            view.scaleType = it
+            scaleType = null
+        }
+
+        renderMode?.let {
+            view.renderMode = it
+            renderMode = null
+        }
+
+        layerType?.let {
+            view.setLayerType(it, null)
+        }
+
+        imageAssetsFolder?.let {
+            view.imageAssetsFolder = it
+            imageAssetsFolder = null
+        }
+
+        enableMergePaths?.let {
+            view.enableMergePathsForKitKatAndAbove(it)
+            enableMergePaths = null
+        }
+
+        colorFilters?.let {
+            if (it.size() > 0) {
+                for (i in 0 until it.size()) {
+                    val current = it.getMap(i)
+
+                    val color: Int = if (current.getType("color") == ReadableType.Map) {
+                        ColorPropConverter.getColor(current.getMap("color"), view.context)
+                    } else {
+                        current.getInt("color")
+                    }
+
+                    val path = current.getString("keypath")
+                    val pathWithGlobStar = "$path.**"
+
+                    val colorFilter: ColorFilter = SimpleColorFilter(color)
+                    val callback = LottieValueCallback(colorFilter)
+
+                    val keys = pathWithGlobStar.split(Pattern.quote(".")).toTypedArray()
+                    val keyPath = KeyPath(*keys)
+
+                    view.addValueCallback(keyPath, LottieProperty.COLOR_FILTER, callback)
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/airbnb/android/react/lottie/LottiePackage.kt

@@ -0,0 +1,18 @@
+package com.airbnb.android.react.lottie
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+@Suppress("unused")
+class LottiePackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return emptyList()
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(LottieAnimationViewManager())
+    }
+}