and

import android.util.Log;
import android.view.View;

public class AnimationThread extends Thread {
    private static final String TAG = AnimationThread.class.getSimpleName();
    public static final long DEFAULT_SLEEP_TIME = 25;
    public static final long DEFAULT_INCREMENT = 1;
    public static final int STATE_ZOOM_UNKNOW = 0x00;
    public static final int STATE_ZOOM_OUT = 0x01;
    public static final int STATE_ZOOM_IN = 0x02;

    public interface AnimationListener{
        void onStart();
        void onEnd();
        void onError();
    }

    private float currentScale;
    private float startScale;
    private float endScale;
    private float increment;
    private long sleepTime;
    private int animationState;
    private boolean doNotNeedAnimation;
    private boolean normalOver;
    private View view;
    private AnimationListener listener;

    public AnimationThread(View view, float startScale, float endScale) {
        this.view = view;
        this.startScale = startScale;
        this.endScale = endScale;
        currentScale = startScale;
        sleepTime = DEFAULT_SLEEP_TIME;
        increment = DEFAULT_INCREMENT;
        if (startScale > endScale) {
            animationState = STATE_ZOOM_OUT;
        } else if (startScale < endScale) {
            animationState = STATE_ZOOM_IN;
        } else {
            animationState = STATE_ZOOM_UNKNOW;
        }
    }

    public AnimationThread(View view, float startScale, float endScale, float increment) {
        this(view, startScale, endScale);
        this.increment = increment;
    }

    public AnimationThread(View view, float startScale, float endScale, float increment, long sleepTime) {
        this(view, startScale, endScale, increment);
        this.sleepTime = sleepTime;
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setOnListener(AnimationListener listener) {
        this.listener = listener;
    }

    public boolean isNormalOver() {
        return normalOver;
    }

    public void setEndScale(float value) {
        endScale = value;
    }

    public void setCurrentScale(float value) {
        currentScale = value;
    }

    public void setSleepTime(long time) {
        sleepTime = time;
    }

    public void setAnimationState(int flag) {
        if (flag != STATE_ZOOM_OUT && flag != STATE_ZOOM_IN) {
            throw new IllegalArgumentException("flag[" + flag + "] value is error.");
        }

        if (animationState != flag) {
            animationState = flag;
            synchronized (TAG) {
                if (animationState == STATE_ZOOM_OUT) {
                    if (currentScale < endScale) {
                        switchStart2EndScaleLocked();
                    }
                } else {
                    if (currentScale > endScale) {
                        switchStart2EndScaleLocked();
                    }
                }
            }
        }
    } 
public void changeAnimationState() {
        if (animationState == STATE_ZOOM_IN) {
            synchronized (TAG) {
                animationState = STATE_ZOOM_OUT;
                if (currentScale < endScale) {
                    switchStart2EndScaleLocked();
                }
            }
        } else {
            synchronized (TAG) {
                animationState = STATE_ZOOM_IN;
                if (currentScale > endScale) {
                    switchStart2EndScaleLocked();
                }
            }
        }
    }

    public int getAnimationState() {
        return animationState;
    }

    public void stopAnimation() {
        doNotNeedAnimation = true;
    }

    @Override
    public void run() {
        try {           
            if (listener != null) {
                listener.onStart();
            }

            while (!doNotNeedAnimation) {
                synchronized (TAG) {
                    if (animationState == STATE_ZOOM_OUT) {
                        currentScale -= increment;
                        if (currentScale <= endScale) {
                            currentScale = endScale;
                            normalOver = true;
                            break;
                        }
                    } else if (animationState == STATE_ZOOM_IN) {
                        currentScale += increment;
                        if (currentScale >= endScale) {
                            currentScale = endScale;
                            normalOver = true;
                            break;
                        }
                    } else {
                        break;
                    }
                }

                view.postInvalidate();
                sleep(sleepTime);
            }

            view.postInvalidate();

        } catch (Exception e) {
            Log.w(TAG, "thread interrupted case=" + e.toString());
            if (listener != null) {
                listener.onError();
            }
        }

        if (normalOver && listener != null) {
            listener.onEnd();
        }
    }

    private void switchStart2EndScaleLocked() {
        float tmp = endScale;
        endScale = startScale;
        startScale = tmp;
    }

}