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

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

@@ -0,0 +1,224 @@
+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();
+    }
+
+    /** Rejoin the source position. Binding windows include delays in their frames. */
+    public void control(long elapsed, boolean paused) {
+        if (animator == null) return;
+        animator.setCurrentPlayTime(Math.max(0, elapsed - animator.getStartDelay()));
+        if (paused) animator.pause(); else animator.resume();
+    }
+
+    public boolean isPlaying() { return animator != null; }
+    public float getCorner() { return corner; }
+    public float[] getGeometry() { return geometry.clone(); }
+    public float[] getStops() { return stops.clone(); }
+    public int[] getColors() { return colors.clone(); }
+    public int getSampleCount() { return times == null ? 0 : times.length; }
+
+    public void dispose() {
+        cancel();
+        colors = new int[0];
+        stops = new float[0];
+        setCallback(null);
+    }
+
+    public void cancel() {
+        ValueAnimator running = animator;
+        animator = null;
+        listener = null;
+        if (running != null) {
+            running.removeAllUpdateListeners();
+            running.removeAllListeners();
+            running.cancel();
+        }
+        times = null;
+        frameColors = null;
+        frameStops = null;
+        frameGeometry = null;
+    }
+
+    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/KeyboardFrame.java

@@ -0,0 +1,53 @@
+package org.rafaelaugusto.jolt;
+
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.view.WindowInsets;
+
+/** Before Android 11: how much of the window the keyboard covers, read from the visible frame on each layout. */
+public final class KeyboardFrame implements ViewTreeObserver.OnGlobalLayoutListener {
+    public interface Listener {
+        void onChange(int height);
+    }
+
+    private final View root;
+    private final Listener listener;
+    private int height;
+
+    public KeyboardFrame(View root, Listener listener) {
+        this.root = root;
+        this.listener = listener;
+    }
+
+    public void attach() {
+        height = covered(root);
+        root.getViewTreeObserver().addOnGlobalLayoutListener(this);
+    }
+
+    public void detach() {
+        root.getViewTreeObserver().removeOnGlobalLayoutListener(this);
+    }
+
+    public int height() {
+        return height;
+    }
+
+    /** Pixels of the window below the visible frame, when that is more than the navigation bar. */
+    static int covered(View root) {
+        Rect frame = new Rect();
+        root.getWindowVisibleDisplayFrame(frame);
+        int below = root.getHeight() - frame.bottom;
+        WindowInsets insets = root.getRootWindowInsets();
+        int bars = insets == null ? 0 : insets.getStableInsetBottom();
+        return below > bars ? below : 0;
+    }
+
+    @Override
+    public void onGlobalLayout() {
+        int next = covered(root);
+        if (next == height) return;
+        height = next;
+        listener.onChange(next);
+    }
+}

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

@@ -0,0 +1,57 @@
+package org.rafaelaugusto.jolt;
+
+import android.view.View;
+import android.view.ViewTreeObserver;
+
+/** Before Android 11: catches the view where it was when a keyboard layout moves it, and says where it should end up. */
+public final class KeyboardFrameFollower implements ViewTreeObserver.OnGlobalLayoutListener {
+    public interface Listener {
+        void onMove(float from, float to, int keyboard);
+    }
+
+    private final View view;
+    private final float offset;
+    private final Listener listener;
+    private int keyboard;
+    private float visualBottom;
+
+    public KeyboardFrameFollower(View view, float offset, Listener listener) {
+        this.view = view;
+        this.offset = offset;
+        this.listener = listener;
+    }
+
+    public void attach() {
+        keyboard = KeyboardFrame.covered(view.getRootView());
+        visualBottom = bottom();
+        view.getViewTreeObserver().addOnGlobalLayoutListener(this);
+    }
+
+    public void detach() {
+        view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
+    }
+
+    private float bottom() {
+        int[] location = new int[2];
+        view.getLocationInWindow(location);
+        return location[1] + view.getHeight();
+    }
+
+    @Override
+    public void onGlobalLayout() {
+        int next = KeyboardFrame.covered(view.getRootView());
+        if (next == keyboard) {
+            visualBottom = bottom();
+            return;
+        }
+        keyboard = next;
+        // The layout for the keyboard is done; the view may already have jumped with it.
+        float untranslated = bottom() - view.getTranslationY();
+        float top = view.getRootView().getHeight() - next;
+        float to = next > 0 ? -Math.max(0, untranslated + offset - top) : 0;
+        float from = visualBottom - untranslated;
+        view.setTranslationY(from);
+        visualBottom = untranslated + to;
+        listener.onMove(from, to, next);
+    }
+}

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