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

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

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

@@ -2,11 +2,13 @@ package dev.apexnative.navigation.views.element.animators
 
 import android.view.View
 import android.view.ViewGroup
+import com.facebook.react.uimanager.ReactOverflowView
+import dev.apexnative.navigation.utils.borderRadius
 import dev.apexnative.navigation.views.animations.ValueInterpolation
 import kotlin.math.abs
 import kotlin.math.cos
+import kotlin.math.max
 import kotlin.math.min
-import kotlin.math.roundToInt
 import kotlin.math.sin
 
 /**
@@ -41,6 +43,23 @@ internal class ViewPlacement(
         )
     }
 
+    /**
+     * The point [x], [y] of the parent in the view's coordinates: [toParent] undone. None when a scale of 0 flattens
+     * the view.
+     */
+    fun toChild(x: Float, y: Float): FloatArray? {
+        if (scaleX == 0f || scaleY == 0f) return null
+        val dx = x - (pivotX + translationX + left - parentScrollX)
+        val dy = y - (pivotY + translationY + top - parentScrollY)
+        val radians = Math.toRadians(rotation.toDouble())
+        val cos = cos(radians).toFloat()
+        val sin = sin(radians).toFloat()
+        return floatArrayOf(
+            (dx * cos + dy * sin) / scaleX + pivotX,
+            (-dx * sin + dy * cos) / scaleY + pivotY,
+        )
+    }
+
     /** Whether the view shows mirrored: one of its scales is negative. */
     val mirrors: Boolean get() = scaleX * scaleY < 0
 
@@ -49,12 +68,12 @@ internal class ViewPlacement(
         private const val FLIP_TOLERANCE = 0.5f
         private const val HALF_TURN = 180f
 
-        /** [view] as it lies now; [frameOf] the view whose frame and parent it takes (a stand-in where it was). */
-        fun of(view: View, frameOf: View = view): ViewPlacement {
-            val parent = frameOf.parent as? View
+        /** [view] as it lies now. */
+        fun of(view: View): ViewPlacement {
+            val parent = view.parent as? View
             return withTilts(
-                left = frameOf.left.toFloat(),
-                top = frameOf.top.toFloat(),
+                left = view.left.toFloat(),
+                top = view.top.toFloat(),
                 translationX = view.translationX,
                 translationY = view.translationY,
                 scaleX = view.scaleX,
@@ -113,12 +132,13 @@ internal class ViewPlacement(
  * Where the points of a view are drawn in a transition's layer: through its own placement and each parent's ([chain],
  * the view first, up to the top view of the window but not it), then moved by [offsetX], [offsetY] (where the top view
  * is from the layer's corner). The angle and the scale are those of the whole chain: a turned or scaled parent turns
- * or scales what is in it.
+ * or scales what is in it. [clips] are the parents that cut what the view draws, the innermost first.
  */
 internal class LayerPlace(
     private val chain: List<ViewPlacement>,
     private val offsetX: Float,
     private val offsetY: Float,
+    private val clips: List<Clip> = emptyList(),
 ) {
     /** The angle the view is drawn at, degrees, clockwise: a mirrored parent turns what is in it the other way. */
     val rotation: Float = chain.fold(0f) { inner, placement ->
@@ -153,28 +173,158 @@ internal class LayerPlace(
         )
     }
 
+    /**
+     * The part of a view of [width] × [height] drawn here that its [clips] leave visible, as iOS works it out: the
+     * view's bounds cut by the bounds of each clip, brought into the view's coordinates (the box around them where a
+     * turn tilts them), with the corners of the last clip that cut something. Uncut, it is the whole view with its own
+     * [cornerRadius] (in its pixels).
+     */
+    fun visible(width: Int, height: Int, cornerRadius: Float): VisiblePart {
+        val w = width.toFloat()
+        val h = height.toFloat()
+        val visible = floatArrayOf(0f, 0f, w, h)
+        var radius = 0f
+        for (clip in clips) {
+            val cut = intersection(visible, boundsInView(clip))
+            if (!cut.contentEquals(visible)) radius = clip.radius
+            cut.copyInto(visible)
+        }
+        val clipped = abs(visible[0]) > SAME_RECT || abs(visible[1]) > SAME_RECT ||
+            abs(visible[2] - w) > SAME_RECT || abs(visible[3] - h) > SAME_RECT
+        val shown = if (clipped) visible else floatArrayOf(0f, 0f, w, h)
+        val scaleX = abs(scaleX)
+        val scaleY = abs(scaleY)
+        return VisiblePart(
+            left = (shown[0] - w / 2) * scaleX,
+            top = (shown[1] - h / 2) * scaleY,
+            right = (shown[2] - w / 2) * scaleX,
+            bottom = (shown[3] - h / 2) * scaleY,
+            radius = (if (clipped) radius else cornerRadius) * min(scaleX, scaleY),
+            clipped = clipped,
+        )
+    }
+
+    // The bounds of [clip] in the view's coordinates: the box around its corners brought down the chain. Empty when a
+    // placement on the way flattens the view.
+    private fun boundsInView(clip: Clip): FloatArray {
+        val box = floatArrayOf(Float.MAX_VALUE, Float.MAX_VALUE, -Float.MAX_VALUE, -Float.MAX_VALUE)
+        for (corner in 0 until CORNERS) {
+            var point: FloatArray? = floatArrayOf(
+                if (corner % 2 == 0) 0f else clip.width,
+                if (corner < 2) 0f else clip.height,
+            )
+            for (level in clip.level - 1 downTo 0) point = point?.let { chain[level].toChild(it[0], it[1]) }
+            point ?: return FloatArray(RECT)
+            box[0] = min(box[0], point[0])
+            box[1] = min(box[1], point[1])
+            box[2] = max(box[2], point[0])
+            box[3] = max(box[3], point[1])
+        }
+        return box
+    }
+
     companion object {
+        private const val CORNERS = 4
+        private const val RECT = 4
+
+        // How close two rects count as the same, in pixels: a visible part that is the whole view needs no mask.
+        private const val SAME_RECT = 0.5f
+        private const val VISIBLE = "visible"
+
         /**
-         * Where [view] is drawn in [layer]. With [standIn], [view] counts as lying where that one lies (its frame and
-         * parents) with its own properties: an element that moved into the layer, at the place it goes back to.
+         * Where [view] is drawn in [layer]. With [clipRoot] (the view of its screen), the parents up to it that cut
+         * what they draw are its clips: as on iOS, the parents above the screen don't count.
          */
-        fun of(view: View, layer: View, standIn: View? = null): LayerPlace {
-            val placed = standIn ?: view
-            val chain = arrayListOf(ViewPlacement.of(view, placed))
-            var parent = placed.parent as? View
+        fun of(view: View, layer: View, clipRoot: View? = null): LayerPlace {
+            val chain = arrayListOf(ViewPlacement.of(view))
+            val clips = ArrayList<Clip>()
+            var clipping = clipRoot != null
+            var parent = view.parent as? View
             while (parent != null) {
+                if (clipping) {
+                    clipOf(parent, chain.size)?.let(clips::add)
+                    clipping = parent !== clipRoot
+                }
                 val above = parent.parent as? View ?: break
                 chain += ViewPlacement.of(parent)
                 parent = above
             }
             // The window's top view (no parent view) lies where it is on the screen, with no properties of its own.
-            val base = parent ?: placed
+            val base = parent ?: view
             val screen = IntArray(2)
             base.getLocationOnScreen(screen)
             val origin = IntArray(2)
             layer.getLocationOnScreen(origin)
-            return LayerPlace(chain, (screen[0] - origin[0]).toFloat(), (screen[1] - origin[1]).toFloat())
+            return LayerPlace(chain, (screen[0] - origin[0]).toFloat(), (screen[1] - origin[1]).toFloat(), clips)
         }
+
+        /** The rect [a] cut by [b] (left, top, right, bottom); an empty one at 0, 0 when they don't meet, as on iOS. */
+        internal fun intersection(a: FloatArray, b: FloatArray): FloatArray {
+            val left = max(a[0], b[0])
+            val top = max(a[1], b[1])
+            val right = min(a[2], b[2])
+            val bottom = min(a[3], b[3])
+            return if (left < right && top < bottom) floatArrayOf(left, top, right, bottom) else FloatArray(RECT)
+        }
+
+        // The clip of [parent], at [level] of the chain, when it cuts what it draws to its bounds: a React Native view
+        // whose `overflow` isn't visible (a scroll view's is `scroll` unless set) with its corners, and any view whose
+        // own parent keeps its children in (`clipChildren`: Android cuts each child to its bounds, square), as the
+        // screen's own views do. React Native's views let their children out, so their `overflow` alone counts.
+        private fun clipOf(parent: View, level: Int): Clip? {
+            val overflows = parent is ReactOverflowView && parent.overflow.let { it != null && it != VISIBLE }
+            val keptIn = (parent.parent as? ViewGroup)?.clipChildren == true
+            if (!overflows && !keptIn) return null
+            val radius = if (overflows) parent.borderRadius else 0f
+            return Clip(level, parent.width.toFloat(), parent.height.toFloat(), radius)
+        }
+    }
+}
+
+/**
+ * A parent that cuts what a view draws to its bounds: its [level] in the view's chain (1 the view's parent: its
+ * coordinates come down to the view's through the placements before it), its size and its corner radius. Pixels.
+ */
+internal class Clip(val level: Int, val width: Float, val height: Float, val radius: Float = 0f)
+
+/**
+ * The part of a shared element's copy that shows at one end of its flight: left, top, right, bottom from the copy's
+ * center at the size it is drawn at, and its corner radius there. [clipped]: a parent cuts the view; else it is the
+ * whole copy with its own corners.
+ */
+internal class VisiblePart(
+    val left: Float,
+    val top: Float,
+    val right: Float,
+    val bottom: Float,
+    val radius: Float,
+    val clipped: Boolean,
+)
+
+/**
+ * The mask of a copy cut by its views' parents, as on iOS: a rounded rect that goes from the part of the copy that
+ * shows at one end to the part that shows at the other, evenly.
+ */
+internal class FlightMask private constructor(private val from: VisiblePart, private val to: VisiblePart) {
+    /**
+     * Fills [out] with the mask at [fraction] of the way (the curve's value), [time] the part of the time: left, top,
+     * right, bottom from the copy's center, then the corner radius.
+     */
+    fun at(fraction: Float, time: Float, out: FloatArray) {
+        out[0] = ValueInterpolation.number(from.left, to.left, fraction, time)
+        out[1] = ValueInterpolation.number(from.top, to.top, fraction, time)
+        out[2] = ValueInterpolation.number(from.right, to.right, fraction, time)
+        out[3] = ValueInterpolation.number(from.bottom, to.bottom, fraction, time)
+        out[4] = ValueInterpolation.number(from.radius, to.radius, fraction, time)
+    }
+
+    companion object {
+        /** The values [at] fills. */
+        const val SIZE = 5
+
+        /** The mask between [from] and [to]; none when neither is cut, and the copy shows whole. */
+        fun of(from: VisiblePart, to: VisiblePart): FlightMask? =
+            if (from.clipped || to.clipped) FlightMask(from, to) else null
     }
 }
 
@@ -191,48 +341,14 @@ internal class FlightEnd(
     val mirrorX: Float = 1f,
     val mirrorY: Float = 1f,
     val scale: Float = 1f,
-) {
-    /** Whether [other] is drawn at the same place, size, angle and mirror: within half a pixel and 0.1°. */
-    fun sameAs(other: FlightEnd): Boolean =
-        abs(centerX - other.centerX) < SAME_PLACE && abs(centerY - other.centerY) < SAME_PLACE &&
-            abs(width - other.width) < SAME_PLACE && abs(height - other.height) < SAME_PLACE &&
-            abs(rotation - other.rotation) < SAME_ANGLE && mirrorX == other.mirrorX && mirrorY == other.mirrorY
-
-    companion object {
-        private const val SAME_PLACE = 0.5f
-        private const val SAME_ANGLE = 0.1f
-
-        /**
-         * Whether `to` shows elsewhere in its screen than in the layer with its own properties alone ([standIn] is
-         * where it was): a parent of its scales or turns it. A flight that landed then keeps it where it lands until
-         * the transition gives it back, or it would jump to its place in the layer meanwhile.
-         */
-        fun holdsAtEnd(to: View, standIn: View?, layer: View): Boolean {
-            if (standIn == null) return false
-            val inScreen = LayerPlace.of(to, layer, standIn).end(to.width, to.height)
-            return !inScreen.sameAs(LayerPlace.of(to, layer).end(to.width, to.height))
-        }
-    }
-}
+)
 
 /**
- * Where a shared element flies in its transition's layer: from where `from` is drawn to where `to` is drawn once it
- * is back in its screen, both through their own and their parents' translation, scale and rotation. The center, the
- * size and the mirror go evenly, the angle along the shorter arc (as on iOS). `to` lies in the layer at its margins
- * ([toLeft], [toTop]) meanwhile.
+ * Where a shared element flies in its transition's layer: from where `from` is drawn to where `to` is drawn in its
+ * screen, both through their own and their parents' translation, scale and rotation. The center, the size and the
+ * mirror go evenly, the angle along the shorter arc (as on iOS).
  */
-internal class FlightGeometry(
-    val from: FlightEnd,
-    val to: FlightEnd,
-    val toLeft: Int,
-    val toTop: Int,
-    /** Whether `to` keeps the flight's last frame at the end ([FlightEnd.holdsAtEnd]). */
-    val holdsAtEnd: Boolean = false,
-) {
-    /** The width and height `to` is laid out at meanwhile: the larger of the two sizes. */
-    val largest: Pair<Int, Int>
-        get() = maxOf(from.width, to.width).roundToInt() to maxOf(from.height, to.height).roundToInt()
-
+internal class FlightGeometry(val from: FlightEnd, val to: FlightEnd) {
     /** The flight at [fraction] of the way (the curve's value), [time] the part of the time. */
     fun at(fraction: Float, time: Float): FlightEnd = FlightEnd(
         centerX = ValueInterpolation.number(from.centerX, to.centerX, fraction, time),
@@ -244,103 +360,4 @@ internal class FlightGeometry(
         mirrorY = ValueInterpolation.number(from.mirrorY, to.mirrorY, fraction, time),
         scale = ValueInterpolation.number(from.scale, to.scale, fraction, time),
     )
-
-    /**
-     * The translation and pivot that draw a view laid out at its margins with [width] × [height] (or showing that part
-     * of a larger layout from its corner) at [frame]'s center and angle, unscaled: x, y of the translation, then of
-     * the pivot.
-     */
-    fun moveOf(frame: FlightEnd, width: Int, height: Int): FloatArray = floatArrayOf(
-        frame.centerX - (toLeft + width / 2f),
-        frame.centerY - (toTop + height / 2f),
-        width / 2f,
-        height / 2f,
-    )
-
-    companion object {
-        /**
-         * The flight of [from] to [to], which is in [layer] already in place of [toStandIn] (the stub where it was);
-         * none when [to] has no place there.
-         */
-        fun of(from: View, to: View, toStandIn: View?, layer: View): FlightGeometry? {
-            val place = to.layoutParams as? ViewGroup.MarginLayoutParams ?: return null
-            val fromEnd = LayerPlace.of(from, layer).end(from.width, from.height)
-            val toEnd = LayerPlace.of(to, layer, toStandIn).end(to.width, to.height)
-            val holds = FlightEnd.holdsAtEnd(to, toStandIn, layer)
-            return FlightGeometry(fromEnd, toEnd, place.leftMargin, place.topMargin, holds)
-        }
-    }
-}
-
-/**
- * The properties a moving `to` is drawn with in the layer when its flight starts, put back when it ends: the
- * flight draws it unscaled (but mirrored where an end is) and untilted at the flight's angle about the middle of what
- * shows.
- */
-internal class MovedProperties(private val view: View) {
-    private val translationX = view.translationX
-    private val translationY = view.translationY
-    private val scaleX = view.scaleX
-    private val scaleY = view.scaleY
-    private val rotation = view.rotation
-    private val rotationX = view.rotationX
-    private val rotationY = view.rotationY
-    private val pivotX = view.pivotX
-    private val pivotY = view.pivotY
-    private val ownWidth = view.width
-    private val ownHeight = view.height
-
-    /** [view] at [frame], laid out at [width] × [height] from its margins (or showing that part from its corner). */
-    fun show(geometry: FlightGeometry, frame: FlightEnd, width: Int, height: Int) {
-        val move = geometry.moveOf(frame, width, height)
-        view.pivotX = move[2]
-        view.pivotY = move[3]
-        view.translationX = move[0]
-        view.translationY = move[1]
-        view.scaleX = frame.mirrorX
-        view.scaleY = frame.mirrorY
-        view.rotation = frame.rotation
-        view.rotationX = 0f
-        view.rotationY = 0f
-    }
-
-    /**
-     * [view] at the end of a flight that [landed]: kept at the flight's last frame, laid out by [layOut] at the size it
-     * shows, when the geometry holds it there; else as it was at the start, laid out by [layOut] at its own size.
-     */
-    fun end(geometry: FlightGeometry, landed: Boolean, layOut: (width: Int, height: Int) -> Unit) {
-        if (geometry.holdsAtEnd && landed) {
-            val width = geometry.to.width.roundToInt()
-            val height = geometry.to.height.roundToInt()
-            layOut(width, height)
-            show(geometry, geometry.to, width, height)
-        } else {
-            restore()
-            layOut(ownWidth, ownHeight)
-        }
-    }
-
-    /** [view] as it was at the start. */
-    fun restore() {
-        view.translationX = translationX
-        view.translationY = translationY
-        view.scaleX = scaleX
-        view.scaleY = scaleY
-        view.rotation = rotation
-        view.rotationX = rotationX
-        view.rotationY = rotationY
-        view.pivotX = pivotX
-        view.pivotY = pivotY
-    }
-}
-
-/** An outline of the size and corners a flying view shows meanwhile: its own bounds are larger. */
-internal class FlightOutline : android.view.ViewOutlineProvider() {
-    var width = 0
-    var height = 0
-    var radius = 0f
-
-    override fun getOutline(view: View, outline: android.graphics.Outline) {
-        outline.setRoundRect(0, 0, width, height, radius)
-    }
 }