@rafaelaugusto/jolt 0.1.0-beta.8 → 0.1.0-rc.1

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

@@ -0,0 +1,210 @@
+package org.rafaelaugusto.jolt;
+
+import android.app.Activity;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.ColorFilter;
+import android.graphics.PixelFormat;
+import android.graphics.drawable.Drawable;
+import android.app.Application;
+import android.os.Bundle;
+import android.os.SystemClock;
+import android.view.Choreographer;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import java.util.HashSet;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Native touch, collision stepping and view writes. No per-event/per-frame JS callback exists. */
+public final class CircleWorld implements Choreographer.FrameCallback, View.OnAttachStateChangeListener {
+    private static final HashSet<CircleWorld> worlds=new HashSet<>();
+    private final CircleMath state;
+    private View container;
+    private final View[] views;
+    private final CircleGuide[] guides;
+    private final boolean[] clickable;
+    private final double[] initialX,initialY,initialVX,initialVY,originalX,originalY;
+    private final float density;
+    private final int[] location=new int[2];
+    private Application application;
+    private Application.ActivityLifecycleCallbacks lifecycle;
+    private boolean enabled,disposed,background,fits,scheduled;
+    private double previous,accumulator,processingMs,droppedMs,offsetX,offsetY;
+    private long frames,dragStarts,dragMoves,dragEnds,dragCancels,lastMove;
+    private int dragging=-1;
+    private VelocityTracker velocity;
+    public static int worldCount(){return worlds.size();}
+    public static int activeCount(){int count=0;for(CircleWorld w:worlds)if(w.scheduled)count++;return count;}
+    public CircleWorld(View host,String options){
+        container=host;density=host.getResources().getDisplayMetrics().density;
+        try {
+            JSONObject config=new JSONObject(options);JSONArray data=config.getJSONArray("bodies");
+            int count=data.length();if(count<1||count>16)throw new IllegalArgumentException("Physics needs 1–16 circles");
+            state=new CircleMath(count);views=new View[count];guides=new CircleGuide[count];clickable=new boolean[count];
+            initialX=new double[count];initialY=new double[count];initialVX=new double[count];initialVY=new double[count];originalX=new double[count];originalY=new double[count];
+            state.width=config.getDouble("width");state.height=config.getDouble("height");
+            state.gx=config.getJSONObject("gravity").getDouble("x");state.gy=config.getJSONObject("gravity").getDouble("y");
+            state.restitution=config.getDouble("restitution");state.damping=config.getDouble("damping");
+            for(int i=0;i<count;i++){
+                JSONObject v=data.getJSONObject(i);CircleMath.Body b=state.bodies[i];
+                b.x=v.getDouble("x");b.y=v.getDouble("y");b.r=v.getDouble("radius");b.m=v.getDouble("mass");b.vx=v.getDouble("vx");b.vy=v.getDouble("vy");
+                initialX[i]=b.x/state.width;initialY[i]=b.y/state.height;initialVX[i]=b.vx;initialVY[i]=b.vy;
+                configureAttachment(i,v.optJSONObject("attachment"));
+                JSONObject snap=v.optJSONObject("snap");
+                if(snap!=null){
+                    JSONArray points=snap.getJSONArray("points");if(points.length()>CircleMath.SNAP_LIMIT)throw new IllegalArgumentException("Too many snap points");
+                    b.snap.count=points.length();b.snap.stiffness=snap.getDouble("stiffness");b.snap.damping=snap.getDouble("damping");b.snap.projection=snap.getDouble("projection");
+                    for(int j=0;j<points.length();j++){JSONObject point=points.getJSONObject(j);b.snap.u[j]=point.getDouble("x")/state.width;b.snap.v[j]=point.getDouble("y")/state.height;}
+                }
+            }
+        }catch(JSONException e){throw new IllegalArgumentException(e);}
+        fits=state.fits(state.width,state.height);
+        host.addOnAttachStateChangeListener(this);
+        if(host.getContext().getApplicationContext() instanceof Application){
+            application=(Application)host.getContext().getApplicationContext();
+            lifecycle=new Application.ActivityLifecycleCallbacks(){
+                private boolean owns(Activity a){return container!=null && container.getRootView()==a.getWindow().getDecorView();}
+                @Override public void onActivityPaused(Activity a){if(owns(a)){background=true;cancelDrag();refresh();}}
+                @Override public void onActivityResumed(Activity a){if(owns(a)){background=false;refresh();}}
+                @Override public void onActivityCreated(Activity a,Bundle b){}
+                @Override public void onActivityStarted(Activity a){}
+                @Override public void onActivityStopped(Activity a){}
+                @Override public void onActivitySaveInstanceState(Activity a,Bundle b){}
+                @Override public void onActivityDestroyed(Activity a){}
+            };
+            application.registerActivityLifecycleCallbacks(lifecycle);
+        }
+        worlds.add(this);
+    }
+    private final class CircleGuide extends Drawable {
+        private final int index;
+        private final Paint paint=new Paint(Paint.ANTI_ALIAS_FLAG);
+        CircleGuide(int index,int color,double width){this.index=index;paint.setColor(0xff000000|color);paint.setStrokeWidth((float)width*density);paint.setStyle(Paint.Style.STROKE);paint.setStrokeCap(Paint.Cap.ROUND);}
+        @Override public void draw(Canvas canvas){
+            CircleMath.Body b=state.bodies[index];
+            double x=b.snap.active?state.snapX(b,b.snap.index):b.attachment.u*state.width;
+            double y=b.snap.active?state.snapY(b,b.snap.index):b.attachment.v*state.height;
+            double dx=b.x-x,dy=b.y-y,d=Math.hypot(dx,dy);
+            if(d>b.r){canvas.drawLine((float)x*density,(float)y*density,(float)(b.x-dx/d*b.r)*density,(float)(b.y-dy/d*b.r)*density,paint);canvas.drawCircle((float)x*density,(float)y*density,2.5f*density,paint);}
+        }
+        @Override public void setAlpha(int alpha){paint.setAlpha(alpha);invalidateSelf();}
+        @Override public void setColorFilter(ColorFilter filter){paint.setColorFilter(filter);invalidateSelf();}
+        @Override public int getOpacity(){return PixelFormat.TRANSLUCENT;}
+    }
+    private void configureAttachment(int index,JSONObject options) throws JSONException {
+        if(options==null)state.attach(index,false,0,0,0,180,24);
+        else state.attach(index,true,options.getDouble("x"),options.getDouble("y"),options.getDouble("length"),options.getDouble("stiffness"),options.getDouble("damping"));
+        if(guides[index]!=null){container.getOverlay().remove(guides[index]);guides[index]=null;}
+        JSONObject line=options==null?null:options.optJSONObject("line");
+        if(line!=null){guides[index]=new CircleGuide(index,line.getInt("color"),line.getDouble("width"));container.getOverlay().add(guides[index]);}
+    }
+    public void attach(int index,String options){
+        if(disposed||index<0||index>=views.length)return;
+        try{configureAttachment(index,options.equals("null")?null:new JSONObject(options));}catch(JSONException e){throw new IllegalArgumentException(e);}
+        apply();refresh();
+    }
+    public void snapTo(int index,int target){if(disposed||index<0||index>=views.length)return;state.snapTo(index,target);apply();refresh();}
+    public void connect(View view,int index){
+        if(disposed||index<0||index>=views.length)return;
+        if(view.getParent()!=container)throw new IllegalArgumentException("Physics circles must be direct native children");
+        views[index]=view;originalX[index]=view.getTranslationX();originalY[index]=view.getTranslationY();clickable[index]=view.isClickable();
+        view.setClickable(true);view.setOnTouchListener((v,event)->touch(index,event));apply();
+    }
+    private boolean ready(){return enabled&&!disposed&&!background&&fits&&container.isAttachedToWindow();}
+    private void refresh(){
+        if(ready()&&!state.sleeping){if(!scheduled){scheduled=true;Choreographer.getInstance().postFrameCallback(this);}}
+        else {if(scheduled)Choreographer.getInstance().removeFrameCallback(this);scheduled=false;previous=0;accumulator=0;}
+    }
+    @Override public void doFrame(long nanos){
+        scheduled=false;
+        if(!ready()){cancelDrag();refresh();return;}
+        long started=System.nanoTime();double now=nanos/1e9,elapsed=previous>0?Math.max(0,now-previous):0;previous=now;
+        droppedMs+=Math.max(0,elapsed-1.0/15)*1000;accumulator+=Math.min(elapsed,1.0/15);
+        int budget=16;
+        while(accumulator+1e-10>=CircleMath.DT&&budget-->0&&!state.sleeping){state.step();accumulator-=CircleMath.DT;}
+        apply();frames++;processingMs+=(System.nanoTime()-started)/1e6;refresh();
+    }
+    private void apply(){
+        for(int i=0;i<views.length;i++)if(views[i]!=null){
+            View v=views[i];if(v.getParent()!=container){enabled=false;continue;}
+            v.setTranslationX((float)(state.bodies[i].x*density-v.getLeft()-v.getWidth()/2.0));
+            v.setTranslationY((float)(state.bodies[i].y*density-v.getTop()-v.getHeight()/2.0));
+        }
+        for(CircleGuide guide:guides)if(guide!=null){guide.setBounds(0,0,container.getWidth(),container.getHeight());guide.invalidateSelf();}
+    }
+    private void sampleVelocity(MotionEvent event){
+        if(velocity==null)return;
+        MotionEvent raw=MotionEvent.obtain(event);raw.offsetLocation(event.getRawX()-event.getX(),event.getRawY()-event.getY());velocity.addMovement(raw);raw.recycle();
+    }
+    private boolean touch(int index,MotionEvent event){
+        if(!ready())return false;
+        int action=event.getActionMasked();container.getLocationOnScreen(location);
+        double x=(event.getRawX()-location[0])/density,y=(event.getRawY()-location[1])/density;
+        if(action==MotionEvent.ACTION_DOWN){
+            if(dragging>=0)return false;
+            CircleMath.Body b=state.bodies[index];if(Math.hypot(x-b.x,y-b.y)>b.r)return false;
+            dragging=index;offsetX=b.x-x;offsetY=b.y-y;velocity=VelocityTracker.obtain();lastMove=SystemClock.uptimeMillis();dragStarts++;
+            container.getParent().requestDisallowInterceptTouchEvent(true);state.drag(index,b.x,b.y);sampleVelocity(event);refresh();return true;
+        }
+        if(dragging!=index)return false;
+        if(action==MotionEvent.ACTION_POINTER_DOWN||action==MotionEvent.ACTION_CANCEL){cancelDrag();refresh();return true;}
+        sampleVelocity(event);
+        if(action==MotionEvent.ACTION_MOVE){state.drag(index,x+offsetX,y+offsetY);lastMove=SystemClock.uptimeMillis();dragMoves++;refresh();}
+        else if(action==MotionEvent.ACTION_UP){
+            velocity.computeCurrentVelocity(1000,(float)CircleMath.SPEED*density);
+            boolean fresh=SystemClock.uptimeMillis()-lastMove<=80;
+            state.release(index,fresh?velocity.getXVelocity()/density:0,fresh?velocity.getYVelocity()/density:0);
+            dragging=-1;dragEnds++;releaseTracker();refresh();
+        }
+        return true;
+    }
+    private void releaseTracker(){
+        if(velocity!=null){velocity.recycle();velocity=null;}
+        if(container!=null&&container.getParent()!=null)container.getParent().requestDisallowInterceptTouchEvent(false);
+    }
+    private void cancelDrag(){if(dragging>=0){state.cancel(dragging);dragging=-1;dragCancels++;apply();}releaseTracker();}
+    public void setEnabled(boolean active){if(disposed)return;boolean changed=enabled!=active;enabled=active;if(!active)cancelDrag();else if(changed)state.wake();refresh();}
+    public void resize(double width,double height){
+        if(disposed)return;fits=state.fits(width,height);
+        if(!fits){cancelDrag();refresh();return;}
+        if(Math.abs(width-state.width)>.1||Math.abs(height-state.height)>.1){cancelDrag();state.resize(width,height);}
+        apply();refresh();
+    }
+    public void impulse(int index,double x,double y){
+        if(!ready()||index<0||index>=views.length||state.bodies[index].held||!Double.isFinite(x)||!Double.isFinite(y))return;
+        CircleMath.Body b=state.bodies[index];b.vx+=x/b.m;b.vy+=y/b.m;CircleMath.limit(b);state.wake();refresh();
+    }
+    public void reset(){
+        if(disposed)return;cancelDrag();
+        for(int i=0;i<views.length;i++){CircleMath.Body b=state.bodies[i];b.x=initialX[i]*state.width;b.y=initialY[i]*state.height;b.vx=initialVX[i];b.vy=initialVY[i];b.snap.active=b.snap.previousActive=false;b.released=false;}
+        state.contacts(false,64);state.wake();apply();refresh();
+    }
+    @Override public void onViewAttachedToWindow(View v){refresh();}
+    @Override public void onViewDetachedFromWindow(View v){cancelDrag();refresh();}
+    public String snapshot(){
+        try {
+            int guideCount=0;for(CircleGuide guide:guides)if(guide!=null)guideCount++;
+            JSONArray bodies=new JSONArray();
+            for(CircleMath.Body b:state.bodies){
+                Object attachment=b.attachment.enabled?new JSONObject().put("anchor",new JSONObject().put("x",b.attachment.u*state.width).put("y",b.attachment.v*state.height)).put("length",b.attachment.length).put("stiffness",b.attachment.stiffness).put("damping",b.attachment.damping):JSONObject.NULL;
+                Object snap=JSONObject.NULL;
+                if(b.snap.active){double x=state.snapX(b,b.snap.index),y=state.snapY(b,b.snap.index);snap=new JSONObject().put("index",b.snap.index).put("point",new JSONObject().put("x",x).put("y",y)).put("settled",Math.hypot(b.x-x,b.y-y)<=.25&&Math.hypot(b.vx,b.vy)<=4&&!b.held);}
+                Object release=b.released?new JSONObject().put("x",b.releaseX).put("y",b.releaseY).put("vx",b.releaseVX).put("vy",b.releaseVY):JSONObject.NULL;
+                bodies.put(new JSONObject().put("x",b.x).put("y",b.y).put("vx",b.vx).put("vy",b.vy).put("radius",b.r).put("held",b.held).put("attachment",attachment).put("snap",snap).put("release",release));
+            }
+            String status=disposed?"disposed":!enabled?"paused":background||!container.isAttachedToWindow()?"detached":!fits?"invalid-bounds":state.sleeping?"sleeping":"running";
+            return new JSONObject().put("status",status).put("guides",guideCount).put("bodies",bodies).put("frames",frames).put("steps",state.steps).put("contacts",state.contacts).put("dragStarts",dragStarts).put("dragMoves",dragMoves).put("dragEnds",dragEnds).put("dragCancels",dragCancels).put("processingMs",processingMs).put("droppedMs",droppedMs).put("clock",scheduled).toString();
+        }catch(JSONException e){throw new IllegalStateException(e);}
+    }
+    public void dispose(){
+        if(disposed)return;enabled=false;cancelDrag();disposed=true;refresh();
+        if(application!=null)application.unregisterActivityLifecycleCallbacks(lifecycle);application=null;lifecycle=null;
+        container.removeOnAttachStateChangeListener(this);
+        for(int i=0;i<views.length;i++)if(views[i]!=null){View v=views[i];v.setOnTouchListener(null);v.setClickable(clickable[i]);v.setTranslationX((float)originalX[i]);v.setTranslationY((float)originalY[i]);views[i]=null;}
+        for(int i=0;i<guides.length;i++)if(guides[i]!=null){container.getOverlay().remove(guides[i]);guides[i]=null;}
+        container=null;worlds.remove(this);
+    }
+}

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

@@ -0,0 +1,227 @@
+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, replayOnly;
+    private double minX, maxX, minY, maxY, minScale, maxScale;
+    private double downX, downY, lastX, lastY, lastSpan, lastAngle, velocityX, velocityY, replayRemainder;
+    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);
+            replayOnly = config.optBoolean("replay", 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);
+        if (replayOnly && surface.hasSession())
+            throw new IllegalStateException("Replay requires an unowned gesture surface");
+        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 (replayOnly || !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) {
+        if (replayOnly) return;
+        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 static boolean supportsScrollReplay() { return true; }
+    /** Semantic replay uses the same pre-scroll / child / post-scroll consumption as GestureSurface. */
+    public void replayScroll(int phase, double delta, double speed) {
+        if (!replayOnly || disposed || scroll == null || !Double.isFinite(delta) || !Double.isFinite(speed))
+            throw new IllegalStateException("Scroll replay needs an isolated replay session and finite input");
+        if (phase == 1) {
+            cancel(); contact = true; fromScroll = true; velocityX = velocityY = replayRemainder = 0; begin();
+        } else if (phase == 2 && contact) {
+            velocityY = speed;
+            // Carry fractions between samples, just as a cumulative OS coordinate does.
+            double pixels = -delta * density + replayRemainder;
+            int remaining = (int)Math.round(pixels);
+            replayRemainder = pixels - remaining;
+            remaining -= consume(remaining, !scroll.canScrollVertically(-1));
+            int before = scroll.getScrollY();
+            scroll.scrollBy(0, remaining);
+            remaining -= scroll.getScrollY() - before;
+            consume(remaining, true);
+        } else if (phase == 3 || phase == 4) finish(phase == 4);
+    }
+    public void replayScrollOffset(double offset) {
+        if (!replayOnly || disposed || !Double.isFinite(offset))
+            throw new IllegalStateException("Invalid scroll replay offset");
+        scroll.scrollTo(scroll.getScrollX(), (int)Math.round(offset * density));
+    }
+    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,54 @@
+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; }
+    public boolean hasSession() { return session != null; }
+    @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();
+    }
+}