@rafaelaugusto/jolt 0.1.0-beta.6 → 0.1.0-beta.7

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/PhotoZoom.java

@@ -0,0 +1,250 @@
+package org.rafaelaugusto.jolt;
+
+import android.animation.ValueAnimator;
+import android.graphics.RectF;
+import android.view.*;
+import android.widget.ImageView;
+
+/** Focal zoom, bounds, pan and dismissal; no pointer/frame callback crosses to JS. */
+public final class PhotoZoom implements View.OnTouchListener, View.OnLayoutChangeListener {
+    public interface Listener {
+        void onDismiss(float x,float y,float scale,float velocity,float progress);
+        void onSettled(float x,float y,float scale);
+    }
+    private final ImageView image;
+    private final View viewport,backdrop,chrome;
+    private final Listener listener;
+    private final View.OnTouchListener previousTouch,previousImageTouch;
+    private final ScaleGestureDetector pinch;
+    private final GestureDetector taps;
+    private final float minimum,maximum,doubleTap,density,slop;
+    private final float bitmapWidth,bitmapHeight;
+    private final boolean dismiss,originalClickable,originalImageClickable,originalClip,originalClipPadding;
+    private final float originalScaleX,originalScaleY,originalX,originalY,backdropAlpha,chromeAlpha;
+    private final RectF content=new RectF();
+    private float anchorX,anchorY,width,height,x,y,scale,progress;
+    private float lastX,lastY,downX,downY,lastFocusX,lastFocusY,vx,vy;
+    private float rawPanX,rawPanY,pinchFloor;
+    private int pointer=-1,mode; // 0 undecided, 1 pan, 2 dismiss, 3 handed to parent
+    private boolean disposed,pending,reduced,active=true;
+    private VelocityTracker velocity;
+    private ValueAnimator animation;
+
+    public PhotoZoom(ImageView image,View viewport,float bitmapWidth,float bitmapHeight,float minimum,float maximum,float doubleTap,
+                     boolean dismiss,boolean reduced,View backdrop,View chrome,
+                     View.OnTouchListener previousTouch,View.OnTouchListener previousImageTouch,Listener listener) {
+        this.image=image;this.viewport=viewport;this.minimum=minimum;this.maximum=maximum;
+        this.bitmapWidth=bitmapWidth;this.bitmapHeight=bitmapHeight;
+        this.doubleTap=doubleTap;this.dismiss=dismiss;this.reduced=reduced;
+        this.backdrop=backdrop;this.chrome=chrome;this.previousTouch=previousTouch;this.listener=listener;
+        this.previousImageTouch=previousImageTouch;
+        density=image.getResources().getDisplayMetrics().density;
+        slop=ViewConfiguration.get(image.getContext()).getScaledTouchSlop();
+        originalScaleX=image.getScaleX();originalScaleY=image.getScaleY();
+        originalX=image.getTranslationX();originalY=image.getTranslationY();
+        originalClickable=viewport.isClickable();
+        originalImageClickable=image.isClickable();
+        originalClip=!(viewport instanceof ViewGroup)||((ViewGroup)viewport).getClipChildren();
+        originalClipPadding=!(viewport instanceof ViewGroup)||((ViewGroup)viewport).getClipToPadding();
+        backdropAlpha=backdrop==null?1:backdrop.getAlpha();chromeAlpha=chrome==null?1:chrome.getAlpha();
+        scale=minimum;
+        pinch=new ScaleGestureDetector(image.getContext(),new ScaleGestureDetector.SimpleOnScaleGestureListener(){
+            @Override public boolean onScaleBegin(ScaleGestureDetector detector){
+                if(pending || disposed) return false;
+                cancelAnimation();mode=1;pinchFloor=Math.min(minimum,scale);
+                lastFocusX=detector.getFocusX();lastFocusY=detector.getFocusY();
+                disallow(true);return true;
+            }
+            @Override public boolean onScale(ScaleGestureDetector detector){
+                float next=clamp(scale*detector.getScaleFactor(),pinchFloor,maximum);
+                float fx=detector.getFocusX(),fy=detector.getFocusY();
+                x=fx-anchorX-(lastFocusX-anchorX-x)*next/scale;
+                y=fy-anchorY-(lastFocusY-anchorY-y)*next/scale;
+                scale=next;lastFocusX=fx;lastFocusY=fy;
+                progress=clamp((minimum-scale)/(minimum*.15f),0,1);
+                rebasePan();
+                apply();return true;
+            }
+        });
+        taps=new GestureDetector(image.getContext(),new GestureDetector.SimpleOnGestureListener(){
+            @Override public boolean onDown(MotionEvent e){return true;}
+            @Override public boolean onDoubleTap(MotionEvent e){
+                if(!pending) zoom(scale>minimum+.01f?minimum:Math.min(maximum,doubleTap),e.getX(),e.getY(),true);
+                return true;
+            }
+            @Override public boolean onSingleTapConfirmed(MotionEvent e){viewport.performClick();return true;}
+        });
+        viewport.setClickable(true);viewport.setOnTouchListener(this);
+        image.setClickable(true);image.setOnTouchListener((v,event)->{
+            MotionEvent local=MotionEvent.obtain(event);
+            local.transform(image.getMatrix());
+            local.offsetLocation(image.getLeft()-viewport.getScrollX(),image.getTop()-viewport.getScrollY());
+            boolean consumed=onTouch(viewport,local);local.recycle();return consumed;
+        });
+        if(viewport instanceof ViewGroup){((ViewGroup)viewport).setClipChildren(true);((ViewGroup)viewport).setClipToPadding(true);}
+        viewport.addOnLayoutChangeListener(this);image.addOnLayoutChangeListener(this);
+        measure();apply();
+    }
+    public float getX(){return x/density;}
+    public float getY(){return y/density;}
+    public float getScale(){return scale;}
+    public float getDismissProgress(){return progress;}
+    public boolean isDismissPending(){return pending;}
+    public void setReduced(boolean value){reduced=value;if(value){if(pending)reset(false);else settle(false);}}
+    public void setActive(boolean value){active=value;if(!value){cancelAnimation();endTouch();pending=false;settle(false);}}
+    public void zoom(float value,float focusX,float focusY,boolean animated){
+        if(disposed || pending) return;
+        cancelAnimation();
+        float next=clamp(value,minimum,maximum);
+        float tx=focusX-anchorX-(focusX-anchorX-x)*next/scale;
+        float ty=focusY-anchorY-(focusY-anchorY-y)*next/scale;
+        float[] bounds=bounds(next);
+        spring(clamp(tx,bounds[0],bounds[1]),clamp(ty,bounds[2],bounds[3]),next,0,0,animated,false);
+    }
+    public void reset(boolean animated){
+        if(disposed)return;
+        pending=false;mode=0;float[] b=bounds(minimum);
+        spring(clamp(0,b[0],b[1]),clamp(0,b[2],b[3]),minimum,0,0,animated,false);
+    }
+    public void requestDismiss(){
+        if(disposed || pending || !dismiss)return;
+        // Programmatic close normalizes zoom before emitting one route intent.
+        float[] b=bounds(minimum);
+        spring(clamp(0,b[0],b[1]),clamp(0,b[2],b[3]),minimum,0,0,true,true);
+    }
+    public void stop(){
+        if(disposed)return;
+        disposed=true;cancelAnimation();endTouch();
+        viewport.setOnTouchListener(previousTouch);viewport.setClickable(originalClickable);
+        image.setOnTouchListener(previousImageTouch);image.setClickable(originalImageClickable);
+        if(viewport instanceof ViewGroup){((ViewGroup)viewport).setClipChildren(originalClip);((ViewGroup)viewport).setClipToPadding(originalClipPadding);}
+        viewport.removeOnLayoutChangeListener(this);image.removeOnLayoutChangeListener(this);
+        image.setScaleX(originalScaleX);image.setScaleY(originalScaleY);
+        image.setTranslationX(originalX);image.setTranslationY(originalY);
+        if(backdrop!=null)backdrop.setAlpha(backdropAlpha);if(chrome!=null)chrome.setAlpha(chromeAlpha);
+    }
+    private void measure(){
+        width=viewport.getWidth();height=viewport.getHeight();
+        float iw=image.getWidth(),ih=image.getHeight();
+        float left=image.getPaddingLeft(),top=image.getPaddingTop();
+        float cw=iw-left-image.getPaddingRight(),ch=ih-top-image.getPaddingBottom();
+        float dw=Math.max(1,bitmapWidth),dh=Math.max(1,bitmapHeight);
+        ImageView.ScaleType fit=image.getScaleType();
+        float factor=fit==ImageView.ScaleType.CENTER_CROP?Math.max(cw/dw,ch/dh):Math.min(cw/dw,ch/dh);
+        if(fit==ImageView.ScaleType.FIT_XY){dw=cw;dh=ch;}
+        else if(fit!=ImageView.ScaleType.CENTER && fit!=ImageView.ScaleType.MATRIX){dw*=factor;dh*=factor;}
+        anchorX=image.getLeft()+image.getPivotX()+originalX;
+        anchorY=image.getTop()+image.getPivotY()+originalY;
+        // ImageView clips the raster before its outer transform is applied.
+        float ox=left+(fit==ImageView.ScaleType.MATRIX?0:(cw-dw)/2),oy=top+(fit==ImageView.ScaleType.MATRIX?0:(ch-dh)/2);
+        content.set((Math.max(left,ox)-image.getPivotX())*originalScaleX,
+                    (Math.max(top,oy)-image.getPivotY())*originalScaleY,
+                    (Math.min(left+cw,ox+dw)-image.getPivotX())*originalScaleX,
+                    (Math.min(top+ch,oy+dh)-image.getPivotY())*originalScaleY);
+    }
+    private float[] bounds(float s){
+        float loX=width-anchorX-content.right*s,hiX=-anchorX-content.left*s;
+        float loY=height-anchorY-content.bottom*s,hiY=-anchorY-content.top*s;
+        if(loX>hiX)loX=hiX=(loX+hiX)/2;
+        if(loY>hiY)loY=hiY=(loY+hiY)/2;
+        return new float[]{loX,hiX,loY,hiY};
+    }
+    private void apply(){
+        image.setScaleX(originalScaleX*scale);image.setScaleY(originalScaleY*scale);
+        image.setTranslationX(originalX+x);image.setTranslationY(originalY+y);
+        if(backdrop!=null)backdrop.setAlpha(backdropAlpha*(1-progress));
+        if(chrome!=null)chrome.setAlpha(chromeAlpha*(1-progress));
+    }
+    private void settle(boolean animated){
+        if(disposed)return;
+        float s=clamp(scale,minimum,maximum),b[]=bounds(s);
+        float tx=clamp(x,b[0],b[1]),ty=clamp(y,b[2],b[3]);
+        if(mode==2){s=minimum;b=bounds(s);tx=clamp(0,b[0],b[1]);ty=clamp(0,b[2],b[3]);}
+        else {tx=clamp(tx+vx*.12f,b[0],b[1]);ty=clamp(ty+vy*.12f,b[2],b[3]);}
+        spring(tx,ty,s,vx,vy,animated,false);
+    }
+    private void cancelAnimation(){if(animation!=null){animation.cancel();animation=null;}}
+    private void spring(float tx,float ty,float targetScale,float velocityX,float velocityY,boolean animated,boolean close){
+        cancelAnimation();
+        final float sx=x,sy=y,ss=scale,sp=progress;
+        if(!animated || reduced){x=tx;y=ty;scale=targetScale;progress=0;apply();if(close)emitDismiss(0);else listener.onSettled(x/density,y/density,scale);return;}
+        animation=ValueAnimator.ofFloat(0,1);animation.setDuration(550);
+        animation.setInterpolator(new android.view.animation.LinearInterpolator());
+        animation.addUpdateListener(a->{
+            float fraction=(float)a.getAnimatedValue(),t=fraction*.55f;
+            float decay=(float)Math.exp(-16*t);
+            x=tx+((sx-tx)+(velocityX+16*(sx-tx))*t)*decay;
+            y=ty+((sy-ty)+(velocityY+16*(sy-ty))*t)*decay;
+            scale=targetScale+(ss-targetScale)*(1+16*t)*decay;
+            progress=sp*(1+16*t)*decay;
+            if(fraction>=1){x=tx;y=ty;scale=targetScale;progress=0;}
+            apply();
+            if(fraction>=1){animation=null;if(close)emitDismiss(0);else listener.onSettled(x/density,y/density,scale);}
+        });animation.start();
+    }
+    private void emitDismiss(float velocityY){
+        if(pending || disposed)return;
+        pending=true;listener.onDismiss(x/density,y/density,scale,velocityY/density,progress);
+    }
+    private void disallow(boolean value){if(viewport.getParent()!=null)viewport.getParent().requestDisallowInterceptTouchEvent(value);}
+    private void endTouch(){pointer=-1;if(velocity!=null){velocity.recycle();velocity=null;}disallow(false);}
+    @Override public boolean onTouch(View view,MotionEvent event){
+        if(disposed || !active || pending)return false;
+        int action=event.getActionMasked();
+        if(action==MotionEvent.ACTION_DOWN){
+            cancelAnimation();mode=0;vx=vy=0;
+            pointer=event.getPointerId(0);lastX=downX=event.getX();lastY=downY=event.getY();
+            rebasePan();
+            if(velocity!=null)velocity.recycle();velocity=VelocityTracker.obtain();disallow(true);
+        }
+        if(velocity!=null)velocity.addMovement(event);
+        pinch.onTouchEvent(event);taps.onTouchEvent(event);
+        int index=event.findPointerIndex(pointer);
+        if(action==MotionEvent.ACTION_MOVE && !pinch.isInProgress() && event.getPointerCount()==1 && index>=0){
+            float px=event.getX(index),py=event.getY(index),totalX=px-downX,totalY=py-downY;
+            if(mode==0 && Math.hypot(totalX,totalY)>slop){
+                if(scale<=minimum+.001f){
+                    if(dismiss && Math.abs(totalY)>Math.abs(totalX)*1.2f)mode=2;
+                    else {mode=3;disallow(false);return false;}
+                }else mode=1;
+            }
+            if(mode==1){
+                float[] b=bounds(scale);
+                rawPanX+=px-lastX;rawPanY+=py-lastY;
+                x=rubber(rawPanX,b[0],b[1],width);y=rubber(rawPanY,b[2],b[3],height);
+            }else if(mode==2){
+                x+= (px-lastX)*.4f;y+=py-lastY;
+                progress=clamp(Math.abs(y)/Math.max(height*.5f,1),0,1);
+                scale=minimum*(1-progress*.15f);
+            }
+            lastX=px;lastY=py;apply();
+        }
+        if(action==MotionEvent.ACTION_POINTER_UP){
+            int next=event.getActionIndex()==0?1:0;
+            if(next<event.getPointerCount()){pointer=event.getPointerId(next);lastX=downX=event.getX(next);lastY=downY=event.getY(next);rebasePan();}
+        }
+        if(action==MotionEvent.ACTION_UP || action==MotionEvent.ACTION_CANCEL){
+            if(velocity!=null){velocity.computeCurrentVelocity(1000);vx=velocity.getXVelocity(pointer);vy=velocity.getYVelocity(pointer);}
+            boolean commit=action==MotionEvent.ACTION_UP && mode==2 && (progress>.35f || (Math.abs(vy)>1000*density && y*vy>0));
+            boolean wasAnimation=animation!=null;
+            endTouch();
+            if(commit)emitDismiss(vy);
+            else if(mode!=3 && !wasAnimation)settle(true);
+        }
+        return mode!=3;
+    }
+    @Override public void onLayoutChange(View v,int l,int t,int r,int b,int ol,int ot,int or,int ob){
+        if(disposed || (l==ol&&t==ot&&r==or&&b==ob))return;
+        cancelAnimation();pending=false;measure();vx=vy=0;mode=0;settle(false);
+    }
+    private static float clamp(float v,float lo,float hi){return Math.max(lo,Math.min(hi,v));}
+    private void rebasePan(){float[] b=bounds(scale);rawPanX=unrubber(x,b[0],b[1],width);rawPanY=unrubber(y,b[2],b[3],height);}
+    private static float unrubber(float v,float lo,float hi,float dimension){
+        float edge=clamp(v,lo,hi),d=v-edge,size=Math.max(1,dimension);
+        return edge+d/(.55f*Math.max(.001f,1-Math.abs(d)/size));
+    }
+    private static float rubber(float value,float lo,float hi,float dimension){
+        float edge=clamp(value,lo,hi),d=value-edge;
+        return edge+Math.signum(d)*dimension*(1-1/(Math.abs(d)*.55f/Math.max(1,dimension)+1));
+    }
+}

package/platforms/android/proguard-rules.pro

@@ -11,3 +11,7 @@
 -keep class org.rafaelaugusto.jolt.TextReveal$* { *; }
 -keep class org.rafaelaugusto.jolt.NumberRoll { *; }
 -keep class org.rafaelaugusto.jolt.NumberRoll$* { *; }
+-keep class org.rafaelaugusto.jolt.ImageEffect { *; }
+-keep class org.rafaelaugusto.jolt.ImageEffect$* { *; }
+-keep class org.rafaelaugusto.jolt.PhotoZoom { *; }
+-keep class org.rafaelaugusto.jolt.PhotoZoom$* { *; }

package/platforms/ios/build.xcconfig

@@ -0,0 +1 @@
+OTHER_LDFLAGS = $(inherited) -framework Metal -framework MetalKit

package/platforms/ios/src/JoltImageEffect.h

@@ -0,0 +1,25 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+@interface JoltImageEffect : NSObject
++ (nullable instancetype)createWithView:(UIImageView *)view
+                          destination:(nullable UIImage *)destination
+                                 mode:(NSInteger)mode
+                              originX:(double)x originY:(double)y
+                            amplitude:(double)amplitude radius:(double)radius
+                             duration:(double)duration seed:(double)seed
+                             listener:(void (^)(BOOL, double))listener;
+@property(nonatomic, readonly) double progress;
+@property(nonatomic, readonly) BOOL paused;
+@property(nonatomic, readonly) NSUInteger frames;
+@property(nonatomic, readonly) double longestFrame;
+@property(nonatomic, readonly) NSUInteger textureBytes;
+- (void)play:(double)endpoint;
+- (void)pause;
+- (void)resume;
+- (void)seek:(double)progress;
+- (void)finish:(double)endpoint;
+- (void)stop;
+- (void)stopPreservingImage;
+@end
+NS_ASSUME_NONNULL_END