Merge pull request #101 from rive-app/96

96

Author: mjtalbot

.github/workflows/build.yml

@@ -18,7 +18,7 @@ jobs:
       - name: Build Android
         uses: reactivecircus/android-emulator-runner@v2
         with:
-          api-level: 29
+          api-level: 30
           script: ./gradlew kotlin:assembleRelease
       - name: Upload artifact
         uses: actions/upload-artifact@v2
@@ -55,7 +55,7 @@ jobs:
       - name: Publish to MavenCentral
         uses: reactivecircus/android-emulator-runner@v2
         with:
-          api-level: 29
+          api-level: 30
           script: ./gradlew publishAllPublicationsToSonatypeRepository --max-workers 1 closeAndReleaseSonatypeStagingRepository
         env:
           OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}

README.md

@@ -13,7 +13,7 @@ This is the Android runtime for [Rive](https://rive.app), currently in beta. The
 To add Rive in your project, include the following in your `dependencies`:
 
 ```
-implementation 'app.rive:rive-android:0.0.2'
+implementation 'app.rive:rive-android:0.0.4'
 ```
 
 ## RiveAnimationView

app/src/main/java/app/rive/runtime/example/AndroidPlayerActivity.kt

@@ -1,18 +1,24 @@
 package app.rive.runtime.example
 
+import android.graphics.Color
 import android.os.Bundle
 import android.view.Gravity
 import android.view.View
 import android.widget.*
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.widget.AppCompatButton
+import androidx.appcompat.widget.AppCompatCheckBox
+import androidx.appcompat.widget.AppCompatEditText
 import app.rive.runtime.kotlin.RiveAnimationView
 import app.rive.runtime.kotlin.RiveDrawable.Listener
 import app.rive.runtime.kotlin.core.*
 
 class AndroidPlayerActivity : AppCompatActivity() {
     var loop: Loop = Loop.NONE
     var direction: Direction = Direction.AUTO
+    var playButtonMap: HashMap<String, View> = HashMap()
+    var pauseButtonMap: HashMap<String, View> = HashMap()
+    var stopButtonMap: HashMap<String, View> = HashMap()
 
     val animationResources = listOf(
         R.raw.artboard_animations,
@@ -22,13 +28,16 @@ class AndroidPlayerActivity : AppCompatActivity() {
         R.raw.flux_capacitor,
         R.raw.loopy,
         R.raw.mascot,
+        R.raw.neostream,
         R.raw.off_road_car_blog,
         R.raw.progress,
         R.raw.pull,
         R.raw.rope,
+        R.raw.skills,
         R.raw.trailblaze,
+        R.raw.ui_swipe_left_to_delete,
         R.raw.vader,
-        R.raw.wacky
+        R.raw.wacky,
     )
 
     val animationView by lazy(LazyThreadSafetyMode.NONE) {
@@ -44,6 +53,11 @@ class AndroidPlayerActivity : AppCompatActivity() {
         animationView.artboardName
         animationView.setRiveResource(animationResources[index], artboardName = null)
         setSpinner()
+
+        playButtonMap.clear()
+        pauseButtonMap.clear()
+        stopButtonMap.clear()
+
         animationView.drawable.file?.firstArtboard?.name?.let {
             loadArtboard(it)
         }
@@ -92,25 +106,31 @@ class AndroidPlayerActivity : AppCompatActivity() {
         layout.gravity = Gravity.END
 
         var text = TextView(this)
-        text.setText(animationName)
+        text.text = animationName
 
         var playButton = AppCompatButton(this)
-        playButton.setText(">")
+        playButton.text = ">"
+        playButton.background.setTint(Color.WHITE)
         playButton.setOnClickListener {
             animationView.play(animationName, loop, direction)
         }
+        playButtonMap[animationName] = playButton
 
         var pauseButton = AppCompatButton(this)
-        pauseButton.setText("||")
+        pauseButton.text = "||"
+        pauseButton.background.setTint(Color.WHITE)
         pauseButton.setOnClickListener {
             animationView.pause(animationName)
         }
+        pauseButtonMap[animationName] = pauseButton
 
         var stopButton = AppCompatButton(this)
-        stopButton.setText("[]")
+        stopButton.text = "[]"
+        stopButton.background.setTint(Color.RED)
         stopButton.setOnClickListener {
             animationView.stop(animationName)
         }
+        stopButtonMap[animationName] = stopButton
 
 
         layout.addView(text)
@@ -120,12 +140,128 @@ class AndroidPlayerActivity : AppCompatActivity() {
         return layout
     }
 
+
+    fun addStateMachineControl(artboard: Artboard, stateMachineName: String): List<View> {
+        val views = mutableListOf<View>()
+        val layout = LinearLayout(this)
+        layout.orientation = LinearLayout.HORIZONTAL
+        layout.gravity = Gravity.END
+
+        val text = TextView(this)
+        text.text = stateMachineName
+
+        val playButton = AppCompatButton(this)
+        playButton.text = ">"
+        playButton.background.setTint(Color.WHITE)
+        playButton.setOnClickListener {
+            animationView.play(stateMachineName, loop, direction, isStateMachine = true)
+        }
+        playButtonMap[stateMachineName] = playButton
+
+        val pauseButton = AppCompatButton(this)
+        pauseButton.text = "||"
+        pauseButton.background.setTint(Color.WHITE)
+        pauseButton.setOnClickListener {
+            animationView.pause(stateMachineName, isStateMachine = true)
+        }
+        pauseButtonMap[stateMachineName] = pauseButton
+
+        val stopButton = AppCompatButton(this)
+        stopButton.text = "[]"
+        stopButton.background.setTint(Color.RED)
+        stopButton.setOnClickListener {
+            animationView.stop(stateMachineName, isStateMachine = true)
+        }
+        stopButtonMap[stateMachineName] = stopButton
+
+        val stateMachine = artboard.stateMachine(stateMachineName)
+
+        layout.addView(text)
+        layout.addView(playButton)
+        layout.addView(pauseButton)
+        layout.addView(stopButton)
+        views.add(layout)
+
+
+        stateMachine.inputs.forEach {
+            val layout = LinearLayout(this)
+            layout.orientation = LinearLayout.HORIZONTAL
+            layout.gravity = Gravity.END
+
+            val text = TextView(this)
+            text.text = it.name
+            layout.addView(text)
+
+            if (it.isTrigger) {
+                val triggerButton = AppCompatButton(this)
+                triggerButton.text = "Fire"
+                triggerButton.background.setTint(Color.WHITE)
+                triggerButton.setOnClickListener { _ ->
+                    animationView.fireState(stateMachineName, it.name)
+                }
+                layout.addView(triggerButton)
+            }
+
+            if (it.isBoolean) {
+                val boolBox = AppCompatCheckBox(this)
+                if ((it as StateMachineBooleanInput).value) {
+                    boolBox.isChecked = true
+                }
+                boolBox.setOnCheckedChangeListener { _, b ->
+                    animationView.setBooleanState(stateMachineName, it.name, b)
+                }
+                layout.addView(boolBox)
+            }
+
+            if (it.isNumber) {
+                val editText = AppCompatEditText(this)
+                editText.setText((it as StateMachineNumberInput).value.toString())
+                val editTriggerButton = AppCompatButton(this)
+                editTriggerButton.text = "Apply"
+                editTriggerButton.background.setTint(Color.WHITE)
+                editTriggerButton.setOnClickListener { _ ->
+                    try {
+                        var value = editText.text.toString().toFloat()
+                        animationView.setNumberState(stateMachineName, it.name, value)
+                    } catch (e: Error) {
+
+                    }
+                }
+
+                layout.addView(editText)
+                layout.addView(editTriggerButton)
+            }
+
+            views.add(layout)
+        }
+
+        return views
+    }
+
     fun loadArtboard(artboardName: String) {
         var controls = findViewById<LinearLayout>(R.id.controls)
         controls.removeAllViews()
-        animationView.drawable.file?.artboard(artboardName)?.animationNames?.forEach {
-            controls.addView(addAnimationControl(it))
+        animationView.drawable.file?.artboard(artboardName)?.let { artboard ->
+            if (artboard.stateMachineNames.size > 0) {
+                val stateMachineHeader = TextView(this)
+                stateMachineHeader.text = "State Machines:"
+                controls.addView(stateMachineHeader)
+                artboard.stateMachineNames.forEach {
+                    addStateMachineControl(artboard, it).forEach {
+                        controls.addView(it)
+                    }
+                }
+            }
+            if (artboard.animationNames.size > 0) {
+                val animationsHeader = TextView(this)
+                animationsHeader.text = "Animations:"
+                controls.addView(animationsHeader)
+                artboard.animationNames.forEach {
+                    controls.addView(addAnimationControl(it))
+                }
+            }
         }
+
     }
 
     fun setSpinner() {
@@ -135,7 +271,7 @@ class AndroidPlayerActivity : AppCompatActivity() {
                 this,
                 android.R.layout.simple_spinner_dropdown_item,
                 artboardNames
-            );
+            )
             dropdown.adapter = adapter
             dropdown.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
                 override fun onItemSelected(
@@ -163,7 +299,7 @@ class AndroidPlayerActivity : AppCompatActivity() {
                 this,
                 android.R.layout.simple_spinner_dropdown_item,
                 resourceNames
-            );
+            )
             dropdown.adapter = adapter
             dropdown.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
                 override fun onItemSelected(
@@ -190,36 +326,92 @@ class AndroidPlayerActivity : AppCompatActivity() {
         val events = findViewById<LinearLayout>(R.id.events)
         val listener = object : Listener {
             override fun notifyPlay(animation: PlayableInstance) {
-                val text = TextView(that)
-                text.setText("Play ${(animation as LinearAnimationInstance).animation.name}")
-                events.addView(text, 0)
+                var text: String? = null
+                if (animation is LinearAnimationInstance) {
+                    text = animation.animation.name
+                } else if (animation is StateMachineInstance) {
+                    text = animation.stateMachine.name
+                }
+                text?.let {
+                    val textView = TextView(that)
+                    textView.text = "Play $text"
+                    events.addView(textView, 0)
+                    playButtonMap.get(text)?.let {
+                        it.background.setTint(Color.GREEN)
+                    }
+                    pauseButtonMap.get(text)?.let {
+                        it.background.setTint(Color.WHITE)
+                    }
+                    stopButtonMap.get(text)?.let {
+                        it.background.setTint(Color.WHITE)
+                    }
+                }
             }
 
             override fun notifyPause(animation: PlayableInstance) {
-                val text = TextView(that)
-                text.setText("Pause ${(animation as LinearAnimationInstance).animation.name}")
-                events.addView(text, 0)
+                var text: String? = null
+                if (animation is LinearAnimationInstance) {
+                    text = animation.animation.name
+                } else if (animation is StateMachineInstance) {
+                    text = animation.stateMachine.name
+                }
+                text?.let {
+                    val textView = TextView(that)
+                    textView.text = "Pause $text"
+                    events.addView(textView, 0)
+                    playButtonMap.get(text)?.let {
+                        it.background.setTint(Color.WHITE)
+                    }
+                    pauseButtonMap.get(text)?.let {
+                        it.background.setTint(Color.BLUE)
+                    }
+                    stopButtonMap.get(text)?.let {
+                        it.background.setTint(Color.WHITE)
+                    }
+                }
             }
 
             override fun notifyStop(animation: PlayableInstance) {
-                val text = TextView(that)
-                text.setText("Stop ${(animation as LinearAnimationInstance).animation.name}")
-                events.addView(text, 0)
+                var text: String? = null
+                if (animation is LinearAnimationInstance) {
+                    text = animation.animation.name
+                } else if (animation is StateMachineInstance) {
+                    text = animation.stateMachine.name
+                }
+                text?.let {
+                    val textView = TextView(that)
+                    textView.text = "Stop $text"
+                    events.addView(textView, 0)
+                    playButtonMap.get(text)?.let {
+                        it.background.setTint(Color.WHITE)
+                    }
+                    pauseButtonMap.get(text)?.let {
+                        it.background.setTint(Color.WHITE)
+                    }
+                    stopButtonMap.get(text)?.let {
+                        it.background.setTint(Color.RED)
+                    }
+                }
             }
 
             override fun notifyLoop(animation: PlayableInstance) {
-                val text = TextView(that)
-                text.setText("Loop ${(animation as LinearAnimationInstance).animation.name}")
-                events.addView(text, 0)
+                if (animation is LinearAnimationInstance) {
+                    val text = TextView(that)
+                    text.text = "Loop ${animation.animation.name}"
+                    events.addView(text, 0)
+                }
             }
         }
 
         animationView.registerListener(listener)
-
     }
 
+
     override fun onDestroy() {
         super.onDestroy()
         animationView.destroy()
     }
+
+
 }
+