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

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();
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+package org.rafaelaugusto.jolt;
+
+import android.content.Context;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.widget.Button;
+
+/** A focusable button with explicit keyboard move actions. */
+public final class ReorderHandle extends Button {
+    public interface MoveListener { void move(int direction); }
+    private MoveListener move;
+    public ReorderHandle(Context context) { super(context); setFocusable(true); setFocusableInTouchMode(true); }
+    public void setMoveListener(MoveListener value) { move = value; }
+    @Override public boolean onTouchEvent(MotionEvent event) {
+        if (event.getActionMasked() == MotionEvent.ACTION_DOWN) requestFocus();
+        return super.onTouchEvent(event);
+    }
+    @Override public boolean onKeyDown(int code, KeyEvent event) {
+        if (event.isAltPressed() && move != null && (code == KeyEvent.KEYCODE_DPAD_UP || code == KeyEvent.KEYCODE_DPAD_DOWN)) {
+            if (event.getRepeatCount() == 0) move.move(code == KeyEvent.KEYCODE_DPAD_UP ? -1 : 1);
+            return true;
+        }
+        return super.onKeyDown(code, event);
+    }
+}

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

@@ -0,0 +1,213 @@
+package org.rafaelaugusto.jolt;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.view.Choreographer;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.ListView;
+import org.json.JSONObject;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+/** Core ListView input, snapshot, recycling and edge autoscroll stay on the UI thread. */
+public final class ReorderSession implements View.OnTouchListener, Choreographer.FrameCallback, View.OnLayoutChangeListener, View.OnAttachStateChangeListener {
+    public interface Listener { void onState(int state, int index, int toIndex); }
+    private static final class Cell {
+        final float translation, alpha;
+        final int index;
+        final SpringState spring = new SpringState(0, 0);
+        Cell(View view, int index) { this.translation = view.getTranslationY(); this.alpha = view.getAlpha(); this.index = index; }
+    }
+    final ListView list;
+    private final ReorderSurface surface;
+    private final Listener listener;
+    private final WeakHashMap<View, Cell> cells = new WeakHashMap<>();
+    private final Set<View> handles = Collections.newSetFromMap(new WeakHashMap<View, Boolean>());
+    private final float density, edgeSize, edgeSpeed, slop;
+    private final long longPress;
+    private final boolean handlesOnly;
+    private final Runnable activate = () -> begin();
+    private boolean enabled = true, disposed, active, settling, pending, reduced;
+    private int from, target, count, generation, width, height;
+    private float downX, downY, pointerX, pointerY, grabOffset, rowHeight, remainder;
+    private long previousTime;
+    private ImageView overlay;
+    private Bitmap bitmap;
+    private ValueAnimator drop;
+
+    public ReorderSession(ReorderSurface surface, ListView list, String options, Listener listener) {
+        this.surface = surface; this.list = list; this.listener = listener;
+        density = list.getResources().getDisplayMetrics().density;
+        slop = ViewConfiguration.get(list.getContext()).getScaledTouchSlop();
+        try {
+            JSONObject config = new JSONObject(options);
+            longPress = config.getLong("longPress"); edgeSize = (float)config.getDouble("edgeSize") * density;
+            edgeSpeed = (float)config.getDouble("edgeSpeed") * density;
+            reduced = config.getBoolean("reducedMotion"); handlesOnly = config.getBoolean("handles");
+        } catch (Exception error) { throw new IllegalArgumentException(error); }
+        surface.setSession(this); list.addOnLayoutChangeListener(this); list.addOnAttachStateChangeListener(this);
+    }
+    public boolean isActive() { return active; }
+    public void registerHandle(View view) {
+        if (!disposed && view != null) {
+            handles.add(view);
+        }
+    }
+    private boolean inHandle(float x, float y) {
+        if (!handlesOnly) return true;
+        Rect rect = new Rect();
+        for (View handle : handles) {
+            if (handle == null || !handle.isShown()) continue;
+            android.view.ViewParent parent = handle.getParent();
+            while (parent != null && parent != list) parent = parent.getParent();
+            if (parent != list) continue;
+            handle.getDrawingRect(rect); list.offsetDescendantRectToMyCoords(handle, rect);
+            if (rect.contains((int)x, (int)y)) return true;
+        }
+        return false;
+    }
+    @Override public boolean onTouch(View view, MotionEvent event) {
+        if (disposed) return false;
+        int action = event.getActionMasked();
+        if (action == MotionEvent.ACTION_DOWN) {
+            cancel();
+            downX = pointerX = event.getX(); downY = pointerY = event.getY();
+            if (enabled && list.isEnabled() && inHandle(downX, downY) && list.pointToPosition((int)downX, (int)downY) >= 0) {
+                pending = true; list.postDelayed(activate, longPress);
+            }
+        }
+        if (event.getPointerCount() > 1) { boolean handled = active; cancel(); return handled; }
+        if (action == MotionEvent.ACTION_MOVE) {
+            pointerX = event.getX(); pointerY = event.getY();
+            if (pending && Math.hypot(pointerX - downX, pointerY - downY) > slop) clearPending();
+            if (active && !settling) update(0);
+        }
+        boolean owned = active;
+        if (action == MotionEvent.ACTION_UP) { clearPending(); if (active && !settling) drop(); }
+        else if (action == MotionEvent.ACTION_CANCEL) { clearPending(); if (active) finish(false, 0); }
+        if (owned) return true;
+        return false;
+    }
+    private void clearPending() { pending = false; list.removeCallbacks(activate); }
+    private void emit(int state, int detail) { if (!disposed && listener != null) listener.onState(state, from, detail); }
+    private void begin() {
+        if (!pending || disposed || !enabled || !list.isAttachedToWindow()) return;
+        clearPending();
+        int index = list.pointToPosition((int)pointerX, (int)pointerY);
+        View cell = list.getChildAt(index - list.getFirstVisiblePosition());
+        if (cell == null || index < 0 || cell.getWidth() <= 0 || cell.getHeight() <= 0 || (long)cell.getWidth() * cell.getHeight() > 8000000) return;
+        bitmap = Bitmap.createBitmap(cell.getWidth(), cell.getHeight(), Bitmap.Config.ARGB_8888);
+        cell.draw(new Canvas(bitmap));
+        overlay = new ImageView(list.getContext()); overlay.setImageBitmap(bitmap);
+        overlay.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_NO);
+        overlay.layout(cell.getLeft(), 0, cell.getRight(), cell.getHeight());
+        overlay.setTranslationY(cell.getTop()); overlay.setElevation(12 * density);
+        list.getOverlay().add(overlay);
+        rowHeight = cell.getHeight() + list.getDividerHeight(); grabOffset = pointerY - cell.getTop();
+        width = list.getWidth(); height = list.getHeight(); count = list.getCount();
+        from = target = index; active = true; settling = false; remainder = 0; generation++;
+        // Stop the ListView's pending click/scroll, retaining this pointer stream.
+        MotionEvent cancel = MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, pointerX, pointerY, 0);
+        list.onTouchEvent(cancel); cancel.recycle();
+        if (surface.getParent() != null) surface.getParent().requestDisallowInterceptTouchEvent(true);
+        previousTime = System.nanoTime();
+        emit(1, from);
+        if (!active || disposed) return;
+        update(0); Choreographer.getInstance().postFrameCallback(this);
+    }
+    @Override public void doFrame(long time) {
+        if (!active || settling || disposed) return;
+        if (!list.isAttachedToWindow() || count != list.getCount() || width != list.getWidth() || height != list.getHeight()) { finish(false, 1); return; }
+        double dt = Math.min(.04, Math.max(0, (time - previousTime) / 1e9)); previousTime = time;
+        float edge = Math.min(edgeSize, list.getHeight() / 3f), direction = 0;
+        if (pointerY < list.getPaddingTop() + edge) direction = -Math.min(1, (list.getPaddingTop() + edge - pointerY) / edge);
+        else if (pointerY > list.getHeight() - list.getPaddingBottom() - edge) direction = Math.min(1, (pointerY - list.getHeight() + list.getPaddingBottom() + edge) / edge);
+        float distance = (float)(direction * edgeSpeed * dt) + remainder;
+        int pixels = (int)distance; remainder = distance - pixels;
+        if (pixels != 0) list.scrollListBy(pixels);
+        update(dt);
+        if (active) Choreographer.getInstance().postFrameCallback(this);
+    }
+    private void restore(View view, Cell state) { view.setTranslationY(state.translation); view.setAlpha(state.alpha); }
+    private void update(double dt) {
+        if (!active || settling) return;
+        float top = pointerY - grabOffset;
+        overlay.setTranslationY(top);
+        int first = list.getFirstVisiblePosition(), visible = list.getChildCount(), destination = from;
+        for (int offset = 0; offset < visible; offset++) {
+            int index = first + offset; if (index == from) continue;
+            View view = list.getChildAt(offset);
+            float midpoint = view.getTop() + view.getHeight() / 2f - (index > from ? rowHeight : 0);
+            int insertion = index - (index > from ? 1 : 0);
+            destination = insertion;
+            if (top < midpoint) break;
+            destination = insertion + 1;
+        }
+        target = Math.max(0, Math.min(count - 1, destination));
+        for (View view : new ArrayList<>(cells.keySet())) {
+            int index = list.getPositionForView(view);
+            Cell state = cells.get(view);
+            if (index < first || index >= first + visible || index != state.index) { restore(view, state); cells.remove(view); }
+        }
+        for (int offset = 0; offset < visible; offset++) {
+            int index = first + offset; View view = list.getChildAt(offset);
+            Cell state = cells.get(view);
+            if (state == null) { state = new Cell(view, index); cells.put(view, state); }
+            float displacement = index > from && index <= target ? -rowHeight : index < from && index >= target ? rowHeight : 0;
+            if (reduced) { state.spring.position = displacement; state.spring.velocity = 0; }
+            else state.spring.advance(displacement, 360, 34, 1, dt);
+            view.setTranslationY(state.translation + (float)state.spring.position);
+            view.setAlpha(index == from ? 0 : state.alpha);
+        }
+    }
+    private void drop() {
+        if (!active || settling) return;
+        settling = true; Choreographer.getInstance().removeFrameCallback(this);
+        View destination = list.getChildAt(target - list.getFirstVisiblePosition());
+        float end = destination == null ? overlay.getTranslationY() : target > from ? destination.getBottom() - bitmap.getHeight() : destination.getTop();
+        if (reduced) { finish(true, 0); return; }
+        final int ticket = generation;
+        drop = ValueAnimator.ofFloat(overlay.getTranslationY(), end); drop.setDuration(180);
+        drop.addUpdateListener(animation -> { if (overlay != null) overlay.setTranslationY((float)animation.getAnimatedValue()); });
+        drop.addListener(new AnimatorListenerAdapter() {
+            @Override public void onAnimationEnd(Animator animation) { if (active && generation == ticket) finish(true, 0); }
+        });
+        drop.start();
+    }
+    private void finish(boolean commit, int detail) {
+        if (!active) return;
+        active = false; settling = false; generation++;
+        Choreographer.getInstance().removeFrameCallback(this);
+        if (drop != null) { ValueAnimator previous = drop; drop = null; previous.cancel(); }
+        if (overlay != null) { list.getOverlay().remove(overlay); overlay.setImageDrawable(null); overlay = null; }
+        if (bitmap != null) { bitmap.recycle(); bitmap = null; }
+        for (View view : new ArrayList<>(cells.keySet())) restore(view, cells.get(view));
+        cells.clear();
+        if (surface.getParent() != null) surface.getParent().requestDisallowInterceptTouchEvent(false);
+        emit(commit ? 2 : 3, commit ? target : detail);
+    }
+    public void cancel() { clearPending(); finish(false, 0); }
+    public void setEnabled(boolean value) { enabled = value; if (!value) cancel(); }
+    public void setReducedMotion(boolean value) { reduced = value; }
+    @Override public void onLayoutChange(View view, int l, int t, int r, int b, int ol, int ot, int or, int ob) {
+        if (active && (r - l != width || b - t != height)) finish(false, 1);
+    }
+    @Override public void onViewDetachedFromWindow(View view) { cancel(); }
+    @Override public void onViewAttachedToWindow(View view) {}
+    public void dispose() {
+        if (disposed) return;
+        cancel(); disposed = true; surface.setSession(null);
+        list.removeOnLayoutChangeListener(this); list.removeOnAttachStateChangeListener(this);
+        handles.clear();
+    }
+}

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

@@ -0,0 +1,27 @@
+package org.rafaelaugusto.jolt;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.view.MotionEvent;
+
+/** Capture input above recycled cells without replacing any Core touch listener. */
+public final class ReorderSurface extends org.nativescript.widgets.GridLayout {
+    private ReorderSession session;
+    public ReorderSurface(Context context) { super(context); }
+    void setSession(ReorderSession value) { session = value; }
+    @Override public boolean dispatchTouchEvent(MotionEvent event) {
+        ReorderSession current = session;
+        if (current != null) {
+            Rect rect = new Rect(); current.list.getDrawingRect(rect);
+            offsetDescendantRectToMyCoords(current.list, rect);
+            MotionEvent local = MotionEvent.obtain(event); local.offsetLocation(-rect.left, -rect.top);
+            current.onTouch(current.list, local); local.recycle();
+        }
+        return super.dispatchTouchEvent(event) || current != null;
+    }
+    @Override public boolean onInterceptTouchEvent(MotionEvent event) {
+        return session != null && session.isActive() || super.onInterceptTouchEvent(event);
+    }
+    @Override public boolean onTouchEvent(MotionEvent event) { return session != null || super.onTouchEvent(event); }
+    @Override protected void onDetachedFromWindow() { if (session != null) session.cancel(); super.onDetachedFromWindow(); }
+}

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

@@ -0,0 +1,84 @@
+package org.rafaelaugusto.jolt;
+
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.widget.ListView;
+import android.widget.TextView;
+import org.json.JSONObject;
+
+/** Native ListView input; does not replace Core's adapter, item listener or scroll listener. */
+public final class ScrollHeader implements ViewTreeObserver.OnScrollChangedListener, View.OnLayoutChangeListener {
+    public interface Listener { void changed(); }
+    private static int active;
+    public static int activeCount(){return active;}
+    private final ListView list;
+    private LiveSpring node;
+    private Listener listener;
+    private final View title, toolbarTitle, toolbar;
+    private final TextView diagnostic;
+    private final int titleAccessibility, toolbarAccessibility;
+    private final int toolbarVisibility;
+    private final float density;
+    private ViewTreeObserver observer;
+    private boolean enabled, disposed;
+    private double handoff, minimumOffset, maximumOffset, fadeStart, range, spacer, rowHeight, offset=Double.NaN;
+    private int phase=-1, updates, callbacks;
+    public ScrollHeader(ListView list, LiveSpring node, View title, View toolbarTitle, View toolbar, View diagnostic, String options, Listener listener) {
+        this.list=list;this.node=node;this.title=title;this.toolbarTitle=toolbarTitle;this.toolbar=toolbar;this.listener=listener;
+        this.diagnostic=diagnostic instanceof TextView?(TextView)diagnostic:null;
+        density=list.getResources().getDisplayMetrics().density;
+        titleAccessibility=title.getImportantForAccessibility();toolbarAccessibility=toolbarTitle.getImportantForAccessibility();toolbarVisibility=toolbar.getVisibility();
+        configure(options);setEnabled(true);
+    }
+    public void configure(String options) {
+        try {JSONObject c=new JSONObject(options);handoff=c.getDouble("handoff");range=c.getDouble("range");spacer=c.getDouble("spacer");rowHeight=c.getDouble("rowHeight");fadeStart=c.getJSONArray("toolbarFade").getDouble(0)*range;}
+        catch(Exception error){throw new IllegalArgumentException(error);}
+        if(enabled)update(true);
+    }
+    public void setEnabled(boolean value) {
+        if(disposed || enabled==value)return;
+        enabled=value;
+        if(value){observer=list.getViewTreeObserver();observer.addOnScrollChangedListener(this);list.addOnLayoutChangeListener(this);active++;update(true);}
+        else{if(observer!=null && observer.isAlive())observer.removeOnScrollChangedListener(this);observer=null;list.removeOnLayoutChangeListener(this);active--;}
+    }
+    @Override public void onScrollChanged(){update(false);}
+    @Override public void onLayoutChange(View view,int l,int t,int r,int b,int ol,int ot,int or,int ob){update(true);}
+    private double current() {
+        View child=list.getChildAt(0);if(child==null)return 0;
+        int first=list.getFirstVisiblePosition();double divider=list.getDividerHeight()/density;
+        return (first==0?0:spacer+divider+(first-1)*(rowHeight+divider))+(list.getPaddingTop()-child.getTop())/density;
+    }
+    private void update(boolean force) {
+        if(disposed)return;
+        double next=current();if(!force && Math.abs(next-offset)<.001)return;
+        offset=next;minimumOffset=Math.min(minimumOffset,offset);maximumOffset=Math.max(maximumOffset,offset);updates++;node.setTarget(offset);
+        boolean compact=offset>=range*handoff;
+        title.setImportantForAccessibility(compact?View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS:titleAccessibility);
+        toolbarTitle.setImportantForAccessibility(compact?toolbarAccessibility:View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS);
+        toolbar.setVisibility(offset > fadeStart ? toolbarVisibility : View.INVISIBLE);
+        int nextPhase=offset<=.5?0:offset>=range-.5?2:1;
+        if(nextPhase!=phase){phase=nextPhase;callbacks++;if(listener!=null)listener.changed();}
+        if(diagnostic!=null)diagnostic.setText(String.format(java.util.Locale.US,"y %.0f · range %.0f · native %d · JS %d",offset,range,updates,callbacks));
+    }
+    public String snapshot() {
+        try {return new JSONObject().put("minimumOffset",minimumOffset).put("maximumOffset",maximumOffset).put("offset",Double.isFinite(offset)?offset:0).put("phase",new String[]{"expanded","between","collapsed"}[Math.max(0,phase)])
+            .put("updates",updates).put("callbacks",callbacks).put("first",list.getFirstVisiblePosition()).put("visible",list.getChildCount()).put("total",list.getCount()).toString();}
+        catch(Exception error){throw new IllegalStateException(error);}
+    }
+    public void scroll(double target,boolean animated) {
+        if(disposed || !Double.isFinite(target))return;
+        target=Math.max(0,target);
+        if(animated){list.smoothScrollBy((int)Math.round((target-current())*density),300);return;}
+        double divider=list.getDividerHeight()/density, stride=rowHeight+divider;
+        int index=target<spacer+divider?0:1+(int)Math.floor((target-spacer-divider)/stride);
+        index=Math.max(0,Math.min(list.getCount()-1,index));
+        double start=index==0?0:spacer+divider+(index-1)*stride;
+        list.setSelectionFromTop(index,(int)Math.round((start-target)*density));
+        list.post(new Runnable(){public void run(){if(!disposed)update(true);}});
+    }
+    public void dispose() {
+        if(disposed)return;setEnabled(false);disposed=true;
+        title.setImportantForAccessibility(titleAccessibility);toolbarTitle.setImportantForAccessibility(toolbarAccessibility);toolbar.setVisibility(toolbarVisibility);
+        node=null;listener=null;
+    }
+}

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

@@ -0,0 +1,28 @@
+package org.rafaelaugusto.jolt;
+/** Pure math shared by hardware and explicit test-input playback. Hamilton quaternions xyzw. */
+public final class SensorMath {
+    private SensorMath() {}
+    public static boolean normalize(double[] q) {
+        double length=0;
+        for(double v:q) { if(!Double.isFinite(v)) return false; length+=v*v; }
+        length=Math.sqrt(length);
+        if(!Double.isFinite(length)||length<1e-8) return false;
+        for(int i=0;i<4;i++) q[i]/=length;
+        return true;
+    }
+    public static double[] multiply(double[] a,double[] b) {
+        return new double[]{a[3]*b[0]+a[0]*b[3]+a[1]*b[2]-a[2]*b[1], a[3]*b[1]-a[0]*b[2]+a[1]*b[3]+a[2]*b[0], a[3]*b[2]+a[0]*b[1]-a[1]*b[0]+a[2]*b[3], a[3]*b[3]-a[0]*b[0]-a[1]*b[1]-a[2]*b[2]};
+    }
+    public static double[] inverse(double[] q) {return new double[]{-q[0],-q[1],-q[2],q[3]};}
+    public static double[] vector(double[] v,double degrees) {
+        double a=degrees*Math.PI/180,c=Math.cos(a),s=Math.sin(a);
+        return new double[]{c*v[0]+s*v[1],-s*v[0]+c*v[1],v[2]};
+    }
+    public static double[] rotation(double[] q,double degrees,double[] previous) {
+        double[] v=vector(q,degrees), r={v[0],v[1],v[2],q[3]};
+        double dot=0;for(int i=0;i<4;i++)dot+=r[i]*previous[i];
+        if(dot<0)for(int i=0;i<4;i++)r[i]=-r[i];
+        double x=r[0],y=r[1],z=r[2],w=r[3];
+        return new double[]{Math.atan2(2*(w*x+y*z),1-2*(x*x+y*y)),Math.asin(Math.max(-1,Math.min(1,2*(w*y-z*x)))),Math.atan2(2*(w*z+x*y),1-2*(y*y+z*z)),x,y,z,w};
+    }
+}