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

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

@@ -0,0 +1,217 @@
+package org.rafaelaugusto.jolt;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import android.view.Choreographer;
+import android.view.Surface;
+import android.view.WindowManager;
+import java.util.ArrayList;
+import java.util.Arrays;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Shared hardware subscriptions, native display coalescing and native-only live-value delivery. */
+public final class SensorSource {
+    public interface Listener { void changed(); }
+    private static final ArrayList<SensorSource> sources=new ArrayList<>();
+    private static SensorManager manager;
+    private static WindowManager window;
+    private static Sensor rotationHardware, gravityHardware;
+    private static boolean scheduled, background;
+    private static int rotationRate, gravityRate;
+    private static final Handler main=new Handler(Looper.getMainLooper());
+    private static final SensorEventListener hardware=new SensorEventListener() {
+        @Override public void onAccuracyChanged(Sensor sensor,int accuracy) {}
+        @Override public void onSensorChanged(SensorEvent event) {
+            if(background) return;
+            boolean rotation=event.sensor.getType()==Sensor.TYPE_GAME_ROTATION_VECTOR;
+            double[] values;
+            if(rotation) {
+                if(event.values.length<4)return;
+                values=new double[]{event.values[0],event.values[1],event.values[2],event.values[3]};
+            } else {
+                if(event.values.length<3)return;
+                // Android reports proper acceleration against gravity; canonical gravity points down.
+                values=new double[]{-event.values[0],-event.values[1],-event.values[2]};
+            }
+            for(SensorSource source:new ArrayList<>(sources))
+                if(source.enabled && source.trace==null && source.error==null && source.rotation==rotation)
+                    source.receive(values,event.timestamp/1e6);
+        }
+    };
+    private static final Choreographer.FrameCallback clock=new Choreographer.FrameCallback() {
+        @Override public void doFrame(long nanos) {
+            scheduled=false;
+            for(SensorSource source:new ArrayList<>(sources)) if(source.enabled&&!background)source.frame(nanos/1e6);
+            schedule();
+        }
+    };
+    private static void initialize(Context context) {
+        if(manager!=null)return;
+        Context app=context.getApplicationContext();
+        manager=(SensorManager)app.getSystemService(Context.SENSOR_SERVICE);
+        window=(WindowManager)app.getSystemService(Context.WINDOW_SERVICE);
+        rotationHardware=manager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR);
+        gravityHardware=manager.getDefaultSensor(Sensor.TYPE_GRAVITY);
+        if(app instanceof Application)((Application)app).registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
+            @Override public void onActivityPaused(Activity activity) {
+                background=true;
+                for(SensorSource s:sources) s.holdReplay();
+                refresh();
+            }
+            @Override public void onActivityResumed(Activity activity) {
+                background=false;
+                for(SensorSource s:sources) {s.rebase=true;s.receivedAt=SystemClock.uptimeMillis();s.replayStart=0;}
+                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){}
+        });
+    }
+    private static boolean ticking() {
+        if(background)return false;
+        for(SensorSource s:sources)if(s.enabled && !s.disposed && (s.trace!=null || (s.available && s.error==null)))return true;
+        return false;
+    }
+    private static void schedule() {
+        if(ticking()) {
+            if(!scheduled){scheduled=true;Choreographer.getInstance().postFrameCallback(clock);}
+        } else if(scheduled){Choreographer.getInstance().removeFrameCallback(clock);scheduled=false;}
+    }
+    private static void refresh() {
+        if(manager==null)return;
+        int rotation=0, gravity=0;
+        if(!background)for(SensorSource s:sources)if(s.enabled && s.trace==null && s.available && s.error==null) {
+            Sensor hardware=s.rotation?rotationHardware:gravityHardware;
+            int rate=Math.max(5000,Math.max(hardware.getMinDelay(),(int)(s.interval*1000)));
+            if(s.rotation)rotation=rotation==0?rate:Math.min(rotation,rate);
+            else gravity=gravity==0?rate:Math.min(gravity,rate);
+        }
+        rotationRate=register(rotationHardware,rotationRate,rotation,true);
+        gravityRate=register(gravityHardware,gravityRate,gravity,false);
+        schedule();
+    }
+    private static int register(Sensor sensor,int previous,int next,boolean rotation) {
+        if(previous==next)return previous;
+        // A fusion implementation may reset its game-reference frame on re-registration.
+        if(rotation)for(SensorSource s:sources)if(s.rotation&&s.enabled&&s.trace==null)s.rebase=true;
+        if(previous>0)manager.unregisterListener(hardware,sensor);
+        if(next==0)return 0;
+        String error=null;
+        try { if(!manager.registerListener(hardware,sensor,next,0,main))error="registration-failed"; }
+        catch(SecurityException denied){error="access-denied";}
+        catch(RuntimeException failure){error="sensor-start-failed";}
+        if(error==null)return next;
+        for(SensorSource s:new ArrayList<>(sources))if(s.rotation==rotation&&s.enabled&&s.trace==null){s.error=error;s.state("error");}
+        return 0;
+    }
+    public static int activeCount(){return (rotationRate>0?1:0)+(gravityRate>0?1:0);}
+    public static int sourceCount(){return sources.size();}
+    private final boolean rotation, interfaceCoordinates, available;
+    private final double interval;
+    private final LiveSpring[] nodes;
+    private Listener listener;
+    private boolean enabled,disposed,dirty,rebase=true,reset;
+    private String status,error;
+    private double timestamp=-1,pendingTimestamp,receivedAt,committedAt,processingMs;
+    private long samples,frames,callbacks;
+    private double[] reference={0,0,0,1},relative={0,0,0,1},output,pending;
+    private JSONArray trace;
+    private int replayIndex;
+    private double replayStart,replayElapsed,replayOrientation;
+    public SensorSource(Context context,String kind,String options,Listener listener) {
+        initialize(context);
+        rotation=kind.equals("rotation");this.listener=listener;
+        try {
+            JSONObject config=new JSONObject(options);
+            interfaceCoordinates=config.optString("coordinates").equals("interface");
+            double requested=config.optDouble("interval",0);
+            if(requested==0)requested=1000/Math.max(60,window.getDefaultDisplay().getRefreshRate());
+            interval=Math.max(5,Math.min(1000,requested));
+        } catch(JSONException e){throw new IllegalArgumentException(e);}
+        available=(rotation?rotationHardware:gravityHardware)!=null;
+        output=new double[rotation?7:3];if(rotation)output[6]=1;
+        nodes=new LiveSpring[output.length];status=available?"idle":"unavailable";
+        sources.add(this);
+    }
+    public void connect(LiveSpring node,int index){if(index>=0&&index<nodes.length)nodes[index]=node;}
+    private void state(String next){if(status.equals(next))return;status=next;if(listener!=null){callbacks++;listener.changed();}}
+    private void holdReplay(){if(trace!=null&&replayStart>0){replayElapsed=Math.max(0,SystemClock.uptimeMillis()-replayStart);replayStart=0;}}
+    public void setEnabled(boolean active,boolean paused) {
+        if(disposed)return;
+        boolean changed=enabled!=active;enabled=active;
+        if(changed){dirty=false;committedAt=0;rebase=true;if(active){receivedAt=SystemClock.uptimeMillis();error=null;replayStart=0;}else holdReplay();}
+        if(!active)state(paused?"paused":(available?"idle":"unavailable"));
+        else if(changed)state(trace!=null?"replaying":(available?"starting":"unavailable"));
+        refresh();
+    }
+    public void recenter(){if(!disposed&&rotation){reset=true;rebase=true;}}
+    public void replay(String input) {
+        if(disposed)return;
+        try {JSONArray next=new JSONArray(input);if(next.length()<2)return;trace=next;}catch(JSONException e){throw new IllegalArgumentException(e);}
+        replayIndex=0;replayStart=0;replayElapsed=0;error=null;reset=true;rebase=true;dirty=false;committedAt=0;
+        if(enabled)state("replaying");refresh();
+    }
+    private void receive(double[] values,double time) {
+        if(!Double.isFinite(time)||time<0)return;
+        if(trace==null&&timestamp>=0&&time<=pendingTimestamp)return;
+        for(double v:values)if(!Double.isFinite(v))return;
+        double[] copy=values.clone();if(rotation&&!SensorMath.normalize(copy))return;
+        pending=copy;pendingTimestamp=time;samples++;dirty=true;receivedAt=SystemClock.uptimeMillis();
+    }
+    private double orientation() {
+        if(!interfaceCoordinates)return 0;
+        if(trace!=null)return replayOrientation;
+        switch(window.getDefaultDisplay().getRotation()){
+            case Surface.ROTATION_90:return 90;case Surface.ROTATION_180:return 180;case Surface.ROTATION_270:return 270;default:return 0;
+        }
+    }
+    private void frame(double now) {
+        if(disposed||error!=null)return;
+        if(trace!=null) {
+            if(replayStart==0)replayStart=now-replayElapsed;
+            double elapsed=now-replayStart;
+            try {
+                while(replayIndex<trace.length()&&trace.getJSONObject(replayIndex).getDouble("time")<=elapsed){
+                    JSONObject sample=trace.getJSONObject(replayIndex++);JSONArray values=sample.getJSONArray("values");
+                    if(values.length()!=(rotation?4:3))continue;
+                    double[] input=new double[values.length()];for(int i=0;i<input.length;i++)input[i]=values.getDouble(i);
+                    replayOrientation=sample.optDouble("orientation",0);receive(input,sample.getDouble("time"));
+                }
+            }catch(JSONException e){error="invalid-test-input";trace=null;state("error");refresh();return;}
+        } else if(available&&now-receivedAt>Math.max(3000,interval*3)){error="no-data";state("error");refresh();return;}
+        if(dirty&&(committedAt==0||now-committedAt>=interval-.5)) {
+            long start=System.nanoTime();
+            if(rotation) {
+                if(rebase){if(reset)relative=new double[]{0,0,0,1};reference=SensorMath.multiply(pending,SensorMath.inverse(relative));rebase=false;reset=false;}
+                relative=SensorMath.multiply(SensorMath.inverse(reference),pending);
+                output=SensorMath.rotation(relative,orientation(),Arrays.copyOfRange(output,3,7));
+            } else output=SensorMath.vector(pending,orientation());
+            for(int i=0;i<nodes.length;i++)if(nodes[i]!=null)nodes[i].setSensorInput(output[i]);
+            dirty=false;timestamp=pendingTimestamp;frames++;committedAt=now;processingMs+=(System.nanoTime()-start)/1e6;
+            if(trace==null)state("active");
+        }
+        if(trace!=null&&replayIndex>=trace.length()&&!dirty){trace=null;replayStart=0;replayElapsed=0;rebase=true;receivedAt=now;state(available?"starting":"unavailable");refresh();}
+    }
+    public String snapshot() {
+        try {
+            JSONObject result=new JSONObject();result.put("status",status);result.put("available",available);result.put("error",error==null?JSONObject.NULL:error);
+            result.put("timestamp",timestamp<0?JSONObject.NULL:timestamp);result.put("samples",samples);result.put("frames",frames);result.put("callbacks",callbacks);
+            result.put("processingMs",processingMs);result.put("interval",interval);JSONArray values=new JSONArray();for(double v:output)values.put(v);result.put("values",values);return result.toString();
+        }catch(JSONException e){throw new IllegalStateException(e);}
+    }
+    public void dispose(){if(disposed)return;disposed=true;enabled=false;status="disposed";listener=null;trace=null;Arrays.fill(nodes,null);sources.remove(this);refresh();}
+}

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

@@ -0,0 +1,120 @@
+package org.rafaelaugusto.jolt;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PathMeasure;
+import android.graphics.PixelFormat;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.view.animation.LinearInterpolator;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Owned vector surface. JS submits geometry/curves once; all drawing and playback stays native. */
+public final class ShapeLayer extends Drawable {
+    private static int live, active;
+    public static int liveCount(){return live;}
+    public static int activeCount(){return active;}
+    private final Paint fill=new Paint(Paint.ANTI_ALIAS_FLAG), stroke=new Paint(Paint.ANTI_ALIAS_FLAG);
+    private final Path path=new Path(), trimmed=new Path();
+    private final PathMeasure measure=new PathMeasure();
+    private final float[] box=new float[4];
+    private String commands="";
+    // start/end fractions followed by normalized path coordinates.
+    private float[] current=new float[0], from, to, times, samples;
+    private float length;
+    private double duration, delay, repeats;
+    private boolean reverse, disposed;
+    private ValueAnimator animator;
+    public ShapeLayer(String options){
+        try {
+            JSONObject o=new JSONObject(options);JSONArray b=o.getJSONArray("viewBox");
+            for(int i=0;i<4;i++)box[i]=(float)b.getDouble(i);
+            fill.setColor((int)o.getLong("fill"));fill.setStyle(Paint.Style.FILL);
+            stroke.setColor((int)o.getLong("stroke"));stroke.setStyle(Paint.Style.STROKE);stroke.setStrokeWidth((float)o.getDouble("width"));
+            stroke.setStrokeCap(Paint.Cap.valueOf(o.getString("cap").toUpperCase(java.util.Locale.ROOT)));
+            stroke.setStrokeJoin(Paint.Join.valueOf(o.getString("join").toUpperCase(java.util.Locale.ROOT)));
+            path.setFillType(o.getString("rule").equals("evenodd")?Path.FillType.EVEN_ODD:Path.FillType.WINDING);
+        }catch(JSONException e){throw new IllegalArgumentException(e);}
+        live++;
+    }
+    public void paint(String commands,float[] points,float start,float end){
+        if(disposed)return;cancel();this.commands=commands;current=new float[points.length+2];current[0]=start;current[1]=end;System.arraycopy(points,0,current,2,points.length);rebuild();invalidateSelf();
+    }
+    public float[] values(){return current.clone();}
+    public float[] geometryBounds(){RectF b=new RectF();path.computeBounds(b,false);return new float[]{b.left,b.top,b.width(),b.height()};}
+    public boolean isPlaying(){return animator!=null;}
+    public void play(String commands,float[] from,float[] to,float[] times,float[] samples,double duration,double delay,int repeats,boolean reverse){
+        if(disposed)return;cancel();
+        this.commands=commands;this.from=from;this.to=to;this.times=times;this.samples=samples;
+        this.duration=duration;this.delay=delay;this.repeats=repeats;this.reverse=reverse;
+        current=from.clone();rebuild();apply(0);
+        final ValueAnimator a=ValueAnimator.ofFloat(0f,1f);
+        a.setDuration(repeats<0?60000:Math.max(1,(long)Math.ceil(delay+duration*(repeats+1))));
+        a.setRepeatCount(repeats<0?ValueAnimator.INFINITE:0);a.setInterpolator(new LinearInterpolator());
+        a.addUpdateListener(v->apply(v.getCurrentPlayTime()));
+        a.addListener(new AnimatorListenerAdapter(){@Override public void onAnimationEnd(Animator ended){if(animator==a){animator=null;active--;}}});
+        animator=a;active++;a.start();
+    }
+    public void control(double time,boolean paused){
+        if(animator==null)return;
+        animator.setCurrentPlayTime(Math.max(0,(long)time));
+        if(paused)animator.pause();else animator.resume();
+        apply(time);
+    }
+    private void apply(double elapsed){
+        double t=Math.max(0,elapsed-delay), fraction;
+        if(repeats>=0&&t>=duration*(repeats+1))fraction=reverse&&((int)repeats%2==1)?0:1;
+        else {long cycle=(long)(t/duration);fraction=t/duration-cycle;if(reverse&&(cycle%2==1))fraction=1-fraction;}
+        int low=0,high=times.length-1;
+        while(high-low>1){int mid=(low+high)/2;if(times[mid]<=fraction)low=mid;else high=mid;}
+        double span=times[high]-times[low], mix=span>0?Math.max(0,Math.min(1,(fraction-times[low])/span)):1;
+        double progress=samples[low]+(samples[high]-samples[low])*mix;
+        boolean changed=false;
+        for(int i=0;i<current.length;i++){
+            float v=(float)(from[i]+(to[i]-from[i])*progress);
+            if(i<2)v=Math.max(0,Math.min(1,v));else if(v!=current[i])changed=true;
+            current[i]=v;
+        }
+        if(changed)rebuild();invalidateSelf();
+    }
+    private void rebuild(){
+        path.rewind();int i=2;
+        for(int c=0;c<commands.length();c++)switch(commands.charAt(c)){
+            case 'M':path.moveTo(current[i],current[i+1]);i+=2;break;
+            case 'L':path.lineTo(current[i],current[i+1]);i+=2;break;
+            case 'C':path.cubicTo(current[i],current[i+1],current[i+2],current[i+3],current[i+4],current[i+5]);i+=6;break;
+            case 'Q':path.quadTo(current[i],current[i+1],current[i+2],current[i+3]);i+=4;break;
+            case 'Z':path.close();break;
+        }
+        measure.setPath(path,false);length=measure.getLength();
+    }
+    @Override public void draw(Canvas canvas){
+        Rect b=getBounds();if(disposed||current.length<4||b.width()<=0||b.height()<=0)return;
+        float scale=Math.min(b.width()/box[2],b.height()/box[3]);
+        int save=canvas.save();canvas.clipRect(b);
+        canvas.translate(b.exactCenterX()-box[2]*scale/2,b.exactCenterY()-box[3]*scale/2);canvas.scale(scale,scale);canvas.translate(-box[0],-box[1]);
+        canvas.drawPath(path,fill);
+        if(stroke.getStrokeWidth()>0&&current[1]>current[0]){
+            if(current[0]<=0&&current[1]>=1)canvas.drawPath(path,stroke);
+            else{trimmed.rewind();measure.getSegment(length*current[0],length*current[1],trimmed,true);canvas.drawPath(trimmed,stroke);}
+        }
+        canvas.restoreToCount(save);
+    }
+    public void cancel(){
+        ValueAnimator a=animator;animator=null;
+        if(a!=null){active--;a.removeAllUpdateListeners();a.removeAllListeners();a.cancel();}
+        from=to=times=samples=null;
+    }
+    public void dispose(){if(disposed)return;cancel();disposed=true;live--;path.rewind();trimmed.rewind();current=new float[0];setCallback(null);}
+    @Override public void setAlpha(int alpha){fill.setAlpha(alpha);stroke.setAlpha(alpha);invalidateSelf();}
+    @Override public void setColorFilter(ColorFilter filter){fill.setColorFilter(filter);stroke.setColorFilter(filter);invalidateSelf();}
+    @Override public int getOpacity(){return PixelFormat.TRANSLUCENT;}
+}

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

@@ -0,0 +1,287 @@
+package org.rafaelaugusto.jolt;
+
+import android.graphics.*;
+import android.graphics.drawable.BitmapDrawable;
+import android.widget.ImageView;
+import android.view.*;
+import android.webkit.WebView;
+import org.json.*;
+import java.util.*;
+
+/** Window-relative snapshots; frame evaluation and drawing never call JavaScript. */
+public final class SharedLayoutFlight extends View implements Choreographer.FrameCallback {
+    public interface Listener { void onEnd(boolean completed); }
+    private final ViewGroup root;
+    private final float density;
+    private final Map<View,Integer> hidden = new WeakHashMap<>();
+    private static final PorterDuffXfermode ADD = new PorterDuffXfermode(PorterDuff.Mode.ADD);
+    private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
+    private Bitmap source, target, pageBitmap;
+    private RectF pageFrame;
+    private boolean fading, clippedImage;
+    private float sourceWidth, sourceHeight, targetWidth, targetHeight;
+    private boolean sourceImage, targetImage, disposed, running, navigationImage, borrowedTarget;
+    private double[] interactiveStart, interactiveEnd;
+    private View destination;
+    private final double[] pose = new double[14], velocity = new double[14];
+    private double[][] times, values;
+    private double duration, started;
+    private RectF destinationFrame;
+    private int rootWidth, rootHeight;
+    private Listener listener;
+    private static int active;
+
+    private SharedLayoutFlight(View view) {
+        super(view.getContext()); root = (ViewGroup)view.getRootView();
+        density = view.getResources().getDisplayMetrics().density;
+        setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS);
+        setWillNotDraw(false); rootWidth = root.getWidth(); rootHeight = root.getHeight();
+        layout(0,0,rootWidth,rootHeight);
+    }
+    public static int activeCount() { return active; }
+    private static boolean unsupported(View view) {
+        return unsupported(view, false);
+    }
+    private static boolean unsupported(View view, boolean allowScrolling) {
+        if (view instanceof SurfaceView || view instanceof TextureView || view instanceof WebView || (!allowScrolling && (view instanceof android.widget.AbsListView || view instanceof android.widget.ScrollView))) return true;
+        if (view instanceof ViewGroup) {
+            ViewGroup group = (ViewGroup)view;
+            for (int i=0;i<group.getChildCount();i++) if (unsupported(group.getChildAt(i), allowScrolling)) return true;
+        }
+        return false;
+    }
+    private RectF geometry(View view) {
+        if (view == null || !view.isAttachedToWindow() || view.getRootView()!=root || view.getWidth()<=0 || view.getHeight()<=0) return null;
+        float sx=1,sy=1;
+        for (View p=view;p!=null;p=p.getParent() instanceof View ? (View)p.getParent() : null) {
+            if (p!=view && p.getVisibility()!=VISIBLE) return null;
+            if (Math.abs(p.getRotation())>.01 || Math.abs(p.getRotationX())>.01 || Math.abs(p.getRotationY())>.01 || p.getScaleX()<=0 || p.getScaleY()<=0 || Math.abs(p.getAlpha()-1)>.001 || Math.abs(p.getScaleX()-p.getScaleY())>.0001) return null;
+            sx*=p.getScaleX(); sy*=p.getScaleY();
+        }
+        int[] origin=new int[2], local=new int[2]; root.getLocationOnScreen(origin); view.getLocationOnScreen(local);
+        return new RectF(local[0]-origin[0],local[1]-origin[1],local[0]-origin[0]+view.getWidth()*sx,local[1]-origin[1]+view.getHeight()*sy);
+    }
+    private boolean visibleBounds(View view, RectF frame) {
+        if (frame==null || frame.left<-.5 || frame.top<-.5 || frame.right>rootWidth+.5 || frame.bottom>rootHeight+.5) return false;
+        for (ViewParent p=view.getParent();p instanceof View;p=p.getParent()) {
+            if (p instanceof ViewGroup && ((ViewGroup)p).getClipChildren()) {
+                RectF clip=geometry((View)p);
+                if (clip==null || frame.left<clip.left-.5 || frame.top<clip.top-.5 || frame.right>clip.right+.5 || frame.bottom>clip.bottom+.5) return false;
+            }
+        }
+        return true;
+    }
+    private RectF visibleClip(View view, RectF frame) {
+        if(frame==null)return null;
+        RectF clip=new RectF(frame);if(!clip.intersect(0,0,rootWidth,rootHeight))return null;
+        for(ViewParent p=view.getParent();p instanceof View;p=p.getParent())if(p instanceof ViewGroup && ((ViewGroup)p).getClipChildren()) {
+            RectF parent=geometry((View)p);if(parent==null || !clip.intersect(parent))return null;
+        }
+        return clip;
+    }
+    private Bitmap snapshot(View view, long budget) {
+        long pixels=(long)view.getWidth()*view.getHeight();
+        if (pixels<=0 || pixels>budget || unsupported(view)) return null;
+        Bitmap bitmap;
+        try { bitmap=Bitmap.createBitmap(view.getWidth(),view.getHeight(),Bitmap.Config.ARGB_8888); }
+        catch (OutOfMemoryError error) { return null; }
+        int visibility=view.getVisibility();
+        try { view.setVisibility(VISIBLE); view.draw(new Canvas(bitmap)); }
+        catch (RuntimeException | OutOfMemoryError error) { bitmap.recycle(); return null; }
+        finally { view.setVisibility(visibility); }
+        return bitmap;
+    }
+    private void hide(View view) {
+        if (!hidden.containsKey(view)) hidden.put(view,view.getVisibility());
+        view.setVisibility(INVISIBLE);
+    }
+    public static SharedLayoutFlight capture(View view, boolean image, double radius, double maxPixels) {
+        if (!(view.getRootView() instanceof ViewGroup)) return null;
+        SharedLayoutFlight f=new SharedLayoutFlight(view);
+        RectF rect=f.geometry(view);
+        if (!f.visibleBounds(view,rect) || view.getVisibility()!=VISIBLE) return null;
+        Bitmap bitmap=f.snapshot(view,(long)maxPixels); if (bitmap==null) return null;
+        f.source=bitmap; f.sourceWidth=rect.width(); f.sourceHeight=rect.height(); f.sourceImage=image;
+        f.pose[0]=rect.left/f.density; f.pose[1]=rect.top/f.density; f.pose[2]=rect.width()/f.density; f.pose[3]=rect.height()/f.density; f.pose[4]=radius*rect.width()/view.getWidth();
+        f.hide(view); f.root.getOverlay().add(f); active++; return f;
+    }
+
+    private double[] navigationGeometry(View view, double radius) {
+        if(!(view instanceof ImageView)) return null;
+        ImageView image=(ImageView)view;
+        if(!(image.getDrawable() instanceof BitmapDrawable) || image.getColorFilter()!=null || image.getPaddingLeft()!=0 || image.getPaddingTop()!=0 || image.getPaddingRight()!=0 || image.getPaddingBottom()!=0) return null;
+        if(image.getScaleType()!=ImageView.ScaleType.FIT_CENTER && image.getScaleType()!=ImageView.ScaleType.CENTER_CROP) return null;
+        Bitmap bitmap=((BitmapDrawable)image.getDrawable()).getBitmap(); if(bitmap==null || bitmap.isRecycled())return null;
+        RectF rect=geometry(view), clip=clippedImage?visibleClip(view,rect):rect;
+        if(clippedImage?clip==null:!visibleBounds(view,rect))return null;
+        double scale=image.getScaleType()==ImageView.ScaleType.CENTER_CROP?Math.max(rect.width()/bitmap.getWidth(),rect.height()/bitmap.getHeight()):Math.min(rect.width()/bitmap.getWidth(),rect.height()/bitmap.getHeight());
+        double w=bitmap.getWidth()*scale,h=bitmap.getHeight()*scale;
+        double[] pose=new double[]{rect.left/density,rect.top/density,rect.width()/density,rect.height()/density,radius*rect.width()/view.getWidth(),(rect.width()-w)/2/density,(rect.height()-h)/2/density,w/density,h/density};
+        if(!clippedImage)return pose;
+        double[] clipped=Arrays.copyOf(pose,13);clipped[9]=clip.left/density;clipped[10]=clip.top/density;clipped[11]=clip.width()/density;clipped[12]=clip.height()/density;return clipped;
+    }
+    public static SharedLayoutFlight captureNavigationImage(View view, double radius, double maxPixels) {
+        return captureNavigationImage(view,radius,maxPixels,false);
+    }
+    public static SharedLayoutFlight captureClippedNavigationImage(View view, double radius, double maxPixels) {
+        return captureNavigationImage(view,radius,maxPixels,true);
+    }
+    private static SharedLayoutFlight captureNavigationImage(View view, double radius, double maxPixels, boolean clipped) {
+        if(!(view.getRootView() instanceof ViewGroup) || view.getVisibility()!=VISIBLE)return null;
+        SharedLayoutFlight f=new SharedLayoutFlight(view);
+        f.clippedImage=clipped;
+        double[] pose=f.navigationGeometry(view,radius); if(pose==null)return null;
+        Bitmap image=((BitmapDrawable)((ImageView)view).getDrawable()).getBitmap();
+        if((long)image.getWidth()*image.getHeight()>maxPixels)return null;
+        f.navigationImage=true; f.source=image;
+        for(int i=0;i<pose.length;i++)f.pose[i<5?i:i+1]=pose[i];
+        f.hide(view); f.root.getOverlay().add(f); active++; return f;
+    }
+    public String prepareNavigationImage(View view, double radius, double maxPixels) {
+        if(disposed || !navigationImage || view.getVisibility()!=VISIBLE)return null;
+        double[] geometry=navigationGeometry(view,radius); if(geometry==null)return null;
+        Bitmap image=((BitmapDrawable)((ImageView)view).getDrawable()).getBitmap();
+        if((long)image.getWidth()*image.getHeight()+pixels()>maxPixels || Math.abs((double)image.getWidth()/image.getHeight()-(double)source.getWidth()/source.getHeight())>.001)return null;
+        target=image; destination=view; destinationFrame=geometry(view); hide(view);
+        try { return new JSONArray(geometry).toString(); } catch(JSONException error) { throw new IllegalStateException(error); }
+    }
+
+    public boolean holdPage(View page,double maxPixels) {
+        if(disposed || pageBitmap!=null || page==null || unsupported(page, true))return false;
+        RectF frame=geometry(page);if(frame==null)return false;
+        long pixels=(long)page.getWidth()*page.getHeight();if(pixels<=0 || pixels+pixels()>maxPixels)return false;
+        try {pageBitmap=Bitmap.createBitmap(page.getWidth(),page.getHeight(),Bitmap.Config.ARGB_8888);page.draw(new Canvas(pageBitmap));}
+        catch(RuntimeException | OutOfMemoryError error){if(pageBitmap!=null)pageBitmap.recycle();pageBitmap=null;return false;}
+        pageFrame=frame;return true;
+    }
+    public void fade(double milliseconds,Listener callback) {
+        if(disposed){if(callback!=null)callback.onEnd(false);return;}
+        Choreographer.getInstance().removeFrameCallback(this);fading=true;running=true;duration=Math.max(1,Math.min(500,milliseconds));started=android.os.SystemClock.uptimeMillis();listener=callback;
+        Choreographer.getInstance().postFrameCallback(this);
+    }
+    public double pixels() { return (pageBitmap==null?0:(long)pageBitmap.getWidth()*pageBitmap.getHeight())+(source==null?0:(long)source.getWidth()*source.getHeight())+(target==null?0:(long)target.getWidth()*target.getHeight()); }
+    public String state() {
+        try { JSONObject out=new JSONObject(); out.put("pose",new JSONArray(java.util.Arrays.copyOf(pose,navigationImage?(clippedImage?14:10):6))); out.put("velocity",new JSONArray(java.util.Arrays.copyOf(velocity,navigationImage?(clippedImage?14:10):5))); return out.toString(); }
+        catch (JSONException error) { throw new IllegalStateException(error); }
+    }
+    public String prepare(View view, boolean image, double radius, double maxPixels) {
+        if (disposed || (view.getVisibility()!=VISIBLE && !hidden.containsKey(view))) return null;
+        RectF rect=geometry(view);
+        if (!visibleBounds(view,rect)) return null;
+        Bitmap bitmap=snapshot(view,(long)(maxPixels-pixels())); if(bitmap==null) return null;
+        if(target!=null) target.recycle(); target=bitmap; targetWidth=rect.width(); targetHeight=rect.height(); targetImage=image;
+        destination=view; destinationFrame=rect; hide(view);
+        try { return new JSONArray(new double[]{rect.left/density,rect.top/density,rect.width()/density,rect.height()/density,radius*rect.width()/view.getWidth()}).toString(); } catch(JSONException error) { throw new IllegalStateException(error); }
+    }
+    static final class Anchor {
+        Bitmap bitmap; boolean image; double[] geometry; float width,height;
+        void dispose() { if(!image && bitmap!=null)bitmap.recycle(); bitmap=null; }
+        long pixels() { return bitmap==null?0:(long)bitmap.getWidth()*bitmap.getHeight(); }
+    }
+    static Anchor anchor(View view, boolean image, double radius, double budget) {
+        if(view==null || !(view.getRootView() instanceof ViewGroup) || view.getVisibility()!=VISIBLE)return null;
+        SharedLayoutFlight probe=new SharedLayoutFlight(view);
+        RectF rect=probe.geometry(view); if(!probe.visibleBounds(view,rect))return null;
+        Anchor a=new Anchor(); a.image=image; a.width=rect.width(); a.height=rect.height();
+        if(image) {
+            a.geometry=probe.navigationGeometry(view,radius); if(a.geometry==null)return null;
+            a.bitmap=((BitmapDrawable)((ImageView)view).getDrawable()).getBitmap();
+            if(a.pixels()>budget)return null;
+        } else {
+            a.bitmap=probe.snapshot(view,(long)budget); if(a.bitmap==null)return null;
+            a.geometry=new double[]{rect.left/probe.density,rect.top/probe.density,rect.width()/probe.density,rect.height()/probe.density,radius*rect.width()/view.getWidth()};
+        }
+        return a;
+    }
+    boolean prepareAnchor(Anchor anchor, double budget) {
+        if(disposed || anchor==null || anchor.bitmap==null || navigationImage!=anchor.image || pixels()+anchor.pixels()>budget)return false;
+        if(navigationImage && Math.abs((double)source.getWidth()/source.getHeight()-(double)anchor.bitmap.getWidth()/anchor.bitmap.getHeight())>.001)return false;
+        target=anchor.bitmap; borrowedTarget=true; targetWidth=anchor.width; targetHeight=anchor.height; targetImage=false;
+        interactiveStart=pose.clone(); interactiveEnd=pose.clone();
+        for(int i=0;i<anchor.geometry.length;i++)interactiveEnd[i<5?i:i+1]=anchor.geometry[i];
+        interactiveEnd[5]=1; return true;
+    }
+    void updateInteractive(double progress) {
+        if(disposed || interactiveStart==null)return;
+        double p=Math.max(0,Math.min(1,Double.isFinite(progress)?progress:0));
+        for(int i=0;i<pose.length;i++)pose[i]=interactiveStart[i]+(interactiveEnd[i]-interactiveStart[i])*p;
+        invalidate();
+    }
+    public boolean freeze(double maxPixels) {
+        if(disposed) return false;
+        if(running) evaluate(android.os.SystemClock.uptimeMillis());
+        running=false; Choreographer.getInstance().removeFrameCallback(this); listener=null;
+        int w=Math.max(1,(int)Math.ceil(pose[2]*density)),h=Math.max(1,(int)Math.ceil(pose[3]*density));
+        if((long)w*h+pixels()>maxPixels) return false;
+        Bitmap bitmap;
+        try { bitmap=Bitmap.createBitmap(w,h,Bitmap.Config.ARGB_8888); } catch(OutOfMemoryError error) { return false; }
+        Canvas canvas=new Canvas(bitmap); canvas.translate((float)-pose[0]*density,(float)-pose[1]*density); render(canvas);
+        if(source!=null && !navigationImage) source.recycle(); if(target!=null && !borrowedTarget) target.recycle();
+        source=bitmap; target=null; sourceWidth=(float)pose[2]*density; sourceHeight=(float)pose[3]*density; sourceImage=false; pose[5]=0;
+        destination=null; invalidate(); return true;
+    }
+    public void play(String json, Listener callback) {
+        if(disposed) return;
+        try {
+            JSONObject config=new JSONObject(json); JSONArray tracks=config.getJSONArray("tracks");
+            int count=navigationImage?(clippedImage?14:10):6; times=new double[count][]; values=new double[count][]; duration=0;
+            for(int k=0;k<(navigationImage?(clippedImage?14:10):6);k++) {
+                JSONObject track=tracks.getJSONObject(k); JSONArray t=track.getJSONArray("times"),v=track.getJSONArray("values");
+                times[k]=new double[t.length()]; values[k]=new double[v.length()];
+                for(int j=0;j<t.length();j++){times[k][j]=t.getDouble(j);values[k][j]=v.getDouble(j);}
+                duration=Math.max(duration,times[k][t.length()-1]);
+            }
+        } catch(JSONException error) { throw new IllegalArgumentException(error); }
+        listener=callback; started=android.os.SystemClock.uptimeMillis(); running=true;
+        Choreographer.getInstance().postFrameCallback(this);
+    }
+    private void evaluate(double now) {
+        double elapsed=Math.max(0,now-started);
+        for(int k=0;k<(navigationImage?(clippedImage?14:10):6);k++) {
+            double[] t=times[k],v=values[k]; int j=1;
+            while(j<t.length-1 && t[j]<elapsed)j++;
+            double span=t[j]-t[j-1], fraction=span<=0?1:Math.max(0,Math.min(1,(elapsed-t[j-1])/span));
+            pose[k]=v[j-1]+(v[j]-v[j-1])*fraction;
+            if(k!=5) velocity[k]=elapsed>=t[t.length-1]||span<=0?0:(v[j]-v[j-1])*1000/span;
+        }
+    }
+    @Override public void doFrame(long nanos) {
+        if(!running || disposed)return;
+        if(fading){double p=Math.min(1,(android.os.SystemClock.uptimeMillis()-started)/duration);setAlpha((float)(1-p));if(p>=1)end(true);else Choreographer.getInstance().postFrameCallback(this);return;}
+        RectF frame=geometry(destination);
+        if(root.getWidth()!=rootWidth || root.getHeight()!=rootHeight || frame==null || Math.abs(frame.left-destinationFrame.left)>1 || Math.abs(frame.top-destinationFrame.top)>1 || Math.abs(frame.width()-destinationFrame.width())>1 || Math.abs(frame.height()-destinationFrame.height())>1) { end(false); return; }
+        double now=android.os.SystemClock.uptimeMillis(); evaluate(now); invalidate();
+        if(now-started>=duration)end(true); else Choreographer.getInstance().postFrameCallback(this);
+    }
+    private void end(boolean completed) { Listener callback=listener; listener=null; running=false; Choreographer.getInstance().removeFrameCallback(this); if(callback!=null)callback.onEnd(completed); }
+    private void bitmap(Canvas canvas,Bitmap bitmap,float width,float height,boolean image,float alpha,RectF box) {
+        if(bitmap==null || alpha<=0)return;
+        float scale=image?Math.max(box.width()/width,box.height()/height):1;
+        float w=width*scale,h=height*scale;
+        paint.setAlpha(Math.round(alpha*255)); canvas.drawBitmap(bitmap,null,new RectF(box.centerX()-w/2,box.centerY()-h/2,box.centerX()+w/2,box.centerY()+h/2),paint);
+    }
+    private void render(Canvas canvas) {
+        if(pageBitmap!=null){paint.setAlpha((int)Math.round((1-Math.max(0,Math.min(1,pose[5])))*255));canvas.drawBitmap(pageBitmap,null,pageFrame,paint);}
+        RectF box=new RectF((float)pose[0]*density,(float)pose[1]*density,(float)(pose[0]+Math.max(.1,pose[2]))*density,(float)(pose[1]+Math.max(.1,pose[3]))*density);
+        float radius=(float)Math.max(0,Math.min(pose[4]*density,Math.min(box.width(),box.height())/2));
+        Path path=new Path(); path.addRoundRect(box,radius,radius,Path.Direction.CW); int save=canvas.save(); canvas.clipPath(path);
+        if(navigationImage) {
+            if(clippedImage)canvas.clipRect((float)pose[10]*density,(float)pose[11]*density,(float)(pose[10]+Math.max(0,pose[12]))*density,(float)(pose[11]+Math.max(0,pose[13]))*density);
+            paint.setAlpha(255);
+            canvas.drawBitmap(source,null,new RectF(box.left+(float)pose[6]*density,box.top+(float)pose[7]*density,box.left+(float)(pose[6]+Math.max(.1,pose[8]))*density,box.top+(float)(pose[7]+Math.max(.1,pose[9]))*density),paint);
+            canvas.restoreToCount(save); return;
+        }
+        int composite=canvas.saveLayer(box,null);
+        float mix=(float)Math.max(0,Math.min(1,pose[5]));
+        bitmap(canvas,source,sourceWidth,sourceHeight,sourceImage,1-mix,box);
+        paint.setXfermode(ADD); bitmap(canvas,target,targetWidth,targetHeight,targetImage,mix,box); paint.setXfermode(null);
+        canvas.restoreToCount(composite); canvas.restoreToCount(save);
+    }
+    @Override protected void onDraw(Canvas canvas) { render(canvas); }
+    public void dispose() {
+        if(disposed)return; disposed=true; running=false; listener=null;
+        Choreographer.getInstance().removeFrameCallback(this); root.getOverlay().remove(this); active--;
+        for(Map.Entry<View,Integer> entry:hidden.entrySet()) if(entry.getKey().getVisibility()==INVISIBLE)entry.getKey().setVisibility(entry.getValue()); hidden.clear();
+        if(!navigationImage) { if(source!=null)source.recycle(); if(target!=null && !borrowedTarget)target.recycle(); } source=null;target=null;destination=null;if(pageBitmap!=null)pageBitmap.recycle();pageBitmap=null;
+    }
+}