@apexnative/navigation 1.0.0-alpha.6 → 1.0.0-alpha.7

package/android/src/main/java/dev/apexnative/navigation/views/element/TargetsWait.kt

@@ -7,6 +7,7 @@ import dev.apexnative.navigation.options.LayoutAnimation
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.utils.DevelopmentLog
 import dev.apexnative.navigation.utils.NavigationLog
+import dev.apexnative.navigation.utils.SystemAnimations
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
@@ -17,7 +18,8 @@ import kotlinx.coroutines.launch
 /**
  * The wait of a forward transition with elements for its targets: the module's frames (`awaitTransitionTargets`, 0.5 s
  * at most, then one frame more), then the images of the shared elements found ([ImageWait], 1 s at most each). It ends
- * early when the screen that goes is destroyed. A failure in it is logged and the transition starts. Main thread only.
+ * early when the screen that goes is destroyed, and doesn't wait with the system's animations off. A failure in it is
+ * logged and the transition starts. Main thread only.
  */
 internal object TargetsWait {
     // The waits run on the main thread's frames; each is cancelled on its own.
@@ -31,6 +33,11 @@ internal object TargetsWait {
         waiting: () -> Boolean,
         done: () -> Unit,
     ): () -> Unit {
+        // With the system's animations off no element moves ([ElementTransition.start]): nothing to wait for.
+        if (SystemAnimations.areOff(to.peekView()?.context)) {
+            guarded { done() }
+            return NOTHING
+        }
         var stopped = false
         var stopImages: () -> Unit = NOTHING
         val still = { !stopped && waiting() && from?.isDestroyed != true }

package/android/src/main/java/dev/apexnative/navigation/views/element/TransitionLayer.kt

@@ -2,45 +2,35 @@ package dev.apexnative.navigation.views.element
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.graphics.Point
-import android.graphics.Rect
+import android.graphics.Canvas
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
+import dev.apexnative.navigation.views.element.animators.FlightPicture
 
 /**
- * The layer of a transition's elements: full size over the screens' common parent (a stack's view; for a modal, between
- * the modals layer and the overlays layer), there only while the transition runs. Each view in it lies where its layout
- * params say — `leftMargin`, `topMargin` and its size, in the layer's pixels — and nothing re-places it: Fabric's views
- * carry no margins of their own. Nothing in it is clipped by the parents it came from, it takes no touches,
- * accessibility doesn't see it. Main thread only.
+ * The layer the copies of a transition's shared elements fly in: full size over the screens' common parent (a stack's
+ * view; for a modal, between the modals layer and the overlays layer), there only while the transition runs. It holds
+ * no views: it draws the pictures of the flights ([FlightPicture]) in the order they are added, each while it is shown,
+ * on every frame while one of them is [FlightPicture.live]. A picture whose drawing fails draws no more, and its
+ * [FlightPicture.onFailed] runs after the frame. It takes no touches, accessibility doesn't see it. Main thread only.
  */
 @SuppressLint("ViewConstructor")
-internal class TransitionLayer(context: Context) : ViewGroup(context) {
-    // The newest frame Fabric gave a view while it was here (a commit lays it out in its parent's coordinates).
-    private val reactFrames = HashMap<View, Rect>()
+internal class TransitionLayer(context: Context) : View(context) {
+    private val pictures = ArrayList<FlightPicture>()
 
     init {
-        clipChildren = false
-        clipToPadding = false
-        importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+        importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_NO
+        setWillNotDraw(false)
     }
 
-    /** The layer's top left corner on the screen, in pixels: what the views in it are placed from. */
-    val originOnScreen: Point
-        get() {
-            val location = IntArray(2)
-            getLocationOnScreen(location)
-            return Point(location[0], location[1])
-        }
-
     /**
-     * Joins [parent] at [index] (its top without one), laid out at once at the parent's size: its views are in their
-     * places on the frame the transition starts.
+     * Joins [parent] at [index] (its top without one), laid out at once at the parent's size: the places of the views
+     * are measured from it on the frame the transition starts.
      */
     fun attachTo(parent: ViewGroup, index: Int = parent.childCount) {
         // The parent turns these into its own kind of params.
-        parent.addView(this, index.coerceIn(0, parent.childCount), LayoutParams(MATCH, MATCH))
+        parent.addView(this, index.coerceIn(0, parent.childCount), ViewGroup.LayoutParams(MATCH, MATCH))
         measure(
             MeasureSpec.makeMeasureSpec(parent.width, MeasureSpec.EXACTLY),
             MeasureSpec.makeMeasureSpec(parent.height, MeasureSpec.EXACTLY),
@@ -48,51 +38,10 @@ internal class TransitionLayer(context: Context) : ViewGroup(context) {
         layout(0, 0, parent.width, parent.height)
     }
 
-    /** [view] lies at [left], [top] (the layer's pixels) at the size [width] × [height], laid out at once. */
-    fun put(view: View, left: Int, top: Int, width: Int, height: Int) {
-        val params = MarginLayoutParams(width, height).apply {
-            leftMargin = left
-            topMargin = top
-        }
-        addView(view, params)
-        layOut(view, left, top, width, height)
-    }
-
-    /** [view], in the layer, lies at [left], [top] at the size [width] × [height] from now on. */
-    fun place(view: View, left: Int, top: Int, width: Int, height: Int) {
-        noteReactFrame(view)
-        (view.layoutParams as? MarginLayoutParams)?.let {
-            it.leftMargin = left
-            it.topMargin = top
-            it.width = width
-            it.height = height
-        }
-        layOut(view, left, top, width, height)
-    }
-
-    private fun layOut(view: View, left: Int, top: Int, width: Int, height: Int) {
-        view.measure(
-            MeasureSpec.makeMeasureSpec(width.coerceAtLeast(0), MeasureSpec.EXACTLY),
-            MeasureSpec.makeMeasureSpec(height.coerceAtLeast(0), MeasureSpec.EXACTLY),
-        )
-        view.layout(left, top, left + width, top + height)
-    }
-
-    /**
-     * The newest frame React gave [view] while it was in the layer, in its parent's coordinates; none when React
-     * didn't lay it out meanwhile. A frame other than the one the layer gave it can only be React's.
-     */
-    fun frameFromReact(view: View): Rect? {
-        noteReactFrame(view)
-        return reactFrames.remove(view)
-    }
-
-    // The view's frame isn't where the layer put it: React laid it out since.
-    private fun noteReactFrame(view: View) {
-        val params = view.layoutParams as? MarginLayoutParams ?: return
-        val placed = view.left == params.leftMargin && view.top == params.topMargin &&
-            view.width == params.width && view.height == params.height
-        if (!placed) reactFrames[view] = Rect(view.left, view.top, view.right, view.bottom)
+    /** [picture] is drawn over those added before it. */
+    fun add(picture: FlightPicture) {
+        pictures += picture
+        invalidate()
     }
 
     /** The layer leaves its parent. */
@@ -100,53 +49,29 @@ internal class TransitionLayer(context: Context) : ViewGroup(context) {
         (parent as? ViewGroup)?.removeView(this)
     }
 
-    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        setMeasuredDimension(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.getSize(heightMeasureSpec))
-        for (index in 0 until childCount) {
-            val child = getChildAt(index)
-            val params = child.layoutParams
-            child.measure(
-                MeasureSpec.makeMeasureSpec(params.width.coerceAtLeast(0), MeasureSpec.EXACTLY),
-                MeasureSpec.makeMeasureSpec(params.height.coerceAtLeast(0), MeasureSpec.EXACTLY),
-            )
-        }
-    }
-
-    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
-        for (index in 0 until childCount) {
-            val child = getChildAt(index)
-            val params = child.layoutParams as? MarginLayoutParams ?: continue
-            noteReactFrame(child)
-            child.layout(
-                params.leftMargin,
-                params.topMargin,
-                params.leftMargin + child.measuredWidth,
-                params.topMargin + child.measuredHeight,
-            )
+    override fun onDraw(canvas: Canvas) {
+        var live = false
+        for (picture in pictures) {
+            if (!picture.shown) continue
+            live = live || picture.live
+            val count = canvas.save()
+            try {
+                picture.draw(canvas)
+            } catch (e: RuntimeException) {
+                picture.shown = false
+                post { picture.onFailed(e) }
+            } finally {
+                canvas.restoreToCount(count)
+            }
         }
+        // A landed copy gets no more frames from its flight: one that changes by itself asks for them.
+        if (live) postInvalidateOnAnimation()
     }
 
-    override fun checkLayoutParams(params: LayoutParams?): Boolean = params is MarginLayoutParams
-
-    override fun generateDefaultLayoutParams(): LayoutParams = MarginLayoutParams(0, 0)
-
-    override fun generateLayoutParams(params: LayoutParams?): LayoutParams = MarginLayoutParams(params)
-
+    @SuppressLint("ClickableViewAccessibility")
     override fun dispatchTouchEvent(event: MotionEvent?): Boolean = false
 
-    override fun shouldDelayChildPressedState(): Boolean = false
-
-    companion object {
-        private const val MATCH = LayoutParams.MATCH_PARENT
-
-        /** Whether [view] is in a transition's layer now (an element of another transition). */
-        fun holds(view: View): Boolean {
-            var parent = view.parent
-            while (parent != null) {
-                if (parent is TransitionLayer) return true
-                parent = parent.parent
-            }
-            return false
-        }
+    private companion object {
+        const val MATCH = ViewGroup.LayoutParams.MATCH_PARENT
     }
 }

package/android/src/main/java/dev/apexnative/navigation/views/element/animators/ElementPictures.kt

@@ -4,7 +4,12 @@ import android.animation.Animator
 import android.animation.AnimatorListenerAdapter
 import android.animation.TimeInterpolator
 import android.animation.ValueAnimator
+import android.graphics.Canvas
+import android.graphics.Paint
 import android.graphics.Picture
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.graphics.RectF
 import android.util.Log
 import android.view.View
 import android.view.animation.LinearInterpolator
@@ -13,8 +18,7 @@ import dev.apexnative.navigation.views.element.elementStep
 
 /**
  * The view's own drawing with its children, as drawing commands: sharp at any scale. Its opacity and place belong to
- * the parent. Recording can fail (a hardware bitmap in an image on an older Android): the element then moves without
- * pictures.
+ * the parent. Recording can fail (a hardware bitmap in an image before Android 9): the pair then doesn't fly.
  */
 internal fun recordPicture(view: View): Picture? = try {
     Picture().also {
@@ -26,10 +30,59 @@ internal fun recordPicture(view: View): Picture? = try {
         }
     }
 } catch (e: RuntimeException) {
-    Log.w(NavigationLog.TAG, "Element transition: no picture of the element, it moves without one", e)
+    Log.w(NavigationLog.TAG, "[ApexNavigation] Element transition: no picture of the element", e)
     null
 }
 
+/**
+ * What a shared pair's flight draws in its transition's layer, in the layer's coordinates: the copy where the flight
+ * has brought it ([update]). The layer draws it while it is [shown]: from the start of the flight, and after a landing
+ * until the layer goes.
+ */
+internal abstract class FlightPicture {
+    /** Whether the layer draws it now. */
+    var shown = false
+
+    /** Whether what it draws changes by itself (an animated image): the layer draws it on every frame while shown. */
+    open val live: Boolean get() = false
+
+    /** What runs after its drawing failed: it is drawn no more, and the views of its pair show again. */
+    var onFailed: (Exception) -> Unit = {}
+
+    /** The copy at [time] (the part of the time), [progress] the curve's value. */
+    abstract fun update(time: Float, progress: Float)
+
+    /** The copy, on the layer's canvas; the layer saves and restores the canvas around it. */
+    abstract fun draw(canvas: Canvas)
+}
+
+/**
+ * The cut of a copy whose views' parents hide part of them ([FlightMask]): it keeps, of the mask the copy draws on its
+ * layer, only the part that shows. A layer of that part's rounded rect laid over the mask (`DST_IN`), not a clip path:
+ * its edges stay smooth.
+ */
+internal class MaskCut(private val mask: FlightMask) {
+    private val values = FloatArray(FlightMask.SIZE)
+    private val rect = RectF()
+    private val shape = Paint(Paint.ANTI_ALIAS_FLAG)
+    private val cut = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_IN) }
+
+    /** The cut at [time] (the part of the time), [progress] the curve's value. */
+    fun update(time: Float, progress: Float) = mask.at(progress, time, values)
+
+    /** Cuts the mask drawn so far on the copy's layer of [bounds], in the copy's coordinates (0, 0 its center). */
+    fun draw(canvas: Canvas, bounds: RectF) {
+        rect.set(values[0], values[1], values[2], values[3])
+        canvas.saveLayer(bounds, cut)
+        if (!rect.isEmpty) canvas.drawRoundRect(rect, values[RADIUS], values[RADIUS], shape)
+        canvas.restore()
+    }
+
+    private companion object {
+        const val RADIUS = 4
+    }
+}
+
 // Runs in linear time and keeps the curve it is given for the move: an element moves along the transition's curve,
 // while what has to follow the clock (the pictures of a text changing over) can. Its start and its frames each run in
 // [elementStep]: one that fails stops the element — it is cancelled, so its ends put back what it changed and the