@rafaelaugusto/jolt 0.1.0-beta.1 → 0.1.0-beta.11

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

@@ -0,0 +1,195 @@
+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.LinearGradient;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.RadialGradient;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.graphics.SweepGradient;
+import android.view.animation.LinearInterpolator;
+
+/** Paints a linear, radial or conic gradient and plays sampled frames. All frame updates stay in native code. */
+public final class GradientLayer extends android.graphics.drawable.Drawable {
+    public interface Listener {
+        void onEnd(boolean finished);
+    }
+
+    // 0 = linear, 1 = radial, 2 = conic.
+    private final int type;
+    private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private final RectF area = new RectF();
+    private final Matrix matrix = new Matrix();
+    private int[] colors = new int[0];
+    private float[] stops = new float[0];
+    // angle, x, y, radius
+    private final float[] geometry = new float[4];
+    private float corner;
+    private ValueAnimator animator;
+    private Listener listener;
+
+    private float[] times;
+    private int[] frameColors;
+    private float[] frameStops;
+    private float[] frameGeometry;
+
+    public GradientLayer(int type) {
+        this.type = type;
+    }
+
+    public void setCorner(float radius) {
+        corner = radius;
+        invalidateSelf();
+    }
+
+    public void paint(int[] colors, float[] stops, float angle, float x, float y, float radius) {
+        cancel();
+        this.colors = colors;
+        this.stops = stops;
+        geometry[0] = angle;
+        geometry[1] = x;
+        geometry[2] = y;
+        geometry[3] = radius;
+        invalidateSelf();
+    }
+
+    /** Frames are flattened: `colors.length / times.length` colors and stops per frame, four geometry values per frame. */
+    public void play(float[] times, int[] colors, float[] stops, float[] geometry, long duration, long delay, int repeat, boolean reverse, Listener listener) {
+        cancel();
+        this.times = times;
+        frameColors = colors;
+        frameStops = stops;
+        frameGeometry = geometry;
+        this.listener = listener;
+        int count = colors.length / times.length;
+        this.colors = new int[count];
+        this.stops = new float[count];
+        apply(0);
+        final ValueAnimator animation = ValueAnimator.ofFloat(0f, 1f);
+        animation.setDuration(Math.max(duration, 1));
+        animation.setStartDelay(delay);
+        animation.setInterpolator(new LinearInterpolator());
+        if (repeat != 0) {
+            animation.setRepeatCount(repeat < 0 ? ValueAnimator.INFINITE : repeat);
+            animation.setRepeatMode(reverse ? ValueAnimator.REVERSE : ValueAnimator.RESTART);
+        }
+        animation.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator updated) {
+                apply(updated.getAnimatedFraction());
+                invalidateSelf();
+            }
+        });
+        animation.addListener(new AnimatorListenerAdapter() {
+            private boolean cancelled;
+
+            @Override
+            public void onAnimationCancel(Animator ended) {
+                cancelled = true;
+            }
+
+            @Override
+            public void onAnimationEnd(Animator ended) {
+                if (animator != animation) return;
+                animator = null;
+                Listener done = GradientLayer.this.listener;
+                GradientLayer.this.listener = null;
+                if (done != null) done.onEnd(!cancelled);
+            }
+        });
+        animator = animation;
+        animation.start();
+    }
+
+    public void cancel() {
+        ValueAnimator running = animator;
+        animator = null;
+        listener = null;
+        if (running != null) running.cancel();
+    }
+
+    private void apply(float fraction) {
+        int frames = times.length;
+        int count = colors.length;
+        int i = 0;
+        while (i < frames - 2 && fraction > times[i + 1]) i++;
+        float span = times[i + 1] - times[i];
+        float t = span > 0 ? Math.max(0f, Math.min(1f, (fraction - times[i]) / span)) : 1f;
+        for (int c = 0; c < count; c++) {
+            colors[c] = lerpColor(frameColors[i * count + c], frameColors[(i + 1) * count + c], t);
+            stops[c] = lerp(frameStops[i * count + c], frameStops[(i + 1) * count + c], t);
+        }
+        for (int g = 0; g < 4; g++) geometry[g] = lerp(frameGeometry[i * 4 + g], frameGeometry[(i + 1) * 4 + g], t);
+    }
+
+    private static float lerp(float a, float b, float t) {
+        return a + (b - a) * t;
+    }
+
+    private static int lerpColor(int a, int b, float t) {
+        int alpha = Math.round(lerp((a >>> 24) & 0xff, (b >>> 24) & 0xff, t));
+        int red = Math.round(lerp((a >> 16) & 0xff, (b >> 16) & 0xff, t));
+        int green = Math.round(lerp((a >> 8) & 0xff, (b >> 8) & 0xff, t));
+        int blue = Math.round(lerp(a & 0xff, b & 0xff, t));
+        return (alpha << 24) | (red << 16) | (green << 8) | blue;
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        Rect bounds = getBounds();
+        float width = bounds.width();
+        float height = bounds.height();
+        if (width <= 0 || height <= 0 || colors.length < 2) return;
+        double radians = Math.toRadians(geometry[0]);
+        float sin = (float) Math.sin(radians);
+        float cos = (float) Math.cos(radians);
+        float left = bounds.left;
+        float top = bounds.top;
+        Shader shader;
+        if (type == 0) {
+            float half = (Math.abs(width * sin) + Math.abs(height * cos)) / 2f;
+            float cx = left + width / 2f;
+            float cy = top + height / 2f;
+            shader = new LinearGradient(cx - sin * half, cy + cos * half, cx + sin * half, cy - cos * half, colors, stops, Shader.TileMode.CLAMP);
+        } else if (type == 1) {
+            float radius = Math.max(geometry[3] * Math.min(width, height), 0.01f);
+            shader = new RadialGradient(left + geometry[1] * width, top + geometry[2] * height, radius, colors, stops, Shader.TileMode.CLAMP);
+        } else {
+            float cx = left + geometry[1] * width;
+            float cy = top + geometry[2] * height;
+            SweepGradient sweep = new SweepGradient(cx, cy, colors, stops);
+            // Turned so the first color starts at 12 o'clock and sweeps clockwise, as on iOS and in CSS.
+            matrix.setRotate(geometry[0] + 90f, cx, cy);
+            sweep.setLocalMatrix(matrix);
+            shader = sweep;
+        }
+        paint.setShader(shader);
+        area.set(bounds);
+        if (corner > 0) canvas.drawRoundRect(area, corner, corner, paint);
+        else canvas.drawRect(area, 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;
+    }
+}

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

@@ -0,0 +1,288 @@
+package org.rafaelaugusto.jolt;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.graphics.*;
+import android.graphics.drawable.*;
+import android.os.Build;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.ImageView;
+
+/** Image-only GPU effects. All animation and pointer samples stay in Java. */
+public final class ImageEffect {
+    public interface Listener { void onEnd(boolean completed, float progress); }
+    private static final String SHADER =
+        "uniform shader source; uniform shader destination; uniform float2 size;" +
+        "uniform float2 origin; uniform float2 displacement; uniform float progress;" +
+        "uniform float amplitude; uniform float radius; uniform float seed; uniform float mode;" +
+        "half4 main(float2 p) { float2 uv=p/size; float2 q=p;" +
+        "if(mode<1.5){ float2 v=p-origin; float d=length(v);" +
+        "float edge=clamp(min(min(p.x,size.x-p.x),min(p.y,size.y-p.y))/max(amplitude*2.,1.),0.,1.);" +
+        "if(mode<.5){float wave=d-progress*length(size);" +
+        "float a=sin(wave/max(radius*.12,1.))*exp(-pow(wave/max(radius,1.),2.))*amplitude*sin(progress*3.14159265);" +
+        "q-=v/max(d,1.)*a*edge;}else{q-=displacement*exp(-d*d/max(radius*radius,1.))*edge;}" +
+        "return source.eval(clamp(q,float2(.5),size-float2(.5)));}" +
+        "if(progress<=0.)return source.eval(p); if(progress>=1.)return destination.eval(p);" +
+        "float n=fract(sin(dot(floor(p/3.),float2(12.9898,78.233))+seed)*43758.5453);" +
+        "float a=smoothstep(n-.08,n+.08,progress*1.16-.08);" +
+        "return mix(source.eval(p),destination.eval(p),a);}";
+
+    private final ImageView view;
+    private final Listener listener;
+    private final int mode;
+    private final float amplitude, radius;
+    private final long duration;
+    private final Drawable original;
+    private final Bitmap originalBitmap;
+    private final ImageView.ScaleType originalScale;
+    private final View.OnTouchListener previousTouch;
+    private final boolean originalClickable;
+    private Bitmap source, destination, placeholderBitmap;
+    private RuntimeShader shader;
+    private EffectDrawable drawable;
+    private Drawable placeholder;
+    private ValueAnimator animator;
+    private boolean disposed, paused, suppressEnd, attached;
+    private float progress, goal = 1, x, y, dx, dy;
+    private int pointer = -1;
+    private float startX, startY, rawX, rawY;
+    private long frames, lastFrame, longestFrame;
+    private String failureReason="";
+    private final Path contentClip=new Path();
+
+    public ImageEffect(ImageView view, Bitmap from, Bitmap to, float[] geometry, int mode, float x, float y,
+                       float amplitude, float radius, long duration, float seed,
+                       View.OnTouchListener previousTouch, Listener listener) {
+        this.view=view; this.listener=listener; this.mode=mode;
+        this.amplitude=amplitude; this.radius=radius; this.duration=duration;
+        this.x=x; this.y=y; this.previousTouch=previousTouch;
+        original=view.getDrawable(); originalScale=view.getScaleType();
+        originalBitmap=from;
+        originalClickable=view.isClickable();
+        if(Build.VERSION.SDK_INT<33 || !view.isHardwareAccelerated() || from==null || original==null || original instanceof Animatable) {
+            failureReason="Requires API 33, hardware rendering and a static drawable ("+(original==null?"null":original.getClass().getName())+")";
+            return;
+        }
+        int w=view.getWidth(), h=view.getHeight();
+        if(w<=0 || h<=0 || (long)w*h>4194304L) {failureReason="Image surface exceeds the pixel budget";return;}
+        try {
+            float left=view.getPaddingLeft(),top=view.getPaddingTop(),right=view.getPaddingRight(),bottom=view.getPaddingBottom();
+            float[] radii={
+                Math.max(0,geometry[2]-left),Math.max(0,geometry[2]-top),
+                Math.max(0,geometry[3]-right),Math.max(0,geometry[3]-top),
+                Math.max(0,geometry[4]-right),Math.max(0,geometry[4]-bottom),
+                Math.max(0,geometry[5]-left),Math.max(0,geometry[5]-bottom)
+            };
+            contentClip.addRoundRect(new RectF(left,top,w-right,h-bottom),radii,Path.Direction.CW);
+            source=raster(from,geometry[0],w,h);
+            if(mode==2) {
+                if(to==null) { releaseBitmaps(); return; }
+                destination=raster(to,geometry[1],w,h);
+            }
+            shader=new RuntimeShader(SHADER);
+            shader.setInputShader("source",new BitmapShader(source,Shader.TileMode.CLAMP,Shader.TileMode.CLAMP));
+            shader.setInputShader("destination",new BitmapShader(destination==null?source:destination,Shader.TileMode.CLAMP,Shader.TileMode.CLAMP));
+            shader.setFloatUniform("size",w,h); shader.setFloatUniform("mode",mode);
+            shader.setFloatUniform("amplitude",amplitude); shader.setFloatUniform("radius",radius);
+            shader.setFloatUniform("seed",seed);
+            drawable=new EffectDrawable(w,h);
+            drawable.setBounds(0,0,w,h);
+            update();
+            // NativeScript's ImageView rasterizes custom drawables on a software
+            // canvas. An overlay keeps RuntimeShader on the hardware canvas.
+            view.getOverlay().add(drawable);
+            attached=true;
+            // NativeScript's onDraw clips the canvas to its bitmap's mapped
+            // rectangle, including overlays. A full-content transparent alpha
+            // bitmap keeps that clip open in every stretch/rotation mode.
+            // Clearing the drawable leaves its cached bitmap shader invalid.
+            int pw=Math.max(1,w-view.getPaddingLeft()-view.getPaddingRight());
+            int ph=Math.max(1,h-view.getPaddingTop()-view.getPaddingBottom());
+            float angle=Math.abs(geometry[0]%180);
+            if(angle>45 && angle<135){int swap=pw;pw=ph;ph=swap;}
+            placeholderBitmap=Bitmap.createBitmap(pw,ph,Bitmap.Config.ALPHA_8);
+            view.setImageBitmap(placeholderBitmap);
+            placeholder=view.getDrawable();
+            if(mode==1) {
+                view.setClickable(true);
+                view.setOnTouchListener(this::touch);
+            }
+        } catch (RuntimeException | OutOfMemoryError error) {
+            failureReason=error.toString();
+            if(attached) restore(true);
+            releaseBitmaps(); shader=null; drawable=null;
+        }
+    }
+
+    /** Match NativeScript's bitmap mapping without baking backgrounds/borders
+     * into the texture. The stationary inner corner mask is applied at draw time. */
+    private Bitmap raster(Bitmap bitmap,float rotation,int width,int height) {
+        Bitmap result=Bitmap.createBitmap(width,height,Bitmap.Config.ARGB_8888);
+        Canvas canvas=new Canvas(result);
+        float left=view.getPaddingLeft(),top=view.getPaddingTop();
+        float w=width-left-view.getPaddingRight(),h=height-top-view.getPaddingBottom();
+        float iw=bitmap.getWidth(),ih=bitmap.getHeight();
+        Matrix matrix=new Matrix();matrix.postRotate(rotation,iw/2,ih/2);
+        float angle=Math.abs(rotation%180);
+        if(angle>45 && angle<135){matrix.postTranslate((ih-iw)/2,(iw-ih)/2);float swap=iw;iw=ih;ih=swap;}
+        float sx=w/iw,sy=h/ih;
+        RectF visible=new RectF(left,top,left+w,top+h);
+        if(originalScale==ImageView.ScaleType.FIT_XY) matrix.postScale(sx,sy);
+        else if(originalScale==ImageView.ScaleType.MATRIX) visible.intersect(left,top,left+iw,top+ih);
+        else {
+            float scale=originalScale==ImageView.ScaleType.CENTER?1:originalScale==ImageView.ScaleType.CENTER_CROP?Math.max(sx,sy):Math.min(sx,sy);
+            matrix.postTranslate((w-iw)/2,(h-ih)/2);
+            matrix.postScale(scale,scale,w/2,h/2);
+            visible.intersect(left+(w-iw*scale)/2,top+(h-ih*scale)/2,left+(w+iw*scale)/2,top+(h+ih*scale)/2);
+        }
+        matrix.postTranslate(left,top);
+        BitmapShader pixels=new BitmapShader(bitmap,Shader.TileMode.CLAMP,Shader.TileMode.CLAMP);
+        pixels.setLocalMatrix(matrix);
+        Paint paint=new Paint(Paint.ANTI_ALIAS_FLAG|Paint.FILTER_BITMAP_FLAG);
+        paint.setShader(pixels);paint.setColorFilter(view.getColorFilter());
+        canvas.drawRect(visible,paint);
+        return result;
+    }
+
+    public boolean isSupported() { return drawable!=null && !disposed; }
+    public String getFailureReason() { return failureReason; }
+    public float getProgress() { return progress; }
+    public long getFrames() { return frames; }
+    public long getLongestFrameNanos() { return longestFrame; }
+    public long getTextureBytes() { return source==null?0:(long)source.getAllocationByteCount()+(destination==null?0:destination.getAllocationByteCount())+(placeholderBitmap==null?0:placeholderBitmap.getAllocationByteCount()); }
+    public boolean isPaused() { return paused; }
+
+    public void play(float destinationProgress) {
+        if(disposed || drawable==null || mode==1) return;
+        goal=destinationProgress; paused=false;
+        animate(progress,goal,Math.max(1,(long)(duration*Math.abs(goal-progress))),false);
+    }
+    public void pause() {
+        paused=true;
+        if(animator!=null) animator.pause();
+    }
+    public void resume() {
+        if(disposed) return;
+        paused=false;
+        lastFrame=0;
+        if(animator!=null && animator.isPaused()) animator.resume();
+    }
+    public void seek(float value) {
+        if(disposed || mode==1) return;
+        boolean hold=paused;
+        cancelAnimator(); progress=value; update();
+        if(!hold) play(goal);
+    }
+    public void finish(float endpoint) {
+        if(disposed || mode==1) return;
+        cancelAnimator(); progress=endpoint; update();
+        listener.onEnd(true,progress);
+    }
+    public void stop() {
+        detach(true);
+    }
+    public void stopPreservingImage() {
+        detach(false);
+    }
+    private void detach(boolean restoreImage) {
+        if(disposed) return;
+        disposed=true; cancelAnimator();
+        restore(restoreImage); shader=null; drawable=null; releaseBitmaps();
+    }
+    private void restore(boolean restoreImage) {
+        if(attached && drawable!=null) view.getOverlay().remove(drawable);
+        if(restoreImage && attached && view.getDrawable()==placeholder) {
+            // NativeScript caches mBitmap separately from its drawable. Restoring
+            // only the drawable leaves the placeholder's geometry behind.
+            view.setImageBitmap(originalBitmap);
+        }
+        if(mode==1 && drawable!=null) {
+            view.setOnTouchListener(previousTouch); view.setClickable(originalClickable);
+            if(view.getParent()!=null) view.getParent().requestDisallowInterceptTouchEvent(false);
+        }
+        attached=false;
+    }
+    private void releaseBitmaps() {
+        // Draw commands may still reference them; let Android retire the backing storage safely.
+        source=null; destination=null; placeholderBitmap=null;
+    }
+    private void cancelAnimator() {
+        if(animator==null) return;
+        suppressEnd=true; animator.cancel(); animator=null; suppressEnd=false;
+    }
+    private void animate(float from,float to,long milliseconds,boolean settle) {
+        cancelAnimator();
+        lastFrame=0;
+        final float startDx=dx,startDy=dy;
+        animator=ValueAnimator.ofFloat(from,to);
+        animator.setDuration(milliseconds);
+        animator.setInterpolator(new android.view.animation.LinearInterpolator());
+        animator.addUpdateListener(a->{
+            float value=(float)a.getAnimatedValue();
+            if(settle) {float t=value; float decay=(float)(Math.exp(-8*t)*(1-t)); dx=startDx*decay; dy=startDy*decay;}
+            else progress=value;
+            update();
+        });
+        animator.addListener(new AnimatorListenerAdapter(){
+            @Override public void onAnimationEnd(Animator a){
+                if(suppressEnd || disposed) return;
+                animator=null;
+                if(settle) {dx=dy=0;update();}
+                else listener.onEnd(true,progress);
+            }
+        });
+        animator.start();
+    }
+    private boolean touch(View target,MotionEvent event) {
+        if(disposed || paused) return false;
+        int action=event.getActionMasked();
+        if(action==MotionEvent.ACTION_DOWN) {
+            cancelAnimator(); pointer=event.getPointerId(0);
+            x=startX=event.getX(); y=startY=event.getY(); dx=dy=rawX=rawY=0;
+            update(); return true;
+        }
+        int index=event.findPointerIndex(pointer);
+        if(action==MotionEvent.ACTION_MOVE && index>=0) {
+            float vx=event.getX(index)-startX,vy=event.getY(index)-startY;
+            rawX=vx;rawY=vy;
+            float length=(float)Math.hypot(vx,vy);
+            float factor=length==0?0:(float)(amplitude*Math.tanh(length/Math.max(amplitude,1))/length);
+            dx=vx*factor; dy=vy*factor; update(); return true;
+        }
+        if(action==MotionEvent.ACTION_POINTER_UP && event.getPointerId(event.getActionIndex())==pointer) {
+            int next=event.getActionIndex()==0?1:0;
+            if(next<event.getPointerCount()) {
+                pointer=event.getPointerId(next); startX=event.getX(next)-rawX;startY=event.getY(next)-rawY;
+            }
+        }
+        if(action==MotionEvent.ACTION_UP || action==MotionEvent.ACTION_CANCEL) {
+            pointer=-1; animate(0,1,Math.min(600,duration),true);
+            if(action==MotionEvent.ACTION_UP) view.performClick();
+        }
+        return true;
+    }
+    private void update() {
+        if(shader==null || disposed) return;
+        shader.setFloatUniform("origin",x,y);
+        shader.setFloatUniform("displacement",dx,dy);
+        shader.setFloatUniform("progress",progress);
+        if(drawable!=null) drawable.invalidateSelf();
+    }
+    private final class EffectDrawable extends Drawable {
+        private final Paint paint=new Paint(Paint.ANTI_ALIAS_FLAG);
+        private final int width,height;
+        EffectDrawable(int width,int height) {this.width=width;this.height=height;paint.setShader(shader);}
+        @Override public int getIntrinsicWidth(){return width;}
+        @Override public int getIntrinsicHeight(){return height;}
+        @Override public void draw(Canvas canvas){
+            long now=System.nanoTime(); if(lastFrame!=0 && animator!=null && !paused) longestFrame=Math.max(longestFrame,now-lastFrame);
+            lastFrame=now; frames++;
+            canvas.drawPath(contentClip,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;}
+    }
+}

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

@@ -0,0 +1,91 @@
+package org.rafaelaugusto.jolt;
+
+import android.view.View;
+import android.view.WindowInsets;
+import android.view.WindowInsetsAnimation;
+import java.util.List;
+
+/** Keeps a view above the keyboard while the IME animates. All frame updates stay in native code. */
+public final class KeyboardFollower extends WindowInsetsAnimation.Callback {
+    public interface Listener {
+        void onStart();
+        void onSettled(float translation);
+    }
+
+    private final View view;
+    private final float offset;
+    private final Listener listener;
+    private float visualBottom;
+    private float from;
+    private float to;
+    private boolean tracking;
+
+    public KeyboardFollower(View view, float offset, Listener listener) {
+        super(DISPATCH_MODE_CONTINUE_ON_SUBTREE);
+        this.view = view;
+        this.offset = offset;
+        this.listener = listener;
+    }
+
+    public void attach() {
+        view.setWindowInsetsAnimationCallback(this);
+    }
+
+    public void detach() {
+        tracking = false;
+        view.setWindowInsetsAnimationCallback(null);
+        view.setTranslationY(0);
+    }
+
+    private static boolean keyboard(WindowInsetsAnimation animation) {
+        return (animation.getTypeMask() & WindowInsets.Type.ime()) != 0;
+    }
+
+    private float bottom() {
+        int[] location = new int[2];
+        view.getLocationInWindow(location);
+        return location[1] + view.getHeight();
+    }
+
+    @Override
+    public void onPrepare(WindowInsetsAnimation animation) {
+        if (!keyboard(animation)) return;
+        visualBottom = bottom();
+        tracking = true;
+    }
+
+    @Override
+    public WindowInsetsAnimation.Bounds onStart(WindowInsetsAnimation animation, WindowInsetsAnimation.Bounds bounds) {
+        if (!keyboard(animation) || !tracking) return bounds;
+        listener.onStart();
+        // The end state is laid out now; the view may already have moved with the layout.
+        float untranslated = bottom() - view.getTranslationY();
+        WindowInsets insets = view.getRootWindowInsets();
+        int height = insets == null ? 0 : insets.getInsets(WindowInsets.Type.ime()).bottom;
+        float top = view.getRootView().getHeight() - height;
+        to = -Math.max(0, untranslated + offset - top);
+        from = visualBottom - untranslated;
+        view.setTranslationY(from);
+        return bounds;
+    }
+
+    @Override
+    public WindowInsets onProgress(WindowInsets insets, List<WindowInsetsAnimation> running) {
+        if (!tracking) return insets;
+        for (WindowInsetsAnimation animation : running) {
+            if (keyboard(animation)) {
+                view.setTranslationY(from + (to - from) * animation.getInterpolatedFraction());
+                break;
+            }
+        }
+        return insets;
+    }
+
+    @Override
+    public void onEnd(WindowInsetsAnimation animation) {
+        if (!keyboard(animation) || !tracking) return;
+        tracking = false;
+        view.setTranslationY(to);
+        listener.onSettled(to);
+    }
+}

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

@@ -0,0 +1,97 @@
+package org.rafaelaugusto.jolt;
+
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.view.WindowInsets;
+import android.view.WindowInsetsAnimation;
+import android.view.animation.Interpolator;
+import java.util.List;
+
+/** Reports how much of a window the keyboard covers, and how it gets there. Moves nothing. */
+public final class KeyboardObserver extends WindowInsetsAnimation.Callback
+        implements ViewTreeObserver.OnGlobalLayoutListener {
+    public interface Listener {
+        void onChange(int height, long duration, float[] curve);
+    }
+
+    private static final int SAMPLES = 32;
+
+    private final View root;
+    private final Listener listener;
+    private int height;
+    private boolean animating;
+
+    public KeyboardObserver(View root, Listener listener) {
+        super(DISPATCH_MODE_CONTINUE_ON_SUBTREE);
+        this.root = root;
+        this.listener = listener;
+    }
+
+    public void attach() {
+        height = covered();
+        root.setWindowInsetsAnimationCallback(this);
+        root.getViewTreeObserver().addOnGlobalLayoutListener(this);
+    }
+
+    public void detach() {
+        root.setWindowInsetsAnimationCallback(null);
+        root.getViewTreeObserver().removeOnGlobalLayoutListener(this);
+    }
+
+    public int height() {
+        return height;
+    }
+
+    private int covered() {
+        WindowInsets insets = root.getRootWindowInsets();
+        return insets == null ? 0 : insets.getInsets(WindowInsets.Type.ime()).bottom;
+    }
+
+    private static boolean keyboard(WindowInsetsAnimation animation) {
+        return (animation.getTypeMask() & WindowInsets.Type.ime()) != 0;
+    }
+
+    private static float[] sample(Interpolator interpolator) {
+        if (interpolator == null) return null;
+        float[] curve = new float[SAMPLES + 1];
+        for (int i = 0; i <= SAMPLES; i++) curve[i] = interpolator.getInterpolation(i / (float) SAMPLES);
+        return curve;
+    }
+
+    private void report(int next, long duration, float[] curve) {
+        if (next == height) return;
+        height = next;
+        listener.onChange(next, duration, curve);
+    }
+
+    @Override
+    public void onPrepare(WindowInsetsAnimation animation) {
+        // The layout for the end state comes before onStart; let onStart report it with its timing.
+        if (keyboard(animation)) animating = true;
+    }
+
+    @Override
+    public WindowInsetsAnimation.Bounds onStart(WindowInsetsAnimation animation, WindowInsetsAnimation.Bounds bounds) {
+        if (!keyboard(animation)) return bounds;
+        // The end state is already in the root insets when the animation starts.
+        report(covered(), animation.getDurationMillis(), sample(animation.getInterpolator()));
+        return bounds;
+    }
+
+    @Override
+    public WindowInsets onProgress(WindowInsets insets, List<WindowInsetsAnimation> running) {
+        return insets;
+    }
+
+    @Override
+    public void onEnd(WindowInsetsAnimation animation) {
+        if (!keyboard(animation)) return;
+        animating = false;
+        report(covered(), 0, null);
+    }
+
+    @Override
+    public void onGlobalLayout() {
+        if (!animating) report(covered(), 0, null);
+    }
+}