Merge pull request #15 from algolia/feature/remove-coroutines

Feature/remove coroutines

Author: q-litzler

dependency.gradle

@@ -14,28 +14,20 @@ ext.with {
     constraintLayout = '1.1.2'
     espresso = '3.0.2'
 
-    archRuntime = '1.1.1'
-    archCompiler = '1.1.1'
-
     kotlins = '1.2.70'
-    coroutines = '0.26.1'
 
     bintray = '1.8.4'
     maven = '2.1'
 
     dependency_jvm = [
             kotlin_stdlib    : "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlins",
-            kotlin_reflection: "org.jetbrains.kotlin:kotlin-reflect:$kotlins",
             kotlin_test      : "org.jetbrains.kotlin:kotlin-test:$kotlins",
             kotlin_test_junit: "org.jetbrains.kotlin:kotlin-test-junit:$kotlins"
     ]
     dependency_android = [
             appcompat          : "com.android.support:appcompat-v7:$appcompat",
             constraint_layout  : "com.android.support.constraint:constraint-layout:$constraintLayout",
-            arch_extensions    : "android.arch.lifecycle:extensions:$archRuntime",
-            arch_compiler      : "android.arch.lifecycle:common-java8:$archCompiler",
             espresso           : "com.android.support.test.espresso:espresso-core:$espresso",
-            design             : "com.android.support:design:$design",
-            coroutines         : "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines"
+            design             : "com.android.support:design:$design"
     ]
 }

ui/build.gradle

@@ -33,7 +33,6 @@ dependencies {
 
     implementation dependency_jvm.kotlin_stdlib
 
-    implementation dependency_android.coroutines
     implementation dependency_android.appcompat
     implementation dependency_android.constraint_layout
     implementation dependency_android.design
@@ -44,10 +43,4 @@ dependencies {
 
     testImplementation dependency_jvm.kotlin_test
     testImplementation dependency_jvm.kotlin_test_junit
-}
-
-kotlin {
-    experimental {
-        coroutines "enable"
-    }
-}
+}

ui/src/main/kotlin/com/algolia/instantsearch/voice/ui/RippleView.kt

@@ -1,18 +1,16 @@
 package com.algolia.instantsearch.voice.ui
 
 import android.animation.AnimatorSet
+import android.annotation.SuppressLint
 import android.content.Context
 import android.graphics.Canvas
-import android.os.Looper
+import android.os.Build
 import android.util.AttributeSet
 import android.view.View
-import kotlinx.coroutines.experimental.*
-import kotlinx.coroutines.experimental.android.Main
-import kotlinx.coroutines.experimental.android.UI
-import kotlinx.coroutines.experimental.android.awaitFrame
 
 /** A View displaying a ripple effect. */
 class RippleView : View {
+
     enum class State {
         None,
         Playing,
@@ -29,60 +27,69 @@ class RippleView : View {
         init(attrs)
     }
 
+    private val fps = 1000L / 60L
+
     /** All circles used in this RippleView, generated during [init]. */
     private var circles = listOf<DrawableSprite>()
     /** Current animations, filled when [State.Playing] triggers [animation] and emptied when [State.Stopped]. */
     private val animations = mutableMapOf<Int, AnimatorSet>()
 
+    /** This runnable invalidate the view at 60 fps. */
+    private val runnableFps = object : java.lang.Runnable {
+
+        override fun run() {
+            invalidate()
+            postRunnableFps(this, fps)
+        }
+    }
+
+    /** This runnable generates an animation at each [interval][circleCount]. */
+    private val runnableAnimation = object : Runnable {
+
+        private var index = 0
+
+        override fun run() {
+            animations[index] = circles[index].circleAnimation().also { it.start() }
+            index = if (index == circles.lastIndex) 0 else index + 1
+            postRunnableAnimation(this)
+        }
+    }
+
     private var delay: Long = 0L
     private var duration: Long = 0L
     private var circleCount: Long = 0L
     private var radius: Float = 0f
     private var size: Int = 0
 
-    private var jobAnimation: Job? = null
-    private var jobFps : Job? = null
-
     private var state = State.None
         set(value) {
             field = value
             when (value) {
                 State.Playing -> {
                     animations.values.forEach { it.end() }
                     animations.clear()
-                    jobAnimation = animation()
-                }
-                State.Stopped -> try {
-                    jobAnimation?.cancel()
-                    jobAnimation = null
-                } catch (e: UninitializedPropertyAccessException) {
-                    // cancel() was called before start()
+                    postRunnableAnimation(runnableAnimation)
                 }
+                State.Stopped -> removeCallbacks(runnableAnimation)
                 State.None -> Unit
             }
         }
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        jobFps = GlobalScope.launch(Dispatchers.Main) {
-            while (isActive) {
-                awaitFrame()
-                invalidate()
-            }
-        }
+        postRunnableFps(runnableFps, fps)
     }
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
-        jobFps?.cancel()
-        jobFps = null
-        jobAnimation?.cancel()
-        jobAnimation = null
+        removeCallbacks(runnableAnimation)
+        removeCallbacks(runnableFps)
     }
 
+    @SuppressLint("Recycle")
     private fun init(attrs: AttributeSet) {
         context.obtainStyledAttributes(attrs, R.styleable.RippleView, 0, 0).also {
-            val drawable = it.getDrawable(R.styleable.RippleView_drawable)
+            val drawable = it.getDrawable(R.styleable.RippleView_drawable)!!
             delay = it.getInt(R.styleable.RippleView_delay, 500).toLong()
             duration = it.getInt(R.styleable.RippleView_duration, 500).toLong()
             size = it.getDimensionPixelSize(R.styleable.RippleView_size, 0)
@@ -93,13 +100,19 @@ class RippleView : View {
         }.recycle()
     }
 
-    /** This coroutine generates an animation at each [interval][circleCount]. */
-    private fun animation(): Job = GlobalScope.launch(Dispatchers.Main) {
-        var index = 0
-        while (isActive) {
-            animations[index] = circles[index].circleAnimation().also { it.start() }
-            index = if (index == circles.lastIndex) 0 else index + 1
-            delay(delay)
+    private fun postRunnableAnimation(runnable: Runnable) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+            postOnAnimationDelayed(runnable, delay)
+        } else {
+            postDelayed(runnable, delay)
+        }
+    }
+
+    private fun postRunnableFps(runnable: Runnable, fps: Long) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+            postOnAnimation(runnable)
+        } else {
+            postDelayed(runnable, fps)
         }
     }