@rafaelaugusto/jolt 0.1.0-beta.9 → 0.1.0-rc.10

package/platforms/android/java/org/rafaelaugusto/jolt/ParticleEmitter.java

@@ -0,0 +1,192 @@
+package org.rafaelaugusto.jolt;
+
+import android.database.ContentObserver;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import android.provider.Settings;
+import android.view.Choreographer;
+import android.view.View;
+import android.view.ViewParent;
+
+/** A visual-only ViewOverlay drawable: all integration, deadlines and drawing stay in Java. */
+public final class ParticleEmitter extends Drawable implements Choreographer.FrameCallback, View.OnAttachStateChangeListener {
+    public interface Listener { void onEnd(); }
+    private static int activeCount;
+    private View target, host;
+    private final boolean overlay;
+    private final float density;
+    private final ParticleSimulation simulation;
+    private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private final Choreographer choreographer = Choreographer.getInstance();
+    private final Handler handler = new Handler(Looper.getMainLooper());
+    private final float[] point = new float[2];
+    private final int[] location = new int[2];
+    private final long[] intervals = new long[512];
+    private final ContentObserver scaleObserver = new ContentObserver(handler) {
+        @Override public void onChange(boolean selfChange) { if (disabled()) stop(); }
+    };
+    private Listener listener;
+    private boolean started, stopped, observing;
+    private long began, lastFrame, frames, draws, workNanos, drawNanos;
+    private float originX, originY, corner;
+    private final Runnable expire = new Runnable() { @Override public void run() { stop(); } };
+    private final long deadline;
+
+    public ParticleEmitter(View target, boolean overlay, int[] colors, int shape, int source,
+            double rate, double lifetimeMs, float size, float velocity, float velocityRange,
+            float angle, float spread, float gravity, float spin, float spinRange,
+            boolean fade, double durationMs, Listener listener) {
+        this.target = target; this.host = overlay ? target.getRootView() : target; this.overlay = overlay;
+        this.listener = listener;
+        density = target.getResources().getDisplayMetrics().density;
+        simulation = new ParticleSimulation(colors, shape, source, rate, lifetimeMs, size,
+                velocity, velocityRange, angle, spread, gravity, spin, spinRange, fade, durationMs, System.nanoTime());
+        deadline = durationMs < 0 ? -1 : (long)Math.ceil(durationMs + lifetimeMs);
+    }
+
+    private boolean disabled() {
+        return target != null && Settings.Global.getFloat(target.getContext().getContentResolver(),
+                Settings.Global.ANIMATOR_DURATION_SCALE, 1) == 0;
+    }
+    private boolean valid() {
+        return target != null && target.isAttachedToWindow() && target.getWindowVisibility() == View.VISIBLE
+                && target.isShown() && target.getWidth() > 0 && target.getHeight() > 0
+                && host.getWindowToken() != null && host.getWindowToken() == target.getWindowToken()
+                && (!overlay || host == target.getRootView());
+    }
+    public void start() {
+        if (started || stopped) return;
+        if (!valid() || disabled()) { stop(); return; }
+        started = true; activeCount++;
+        began = SystemClock.uptimeMillis();
+        if (overlay) {
+            // Convert the center through transforms and parent scrolling into root-overlay coordinates.
+            point[0] = target.getWidth() * .5f; point[1] = target.getHeight() * .5f;
+            View current = target;
+            while (current != host) {
+                current.getMatrix().mapPoints(point);
+                point[0] += current.getLeft(); point[1] += current.getTop();
+                ViewParent parent = current.getParent();
+                if (!(parent instanceof View)) { stop(); return; }
+                current = (View)parent;
+                point[0] -= current.getScrollX(); point[1] -= current.getScrollY();
+            }
+            originX = point[0]; originY = point[1];
+        }
+        target.addOnAttachStateChangeListener(this);
+        target.getContext().getContentResolver().registerContentObserver(
+                Settings.Global.getUriFor(Settings.Global.ANIMATOR_DURATION_SCALE), false, scaleObserver);
+        observing = true;
+        setBounds(0, 0, host.getWidth(), host.getHeight());
+        host.getOverlay().add(this);
+        if (deadline >= 0) handler.postDelayed(expire, deadline);
+        choreographer.postFrameCallback(this);
+    }
+
+    /** Layout/identity checks at JS boundaries; moving views otherwise stay in their native overlay. */
+    public void refresh(float cornerPixels) {
+        corner = Math.max(0, cornerPixels);
+        if (!stopped && started && !valid()) stop();
+    }
+    @Override public void doFrame(long frameTimeNanos) {
+        if (stopped) return;
+        long workStart = System.nanoTime();
+        if (!valid()) { stop(); return; }
+        if (lastFrame != 0) intervals[(int)((frames - 1) % intervals.length)] = frameTimeNanos - lastFrame;
+        lastFrame = frameTimeNanos; frames++;
+        // Deliberately use monotonic wall time: UI stalls cannot extend emission/lifetime deadlines.
+        simulation.advance((SystemClock.uptimeMillis() - began) / 1000d,
+                overlay ? 0 : target.getWidth() / density, overlay ? 0 : target.getHeight() / density);
+        if (simulation.finished()) { stop(); return; }
+        if (getBounds().width() != host.getWidth() || getBounds().height() != host.getHeight())
+            setBounds(0, 0, host.getWidth(), host.getHeight());
+        invalidateSelf();
+        workNanos += System.nanoTime() - workStart;
+        choreographer.postFrameCallback(this);
+    }
+
+    @Override public void draw(Canvas canvas) {
+        if (stopped) return;
+        long drawStart = System.nanoTime(); draws++;
+        int save = canvas.save();
+        // The overlay is above this host's content, bounded by the host/window viewport.
+        canvas.clipRect(getBounds());
+        if (!overlay && corner > 0) {
+            // A retained path avoids allocating rounded clips per frame.
+            clip.rewind();
+            rect.set(getBounds());
+            clip.addRoundRect(rect, corner, corner, android.graphics.Path.Direction.CW);
+            canvas.clipPath(clip);
+        }
+        if (overlay) canvas.translate(originX, originY);
+        canvas.scale(density, density);
+        float size = simulation.size, radius = size * .5f;
+        paint.setStyle(simulation.shape == 2 ? Paint.Style.STROKE : Paint.Style.FILL);
+        paint.setStrokeWidth(size * (3f / 32));
+        for (int i = 0, count = simulation.live(); i < count; i++) {
+            paint.setColor(simulation.color(i));
+            float x = simulation.x(i), y = simulation.y(i);
+            if (simulation.shape == 1) {
+                int particleSave = canvas.save();
+                canvas.rotate(simulation.rotation(i), x, y);
+                canvas.drawRect(x - radius, y - size * (9f / 32), x + radius, y + size * (9f / 32), paint);
+                canvas.restoreToCount(particleSave);
+            } else canvas.drawCircle(x, y, simulation.shape == 2 ? size * (14f / 32) : radius, paint);
+        }
+        canvas.restoreToCount(save);
+        drawNanos += System.nanoTime() - drawStart;
+    }
+    private final android.graphics.Path clip = new android.graphics.Path();
+    private final android.graphics.RectF rect = new android.graphics.RectF();
+
+    public void stop() {
+        if (stopped) return;
+        stopped = true;
+        choreographer.removeFrameCallback(this);
+        handler.removeCallbacks(expire);
+        if (observing) target.getContext().getContentResolver().unregisterContentObserver(scaleObserver);
+        observing = false;
+        if (started) { activeCount--; target.removeOnAttachStateChangeListener(this); host.getOverlay().remove(this); }
+        simulation.clear();
+        setCallback(null);
+        target = host = null;
+        Listener done = listener; listener = null;
+        if (done != null) done.onEnd();
+    }
+    @Override public void onViewAttachedToWindow(View view) { }
+    @Override public void onViewDetachedFromWindow(View view) { stop(); }
+    @Override public void setAlpha(int alpha) { }
+    @Override public void setColorFilter(ColorFilter filter) { paint.setColorFilter(filter); }
+    @Override public int getOpacity() { return PixelFormat.TRANSLUCENT; }
+
+    // Native conformance/diagnostics. Reads allocate only when explicitly requested, never per frame.
+    public static int getActiveCount() { return activeCount; }
+    public boolean isStopped() { return stopped; }
+    public int getLiveCount() { return simulation.live(); }
+    public int getPeakCount() { return simulation.peak(); }
+    public int getCapacity() { return simulation.capacity(); }
+    public long getEmittedCount() { return simulation.emitted(); }
+    public long getSkippedCount() { return simulation.skipped(); }
+    public long getFrameCount() { return frames; }
+    public long getDrawCount() { return draws; }
+    public long getWorkNanos() { return workNanos; }
+    public long getDrawNanos() { return drawNanos; }
+    public float getDensity() { return density; }
+    public double getTimeSeconds() { return simulation.time(); }
+    public boolean isObserving() { return observing; }
+    public float[] getOriginInWindow() {
+        if (host != null) host.getLocationInWindow(location);
+        return new float[] { originX + location[0], originY + location[1] };
+    }
+    public float[] getParticle(int index) { return new float[] { simulation.x(index), simulation.y(index), simulation.rotation(index), simulation.color(index) }; }
+    public long[] getFrameIntervals() {
+        int count = (int)Math.min(Math.max(0, frames - 1), intervals.length);
+        return java.util.Arrays.copyOf(intervals, count);
+    }
+}

package/platforms/android/java/org/rafaelaugusto/jolt/ParticleSimulation.java

@@ -0,0 +1,114 @@
+package org.rafaelaugusto.jolt;
+
+/** Bounded, allocation-free particle state. Units are DIPs, seconds and degrees.
+ * Android supplies elapsed wall time; the same engine runs in deterministic JVM tests. */
+public final class ParticleSimulation {
+    public static final int MAX_PARTICLES = 10000;
+    public final int shape, source;
+    public final float size;
+    private final int[] palette;
+    private final double rate, lifetime, duration;
+    private final float velocity, velocityRange, angle, spread, gravity, spin, spinRange;
+    private final boolean fade;
+    private double[] births;
+    private float[] xs, ys, vxs, vys, rotations, spins;
+    private int[] colors;
+    private int live, peak;
+    private long scheduled, emitted, skipped;
+    private long random;
+    private double time;
+
+    public ParticleSimulation(int[] palette, int shape, int source, double rate,
+            double lifetimeMs, float size, float velocity, float velocityRange,
+            float angle, float spread, float gravity, float spin, float spinRange,
+            boolean fade, double durationMs, long seed) {
+        if (palette == null || palette.length == 0 || palette.length > 32 || shape < 0 || shape > 2 || source < 0 || source > 2)
+            throw new IllegalArgumentException("Invalid particle colors, shape or source");
+        if (!finite(rate) || rate <= 0 || rate > 50000 || !finite(lifetimeMs) || lifetimeMs < 1 || lifetimeMs > 60000
+                || !finite(durationMs) || (durationMs != -1 && (durationMs < 1 || durationMs > Integer.MAX_VALUE - lifetimeMs - 50))
+                || !finite(size) || size < 1 || size > 128 || !finite(velocity) || velocity < 0 || velocity > 10000
+                || !finite(velocityRange) || velocityRange < 0 || velocityRange > 10000
+                || !finite(angle) || Math.abs(angle) > 360 || !finite(spread) || spread < 0 || spread > 360
+                || !finite(gravity) || Math.abs(gravity) > 10000 || !finite(spin) || Math.abs(spin) > 3600
+                || !finite(spinRange) || spinRange < 0 || spinRange > 3600)
+            throw new IllegalArgumentException("Invalid particle settings");
+        this.palette = palette.clone();
+        this.shape = shape; this.source = source; this.rate = rate;
+        lifetime = lifetimeMs / 1000; duration = durationMs < 0 ? Double.POSITIVE_INFINITY : durationMs / 1000;
+        this.size = size; this.velocity = velocity; this.velocityRange = velocityRange;
+        this.angle = angle; this.spread = spread; this.gravity = gravity;
+        this.spin = spin; this.spinRange = spinRange; this.fade = fade;
+        random = seed == 0 ? 1 : seed;
+        double population = rate * Math.min(lifetime, duration);
+        if (population > MAX_PARTICLES + 0.000001) throw new IllegalArgumentException("Particle population exceeds 10000");
+        int capacity = Math.max(1, Math.min(MAX_PARTICLES, (int)Math.ceil(population)));
+        births = new double[capacity]; xs = new float[capacity]; ys = new float[capacity];
+        vxs = new float[capacity]; vys = new float[capacity]; rotations = new float[capacity];
+        spins = new float[capacity]; colors = new int[capacity];
+    }
+
+    private static boolean finite(double value) { return !Double.isNaN(value) && !Double.isInfinite(value); }
+    private float unit() {
+        // xorshift64*: deterministic internal seed, never part of the public JS contract.
+        random ^= random >>> 12; random ^= random << 25; random ^= random >>> 27;
+        return ((random * 2685821657736338717L) >>> 40) / 16777216f;
+    }
+    private float variation(float range) { return (unit() * 2 - 1) * range; }
+
+    /** Advance directly to the current time, skipping already-dead births after a stall.
+     * No backlog of expired particles and no integration steps proportional to missed frames. */
+    public void advance(double elapsedSeconds, float width, float height) {
+        if (births == null || !finite(elapsedSeconds)) return;
+        time = Math.max(time, Math.max(0, elapsedSeconds));
+        for (int i = live - 1; i >= 0; i--) {
+            if (time - births[i] >= lifetime - 0.000000001) {
+                int last = --live;
+                births[i] = births[last]; xs[i] = xs[last]; ys[i] = ys[last];
+                vxs[i] = vxs[last]; vys[i] = vys[last]; rotations[i] = rotations[last];
+                spins[i] = spins[last]; colors[i] = colors[last];
+            }
+        }
+        long until = (long)Math.floor(Math.min(time, duration) * rate + 0.0000001);
+        long dead = Math.min(until, (long)Math.floor(Math.max(0, time - lifetime) * rate + 0.0000001));
+        if (dead > scheduled) { skipped += dead - scheduled; scheduled = dead; }
+        // scheduled is monotonic; at most capacity particles can be alive in this interval.
+        while (scheduled < until) {
+            long index = ++scheduled;
+            if (live >= births.length) { skipped++; continue; }
+            int i = live++;
+            births[i] = index / rate;
+            xs[i] = source == 0 ? width * .5f : unit() * width;
+            ys[i] = source == 1 ? 0 : source == 2 ? height : height * .5f;
+            double direction = Math.toRadians(angle + variation(spread * .5f));
+            float speed = velocity + variation(velocityRange);
+            vxs[i] = (float)Math.cos(direction) * speed;
+            vys[i] = (float)Math.sin(direction) * speed;
+            rotations[i] = shape == 1 ? unit() * 360 : 0;
+            spins[i] = spin + variation(spinRange);
+            colors[i] = palette[(int)((index - 1) % palette.length)];
+            emitted++;
+        }
+        peak = Math.max(peak, live);
+    }
+
+    public float x(int i) { return xs[i] + vxs[i] * (float)(time - births[i]); }
+    public float y(int i) { float age = (float)(time - births[i]); return ys[i] + vys[i] * age + gravity * age * age * .5f; }
+    public float rotation(int i) { return rotations[i] + spins[i] * (float)(time - births[i]); }
+    public int color(int i) {
+        int color = colors[i];
+        if (!fade) return color;
+        int alpha = Math.round((color >>> 24) * (float)Math.max(0, 1 - (time - births[i]) / lifetime));
+        return (color & 0x00ffffff) | (alpha << 24);
+    }
+    public boolean finished() { return time >= duration + lifetime || (time >= duration && live == 0); }
+    public int live() { return live; }
+    public int peak() { return peak; }
+    public int capacity() { return births == null ? 0 : births.length; }
+    public long emitted() { return emitted; }
+    public long skipped() { return skipped; }
+    public double time() { return time; }
+    public void clear() {
+        live = 0;
+        births = null; xs = ys = vxs = vys = rotations = spins = null; colors = null;
+    }
+}

package/platforms/android/java/org/rafaelaugusto/jolt/PredictiveBackSession.java

@@ -0,0 +1,212 @@
+package org.rafaelaugusto.jolt;
+
+import android.os.Build;
+import android.os.SystemClock;
+import android.view.Choreographer;
+import android.view.View;
+import androidx.activity.BackEventCompat;
+import androidx.activity.OnBackPressedCallback;
+import androidx.activity.OnBackPressedDispatcherOwner;
+import androidx.activity.ViewTreeOnBackPressedDispatcherOwner;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleOwner;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/** AndroidX owns system input. Progress, presentation and spring settlement never cross JS. */
+public final class PredictiveBackSession extends OnBackPressedCallback implements
+        Choreographer.FrameCallback, View.OnAttachStateChangeListener, View.OnLayoutChangeListener, LifecycleEventObserver {
+    public interface Listener { void onState(int state, double progress, double velocity, int edge); }
+    // idle=0, tracking=1, cancelling=2, finishing=3, awaiting commit=4, cancelled=5, completed=6, disposed=7.
+    private final View view;
+    private final OnBackPressedDispatcherOwner owner;
+    private Listener listener;
+    private SharedNavigationScene sharedScene;
+    public void setSharedScene(SharedNavigationScene scene) { if(captured || disposed)throw new IllegalStateException("Attach shared presentation before back begins."); sharedScene=scene; }
+    private final SpringState spring = new SpringState(0, 0);
+    private final double stiffness, damping, mass;
+    private final float density, dx, dy, sx, sy, opacity, rotation;
+    private final boolean mirror;
+    private float baseX, baseY, baseSX, baseSY, baseAlpha, baseRotation;
+    private int width, height, rootWidth, rootHeight, edge = -1, phase;
+    private boolean captured, connected, disposed, scheduled, reduced, inputEnabled = true, ignorePress;
+    private double target, speed = 1;
+    private long lastProgressAt, previousFrame, settleAt;
+    private static int callbacks, active, progressEvents;
+
+    public static PredictiveBackSession attach(View view, String options, Listener listener) {
+        if (Build.VERSION.SDK_INT < 34 || view == null || !view.isAttachedToWindow()) return null;
+        OnBackPressedDispatcherOwner owner = ViewTreeOnBackPressedDispatcherOwner.get(view);
+        if (owner == null || !owner.getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED)) return null;
+        return new PredictiveBackSession(view, owner, options, listener);
+    }
+    private PredictiveBackSession(View view, OnBackPressedDispatcherOwner owner, String options, Listener listener) {
+        super(false);
+        this.view = view; this.owner = owner; this.listener = listener;
+        density = view.getResources().getDisplayMetrics().density;
+        try {
+            JSONObject config = new JSONObject(options), values = config.getJSONObject("values");
+            dx = end(values, "x", 0) * density; dy = end(values, "y", 0) * density;
+            sx = end(values, "scaleX", end(values, "scale", 1)); sy = end(values, "scaleY", end(values, "scale", 1));
+            opacity = end(values, "opacity", 1); rotation = end(values, "rotate", 0);
+            stiffness = config.getDouble("stiffness"); damping = config.getDouble("damping"); mass = config.getDouble("mass");
+            if (!Float.isFinite(dx) || !Float.isFinite(dy) || !Float.isFinite(sx) || !Float.isFinite(sy) || !Float.isFinite(opacity) || !Float.isFinite(rotation))
+                throw new IllegalArgumentException("Predictive back endpoints exceed native float bounds.");
+            mirror = config.getBoolean("mirrorX"); reduced = config.getBoolean("reduced"); speed = config.getDouble("timeScale");
+            inputEnabled = config.getBoolean("enabled");
+        } catch (Exception error) { throw new IllegalArgumentException(error); }
+        connected = true; callbacks++;
+        owner.getOnBackPressedDispatcher().addCallback(owner, this);
+        owner.getLifecycle().addObserver(this);
+        view.addOnAttachStateChangeListener(this); view.addOnLayoutChangeListener(this);
+        setEnabled(inputEnabled);
+    }
+    private static float end(JSONObject values, String key, float fallback) throws Exception {
+        JSONArray pair = values.optJSONArray(key);
+        return pair == null ? fallback : (float)pair.getDouble(1);
+    }
+    public static int callbackCount() { return callbacks; }
+    public static int activeCount() { return active; }
+    public static int progressEventCount() { return progressEvents; }
+    public double getProgress() { return spring.position; }
+    public void setMotion(boolean reduced, double timeScale) {
+        this.reduced = reduced; this.speed = timeScale;
+        if (reduced && captured) {
+            if (phase == 1 || phase == 2) { cancel(); finish(); }
+            else if (phase == 3) finish();
+            else if (phase == 4) apply();
+        }
+    }
+    public void setInputEnabled(boolean enabled) {
+        inputEnabled = enabled;
+        if (!enabled && (phase == 1 || phase == 2)) { cancel(); finish(); }
+        if (!disposed) setEnabled(enabled);
+    }
+    private void emit(int state) {
+        if (listener != null) listener.onState(state, spring.position, spring.velocity, edge);
+    }
+    private void capture() {
+        if (captured) return;
+        captured = true; active++;
+        if(sharedScene!=null && !reduced)sharedScene.begin();
+        baseX = view.getTranslationX(); baseY = view.getTranslationY();
+        baseSX = view.getScaleX(); baseSY = view.getScaleY(); baseAlpha = view.getAlpha(); baseRotation = view.getRotation();
+        width = view.getWidth(); height = view.getHeight();
+        rootWidth = view.getRootView().getWidth(); rootHeight = view.getRootView().getHeight();
+    }
+    private void restore() {
+        if (!captured) return;
+        view.setTranslationX(baseX); view.setTranslationY(baseY);
+        view.setScaleX(baseSX); view.setScaleY(baseSY); view.setAlpha(baseAlpha); view.setRotation(baseRotation);
+        if(sharedScene!=null)sharedScene.finish();
+        captured = false; active--;
+    }
+    @Override public void handleOnBackStarted(BackEventCompat event) {
+        if (disposed || !inputEnabled || phase == 3 || phase == 4) return;
+        if (phase == 2) { finish(); if (disposed || phase != 0) return; }
+        ignorePress = false;
+        capture(); phase = 1; edge = event.getSwipeEdge(); spring.position = 0; spring.velocity = 0;
+        lastProgressAt = SystemClock.uptimeMillis(); apply(); emit(1);
+    }
+    @Override public void handleOnBackProgressed(BackEventCompat event) {
+        if (disposed || phase != 1 || ignorePress) return;
+        progressEvents++;
+        long now = SystemClock.uptimeMillis();
+        double next = Math.max(0, Math.min(1, event.getProgress()));
+        spring.velocity = now > lastProgressAt ? (next - spring.position) * 1000 / (now - lastProgressAt) : spring.velocity;
+        lastProgressAt = now; spring.position = next;
+        if (!validGeometry()) { cancel(); return; }
+        apply();
+    }
+    @Override public void handleOnBackCancelled() {
+        if (disposed) return;
+        ignorePress = false;
+        if (phase == 1) settle(false);
+    }
+    @Override public void handleOnBackPressed() {
+        if (disposed || !inputEnabled || phase == 3 || phase == 4) return;
+        if (ignorePress) { ignorePress = false; return; }
+        if (phase == 2) { finish(); if (disposed || phase != 0) return; }
+        if (!captured) { capture(); edge = -1; spring.position = 0; spring.velocity = 0; }
+        settle(true);
+    }
+    private void settle(boolean commit) {
+        if (disposed || !captured || phase == 4) return;
+        if (SystemClock.uptimeMillis() - lastProgressAt > 100) spring.velocity = 0;
+        phase = commit ? 3 : 2; target = commit ? 1 : 0;
+        settleAt = SystemClock.uptimeMillis(); previousFrame = 0;
+        emit(phase);
+        if (disposed || !captured || (phase != 2 && phase != 3)) return;
+        if (reduced) finish(); else schedule();
+    }
+    private void apply() {
+        double p = reduced ? 0 : Math.max(0, Math.min(1, spring.position));
+        if(sharedScene!=null && sharedScene.isAnimating()){sharedScene.render(p);return;}
+        float direction = mirror && edge == BackEventCompat.EDGE_RIGHT ? -1 : 1;
+        view.setTranslationX(baseX + (float)p * dx * direction); view.setTranslationY(baseY + (float)p * dy);
+        view.setScaleX(baseSX * (float)(1 + (sx - 1) * p)); view.setScaleY(baseSY * (float)(1 + (sy - 1) * p));
+        view.setAlpha(baseAlpha * (float)(1 + (opacity - 1) * p)); view.setRotation(baseRotation + (float)p * rotation * direction);
+    }
+    private boolean validGeometry() {
+        return (sharedScene==null || sharedScene.validActive()) && view.isAttachedToWindow() && view.getWidth() == width && view.getHeight() == height &&
+            view.getRootView().getWidth() == rootWidth && view.getRootView().getHeight() == rootHeight;
+    }
+    private void schedule() {
+        if (scheduled || disposed || (phase != 2 && phase != 3)) return;
+        scheduled = true; Choreographer.getInstance().postFrameCallback(this);
+    }
+    private void unschedule() { Choreographer.getInstance().removeFrameCallback(this); scheduled = false; }
+    @Override public void doFrame(long nanos) {
+        scheduled = false;
+        if (disposed || (phase != 2 && phase != 3)) return;
+        if (!validGeometry()) { cancel(); finish(); return; }
+        double seconds = previousFrame == 0 ? 1.0 / 60 : Math.max(0, (nanos - previousFrame) / 1e9);
+        previousFrame = nanos;
+        spring.advance(target, stiffness * speed * speed, damping * speed, mass, seconds);
+        if (!Double.isFinite(spring.position) || !Double.isFinite(spring.velocity)) { finish(); return; }
+        apply();
+        if ((Math.abs(spring.position - target) < .0005 && Math.abs(spring.velocity) < .005) || SystemClock.uptimeMillis() - settleAt >= 1500) finish();
+        else schedule();
+    }
+    private void finish() {
+        if (disposed || (phase != 2 && phase != 3)) return;
+        unschedule(); boolean commit = phase == 3;
+        spring.position = commit ? 1 : 0; spring.velocity = 0; apply();
+        if (commit) { phase = 4; emit(4); }
+        else { restore(); phase = 0; emit(5); }
+    }
+    public void completeCommit(boolean accepted) {
+        if (disposed || phase != 4) return;
+        if (accepted) { restore(); emit(6); dispose(); }
+        else if (!view.isAttachedToWindow()) { restore(); emit(5); dispose(); }
+        else { phase = 1; settle(false); }
+    }
+    public void cancel() {
+        if (disposed || phase == 4 || phase == 3) return; // Once released, preserve Android's committed decision.
+        if (phase == 1) { ignorePress = true; spring.velocity = 0; settle(false); }
+    }
+    private void disconnect() {
+        if (!connected) return;
+        connected = false; callbacks--; remove(); owner.getLifecycle().removeObserver(this);
+        view.removeOnAttachStateChangeListener(this); view.removeOnLayoutChangeListener(this);
+    }
+    public void dispose() {
+        if (disposed) return;
+        disposed = true; unschedule(); restore(); disconnect(); phase = 0; emit(7); listener = null; sharedScene = null;
+    }
+    @Override public void onViewDetachedFromWindow(View v) {
+        if (phase == 4) { restore(); disconnect(); } else dispose();
+    }
+    @Override public void onViewAttachedToWindow(View v) { }
+    @Override public void onLayoutChange(View v, int l, int t, int r, int b, int ol, int ot, int or, int ob) {
+        if (captured && !validGeometry()) { cancel(); finish(); }
+    }
+    @Override public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
+        if (event == Lifecycle.Event.ON_DESTROY) dispose();
+        else if (event == Lifecycle.Event.ON_STOP && captured && phase != 4) {
+            // Lifecycle callbacks unregister input until STARTED; keep the handle reusable on resume.
+            phase = 2; ignorePress = true; finish();
+        }
+    }
+}