Question

I’ve defined RotateAnimation to rotate a ImageView. So, I want to stop the animation after some repeats. The scenario is as following :

First animation starts from -25 to 25 degree, after one animating, this should be change to -24 to 24 and reversely and … and when reach to 0 to 0 this should be cancel.

    int intervalSize = -25;

    RotateAnimation r = new RotateAnimation(intervalSize, intervalSize, pivotX, pivotY);
    r.setDuration(3000);
    r.setStartOffset(0);
    r.setRepeatMode(RotateAnimation.REVERSE);
    r.setRepeatCount(RotateAnimation.INFINITE);
    startAnimation(r);
    r.setAnimationListener(new AnimationListener() {

        @Override
        public void onAnimationStart(Animation animation) {

        }

        @Override
        public void onAnimationRepeat(Animation animation) {
            if (intervalSize == 0)
                animation.cancel();
            intervalSize--;
        }

        @Override
        public void onAnimationEnd(Animation animation) {

        }
    });

Could any one please how can I reach to this ?

Thanks in advance‌:)

Answer 1

I think your problem is that while you ARE changing your global var interval size upon each animation repeat, the animation that is being repeated is not looking at your var, but rather the primitive ints that were passed to it when you said: new RotateAnimation(intervalSize, intervalSize, pivotX, pivotY);

That is, the animation will always have -25 since that’s what it was constructed with, it doesnt care or know about the subsequent changes to your intervalSize var.

To achieve what you want ideally you’d be able to do something like:

 @Override
        public void onAnimationRepeat(Animation animation) {
            if (intervalSize == 0){
                animation.cancel();
            } else {
              ((RotationAnimation)animation).setFromDegress(intervalSize);
              ((RotationAnimation)animation).setToDegress(intervalSize);
            }
        }

But alas, it doesnt look like there are setter methods for those attributes on RotationAnimation. So that leaves you with the possibility of using the onAnimationEndEvent to create a new Animation with the new intervalSizeValue. As in:

Use onAnimationEnd event and rather than have a repeating animation, have a one time animation. Once it ends, the onAnimationEnd event should construct a new RotationAnimation with your new intervalSize.

Here is a working example that animates the textview from the typical Android HelloWorld app in the way you specify:

 package com.example.rotationtest;

import android.os.Bundle;
import android.app.Activity;
import android.view.ViewTreeObserver.OnGlobalLayoutListener;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.RotateAnimation;
import android.widget.TextView;

public class MainActivity extends Activity {
    private TextView tv;

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

        // the textView we will rotate
        tv = (TextView) this.findViewById(R.id.textView1);

        /***
         * we want to have the correct measured size of the view we are going to animate
         * as we want to do a rotation around it's centerpoint.
         * But, we cant get the measured size of a view until Layout has happened...
         * So use a LayoutListener to know when layout is done
         * But, beware that this is often called back on more than once,
         * so remove the listener after it is called first time
         */
        tv.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                initAnimation();
                tv.getViewTreeObserver().removeGlobalOnLayoutListener(this);
                // above is deprecated. in API16+ use tv.getViewTreeObserver().removeOnGlobalLayoutListener(this);      
            }
        });
    }

    private int mRotationAbsDegrees = 25;
    private int mCurrentFromDegrees;
    private int mCurrentToDegrees;

    private void initAnimation(){
    mCurrentFromDegrees = -1 * mRotationAbsDegrees;
    mCurrentToDegrees = mRotationAbsDegrees;
    makeNewAnimation();
    }

    private void makeNewAnimation(){
    RotateAnimation r = new RotateAnimation(mCurrentFromDegrees, mCurrentToDegrees,  tv.getMeasuredWidth()/2, tv.getMeasuredHeight()/2);
        r.setDuration(3000); // TODO: might want to reduce the time as we get closer to zero mRotationAbsDegrees
        r.setStartOffset(0);
        //r.setRepeatMode(RotateAnimation.REVERSE);
        //r.setRepeatCount(RotateAnimation.INFINITE);
        tv.startAnimation(r);
        r.setAnimationListener(new AnimationListener() {

            @Override public void onAnimationStart(Animation animation) {}

            @Override public void onAnimationRepeat(Animation animation) {}

            @Override
            public void onAnimationEnd(Animation animation) {
            // if we have run down the mRotationAbsDegrees to zero, stop animating
            if (mRotationAbsDegrees <= 0){
                return;
            }
            if (mCurrentFromDegrees < 0){
                // reverse the from to
                mCurrentFromDegrees = -1*mCurrentFromDegrees;
                mCurrentToDegrees  = -1*mCurrentToDegrees;
            } else {
                // reduce the mRotationAbsDegrees
                mRotationAbsDegrees--;
                mCurrentFromDegrees = -1 * mRotationAbsDegrees;
                mCurrentToDegrees = mRotationAbsDegrees;
            }
            makeNewAnimation();
            }
        });
    }
}