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

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

@@ -0,0 +1,190 @@
+package org.rafaelaugusto.jolt;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.text.SpannableStringBuilder;
+import android.text.Spanned;
+import android.text.method.TransformationMethod;
+import android.text.style.ReplacementSpan;
+import android.view.animation.LinearInterpolator;
+import android.view.animation.PathInterpolator;
+import android.widget.TextView;
+
+/** Rolls the changed positions of a TextView with one native animator. */
+public final class NumberRoll {
+    public interface Callback {
+        void onEnd(boolean finished);
+    }
+
+    private static final int MAX_POSITIONS = 256;
+    private final TextView view;
+    private final CharSequence original;
+    private final CharSequence shown;
+    private final TransformationMethod method;
+    private final DigitSpan[] spans;
+    private final int[] starts;
+    private final int[] ends;
+    private final float[] times;
+    private final float[] values;
+    private final long duration;
+    private final long delay;
+    private final long stagger;
+    private final long fade;
+    private final boolean tabular;
+    private final Callback callback;
+    private final PathInterpolator ease = new PathInterpolator(0f, 0f, 0.58f, 1f);
+    private ValueAnimator animator;
+    private CharSequence current;
+    private boolean removedMethod;
+    private boolean ended;
+
+    // Positions are ordered from the end of the text; each one starts `stagger` after the previous.
+    public NumberRoll(TextView view, int[] starts, int[] ends, String[] previous, int direction,
+            float[] times, float[] values, long duration, long delay, long stagger, float shift,
+            long fade, boolean tabular, Callback callback) {
+        this.view = view;
+        this.original = view.getText();
+        // NativeScript installs a TransformationMethod that rebuilds the displayed text from its
+        // own model, discarding spans set from here. Work on what is displayed and remove it while rolling.
+        this.method = view.getTransformationMethod();
+        CharSequence displayed = method != null && original != null ? method.getTransformation(original, view) : original;
+        this.shown = displayed != null ? displayed : "";
+        this.starts = starts;
+        this.ends = ends;
+        this.times = times;
+        this.values = values;
+        this.duration = duration;
+        this.delay = delay;
+        this.stagger = stagger;
+        this.fade = fade;
+        this.tabular = tabular;
+        this.callback = callback;
+        spans = new DigitSpan[starts.length];
+        for (int i = 0; i < starts.length; i++) {
+            String old = i < previous.length && previous[i] != null ? previous[i] : "";
+            spans[i] = new DigitSpan(old, direction, shift, values.length > 0 ? values[0] : shift);
+        }
+    }
+
+    public boolean isSupported() {
+        if (original == null || starts.length == 0 || starts.length > MAX_POSITIONS) return false;
+        if (ends.length != starts.length || times.length < 2 || times.length != values.length) return false;
+        int length = shown.length();
+        for (int i = 0; i < starts.length; i++) {
+            if (starts[i] < 0 || ends[i] > length || starts[i] >= ends[i]) return false;
+        }
+        return true;
+    }
+
+    public void start() {
+        if (ended || animator != null) return;
+        if (tabular) view.setFontFeatureSettings("tnum");
+        SpannableStringBuilder spannable = new SpannableStringBuilder(shown);
+        for (int i = 0; i < spans.length; i++) {
+            spannable.setSpan(spans[i], starts[i], ends[i], Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+        }
+        if (method != null) {
+            removedMethod = true;
+            view.setTransformationMethod(null);
+        }
+        view.setText(spannable);
+        current = view.getText();
+        final long total = delay + duration + stagger * (spans.length - 1);
+        animator = ValueAnimator.ofFloat(0f, 1f);
+        animator.setDuration(Math.max(total, 1));
+        animator.setInterpolator(new LinearInterpolator());
+        animator.addUpdateListener(animation -> update(animation.getAnimatedFraction() * total));
+        animator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                finish(true);
+            }
+        });
+        animator.start();
+    }
+
+    public void cancel() {
+        finish(false);
+        if (animator != null) animator.cancel();
+    }
+
+    private void update(float elapsed) {
+        for (int i = 0; i < spans.length; i++) {
+            float local = elapsed - delay - stagger * i;
+            spans[i].set(sample(local), alpha(local));
+        }
+        view.invalidate();
+    }
+
+    private float sample(float local) {
+        if (local <= 0) return values[0];
+        if (local >= duration) return values[values.length - 1];
+        float t = local / duration;
+        int i = 1;
+        while (i < times.length - 1 && times[i] < t) i++;
+        float span = times[i] - times[i - 1];
+        float fraction = span > 0 ? (t - times[i - 1]) / span : 1f;
+        return values[i - 1] + (values[i] - values[i - 1]) * fraction;
+    }
+
+    private float alpha(float local) {
+        if (local <= 0) return 0f;
+        if (fade <= 0 || local >= fade) return 1f;
+        return ease.getInterpolation(local / fade);
+    }
+
+    private void finish(boolean finished) {
+        if (ended) return;
+        ended = true;
+        if (current != null && view.getText() == current) view.setText(original);
+        if (removedMethod) view.setTransformationMethod(method);
+        callback.onEnd(finished);
+    }
+
+    /** Draws the new glyphs sliding in over the old ones sliding out, clipped to the line. */
+    static final class DigitSpan extends ReplacementSpan {
+        private final String previous;
+        private final int direction;
+        private final float shift;
+        private float offset;
+        private float alpha;
+
+        DigitSpan(String previous, int direction, float shift, float offset) {
+            this.previous = previous;
+            this.direction = direction;
+            this.shift = shift;
+            this.offset = offset;
+        }
+
+        void set(float offset, float alpha) {
+            this.offset = offset;
+            this.alpha = alpha;
+        }
+
+        @Override
+        public int getSize(Paint paint, CharSequence text, int start, int end, Paint.FontMetricsInt fm) {
+            if (fm != null) paint.getFontMetricsInt(fm);
+            return Math.round(Math.max(paint.measureText(text, start, end), paint.measureText(previous)));
+        }
+
+        @Override
+        public void draw(Canvas canvas, CharSequence text, int start, int end, float x, int top, int y,
+                int bottom, Paint paint) {
+            int base = paint.getAlpha();
+            float width = getSize(paint, text, start, end, null);
+            canvas.save();
+            canvas.clipRect(x, top, x + width, bottom);
+            paint.setAlpha(Math.round(base * alpha));
+            canvas.drawText(text, start, end, x, y + direction * offset, paint);
+            if (!previous.isEmpty()) {
+                paint.setAlpha(Math.round(base * (1f - alpha)));
+                canvas.drawText(previous, x, y + direction * (offset - shift), paint);
+            }
+            paint.setAlpha(base);
+            canvas.restore();
+        }
+    }
+}

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/java/org/rafaelaugusto/jolt/TextReveal.java

@@ -0,0 +1,180 @@
+package org.rafaelaugusto.jolt;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.text.SpannableStringBuilder;
+import android.text.Spanned;
+import android.text.TextPaint;
+import android.text.method.TransformationMethod;
+import android.text.style.CharacterStyle;
+import android.text.style.UpdateAppearance;
+import android.view.animation.Interpolator;
+import android.view.animation.LinearInterpolator;
+import android.view.animation.PathInterpolator;
+import android.widget.TextView;
+import java.text.BreakIterator;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Fades a TextView's text in piece by piece. Layout, truncation and the real text stay as they are. */
+public final class TextReveal {
+    public interface Callback {
+        void onEnd(boolean finished);
+    }
+
+    private static final int MAX_PIECES = 256;
+    private static final Interpolator EASE_OUT = new PathInterpolator(0f, 0f, 0.58f, 1f);
+    private final TextView view;
+    private final long duration;
+    private final long stagger;
+    private final long delay;
+    private final float offset;
+    private final Callback callback;
+    private final CharSequence original;
+    private final CharSequence shown;
+    private final TransformationMethod method;
+    private final Piece[] pieces;
+    private ValueAnimator animator;
+    private boolean settled;
+
+    public TextReveal(TextView view, boolean byWord, long duration, long stagger, long delay, float offset, Callback callback) {
+        this.view = view;
+        this.duration = Math.max(duration, 1);
+        this.stagger = stagger;
+        this.delay = delay;
+        this.offset = offset;
+        this.callback = callback;
+        CharSequence text = view.getText();
+        this.original = text == null ? "" : text;
+        // NativeScript's transformation method rebuilds the displayed text from its own model,
+        // so pieces are measured on what is drawn and the spans go on that text.
+        this.method = view.getTransformationMethod();
+        CharSequence displayed = method != null ? method.getTransformation(original, view) : original;
+        this.shown = displayed == null ? "" : displayed;
+        this.pieces = split(shown.toString(), byWord);
+    }
+
+    public boolean isSupported() {
+        return pieces.length <= MAX_PIECES;
+    }
+
+    public void start() {
+        if (settled || animator != null) return;
+        if (pieces.length == 0) {
+            settle(true);
+            return;
+        }
+        SpannableStringBuilder spannable = new SpannableStringBuilder(shown);
+        for (Piece piece : pieces) {
+            piece.alpha = 0f;
+            piece.shift = offset;
+            spannable.setSpan(piece, piece.start, piece.end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+        }
+        if (method != null) view.setTransformationMethod(null);
+        view.setText(spannable);
+        final long total = delay + duration + (pieces.length - 1) * stagger;
+        animator = ValueAnimator.ofFloat(0f, 1f);
+        animator.setDuration(total);
+        animator.setInterpolator(new LinearInterpolator());
+        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                update(animation.getAnimatedFraction() * total);
+                view.invalidate();
+            }
+        });
+        animator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                settle(true);
+            }
+        });
+        animator.start();
+    }
+
+    public void cancel() {
+        settle(false);
+    }
+
+    private void update(float time) {
+        for (int i = 0; i < pieces.length; i++) {
+            float local = (time - delay - i * stagger) / duration;
+            float eased = local <= 0f ? 0f : local >= 1f ? 1f : EASE_OUT.getInterpolation(local);
+            pieces[i].alpha = eased;
+            pieces[i].shift = offset * (1f - eased);
+        }
+    }
+
+    private void settle(boolean finished) {
+        if (settled) return;
+        settled = true;
+        ValueAnimator running = animator;
+        animator = null;
+        if (running != null) running.cancel();
+        CharSequence current = view.getText();
+        // An app change already replaced the spans; its text wins.
+        if (current instanceof Spanned && ((Spanned) current).getSpans(0, current.length(), Piece.class).length > 0) {
+            view.setText(original);
+        }
+        if (method != null && view.getTransformationMethod() == null) view.setTransformationMethod(method);
+        callback.onEnd(finished);
+    }
+
+    private static Piece[] split(String text, boolean byWord) {
+        List<Piece> pieces = new ArrayList<>();
+        BreakIterator iterator = byWord ? BreakIterator.getWordInstance() : BreakIterator.getCharacterInstance();
+        iterator.setText(text);
+        int start = iterator.first();
+        for (int end = iterator.next(); end != BreakIterator.DONE; start = end, end = iterator.next()) {
+            if (byWord ? isWord(text, start, end) : !isBlank(text, start, end)) pieces.add(new Piece(start, end));
+        }
+        if (byWord) {
+            // Spaces and punctuation stay with the word before them, so every visible mark is revealed.
+            for (int i = 0; i < pieces.size(); i++) {
+                Piece piece = pieces.get(i);
+                if (i == 0) piece.start = 0;
+                piece.end = i + 1 < pieces.size() ? pieces.get(i + 1).start : text.length();
+            }
+            if (pieces.isEmpty() && !isBlank(text, 0, text.length())) pieces.add(new Piece(0, text.length()));
+        }
+        return pieces.toArray(new Piece[0]);
+    }
+
+    private static boolean isWord(String text, int start, int end) {
+        for (int i = start; i < end; ) {
+            int point = text.codePointAt(i);
+            if (Character.isLetterOrDigit(point)) return true;
+            i += Character.charCount(point);
+        }
+        return false;
+    }
+
+    private static boolean isBlank(String text, int start, int end) {
+        for (int i = start; i < end; ) {
+            int point = text.codePointAt(i);
+            if (!Character.isWhitespace(point) && !Character.isSpaceChar(point)) return false;
+            i += Character.charCount(point);
+        }
+        return true;
+    }
+
+    /** Only changes how its range is drawn, so the TextView's layout never sees it. */
+    private static final class Piece extends CharacterStyle implements UpdateAppearance {
+        int start;
+        int end;
+        float alpha;
+        float shift;
+
+        Piece(int start, int end) {
+            this.start = start;
+            this.end = end;
+        }
+
+        @Override
+        public void updateDrawState(TextPaint paint) {
+            paint.setAlpha(Math.round(paint.getAlpha() * alpha));
+            paint.baselineShift += Math.round(shift);
+        }
+    }
+}

package/platforms/android/proguard-rules.pro

@@ -0,0 +1,21 @@
+-keep class org.rafaelaugusto.jolt.ColorTarget { *; }
+-keep class org.nativescript.widgets.BorderDrawable { *; }
+-keepnames class org.nativescript.widgets.BoxShadowDrawable
+-keepclassmembers class org.nativescript.widgets.BoxShadowDrawable {
+    public android.graphics.drawable.Drawable getWrappedDrawable();
+}
+-keep class org.rafaelaugusto.jolt.DecorationTarget { *; }
+-keep class org.rafaelaugusto.jolt.KeyboardFollower { *; }
+-keep class org.rafaelaugusto.jolt.KeyboardFollower$* { *; }
+-keep class org.rafaelaugusto.jolt.KeyboardObserver { *; }
+-keep class org.rafaelaugusto.jolt.KeyboardObserver$* { *; }
+-keep class org.rafaelaugusto.jolt.TextReveal { *; }
+-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$* { *; }
+-keep class org.rafaelaugusto.jolt.GradientLayer { *; }
+-keep class org.rafaelaugusto.jolt.GradientLayer$* { *; }

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