Java 如何设置Listner停止动画并向MainActivity Android发送回调

如何使用call back here检查动画是否已完成或停止它将AnimationStopped listner设置为null

当动画停止时，我想在我的主类中设置按钮，但它给我空指针。我很难理解这回电话

public interface AnimationStopCheckListner {
    void callback(boolean result);
}


   public class AnimationsContainer implements AnimationStopCheckListner {
    public int FPS = 30;  // animation FPS

    // single instance procedures
    private static AnimationsContainer mInstance;
    boolean endAnim = false;

    private AnimationsContainer() {
    }

    public static AnimationsContainer getInstance() {
        if (mInstance == null)
            mInstance = new AnimationsContainer();
        return mInstance;
    }


    public final int[] IMAGE_RESOURCES = {R.drawable.menu_000,
            R.drawable.menu_0001, R.drawable.menu_0002, R.drawable.menu_0003,
            R.drawable.menu_0004, R.drawable.menu_0005, R.drawable.menu_0006,
            R.drawable.menu_0007, R.drawable.menu_0008,
            R.drawable.menu_0009, R.drawable.menu_00010
    };


    /**
     * @param imageView
     * @return splash screen animation
     */
    public FramesSequenceAnimation createSplashAnim(ImageView imageView) {
        return new FramesSequenceAnimation(imageView, IMAGE_RESOURCES, FPS);
    }

    @Override
    public void callback(boolean result) {

    }

    /**
     * AnimationPlayer. Plays animation frames sequence in loop
     */

    public class FramesSequenceAnimation {
        private int[] mFrames; // animation frames
        private int mIndex; // current frame
        private boolean mShouldRun; // true if the animation should continue running. Used to stop the animation
        private boolean mIsRunning; // true if the animation currently running. prevents starting the animation twice
        private SoftReference<ImageView> mSoftReferenceImageView; // Used to prevent holding ImageView when it should be dead.
        private Handler mHandler;
        private int mDelayMillis;
        private Bitmap mBitmap = null;
        Context mcontext;
        private BitmapFactory.Options mBitmapOptions;
        AnimationStopCheckListner animationStopCheckListner;


        public void setOnAnimationFramesSequenceAnimation(AnimationStopCheckListner listener) {
            this.animationStopCheckListner = listener;
            Log.e("setinterface", "setting");
        }

        public FramesSequenceAnimation(ImageView imageView, int[] frames, int fps) {
            mHandler = new Handler();
            mFrames = frames;
            mIndex = -1;
            mSoftReferenceImageView = new SoftReference<>(imageView);
            mShouldRun = false;
            mIsRunning = false;
            mDelayMillis = 100 / fps;

            imageView.setImageResource(mFrames[0]);

            // use in place bitmap to save GC work (when animation images are the same size & type)
            if (Build.VERSION.SDK_INT >= 11) {
                Bitmap bmp = ((BitmapDrawable) imageView.getDrawable()).getBitmap();
                int width = bmp.getWidth();
                int height = bmp.getHeight();
                Bitmap.Config config = bmp.getConfig();
                mBitmap = Bitmap.createBitmap(width, height, config);
                mBitmapOptions = new BitmapFactory.Options();
                // setup bitmap reuse options.
                mBitmapOptions.inBitmap = mBitmap;
                mBitmapOptions.inMutable = true;
                mBitmapOptions.inSampleSize = 1;
            }
        }

        private int getNext() {
            mIndex++;
            if (mIndex >= mFrames.length)
                mIndex = 0;

            Log.e("total frames", String.valueOf(mIndex));

            if (mIndex == 58) {

                AnimationsContainer.mInstance.endAnim = true;
                stop();
                setOnAnimationFramesSequenceAnimation(animationStopCheckListner);
                if (animationStopCheckListner != null) {
                    // this is null
                    animationStopCheckListner.callback(true);
                }
            }
            return mFrames[mIndex];
        }

        /**
         * Starts the animation
         */
        public synchronized void start() {
            mShouldRun = true;
            if (mIsRunning)
                return;

            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    ImageView imageView = mSoftReferenceImageView.get();
                    if (!mShouldRun || imageView == null) {
                        mIsRunning = false;
                          /*  if (mOnAnimationStoppedListener != null) {
                                mOnAnimationStoppedListener.onAnimationStopped();
                            }*/
                        return;
                    }

                    mIsRunning = true;
                    mHandler.postDelayed(this, mDelayMillis);

                    if (imageView.isShown()) {
                        int imageRes = getNext();
                        if (mBitmap != null) { // so Build.VERSION.SDK_INT >= 11
                            Bitmap bitmap = null;
                            try {
                                bitmap = BitmapFactory.decodeResource(imageView.getResources(), imageRes, mBitmapOptions);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            if (bitmap != null) {
                                imageView.setImageBitmap(bitmap);
                            } else {
                                imageView.setImageResource(imageRes);
                                mBitmap.recycle();
                                mBitmap = null;
                            }
                        } else {
                            imageView.setImageResource(imageRes);
                        }
                    }
                }
            };

            mHandler.post(runnable);

        }

        /**
         * Stops the animation
         */
        public synchronized void stop() {
            mShouldRun = false;

        }
    }

}

公共界面动画TopCheckListner{
无效回调（布尔结果）；
}
公共类AnimationContainer实现AnimationStopCheckListner{
public int FPS=30；//动画FPS
//单实例程序
私有静态动画容器；
布尔值endAnim=false；
私有动画容器（）{
}
公共静态动画容器getInstance（）{
if（minInstance==null）
MinInstance=新的AnimationContainer（）；
回报率；
}
public final int[]IMAGE_RESOURCES={R.drawable.menu_000，
R.drawable.menu_0001，R.drawable.menu_0002，R.drawable.menu_0003，
R.drawable.menu_0004、R.drawable.menu_0005、R.drawable.menu_0006、，
R.drawable.menu_0007，R.drawable.menu_0008，
R.drawable.menu_0009，R.drawable.menu_00010
};
/**
*@param-imageView
*@return启动屏幕动画
*/
公共框架序列图像创建SplashAnim（图像视图图像视图）{
返回新的FramesSequenceAnimation（图像视图、图像资源、FPS）；
}
@凌驾
公共无效回调（布尔结果）{
}
/**
*动画播放器。循环播放动画帧序列
*/
公共类框架序列映像{
私有int[]mFrames；//动画帧
private int mIndex；//当前帧
私有布尔值mShouldRun；//如果动画应继续运行，则为true。用于停止动画
private boolean mIsRunning；//如果动画当前正在运行，则为true。防止两次启动动画
private SoftReference mSoftReferenceImageView；//用于防止在ImageView应处于死机状态时保留它。
私人经理人；
私人住宅；
私有位图mBitmap=null；
语境；
私有位图工厂；
AnimationStopCheckListner AnimationStopCheckListner；
public void setOnAnimationFramesSequenceAnimation（AnimationStopCheckListner侦听器）{
this.animationStopCheckListner=侦听器；
Log.e（“设置接口”、“设置”）；
}
公共帧序列图像（图像视图图像视图，int[]帧，int fps）{
mHandler=新处理程序（）；
M帧=帧；
mIndex=-1；
mSoftReferenceImageView=新的软参考（imageView）；
mShouldRun=false；
错误运行=错误；
mDelayMillis=100/fps；
setImageResource（mFrames[0]）；
//使用在位位图保存GC工作（当动画图像大小和类型相同时）
如果（Build.VERSION.SDK_INT>=11）{
位图bmp=（（BitmapDrawable）imageView.getDrawable（））.getBitmap（）；
int width=bmp.getWidth（）；
int height=bmp.getHeight（）；
Bitmap.Config=bmp.getConfig（）；
mBitmap=Bitmap.createBitmap（宽度、高度、配置）；
mBitmapOptions=新的BitmapFactory.Options（）；
//设置位图重用选项。
mBitmap=mBitmap；
mBitmapOptions.inMutable=true；
mBitmapOptions.inSampleSize=1；
}
}
private int getNext（）{
mIndex++；
if（mIndex>=mFrames.length）
mIndex=0；
Log.e（“总帧数”，String.valueOf（mIndex））；
如果（mIndex==58）{
animationContainer.minInstance.endAnim=true；
停止（）；
setOnAnimationFramesSequenceAnimation（animationStopCheckListner）；
if（animationStopCheckListner！=null）{
//这是空的
animationStopCheckListner.callback（true）；
}
}
返回mFrames[mIndex]；
}
/**
*启动动画
*/
公共同步的void start（）{
mShouldRun=true；
如果（错误运行）
返回；
Runnable Runnable=新的Runnable（）{
@凌驾
公开募捐{
ImageView ImageView=mSoftReferenceImageView.get（）；
如果（！mShouldRun | | imageView==null）{
错误运行=错误；
/*if（mOnAnimationStoppedListener！=null）{
mOnAnimationStoppedListener.onAnimationStopped（）；
}*/
返回；
}
错误运行=正确；
mHandler.postDelayed（这是mDelayMillis）；
if（imageView.isShown（））{
int imageRes=getNext（）；
如果（mBitmap！=null）{//so Build.VERSION.SDK\u INT>=11
位图=空；
试一试{
位图=BitmapFactory.decodeResource（imageView.getResources（）、imageRes、mBitmapOptions）；
}捕获（例外e）{
e、 printStackTrace（）；
}
if（位图！=null）{
设置图像位图（位图）；
}否则{
设置图像资源（imageRes）；
mBitmap.recycle（）；
mBitmap=null；
}
MainActivty extends AppCompatActivity implements AnimationStopCheckListner 

 AnimationsContainer.getInstance.setOnAnimationFrameSequenceAnimation(this);

  public void callback(boolean result){
    // do your stuff
}