Wie benutzerdefinierte kreisförmige Fortschrittsbalken in Android zu machen?

Question

Ich habe nach dem gepunkteten kreisförmigen Fortschrittsbalken gesucht, aber ich bekomme keine perfekten Beispiele, Es gibt kreisförmige progressbar, aber nicht mit dotted ein So habe ich in der Hoffnung, dass es jemandem helfen wird, und Sie können dies als halten referenzieren und anpassen, für Anfänger wird es sehr hilfreich sein, den Code zu verstehen, da er in jeder Zeile kommentiert, was er tut.

Answer 1

MainActivity.java

public class MainActivity extends AppCompatActivity { 

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 
} 
} 

activity_main.xml:

<?xml version="1.0" encoding="utf-8"?> 
 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 
    xmlns:tools="http://schemas.android.com/tools" 
 
    android:layout_width="match_parent" 
 
    android:layout_height="match_parent" 
 
    android:paddingBottom="@dimen/activity_vertical_margin" 
 
    android:paddingLeft="@dimen/activity_horizontal_margin" 
 
    android:paddingRight="@dimen/activity_horizontal_margin" 
 
    android:paddingTop="@dimen/activity_vertical_margin" 
 
    tools:context="com.example.naveenbm.customcircleprogressbar.MainActivity" 
 
    > 
 

 
    <RelativeLayout 
 
     android:layout_width="match_parent" 
 
     android:layout_height="match_parent" 
 
     android:gravity="center"> 
 

 
     <com.example.custom.customcircleprogressbar.CricleProgressBarCustom 
 
      android:layout_width="wrap_content" 
 
      android:layout_height="wrap_content" 
 
      ></com.example.custom.customcircleprogressbar.CricleProgressBarCustom> 
 

 
    </RelativeLayout> 
 

 
</RelativeLayout>

CircleProgressBarCustom.java

public class CricleProgressBarCustom extends View { 

//Normal dot radius 
private int dotRadius = 10; 

//Expanded Dot Radius 
private int bounceDotRadius = 13; 

//to get identified in which position dot has to expand its radius 
private int dotPosition = 1; 

//specify how many dots you need in a progressbar 
private int dotAmount = 10; 

//specify the circle radius 
private int circleRadius = 50; 


public CricleProgressBarCustom(Context context) { 
    super(context); 
} 

public CricleProgressBarCustom(Context context, AttributeSet attrs) { 
    super(context, attrs); 
} 

public CricleProgressBarCustom(Context context, AttributeSet attrs, int defStyleAttr) { 
    super(context, attrs, defStyleAttr); 
} 

@Override 
protected void onAttachedToWindow() { 
    super.onAttachedToWindow(); 
    //Animation called when attaching to the window, i.e to your screen 
    startAnimation(); 
} 


@Override 
protected void onDraw(Canvas canvas) { 
    super.onDraw(canvas); 
    //take the point to the center of the screen 
    canvas.translate(this.getWidth()/2,this.getHeight()/2); 

    Paint progressPaint = new Paint(); 
    progressPaint.setColor(Color.parseColor("#ff014e")); 

    //call create dot method 
    createDotInCircle(canvas,progressPaint); 
} 

private void createDotInCircle(Canvas canvas,Paint progressPaint) { 
    //angle for each dot angle = (360/number of dots) i.e (360/10) 
    int angle = 36; 

    for(int i = 1; i <= dotAmount; i++){ 

     if(i == dotPosition){ 
      // angle should be in radians i.e formula (angle *(Math.PI/180)) 
      float x = (float) (circleRadius * (Math.cos((angle * i) * (Math.PI/180)))); 
      float y = (float) (circleRadius * (Math.sin((angle * i) * (Math.PI/180)))); 

      canvas.drawCircle(x,y, bounceDotRadius, progressPaint); 

     }else{ 
      // angle should be in radians i.e formula (angle *(Math.PI/180)) 
      float x = (float) (circleRadius * (Math.cos((angle * i) * (Math.PI/180)))); 
      float y = (float) (circleRadius * (Math.sin((angle * i) * (Math.PI/180)))); 

      canvas.drawCircle(x,y, dotRadius, progressPaint); 

     } 

    } 
} 

@Override 
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
    super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
    int width = 0; 
    int height = 0; 

    //Dynamically setting width and height to progressbar 100 is circle radius, dotRadius * 3 to cover the width and height of Progressbar 
    width = 100 + (dotRadius*3); 
    height = 100 + (dotRadius*3); 

    //MUST CALL THIS 
    setMeasuredDimension(width, height); 
} 

private void startAnimation() { 
    BounceAnimation bounceAnimation = new BounceAnimation(); 
    bounceAnimation.setDuration(150); 
    bounceAnimation.setRepeatCount(Animation.INFINITE); 
    bounceAnimation.setInterpolator(new LinearInterpolator()); 
    bounceAnimation.setAnimationListener(new Animation.AnimationListener() { 
     @Override 
     public void onAnimationStart(Animation animation) { 

     } 

     @Override 
     public void onAnimationEnd(Animation animation) { 

     } 

     @Override 
     public void onAnimationRepeat(Animation animation) { 
      dotPosition++; 
      //when dotPosition == dotAmount , then start again applying animation from 0th positon , i.e dotPosition = 0; 
      if (dotPosition > dotAmount) { 
       dotPosition = 1; 
      } 


     } 
    }); 
    startAnimation(bounceAnimation); 
} 


private class BounceAnimation extends Animation { 
    @Override 
    protected void applyTransformation(float interpolatedTime, Transformation t) { 
     super.applyTransformation(interpolatedTime, t); 
     //call invalidate to redraw your view againg. 
     invalidate(); 
    } 
} 
} 

Snap Shot:

Answer 2

Ein Beispiel kann ich Sie für diese verschiedenen Fortschrittsbalken mit glatten Arbeits vorschlägt

https://github.com/ybq/Android-SpinKit

Sie die Klasse setzen ..

wenn Sie wollen Kreis Fortschrittsbalken, als es funktionieren wie ..

ein Textview nehmen, wo Sie wollen ...

und First Take..On Ihre Klasse, wo Sie verwenden. (Erklärung)

private Circle mCircleDrawable = new Circle(); 

als in Ihrem onCreate dies nehmen ..

mCircleDrawable.setBounds(0, 0, 100, 100); 
    mCircleDrawable.setColor(R.color.colorPrimary);// What u want of color progress bar dots... 

TextView progressBar_text=(TextView)findViewById(R.id.progress);// Your Textview.. 
    progressBar_text.setCompoundDrawables(null, null, mCircleDrawable, null);// Set Progress bar on Textview.. 

Sie benötigen die

starten

mCircleDrawable.start(); 

Sie stoppen auch den Kreis, wenn Sie beenden. Auf Detroyed Oder auf PostMethod..If Verwendung (AYSNC)

mCircleDrawable.stop(); 

Die dafür verwendeten Klassen ...

Sie verwenden können, die ganze Bibliothek für diesen und nehmen jeden Fortschrittsbalken Sie Oberlenker Beispiel verwenden müssen

Circle.java

import android.animation.ValueAnimator; 

import com.github.ybq.android.spinkit.animation.SpriteAnimatorBuilder; 
import com.github.ybq.android.spinkit.sprite.CircleSprite; 
import com.github.ybq.android.spinkit.sprite.CircleSpriteGroup; 
import com.github.ybq.android.spinkit.sprite.Sprite; 


public class Circle extends CircleSpriteGroup { 

@Override 
public Sprite[] onCreateChild() { 
    Dot[] dots = new Dot[12]; 
    for (int i = 0; i < dots.length; i++) { 
     dots[i] = new Dot(); 
     dots[i].setAnimationDelay(1200/12 * i + -1200); 
    } 
    return dots; 
} 

class Dot extends CircleSprite { 

    public Dot() { 
     setScale(0f); 
    } 

    @Override 
    public ValueAnimator getAnimation() { 
     float fractions[] = new float[]{0f, 0.5f, 1f}; 
     return new SpriteAnimatorBuilder(this). 
       scale(fractions, 0f, 1f, 0f). 
       duration(1200). 
       easeInOut(fractions) 
       .build(); 
    } 
} 
} 

SpriteAnimatorBuilder.Java

import android.animation.Keyframe; 
import android.animation.ObjectAnimator; 
import android.animation.PropertyValuesHolder; 
import android.util.Property; 
import android.view.animation.Animation; 
import android.view.animation.Interpolator; 


import com.github.ybq.android.spinkit.animation.interpolator.KeyFrameInterpolator; 
import com.github.ybq.android.spinkit.sprite.Sprite; 

import java.util.ArrayList; 
import java.util.List; 
import java.util.Locale; 


public class SpriteAnimatorBuilder { 
private Sprite sprite; 
private List<PropertyValuesHolder> propertyValuesHolders = new ArrayList<> (); 
private Interpolator interpolator; 
private int repeatCount = Animation.INFINITE; 
private long duration = 2000; 

public SpriteAnimatorBuilder(Sprite sprite) { 
    this.sprite = sprite; 
} 

public SpriteAnimatorBuilder scale(float fractions[], float... scale) { 
    holder(fractions, Sprite.SCALE, scale); 
    return this; 
} 

public SpriteAnimatorBuilder alpha(float fractions[], int... alpha) { 
    holder(fractions, Sprite.ALPHA, alpha); 
    return this; 
} 

@SuppressWarnings("unused") 
public SpriteAnimatorBuilder scaleX(float fractions[], float... scaleX) { 
    holder(fractions, Sprite.SCALE, scaleX); 
    return this; 
} 

public SpriteAnimatorBuilder scaleY(float fractions[], float... scaleY) { 
    holder(fractions, Sprite.SCALE_Y, scaleY); 
    return this; 
} 

public SpriteAnimatorBuilder rotateX(float fractions[], int... rotateX) { 
    holder(fractions, Sprite.ROTATE_X, rotateX); 
    return this; 
} 

public SpriteAnimatorBuilder rotateY(float fractions[], int... rotateY) { 
    holder(fractions, Sprite.ROTATE_Y, rotateY); 
    return this; 
} 

@SuppressWarnings("unused") 
public SpriteAnimatorBuilder translateX(float fractions[], int... translateX) { 
    holder(fractions, Sprite.TRANSLATE_X, translateX); 
    return this; 
} 


@SuppressWarnings("unused") 
public SpriteAnimatorBuilder translateY(float fractions[], int... translateY) { 
    holder(fractions, Sprite.TRANSLATE_Y, translateY); 
    return this; 
} 


public SpriteAnimatorBuilder rotate(float fractions[], int... rotate) { 
    holder(fractions, Sprite.ROTATE, rotate); 
    return this; 
} 

public SpriteAnimatorBuilder translateXPercentage(float fractions[], float... translateXPercentage) { 
    holder(fractions, Sprite.TRANSLATE_X_PERCENTAGE, translateXPercentage); 
    return this; 
} 

public SpriteAnimatorBuilder translateYPercentage(float[] fractions, float... translateYPercentage) { 
    holder(fractions, Sprite.TRANSLATE_Y_PERCENTAGE, translateYPercentage); 
    return this; 
} 

public PropertyValuesHolder holder(float[] fractions, Property property, float[] values) { 
    ensurePair(fractions.length, values.length); 
    Keyframe[] keyframes = new Keyframe[fractions.length]; 
    for (int i = 0; i < values.length; i++) { 
     keyframes[i] = Keyframe.ofFloat(fractions[i], values[i]); 
    } 
    PropertyValuesHolder valuesHolder = PropertyValuesHolder. 
      ofKeyframe(property 
        , keyframes 
      ); 
    propertyValuesHolders.add(valuesHolder); 
    return valuesHolder; 
} 

public PropertyValuesHolder holder(float[] fractions, Property property, int[] values) { 
    ensurePair(fractions.length, values.length); 
    Keyframe[] keyframes = new Keyframe[fractions.length]; 
    for (int i = 0; i < values.length; i++) { 
     keyframes[i] = Keyframe.ofInt(fractions[i], values[i]); 
    } 
    PropertyValuesHolder valuesHolder = PropertyValuesHolder. 
      ofKeyframe(property 
        , keyframes 
      ); 
    propertyValuesHolders.add(valuesHolder); 
    return valuesHolder; 
} 

private void ensurePair(int fractionsLength, int valuesLength) { 
    if (fractionsLength != valuesLength) { 
     throw new IllegalStateException(String.format(
       Locale.getDefault(), 
       "The fractions.length must equal values.length, " + 
         "fraction.length[%d], values.length[%d]", 
       fractionsLength, 
       valuesLength)); 
    } 
} 


public SpriteAnimatorBuilder interpolator(Interpolator interpolator) { 
    this.interpolator = interpolator; 
    return this; 
} 

public SpriteAnimatorBuilder easeInOut(float... fractions) { 
    interpolator(KeyFrameInterpolator.easeInOut(
      fractions 
    )); 
    return this; 
} 


public SpriteAnimatorBuilder duration(long duration) { 
    this.duration = duration; 
    return this; 
} 

@SuppressWarnings("unused") 
public SpriteAnimatorBuilder repeatCount(int repeatCount) { 
    this.repeatCount = repeatCount; 
    return this; 
} 


public ObjectAnimator build() { 
    PropertyValuesHolder[] holders = new PropertyValuesHolder[propertyValuesHolders.size()]; 
    ObjectAnimator animator = ObjectAnimator.ofPropertyValuesHolder(sprite, 
      propertyValuesHolders.toArray(holders)); 
    animator.setDuration(duration); 
    animator.setRepeatCount(repeatCount); 
    animator.setInterpolator(interpolator); 
    return animator; 
} 

} 

CircleSprite.

Java

import android.animation.ValueAnimator; 
import android.graphics.Canvas; 
import android.graphics.Paint; 


public class CircleSprite extends ShapeSprite { 

@Override 
public ValueAnimator getAnimation() { 
    return null; 
} 

@Override 
public void drawShape(Canvas canvas, Paint paint) { 
    if (getDrawBounds() != null) { 
     int radius = Math.min(getDrawBounds().width(), getDrawBounds().height())/2; 
     canvas.drawCircle(getDrawBounds().centerX(), 
       getDrawBounds().centerY(), 
       radius, paint); 
    } 
} 
} 

ShapeSprite .java-

import android.graphics.Canvas; 
import android.graphics.Color; 
import android.graphics.ColorFilter; 
import android.graphics.Paint; 


public abstract class ShapeSprite extends Sprite { 

private Paint mPaint; 
private int mUseColor; 
private int mBaseColor; 

public ShapeSprite() { 
    setColor(Color.WHITE); 
    mPaint = new Paint(); 
    mPaint.setAntiAlias(true); 
    mPaint.setColor(mUseColor); 
} 

@Override 
public void setColor(int color) { 
    mBaseColor = color; 
    updateUseColor(); 
} 

@Override 
public int getColor() { 
    return mBaseColor; 
} 

@SuppressWarnings("unused") 
public int getUseColor() { 
    return mUseColor; 
} 

@Override 
public void setAlpha(int alpha) { 
    super.setAlpha(alpha); 
    updateUseColor(); 
} 

private void updateUseColor() { 
    int alpha = getAlpha(); 
    alpha += alpha >> 7; 
    final int baseAlpha = mBaseColor >>> 24; 
    final int useAlpha = baseAlpha * alpha >> 8; 
    mUseColor = (mBaseColor <<8>>> 8) | (useAlpha << 24); 
} 

@Override 
public void setColorFilter(ColorFilter colorFilter) { 
    mPaint.setColorFilter(colorFilter); 
} 

@Override 
protected final void drawSelf(Canvas canvas) { 
    mPaint.setColor(mUseColor); 
    drawShape(canvas, mPaint); 
} 

public abstract void drawShape(Canvas canvas, Paint paint); 

}

CircleSpriteGroup .JAVA

import android.graphics.Canvas; 
import android.graphics.Rect; 


public abstract class CircleSpriteGroup extends SpriteGroup { 

@Override 
public void drawChild(Canvas canvas) { 
    for (int i = 0; i < getChildCount(); i++) { 
     Sprite sprite = getChildAt(i); 
     int count = canvas.save(); 
     canvas.rotate(i * 360/getChildCount(), 
       getBounds().centerX(), 
       getBounds().centerY()); 
     sprite.draw(canvas); 
     canvas.restoreToCount(count); 
    } 
} 

@Override 
protected void onBoundsChange(Rect bounds) { 
    super.onBoundsChange(bounds); 
    bounds = clipSquare(bounds); 
    int radius = (int) (bounds.width() * Math.PI/3.6f/getChildCount()); 
    int left = bounds.centerX() - radius; 
    int right = bounds.centerX() + radius; 
    for (int i = 0; i < getChildCount(); i++) { 
     Sprite sprite = getChildAt(i); 
     sprite.setDrawBounds(left, bounds.top, right, bounds.top + radius * 2); 
    } 
} 
    } 

Sprite.java

import android.animation.ValueAnimator; 
import android.graphics.Camera; 
import android.graphics.Canvas; 
import android.graphics.ColorFilter; 
import android.graphics.Matrix; 
import android.graphics.PixelFormat; 
import android.graphics.Rect; 
import android.graphics.drawable.Animatable; 
import android.graphics.drawable.Drawable; 
import android.util.Property; 

import com.github.ybq.android.spinkit.animation.AnimationUtils; 
import com.github.ybq.android.spinkit.animation.FloatProperty; 
import com.github.ybq.android.spinkit.animation.IntProperty; 


public abstract class Sprite extends Drawable implements 
    ValueAnimator.AnimatorUpdateListener 
    , Animatable 
    , Drawable.Callback { 

private float scale = 1; 
private float scaleX = 1; 
private float scaleY = 1; 
private float pivotX; 
private float pivotY; 
private int animationDelay; 
private int rotateX; 
private int rotateY; 
private int translateX; 
private int translateY; 
private int rotate; 
private float translateXPercentage; 
private float translateYPercentage; 
private ValueAnimator animator; 
private int alpha = 255; 
private static final Rect ZERO_BOUNDS_RECT = new Rect(); 
protected Rect drawBounds = ZERO_BOUNDS_RECT; 
private Camera mCamera; 
private Matrix mMatrix; 

public Sprite() { 
    mCamera = new Camera(); 
    mMatrix = new Matrix(); 
} 

public abstract int getColor(); 

public abstract void setColor(int color); 

@Override 
public void setAlpha(int alpha) { 
    this.alpha = alpha; 
} 

@Override 
public int getAlpha() { 
    return alpha; 
} 

@Override 
public int getOpacity() { 
    return PixelFormat.RGBA_8888; 
} 

public float getTranslateXPercentage() { 
    return translateXPercentage; 
} 

public void setTranslateXPercentage(float translateXPercentage) { 
    this.translateXPercentage = translateXPercentage; 
} 

public float getTranslateYPercentage() { 
    return translateYPercentage; 
} 

public void setTranslateYPercentage(float translateYPercentage) { 
    this.translateYPercentage = translateYPercentage; 
} 

public int getTranslateX() { 
    return translateX; 
} 

public void setTranslateX(int translateX) { 
    this.translateX = translateX; 
} 

public int getTranslateY() { 
    return translateY; 
} 

public void setTranslateY(int translateY) { 
    this.translateY = translateY; 
} 

public int getRotate() { 
    return rotate; 
} 

public void setRotate(int rotate) { 
    this.rotate = rotate; 
} 

public float getScale() { 
    return scale; 
} 

public void setScale(float scale) { 
    this.scale = scale; 
    setScaleX(scale); 
    setScaleY(scale); 
} 

public float getScaleX() { 
    return scaleX; 
} 

public void setScaleX(float scaleX) { 
    this.scaleX = scaleX; 
} 

public float getScaleY() { 
    return scaleY; 
} 

public void setScaleY(float scaleY) { 
    this.scaleY = scaleY; 
} 

public int getRotateX() { 
    return rotateX; 
} 

public void setRotateX(int rotateX) { 
    this.rotateX = rotateX; 
} 

public int getRotateY() { 
    return rotateY; 
} 

public void setRotateY(int rotateY) { 
    this.rotateY = rotateY; 
} 

public float getPivotX() { 
    return pivotX; 
} 

public void setPivotX(float pivotX) { 
    this.pivotX = pivotX; 
} 

public float getPivotY() { 
    return pivotY; 
} 

public void setPivotY(float pivotY) { 
    this.pivotY = pivotY; 
} 

@SuppressWarnings("unused") 
public int getAnimationDelay() { 
    return animationDelay; 
} 

public Sprite setAnimationDelay(int animationDelay) { 
    this.animationDelay = animationDelay; 
    return this; 
} 

@Override 
public void setColorFilter(ColorFilter colorFilter) { 

} 

public abstract ValueAnimator getAnimation(); 

@Override 
public void start() { 
    if (AnimationUtils.isStarted(animator)) { 
     return; 
    } 

    animator = obtainAnimation(); 
    if (animator == null) { 
     return; 
    } 

    AnimationUtils.start(animator); 
    invalidateSelf(); 
} 

public ValueAnimator obtainAnimation() { 
    if (animator == null) { 
     animator = getAnimation(); 
    } 
    if (animator != null) { 
     animator.addUpdateListener(this); 
     animator.setStartDelay(animationDelay); 
    } 
    return animator; 
} 

@Override 
public void stop() { 
    if (AnimationUtils.isStarted(animator)) { 
     animator.removeAllUpdateListeners(); 
     animator.end(); 
     reset(); 
    } 
} 

protected abstract void drawSelf(Canvas canvas); 

public void reset() { 
    scale = 1; 
    rotateX = 0; 
    rotateY = 0; 
    translateX = 0; 
    translateY = 0; 
    rotate = 0; 
    translateXPercentage = 0f; 
    translateYPercentage = 0f; 
} 

@Override 
public boolean isRunning() { 
    return AnimationUtils.isRunning(animator); 
} 

@Override 
protected void onBoundsChange(Rect bounds) { 
    super.onBoundsChange(bounds); 
    setDrawBounds(bounds); 
} 

public void setDrawBounds(Rect drawBounds) { 
    setDrawBounds(drawBounds.left, drawBounds.top, drawBounds.right, drawBounds.bottom); 
} 

public void setDrawBounds(int left, int top, int right, int bottom) { 
    this.drawBounds = new Rect(left, top, right, bottom); 
    setPivotX(getDrawBounds().centerX()); 
    setPivotY(getDrawBounds().centerY()); 
} 

@Override 
public void invalidateDrawable(Drawable who) { 
    invalidateSelf(); 
} 

@Override 
public void scheduleDrawable(Drawable who, Runnable what, long when) { 

} 

@Override 
public void unscheduleDrawable(Drawable who, Runnable what) { 

} 

@Override 
public void onAnimationUpdate(ValueAnimator animation) { 
    final Callback callback = getCallback(); 
    if (callback != null) { 
     callback.invalidateDrawable(this); 
    } 
} 

public Rect getDrawBounds() { 
    return drawBounds; 
} 

@Override 
public void draw(Canvas canvas) { 
    int tx = getTranslateX(); 
    tx = tx == 0 ? (int) (getBounds().width() * getTranslateXPercentage()) : tx; 
    int ty = getTranslateY(); 
    ty = ty == 0 ? (int) (getBounds().height() * getTranslateYPercentage()) : ty; 
    canvas.translate(tx, ty); 
    canvas.scale(getScaleX(), getScaleY(), getPivotX(), getPivotY()); 
    canvas.rotate(getRotate(), getPivotX(), getPivotY()); 

    if (getRotateX() != 0 || getRotateY() != 0) { 
     mCamera.save(); 
     mCamera.rotateX(getRotateX()); 
     mCamera.rotateY(getRotateY()); 
     mCamera.getMatrix(mMatrix); 
     mMatrix.preTranslate(-getPivotX(), -getPivotY()); 
     mMatrix.postTranslate(getPivotX(), getPivotY()); 
     mCamera.restore(); 
     canvas.concat(mMatrix); 
    } 
    drawSelf(canvas); 
} 

public Rect clipSquare(Rect rect) { 
    int w = rect.width(); 
    int h = rect.height(); 
    int min = Math.min(w, h); 
    int cx = rect.centerX(); 
    int cy = rect.centerY(); 
    int r = min/2; 
    return new Rect(
      cx - r, 
      cy - r, 
      cx + r, 
      cy + r 
    ); 
} 

public static final Property<Sprite, Integer> ROTATE_X = new IntProperty<Sprite>("rotateX") { 
    @Override 
    public void setValue(Sprite object, int value) { 
     object.setRotateX(value); 
    } 

    @Override 
    public Integer get(Sprite object) { 
     return object.getRotateX(); 
    } 
}; 

public static final Property<Sprite, Integer> ROTATE = new IntProperty<Sprite>("rotate") { 
    @Override 
    public void setValue(Sprite object, int value) { 
     object.setRotate(value); 
    } 

    @Override 
    public Integer get(Sprite object) { 
     return object.getRotate(); 
    } 
}; 

public static final Property<Sprite, Integer> ROTATE_Y = new IntProperty<Sprite>("rotateY") { 
    @Override 
    public void setValue(Sprite object, int value) { 
     object.setRotateY(value); 
    } 

    @Override 
    public Integer get(Sprite object) { 
     return object.getRotateY(); 
    } 
}; 

@SuppressWarnings("unused") 
public static final Property<Sprite, Integer> TRANSLATE_X = new IntProperty<Sprite>("translateX") { 
    @Override 
    public void setValue(Sprite object, int value) { 
     object.setTranslateX(value); 
    } 

    @Override 
    public Integer get(Sprite object) { 
     return object.getTranslateX(); 
    } 
}; 

@SuppressWarnings("unused") 
public static final Property<Sprite, Integer> TRANSLATE_Y = new IntProperty<Sprite>("translateY") { 
    @Override 
    public void setValue(Sprite object, int value) { 
     object.setTranslateY(value); 
    } 

    @Override 
    public Integer get(Sprite object) { 
     return object.getTranslateY(); 
    } 
}; 

public static final Property<Sprite, Float> TRANSLATE_X_PERCENTAGE = new FloatProperty<Sprite>("translateXPercentage") { 
    @Override 
    public void setValue(Sprite object, float value) { 
     object.setTranslateXPercentage(value); 
    } 

    @Override 
    public Float get(Sprite object) { 
     return object.getTranslateXPercentage(); 
    } 
}; 

public static final Property<Sprite, Float> TRANSLATE_Y_PERCENTAGE = new FloatProperty<Sprite>("translateYPercentage") { 
    @Override 
    public void setValue(Sprite object, float value) { 
     object.setTranslateYPercentage(value); 
    } 

    @Override 
    public Float get(Sprite object) { 
     return object.getTranslateYPercentage(); 
    } 
}; 

@SuppressWarnings("unused") 
public static final Property<Sprite, Float> SCALE_X = new FloatProperty<Sprite>("scaleX") { 
    @Override 
    public void setValue(Sprite object, float value) { 
     object.setScaleX(value); 
    } 

    @Override 
    public Float get(Sprite object) { 
     return object.getScaleX(); 
    } 
}; 

public static final Property<Sprite, Float> SCALE_Y = new FloatProperty<Sprite>("scaleY") { 
    @Override 
    public void setValue(Sprite object, float value) { 
     object.setScaleY(value); 
    } 

    @Override 
    public Float get(Sprite object) { 
     return object.getScaleY(); 
    } 
}; 

public static final Property<Sprite, Float> SCALE = new FloatProperty<Sprite>("scale") { 
    @Override 
    public void setValue(Sprite object, float value) { 
     object.setScale(value); 
    } 

    @Override 
    public Float get(Sprite object) { 
     return object.getScale(); 
    } 
}; 

public static final Property<Sprite, Integer> ALPHA = new IntProperty<Sprite>("alpha") { 
    @Override 
    public void setValue(Sprite object, int value) { 
     object.setAlpha(value); 
    } 

    @Override 
    public Integer get(Sprite object) { 
     return object.getAlpha(); 
    } 
}; 

    } 

KeyFrameInterpolator.java

import android.animation.TimeInterpolator; 
import android.view.animation.Interpolator; 


public class KeyFrameInterpolator implements Interpolator { 

private TimeInterpolator interpolator; 
private float[] fractions; 


public static KeyFrameInterpolator easeInOut(float... fractions) { 
    KeyFrameInterpolator interpolator = new KeyFrameInterpolator(Ease.inOut()); 
    interpolator.setFractions(fractions); 
    return interpolator; 
} 

public KeyFrameInterpolator(TimeInterpolator interpolator) { 
    this.interpolator = interpolator; 
} 

public void setFractions(float... fractions) { 
    this.fractions = fractions; 
} 

@Override 
public synchronized float getInterpolation(float input) { 
    if (fractions.length > 1) { 
     for (int i = 0; i < fractions.length - 1; i++) { 
      float start = fractions[i]; 
      float end = fractions[i + 1]; 
      float duration = end - start; 
      if (input >= start && input <= end) { 
       input = (input - start)/duration; 
       return start + (interpolator.getInterpolation(input) 
         * duration); 
      } 
     } 
    } 
    return interpolator.getInterpolation(input); 
} 
} 

AnimationUtils.java

import android.animation.Animator; 
import android.animation.ValueAnimator; 

import com.github.ybq.android.spinkit.sprite.Sprite; 

public class AnimationUtils { 

public static void start(Animator animator) { 
    if (animator != null && !animator.isStarted()) { 
     animator.start(); 
    } 
} 

public static void stop(Animator animator) { 
    if (animator != null && !animator.isRunning()) { 
     animator.end(); 
    } 
} 

public static void start(Sprite... sprites) { 
    for (Sprite sprite : sprites) { 
     sprite.start(); 
    } 
} 

public static void stop(Sprite... sprites) { 
    for (Sprite sprite : sprites) { 
     sprite.stop(); 
    } 
} 

public static boolean isRunning(Sprite... sprites) { 
    for (Sprite sprite : sprites) { 
     if (sprite.isRunning()) { 
      return true; 
     } 
    } 
    return false; 
} 

public static boolean isRunning(ValueAnimator animator) { 
    return animator != null && animator.isRunning(); 
} 

public static boolean isStarted(ValueAnimator animator) { 
    return animator != null && animator.isStarted(); 
} 
} 

FloatProperty.java

import android.util.Property; 


public abstract class FloatProperty<T> extends Property<T, Float> { 

public FloatProperty(String name) { 
    super(Float.class, name); 
} 

/** 
* A type-specific override of the {@link #set(Object, Float)} that is faster when dealing 
* with fields of type <code>float</code>. 
*/ 
public abstract void setValue(T object, float value); 

@Override 
final public void set(T object, Float value) { 
    setValue(object, value); 
} 

    } 

IntProperty.java

import android.util.Property; 


public abstract class IntProperty<T> extends Property<T, Integer> { 

public IntProperty(String name) { 
    super(Integer.class, name); 
} 


public abstract void setValue(T object, int value); 

@Override 
final public void set(T object, Integer value) { 
    setValue(object, value); 
} 

}