@rafaelaugusto/jolt 0.1.0-beta.15 → 0.1.0-beta.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rafaelaugusto/jolt",
-  "version": "0.1.0-beta.15",
+  "version": "0.1.0-beta.17",
   "description": "Native animations for NativeScript: presets, springs, keyframes and stagger in one call.",
   "keywords": [
     "nativescript",
@@ -34,9 +34,21 @@
       "default": "./dist/vue/index.js"
     },
     "./package.json": "./package.json",
+    "./gestures": {
+      "types": "./dist/gestures/index.d.ts",
+      "default": "./dist/gestures/index.js"
+    },
     "./native": {
       "types": "./dist/native/index.d.ts",
       "default": "./dist/native/index.js"
+    },
+    "./bottom-sheet": {
+      "types": "./dist/bottom-sheet/index.d.ts",
+      "default": "./dist/bottom-sheet/index.js"
+    },
+    "./reorder": {
+      "types": "./dist/reorder/index.d.ts",
+      "default": "./dist/reorder/index.js"
     }
   },
   "files": [

package/platforms/android/include.gradle

@@ -1,3 +1,12 @@
+// Compile against the host's widgets; the app already packages NativeScript core.
+dependencies {
+    compileOnly 'androidx.core:core:1.13.0'
+    if (project.hasProperty('tempBuild')) {
+        def widgets = new File(project.ext.USER_PROJECT_ROOT, 'node_modules/@nativescript/core/platforms/android/widgets-release.aar')
+        compileOnly files(zipTree(widgets).matching { include 'classes.jar' })
+    }
+}
+
 // Applied by the NativeScript app. Preserve fields used by the native color target.
 def joltDependency = nativescriptDependencies.find { it.name == '@rafaelaugusto/jolt' }
 if (joltDependency != null) {

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

@@ -0,0 +1,198 @@
+package org.rafaelaugusto.jolt;
+
+import android.graphics.Rect;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import org.json.JSONObject;
+import org.json.JSONException;
+
+/** Native arbitration, pointer rebasing and NestedScrollView consumption. */
+public final class GestureSession {
+    public interface Listener { void onState(int state, double velocityX, double velocityY); }
+    private final GestureSurface surface;
+    private final View scroll;
+    private final LiveSpring x, y, scale, rotation;
+    private final Listener listener;
+    private final GestureDetector taps;
+    private final double density, threshold, failOffset;
+    private final int axis;
+    private final boolean pinch, rotate, tapEnabled, doubleEnabled, contactEvents;
+    private double minX, maxX, minY, maxY, minScale, maxScale;
+    private double downX, downY, lastX, lastY, lastSpan, lastAngle, velocityX, velocityY;
+    private boolean enabled = true, disposed, active, rejected, fromScroll, contact, ending;
+    private VelocityTracker velocity;
+
+    public GestureSession(GestureSurface surface, View scroll, LiveSpring x, LiveSpring y, LiveSpring scale, LiveSpring rotation, String options, Listener listener) {
+        if (scroll != null && !(scroll instanceof androidx.core.view.NestedScrollingChild3))
+            throw new IllegalArgumentException("Scroll handoff requires NativeScript's NestedScrollView implementation");
+        this.surface = surface; this.scroll = scroll; this.x = x; this.y = y; this.scale = scale; this.rotation = rotation; this.listener = listener;
+        density = surface.getResources().getDisplayMetrics().density;
+        try {
+            JSONObject config = new JSONObject(options);
+            axis = config.getInt("axis"); threshold = config.getDouble("threshold"); failOffset = config.getDouble("failOffset");
+            pinch = config.getBoolean("pinch"); rotate = config.getBoolean("rotate");
+            tapEnabled = config.getBoolean("tap"); doubleEnabled = config.getBoolean("doubleTap");
+            contactEvents = config.optBoolean("contactEvents", false);
+            minX = config.getDouble("minX"); maxX = config.getDouble("maxX"); minY = config.getDouble("minY"); maxY = config.getDouble("maxY");
+            minScale = config.getDouble("minScale"); maxScale = config.getDouble("maxScale");
+        } catch (JSONException error) { throw new IllegalArgumentException(error); }
+        taps = new GestureDetector(surface.getContext(), new GestureDetector.SimpleOnGestureListener() {
+            @Override public boolean onDown(MotionEvent event) { return true; }
+            @Override public boolean onSingleTapUp(MotionEvent event) { if (tapEnabled && !doubleEnabled) emit(4); return true; }
+            @Override public boolean onSingleTapConfirmed(MotionEvent event) { if (tapEnabled) emit(4); return true; }
+            @Override public boolean onDoubleTapEvent(MotionEvent event) { if (event.getActionMasked() == MotionEvent.ACTION_UP) emit(5); return true; }
+        });
+        if (!doubleEnabled) taps.setOnDoubleTapListener(null);
+        surface.setSession(this);
+    }
+    public static boolean supportsContactEvents() { return true; }
+    public boolean isActive() { return active; }
+    boolean intercepts() { return enabled && active && !fromScroll; }
+    boolean accepts(View target) { return enabled && !disposed && target == scroll; }
+    private static double clamp(double value, double min, double max) { return Math.max(min, Math.min(max, value)); }
+    private void emit(int state) { if (!disposed && listener != null) listener.onState(state, velocityX, velocityY); }
+    private void begin() {
+        if (active || !enabled || disposed) return;
+        active = true;
+        x.holdInput(x.getPosition(), 0); y.holdInput(y.getPosition(), 0);
+        scale.holdInput(scale.getPosition(), 0); rotation.holdInput(rotation.getPosition(), 0);
+        if (surface.getParent() != null) surface.getParent().requestDisallowInterceptTouchEvent(true);
+        emit(1);
+    }
+    void before(MotionEvent event) {
+        if (!enabled || disposed) return;
+        if (!surface.isEnabled()) { cancel(); return; }
+        int action = event.getActionMasked();
+        if (action == MotionEvent.ACTION_DOWN) {
+            cancel(); if (disposed || !enabled) return;
+            contact = true; rejected = false; velocityX = velocityY = 0;
+            velocity = VelocityTracker.obtain();
+            fromScroll = false;
+            if (scroll != null) {
+                Rect bounds = new Rect(); scroll.getDrawingRect(bounds); surface.offsetDescendantRectToMyCoords(scroll, bounds);
+                fromScroll = bounds.contains((int)event.getX(), (int)event.getY());
+            }
+            rebase(event, -1); downX = lastX; downY = lastY;
+            if (contactEvents) emit(6);
+        }
+        if (!contact) return;
+        if (velocity != null) {
+            MotionEvent raw = MotionEvent.obtain(event);
+            raw.offsetLocation(event.getRawX() - event.getX(), event.getRawY() - event.getY());
+            velocity.addMovement(raw); raw.recycle();
+            if (action == MotionEvent.ACTION_UP) {
+                velocity.computeCurrentVelocity(1000);
+                velocityX = (axis & 1) != 0 ? velocity.getXVelocity(event.getPointerId(0)) / density : 0;
+                velocityY = (axis & 2) != 0 ? velocity.getYVelocity(event.getPointerId(0)) / density : 0;
+            }
+        }
+        if (tapEnabled || doubleEnabled) taps.onTouchEvent(event);
+        if (disposed || !enabled) return;
+        if (action == MotionEvent.ACTION_POINTER_DOWN || action == MotionEvent.ACTION_POINTER_UP) {
+            rebase(event, action == MotionEvent.ACTION_POINTER_UP ? event.getActionIndex() : -1);
+            if (!active) { downX = lastX; downY = lastY; }
+            if (velocity != null) velocity.clear();
+            if (!fromScroll && (pinch || rotate) && event.getPointerCount() >= 2 && action == MotionEvent.ACTION_POINTER_DOWN) begin();
+            return;
+        }
+        if (action != MotionEvent.ACTION_MOVE) return;
+        double cx = 0, cy = 0;
+        for (int index = 0; index < event.getPointerCount(); index++) { cx += event.getX(index); cy += event.getY(index); }
+        cx /= event.getPointerCount() * density; cy /= event.getPointerCount() * density;
+        cx += (event.getRawX() - event.getX()) / density; cy += (event.getRawY() - event.getY()) / density;
+        if (velocity != null) {
+            velocity.computeCurrentVelocity(1000);
+            velocityX = (axis & 1) != 0 ? velocity.getXVelocity(event.getPointerId(0)) / density : 0;
+            velocityY = (axis & 2) != 0 ? velocity.getYVelocity(event.getPointerId(0)) / density : 0;
+        }
+        if (!active && !fromScroll && !rejected) {
+            double dx = Math.abs(cx - downX), dy = Math.abs(cy - downY);
+            if (axis == 1 && dy > failOffset || axis == 2 && dx > failOffset) rejected = true;
+            else if (axis != 0 && (axis == 1 ? dx : axis == 2 ? dy : Math.hypot(dx, dy)) >= threshold) begin();
+        }
+        if (active && !fromScroll && !disposed) {
+            if ((axis & 1) != 0) x.holdInput(clamp(x.getPosition() + cx - lastX, minX, maxX), velocityX);
+            if ((axis & 2) != 0) y.holdInput(clamp(y.getPosition() + cy - lastY, minY, maxY), velocityY);
+            if (event.getPointerCount() >= 2) {
+                double dx = event.getX(1) - event.getX(0), dy = event.getY(1) - event.getY(0);
+                double span = Math.hypot(dx, dy), angle = Math.atan2(dy, dx);
+                if (pinch && lastSpan > 0) scale.holdInput(clamp(scale.getPosition() * span / lastSpan, minScale, maxScale), 0);
+                if (rotate && lastSpan > 0) rotation.holdInput(rotation.getPosition() + Math.atan2(Math.sin(angle - lastAngle), Math.cos(angle - lastAngle)) * 180 / Math.PI, 0);
+                lastSpan = span; lastAngle = angle;
+            }
+        }
+        lastX = cx; lastY = cy;
+    }
+    private void rebase(MotionEvent event, int excluding) {
+        double cx = 0, cy = 0; int count = 0, a = -1, b = -1;
+        for (int index = 0; index < event.getPointerCount(); index++) if (index != excluding) {
+            cx += event.getX(index); cy += event.getY(index); count++;
+            if (a < 0) a = index; else if (b < 0) b = index;
+        }
+        if (count > 0) { lastX = (cx / count + event.getRawX() - event.getX()) / density; lastY = (cy / count + event.getRawY() - event.getY()) / density; }
+        lastSpan = b < 0 ? 0 : Math.hypot(event.getX(b) - event.getX(a), event.getY(b) - event.getY(a));
+        lastAngle = b < 0 ? 0 : Math.atan2(event.getY(b) - event.getY(a), event.getX(b) - event.getX(a));
+    }
+    void after(MotionEvent event) {
+        int action = event.getActionMasked();
+        if (action == MotionEvent.ACTION_UP) finish(false);
+        else if (action == MotionEvent.ACTION_CANCEL) finish(true);
+    }
+    int consume(int pixels, boolean atTop) {
+        if (!contact || pixels == 0 || pixels < 0 && !atTop) return 0;
+        double before = y.getPosition(), next = clamp(before - pixels / density, minY, maxY);
+        int consumed = (int)Math.round((before - next) * density);
+        if (consumed == 0) return 0;
+        begin();
+        if (disposed || !enabled || !active) return 0;
+        y.holdInput(before - consumed / density, velocityY);
+        return consumed;
+    }
+    boolean preFling(float vx, float vy) {
+        if (!active) return false;
+        velocityX = 0; velocityY = -vy / density;
+        return y.getPosition() > minY + .01 || vy < 0 && !scroll.canScrollVertically(-1);
+    }
+    private void finish(boolean cancelled) {
+        boolean hadContact = contact;
+        contact = false;
+        if (velocity != null) { velocity.recycle(); velocity = null; }
+        if (!active) { if (hadContact && contactEvents) emit(7); return; }
+        active = false;
+        x.releaseInput(x.getPosition(), 0); y.releaseInput(y.getPosition(), 0);
+        scale.releaseInput(scale.getPosition(), 0); rotation.releaseInput(rotation.getPosition(), 0);
+        if (surface.getParent() != null) surface.getParent().requestDisallowInterceptTouchEvent(false);
+        ending = !cancelled;
+        try { emit(cancelled ? 3 : 2); } finally { ending = false; }
+        if (hadContact && contactEvents) emit(7);
+    }
+    public void cancel() {
+        if (active) finish(true);
+        else {
+            finish(true);
+            x.releaseInput(x.getPosition(), 0); y.releaseInput(y.getPosition(), 0);
+            scale.releaseInput(scale.getPosition(), 0); rotation.releaseInput(rotation.getPosition(), 0);
+        }
+    }
+    public void setEnabled(boolean value) { enabled = value; if (!value) cancel(); }
+    public void settle(double tx, double ty, double ts, double tr, boolean animated) {
+        if (disposed) return;
+        double vx = ending ? velocityX : x.getVelocity(), vy = ending ? velocityY : y.getVelocity();
+        cancel();
+        double[] targets = {clamp(tx, minX, maxX), clamp(ty, minY, maxY), clamp(ts, minScale, maxScale), tr};
+        LiveSpring[] nodes = {x, y, scale, rotation};
+        for (int index = 0; index < nodes.length; index++) {
+            if (!animated) nodes[index].holdInput(targets[index], 0);
+            nodes[index].releaseInput(targets[index], animated ? index == 0 ? vx : index == 1 ? vy : 0 : 0);
+        }
+    }
+    public void updateBounds(double left, double right, double top, double bottom) { minX = left; maxX = right; minY = top; maxY = bottom; }
+    public void dispose() {
+        if (disposed) return;
+        cancel(); disposed = true; surface.setSession(null);
+        MotionEvent cancel = MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0, 0, 0);
+        taps.onTouchEvent(cancel); cancel.recycle();
+    }
+}

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

@@ -0,0 +1,53 @@
+package org.rafaelaugusto.jolt;
+
+import android.content.Context;
+import android.view.MotionEvent;
+import android.view.View;
+import androidx.core.view.NestedScrollingParent3;
+import androidx.core.view.NestedScrollingParentHelper;
+import androidx.core.view.ViewCompat;
+
+/** A GridLayout dispatch boundary; it does not replace NativeScript's touch listener. */
+public final class GestureSurface extends org.nativescript.widgets.GridLayout implements NestedScrollingParent3 {
+    private GestureSession session;
+    private final NestedScrollingParentHelper nested = new NestedScrollingParentHelper(this);
+    public GestureSurface(Context context) { super(context); }
+    public void setSession(GestureSession value) { session = value; }
+    @Override public boolean dispatchTouchEvent(MotionEvent event) {
+        GestureSession current = session;
+        if (current != null) current.before(event);
+        boolean handled = super.dispatchTouchEvent(event);
+        if (current != null) current.after(event);
+        return handled || current != null;
+    }
+    @Override public boolean onInterceptTouchEvent(MotionEvent event) {
+        return session != null && session.intercepts() || super.onInterceptTouchEvent(event);
+    }
+    @Override public boolean onTouchEvent(MotionEvent event) {
+        return session != null || super.onTouchEvent(event);
+    }
+    @Override public boolean onStartNestedScroll(View child, View target, int axes, int type) {
+        return session != null && type == ViewCompat.TYPE_TOUCH && (axes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0 && session.accepts(target);
+    }
+    @Override public void onNestedScrollAccepted(View child, View target, int axes, int type) { nested.onNestedScrollAccepted(child, target, axes, type); }
+    @Override public void onStopNestedScroll(View target, int type) { nested.onStopNestedScroll(target, type); }
+    @Override public void onNestedPreScroll(View target, int dx, int dy, int[] consumed, int type) {
+        if (session != null && type == ViewCompat.TYPE_TOUCH && session.accepts(target)) consumed[1] += session.consume(dy, !target.canScrollVertically(-1));
+    }
+    @Override public void onNestedScroll(View target, int dx, int dy, int remainingX, int remainingY, int type, int[] consumed) {
+        if (session != null && type == ViewCompat.TYPE_TOUCH && session.accepts(target)) consumed[1] += session.consume(remainingY, true);
+    }
+    @Override public boolean onNestedPreFling(View target, float vx, float vy) { return session != null && session.accepts(target) && session.preFling(vx, vy); }
+    @Override public boolean onNestedFling(View target, float vx, float vy, boolean consumed) { return false; }
+    @Override public int getNestedScrollAxes() { return nested.getNestedScrollAxes(); }
+    @Override public boolean onStartNestedScroll(View child, View target, int axes) { return onStartNestedScroll(child, target, axes, ViewCompat.TYPE_TOUCH); }
+    @Override public void onNestedScrollAccepted(View child, View target, int axes) { onNestedScrollAccepted(child, target, axes, ViewCompat.TYPE_TOUCH); }
+    @Override public void onStopNestedScroll(View target) { onStopNestedScroll(target, ViewCompat.TYPE_TOUCH); }
+    @Override public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) { onNestedPreScroll(target, dx, dy, consumed, ViewCompat.TYPE_TOUCH); }
+    @Override public void onNestedScroll(View target, int dx, int dy, int rx, int ry) { onNestedScroll(target, dx, dy, rx, ry, ViewCompat.TYPE_TOUCH); }
+    @Override public void onNestedScroll(View target, int dx, int dy, int rx, int ry, int type) { onNestedScroll(target, dx, dy, rx, ry, type, new int[2]); }
+    @Override protected void onDetachedFromWindow() {
+        if (session != null) session.cancel();
+        super.onDetachedFromWindow();
+    }
+}

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

@@ -0,0 +1,270 @@
+package org.rafaelaugusto.jolt;
+
+import android.os.SystemClock;
+import android.view.Choreographer;
+import android.view.View;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Persistent native follower graph. The frame callback never enters JavaScript. */
+public final class LiveSpring {
+    private static final ArrayList<LiveSpring> nodes = new ArrayList<>();
+    private static boolean scheduled;
+    private static long previousFrame;
+    private static final Choreographer.FrameCallback clock = new Choreographer.FrameCallback() {
+        @Override public void doFrame(long nanos) {
+            scheduled = false;
+            double now = nanos / 1e6;
+            double remaining = previousFrame == 0 ? 1.0 / 120 : Math.min(.064, Math.max(0, (nanos - previousFrame) / 1e9));
+            previousFrame = nanos;
+            // Older nodes precede their followers. Substeps bound chain phase error at 60/120Hz.
+            while (remaining > 1e-9) {
+                double dt = Math.min(remaining, 1.0 / 240);
+                remaining -= dt;
+                for (int i = 0; i < nodes.size(); i++) nodes.get(i).step(now - remaining * 1000, dt);
+            }
+            boolean active = false;
+            for (int i = 0; i < nodes.size(); i++) {
+                LiveSpring node = nodes.get(i);
+                node.apply();
+                active |= node.moving || node.layersMoving(now);
+            }
+            if (active) schedule(); else previousFrame = 0;
+        }
+    };
+    private static void schedule() {
+        if (scheduled || nodes.isEmpty()) return;
+        scheduled = true;
+        Choreographer.getInstance().postFrameCallback(clock);
+    }
+
+    private final SpringState state;
+    private final double stiffness, damping, mass, restDelta, restSpeed;
+    private final ArrayList<Binding> bindings = new ArrayList<>();
+    private LiveSpring source;
+    private Mapping[] sourceMaps = new Mapping[0];
+    private SampledInput input;
+    private boolean direct = true;
+    private double targetValue;
+    private boolean moving, reduced, disposed, paused, inputHeld;
+
+    public LiveSpring(double initial, double stiffness, double damping, double mass,
+                      double restDelta, double restSpeed, boolean reduced) {
+        state = new SpringState(initial, 0);
+        this.stiffness = stiffness; this.damping = damping; this.mass = mass;
+        this.restDelta = restDelta; this.restSpeed = restSpeed; this.reduced = reduced;
+        targetValue = initial;
+        nodes.add(this);
+    }
+    public double getPosition() { return state.position; }
+    public double getVelocity() { return state.velocity; }
+    public boolean isMoving() { return moving; }
+    public static int activeCount() { return scheduled ? 1 : 0; }
+    public static int nodeCount() { return nodes.size(); }
+
+    public void follow(LiveSpring parent, String mappings) {
+        if (disposed || parent.disposed || nodes.indexOf(parent) >= nodes.indexOf(this))
+            throw new IllegalArgumentException("A spring can only follow an existing live node");
+        sourceMaps = maps(mappings);
+        source = parent;
+        wake();
+    }
+    public void updateInput(String snapshot) {
+        if (disposed) return;
+        try { input = new SampledInput(new JSONObject(snapshot)); }
+        catch (JSONException error) { throw new IllegalArgumentException(error); }
+        direct = false;
+        wake();
+    }
+    public void setTarget(double value) {
+        if (disposed) return;
+        direct = true; targetValue = value; input = null;
+        wake();
+    }
+    public void holdInput(double value, double velocity) {
+        if (disposed) return;
+        inputHeld = true; direct = true; targetValue = value; input = null;
+        state.position = value; state.velocity = velocity; moving = true;
+        apply(); schedule();
+    }
+    public void releaseInput(double target, double velocity) {
+        if (disposed) return;
+        inputHeld = false; state.velocity = velocity; setTarget(target);
+    }
+    public void setReduced(boolean value) { reduced = value; wake(); }
+    public void setPaused(boolean value) {
+        paused = value;
+        if (value) moving = false; else wake();
+    }
+    private void wake() {
+        if (disposed || paused) return;
+        moving = true;
+        if (reduced) { step(SystemClock.uptimeMillis(), 0); apply(); }
+        schedule();
+    }
+    private void step(double now, double dt) {
+        if (disposed || paused || inputHeld) return;
+        double target = source == null ? (direct ? targetValue : input.value(now)) : map(source.state.position, sourceMaps);
+        boolean inputMoving = source == null ? !direct && input.running(now) : source.moving;
+        if (reduced) { state.position = target; state.velocity = 0; }
+        else state.advance(target, stiffness, damping, mass, dt);
+        boolean rest = Math.abs(state.position - target) <= restDelta && Math.abs(state.velocity) <= restSpeed;
+        if (rest && !inputMoving) { state.position = target; state.velocity = 0; }
+        moving = inputMoving || !rest;
+    }
+    public Binding bind(View view, String property, String mappings) {
+        if (disposed) throw new IllegalStateException("Spring disposed");
+        Binding binding = new Binding(view, property, maps(mappings));
+        bindings.add(binding);
+        binding.apply();
+        return binding;
+    }
+    private void apply() {
+        for (int i = bindings.size() - 1; i >= 0; i--) {
+            Binding binding = bindings.get(i);
+            if (binding.view.get() == null) bindings.remove(i); else binding.apply();
+        }
+    }
+    private boolean layersMoving(double now) {
+        for (int i = 0; i < bindings.size(); i++)
+            for (SampledInput layer : bindings.get(i).layers)
+                if (layer.running(now)) return true;
+        return false;
+    }
+    public static void sync(View view) {
+        for (int i = 0; i < nodes.size(); i++) {
+            LiveSpring node = nodes.get(i);
+            for (int j = 0; j < node.bindings.size(); j++) {
+                Binding binding = node.bindings.get(j);
+                if (binding.view.get() == view) binding.apply();
+            }
+        }
+    }
+    public void dispose() {
+        if (disposed) return;
+        disposed = true; moving = false;
+        bindings.clear();
+        nodes.remove(this);
+        // A retained child continues from its own state toward the parent's last value.
+        for (int i = 0; i < nodes.size(); i++) {
+            LiveSpring child = nodes.get(i);
+            if (child.source == this) {
+                child.source = null;
+                child.setTarget(map(state.position, child.sourceMaps));
+            }
+        }
+        source = null;
+        if (nodes.isEmpty() && scheduled) {
+            Choreographer.getInstance().removeFrameCallback(clock);
+            scheduled = false; previousFrame = 0;
+        }
+    }
+
+    public final class Binding {
+        private final WeakReference<View> view;
+        private final String property;
+        private final Mapping[] mappings;
+        private final float density;
+        private boolean stopped;
+        private SampledInput[] layers = new SampledInput[0];
+        Binding(View view, String property, Mapping[] mappings) {
+            this.view = new WeakReference<>(view); this.property = property; this.mappings = mappings;
+            density = view.getResources().getDisplayMetrics().density;
+        }
+        public double getValue() { return map(state.position, mappings); }
+        public void setLayers(String inputs) {
+            try {
+                JSONArray array = new JSONArray(inputs);
+                SampledInput[] next = new SampledInput[array.length()];
+                for (int i = 0; i < next.length; i++) next[i] = new SampledInput(array.getJSONObject(i));
+                layers = next;
+            } catch (JSONException error) { throw new IllegalArgumentException(error); }
+            apply(); schedule();
+        }
+        public void cancel() { stopped = true; bindings.remove(this); }
+        private void apply() {
+            View target = view.get();
+            if (stopped || target == null || !target.isAttachedToWindow()) return;
+            double composed = getValue();
+            boolean multiply = property.equals("opacity") || property.startsWith("scale");
+            double now = SystemClock.uptimeMillis();
+            for (SampledInput layer : layers) composed = multiply ? composed * layer.value(now) : composed + layer.value(now);
+            float value = (float)composed;
+            switch (property) {
+                case "x": target.setTranslationX(value * density); break;
+                case "y": target.setTranslationY(value * density); break;
+                case "scaleX": target.setScaleX(value); break;
+                case "scaleY": target.setScaleY(value); break;
+                case "rotate": target.setRotation(value); break;
+                case "rotateX": target.setRotationX(value); break;
+                case "rotateY": target.setRotationY(value); break;
+                case "opacity": target.setAlpha(Math.max(0, Math.min(1, value))); break;
+                default: throw new IllegalArgumentException("Unsupported live property " + property);
+            }
+        }
+    }
+    private static final class Mapping {
+        final double[] input, output;
+        final boolean clamp;
+        Mapping(JSONObject json) throws JSONException {
+            input = array(json.getJSONArray("input")); output = array(json.getJSONArray("output"));
+            clamp = json.getBoolean("clamp");
+        }
+        double value(double value) {
+            if (clamp && value <= input[0]) return output[0];
+            if (clamp && value >= input[input.length - 1]) return output[output.length - 1];
+            int index = 0;
+            while (index < input.length - 2 && value > input[index + 1]) index++;
+            double span = input[index + 1] - input[index];
+            double fraction = span > 0 ? (value - input[index]) / span : value < input[index] ? 0 : 1;
+            return output[index] + (output[index + 1] - output[index]) * fraction;
+        }
+    }
+    private static Mapping[] maps(String json) {
+        try {
+            JSONArray array = new JSONArray(json);
+            Mapping[] result = new Mapping[array.length()];
+            for (int i = 0; i < result.length; i++) result[i] = new Mapping(array.getJSONObject(i));
+            return result;
+        } catch (JSONException error) { throw new IllegalArgumentException(error); }
+    }
+    private static double map(double value, Mapping[] maps) {
+        for (Mapping mapping : maps) value = mapping.value(value);
+        return value;
+    }
+    private static double[] array(JSONArray input) throws JSONException {
+        double[] result = new double[input.length()];
+        for (int i = 0; i < result.length; i++) result[i] = input.getDouble(i);
+        return result;
+    }
+    private static final class SampledInput {
+        final double value, anchor, elapsed, duration, delay, repeat, end;
+        final double[] values, times;
+        final boolean reverse, playing;
+        SampledInput(JSONObject json) throws JSONException {
+            value = json.getDouble("value");
+            anchor = SystemClock.uptimeMillis(); elapsed = json.getDouble("elapsed");
+            playing = json.getBoolean("running");
+            duration = json.getDouble("duration"); delay = json.getDouble("delay");
+            repeat = json.getDouble("repeat"); end = json.getDouble("to");
+            reverse = json.getBoolean("reverse");
+            values = array(json.getJSONArray("values")); times = array(json.getJSONArray("times"));
+        }
+        boolean running(double now) { return playing && (repeat < 0 || now - anchor + elapsed < delay + duration * (repeat + 1)); }
+        double value(double now) {
+            if (!playing || values.length < 2) return value;
+            if (!running(now)) return end;
+            double time = Math.max(0, now - anchor + elapsed - delay);
+            double iteration = Math.floor(time / Math.max(1, duration));
+            double progress = (time % Math.max(1, duration)) / Math.max(1, duration);
+            if (reverse && iteration % 2 >= 1) progress = 1 - progress;
+            int lo = 0, hi = times.length - 1;
+            while (lo + 1 < hi) { int mid = (lo + hi) / 2; if (times[mid] <= progress) lo = mid; else hi = mid; }
+            double fraction = times[hi] > times[lo] ? (progress - times[lo]) / (times[hi] - times[lo]) : 1;
+            return values[lo] + (values[hi] - values[lo]) * Math.max(0, Math.min(1, fraction));
+        }
+    }
+}

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