AnimationDrawable

最新推荐文章于 2023-06-05 17:26:30 发布
最新推荐文章于 2023-06-05 17:26:30 发布
阅读量1.7k 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/englishfor/article/details/79619495
版权

尽量不要使用 AnimationDrawable,它在初始化的时候就将所有图片加载到内存中,特别占内存,并且还不能释放,释放之后下次进入再次加载时会报错。

说明:
Android 的帧动画可以使用 AnimationDrawable 实现,但是如果你的帧动画中如果
包含过多帧图片,一次性加载所有帧图片所导致的内存消耗会使低端机发生 OOM 异常。帧动画所使用的图片要注意降低内存消耗,当图片比较大时,容易出现 OOM。

下面简单分析AnimationDrawable的原理：
java
//demo
testView = findViewById(R.id.testView);
final AnimationDrawable animationDrawable = (AnimationDrawable).getResources().getDrawable(R.drawable.animation_test);
testView.setBackgroundDrawable(animationDrawable);
animationDrawable.start();

1.生成AnimationDrawable的过程。

//我把log去掉只展示调用逻辑 Resource#getDrawable方法
public Drawable getDrawable(@DrawableRes int id) throws NotFoundException {
        final Drawable d = getDrawable(id, null);
        return d;
    }
    
public Drawable getDrawable(@DrawableRes int id, @Nullable Theme theme)
            throws NotFoundException {
        return getDrawableForDensity(id, 0, theme);
    }
    
    
 public Drawable getDrawableForDensity(@DrawableRes int id, int density, @Nullable Theme theme) {
        final TypedValue value = obtainTempTypedValue();
        try {
        //最终调用到ResourceImpl的 loadDrawable方法
            final ResourcesImpl impl = mResourcesImpl;
            impl.getValueForDensity(id, density, value, true);
            return impl.loadDrawable(this, value, id, density, theme);
        } finally {
            releaseTempTypedValue(value);
        }
    }

ResourcesImpl # loadDrawable方法
Drawable loadDrawable(@NonNull Resources wrapper, @NonNull TypedValue value, int id,
            int density, @Nullable Resources.Theme theme)
            throws NotFoundException {
            //省略的检查cache check preloaded的逻辑，现在不是关注的点
            //First, check whether we have a cached version of this drawable....
            // Next, check preloaded drawables. Preloaded drawables may contain..
            if (cs != null) {
                dr = cs.newDrawable(wrapper);
            } else if (isColorDrawable) {
                dr = new ColorDrawable(value.data);
            } else {
                //最初cs为null，同时不是color drawable所以走到该逻辑
                dr = loadDrawableForCookie(wrapper, value, id, density, null);
            }
            if (dr instanceof DrawableContainer)  {
                needsNewDrawableAfterCache = true;
            }
    }

//ResourcesImpl#loadDrawableForCookie方法逻辑

try {
            if (file.endsWith(".xml")) {
            //我们是从xml中加载所以走一下逻辑
                final XmlResourceParser rp = loadXmlResourceParser(
                        file, id, value.assetCookie, "drawable");
            //调用drawable的方法
                dr = Drawable.createFromXmlForDensity(wrapper, rp, density, theme);
                rp.close();
            } else {
                final InputStream is = mAssets.openNonAsset(
                        value.assetCookie, file, AssetManager.ACCESS_STREAMING);
                dr = Drawable.createFromResourceStream(wrapper, value, is, file, null);
                is.close();
            }
        } catch (Exception e) {
        }

Drawable的createFromXmlForDensity又会调用
Drawable#createFromXmlInnerForDensity方法
static Drawable createFromXmlInnerForDensity(@NonNull Resources r,
            @NonNull XmlPullParser parser, @NonNull AttributeSet attrs, int density,
            @Nullable Theme theme) throws XmlPullParserException, IOException {
        return r.getDrawableInflater().inflateFromXmlForDensity(parser.getName(), parser, attrs,
                density, theme);
    }

最终是DrawableInflater来生成Drawable实例

  Drawable inflateFromXmlForDensity(@NonNull String name, @NonNull XmlPullParser parser,
            @NonNull AttributeSet attrs, int density, @Nullable Theme theme)
            throws XmlPullParserException, IOException {
            1.根据节点生成相应的Drawable。到这里AnimationDrawable的实例构建成功
            /**
            private Drawable inflateFromTag(@NonNull String name) {
        switch (name) {
        对应着我们xml animation-list
            case "animation-list":
                return new AnimationDrawable();
                }
            **/
            Drawable drawable = inflateFromTag(name);
        if (drawable == null) {
            drawable = inflateFromClass(name);
        }
        drawable.setSrcDensityOverride(density);
        2.调用inflate方法
        drawable.inflate(mRes, parser, attrs, theme);
        return drawable;
    }

生成Drawable实例后接着调用其inflate方法
我们查看AnimationDrawable的inflate方法
 public void inflate(Resources r, XmlPullParser parser, AttributeSet attrs, Theme theme)
            throws XmlPullParserException, IOException {
            //inflate 子节点
        inflateChildElements(r, parser, attrs, theme);
        setFrame(0, true, false);
    }

inflate item节点
 private void inflateChildElements(Resources r, XmlPullParser parser, AttributeSet attrs,
            Theme theme) throws XmlPullParserException, IOException {
        int type;
        final int innerDepth = parser.getDepth()+1;
        int depth;
        while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
                && ((depth = parser.getDepth()) >= innerDepth || type != XmlPullParser.END_TAG)) {
                //1.从xml中解析item对应的drawable
                dr = Drawable.createFromXmlInner(r, parser, attrs, theme);
                //2.drawable 和 对应的duration展示时间存放在数组中
            mAnimationState.addFrame(dr, duration);
            if (dr != null) {
            //3.设置Drawable的CallBack。这里CallBack是DrawableContainer实现。DrawableContainer也继承了Drawable类。这里有点类似View和ViewGroup的感觉。AnimationDrawable继承了该类。
                dr.setCallback(this);
            }
        }
    }

接着我们看AnimationDrawable的start方法

 public void start() {
        mAnimating = true;
        if (!isRunning()) {
            // Start from 0th frame.
            //从第一帧开始
            setFrame(0, false, mAnimationState.getChildCount() > 1
                    || !mAnimationState.mOneShot);
        }
    }

接着看setFrame函数
  private void setFrame(int frame, boolean unschedule, boolean animate) {
        mAnimating = animate;
        mCurFrame = frame;
        //根据index来确定当前Drawable
        selectDrawable(frame);
        if (unschedule || animate) {
            unscheduleSelf(this);
        }
        if (animate) {
            // Unscheduling may have clobbered these values; restore them
            mCurFrame = frame;
            //Running状态值改变
            mRunning = true;
            //调度每一个item drawable，传递的时间是当前时间加上duration
            //这里的this代表一个runnable实例，最后传递到Choreographer中
            scheduleSelf(this, SystemClock.uptimeMillis() + mAnimationState.mDurations[frame]);
        }
    }

//这个scheduleSelf函数 是Drawable类实现的。主要是回到drawable
//CallBack接口的scheduleDrawable函数。接下来的任务是看该CallBack的具体
//实现，即setCallBack的调用处。这里用debug查看调用栈。在给view设置background drawable时
public void scheduleSelf(@NonNull Runnable what, long when) {
        final Callback callback = getCallback();
        if (callback != null) {
            callback.scheduleDrawable(this, what, when);
        }
    }
    
    public void setBackgroundDrawable(Drawable background) {
      background.setCallback(this);//此处设置Callback。this是View实例。
      //接下来查看view如何实现该接口
    }

  @Override
    public void scheduleDrawable(@NonNull Drawable who, @NonNull Runnable what, long when) {
        if (verifyDrawable(who) && what != null) {
            final long delay = when - SystemClock.uptimeMillis();
            if (mAttachInfo != null) {
            //view attach到window上时该mAttachInfo不为空。
            //这里的callback类型为animation，之后会分析到
mAttachInfo.mViewRootImpl.mChoreographer.postCallbackDelayed(
                        Choreographer.CALLBACK_ANIMATION, what, who,
                        Choreographer.subtractFrameDelay(delay));
            } else {
                // Postpone the runnable until we know
                // on which thread it needs to run.
                //没attach的时候，先暂存推迟执行
                getRunQueue().postDelayed(what, delay);
            }
        }
    }

接下来去看Choreographer类的postCallbackDelayed方法调用了私有postCallbackDelayedInternal方法
   private void postCallbackDelayedInternal(int callbackType,
            Object action, Object token, long delayMillis) {
        synchronized (mLock) {
            final long now = SystemClock.uptimeMillis();
            final long dueTime = now + delayMillis;
            //根据callback类型存储CallbackRecord.内部实现是按时间
            //将CallbackRecord插入到链表中
        mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
        //如果当前时间大于应该执行的时间，直接调用scheduleFrameLocked

            if (dueTime <= now) {
                scheduleFrameLocked(now);
            } else {
            //否则延迟发送消息，接收消息后也是调用上面的函数进行处理
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                msg.arg1 = callbackType;
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, dueTime);
            }
        }
    }

接下来查看scheduleFrameLocked的逻辑
private void scheduleFrameLocked(long now) {
        if (!mFrameScheduled) {
            mFrameScheduled = true;
            if (USE_VSYNC) {
            //默认USE_VSYNC为true
                if (isRunningOnLooperThreadLocked()) {/判断是否是跟Choreographer的Looper相同
                //这里最终还是会调用doFrame（）函数
                    scheduleVsyncLocked();
                } else {
                    Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
                    msg.setAsynchronous(true);
                    mHandler.sendMessageAtFrontOfQueue(msg);
                }
            } else {
            //为false的话，直接发消息调用doFrame（）函数
                final long nextFrameTime = Math.max(
                        mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);
                if (DEBUG_FRAMES) {
                    Log.d(TAG, "Scheduling next frame in " + (nextFrameTime - now) + " ms.");
                }
                Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, nextFrameTime);
            }
        }
    }

接着再看Choreographer的doFrame
 void doFrame(long frameTimeNanos, int frame) {
        final long startNanos;
        synchronized (mLock) {
        try {
            AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);
            //这里先后执行四种类型的callback
            mFrameInfo.markInputHandlingStart();
            doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);
            //这里执行我们关心的Animation的callback
            mFrameInfo.markAnimationsStart();
            doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);

            mFrameInfo.markPerformTraversalsStart();
            doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);

            doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);
        } finally {
            AnimationUtils.unlockAnimationClock();
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
    }

 void doCallbacks(int callbackType, long frameTimeNanos) {
        CallbackRecord callbacks;
        synchronized (mLock) {
         //这里将执行时间小于当前时间的特定类型的callback都取出来
         mCallbackQueues[callbackType].extractDueCallbacksLocked(
                    now / TimeUtils.NANOS_PER_MS);
            if (callbacks == null) {
                return;
            }
            mCallbacksRunning = true;

        try {
        for (CallbackRecord c = callbacks; c != null; c = c.next) {
               //这里调用CallbackRecord的run函数，执行构造callbackrecord是传递的Action。针对我们要分析的情况，该callback的action是AnimationDrawable schedule函数传递进来的，AnimationDrawable实现的Runnable接口。
               /**
               public void run() {
               //其实现就是调用下一帧
               nextFrame(false);
    }
               **/
                c.run(frameTimeNanos);
            }
        } finally {
            synchronized (mLock) {
                mCallbacksRunning = false;
                do {
                    final CallbackRecord next = callbacks.next;
                    recycleCallbackLocked(callbacks);
                    callbacks = next;
                } while (callbacks != null);
            }
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
    }

总结：到这里我们可以总结一下，AnimationDrawable调用start后首先set第一帧，接着通过Choreographer机制，不断的切换下一个drawable的drawable。
思考：AnimationDrawable只是控制当前的drawable序列。那画面如何更改的。
我们查看View的onDraw方法

 /*
         * Draw traversal performs several drawing steps which must be executed
         * in the appropriate order:
         *
         *      1. Draw the background
         *      2. If necessary, save the canvas' layers to prepare for fading
         *      3. Draw view's content
         *      4. Draw children
         *      5. If necessary, draw the fading edges and restore layers
         *      6. Draw decorations (scrollbars for instance)
         */
         注释中提到，先绘制background。
         我们查看其具体实现。是调用Drawable的draw方法。
         我们知道我们使用AnimationDrawable作为background drawable。
           private void drawBackground(Canvas canvas) {
        final Drawable background = mBackground;
        if ((scrollX | scrollY) == 0) {
            background.draw(canvas);
        } else {
            canvas.translate(scrollX, scrollY);
            background.draw(canvas);
            canvas.translate(-scrollX, -scrollY);
        }
    }

//接着查看AnimationDrawable的draw方法。其中并没有draw方法，这里去查看其父
//类的draw方法，发现他继承的DrawableContainer中有draw方法的实现
@Override
    public void draw(Canvas canvas) {
        if (mCurrDrawable != null) {
            mCurrDrawable.draw(canvas);
        }
        if (mLastDrawable != null) {//为什么要调用last的draw方法？
            mLastDrawable.draw(canvas);
        }
    }
    具体实现是调用currentdrawable 和lastdrawable的draw方法

思考：如何触发draw操作？

//回过头看AnimationDrawable中setFrame（）方法切换每一个drawable的时候
//除了调用上面分析过的scheduleSelf方法，还调用了 selectDrawable（）方法
 private void setFrame(int frame, boolean unschedule, boolean animate) {
        selectDrawable(frame);
        scheduleSelf(this, SystemClock.uptimeMillis() + mAnimationState.mDurations[frame]);
        //看selectDrawable方法实现最后会调用
        //invalidateSelf();来通知重绘
    }

**所以，总体来看AnimationDrawable根据每个item drawable的duration时间
来不断调整当前的drawable。切换drawable的同时出发Choregorapher 的doFrame函数。doFrame函数依次处理 CALLBACK_INPUT ，CALLBACK_ANIMATION，CALLBACK_TRAVERSAL，CALLBACK_COMMIT类型的callback。处理CALLBACK_ANIMATION 类型的callback时触发
**
实验
现在使用16张图
每张图320*320 按4byte一位来算400k 16张差不多6m
有两个页面 第一个页面A只有一个按钮启动第二个页面B B页面播放该帧动画。
刚进入A页面内存稳定35M

实验进入B内存情况退出B内存情况退出B后手动gc退出A
1.退出B后不处理118到122间波动稳定112M112M77M
2.B的onStop中 stop animation同上稳定112M76M20M
3.B的onDestroy中view的background设为null同上稳定112M76M20M
4.同时stop animation onDestroy中view的background设为null同上稳定112M76M20M

疑问：为什么渲染这些图需要100多M内存

achilles偏要执著
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android 动画（AnimationDrawable）
Cricket_7的博客
11-27 250
1，Drawable Animation（帧动画） 【1】介绍和使用方法： 【2】在rec下创建drawable文件。 【2】创建一个xml 文件资源&lt;animation-list &gt; &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;animation-list xmlns:android="http://schem...
AnimationDrawable（帧动画）
Cricket_7的博客
12-19 1122
1，AnimationDrawable（帧动画） 【1】介绍和使用方法： 【2】在rec下创建drawable文件。 【2】创建一个xml 文件资源&lt;animation-list &gt; &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;animation-list xmlns:android="http://schema...
Android中AnimationDrawable使用的简单实例
09-04
介绍了Android中AnimationDrawable使用的简单实例，有需要的朋友可以参考一下
Android应用开发（10）帧动画（AnimationDrawable）
zsyf33078的专栏
03-20 1974
本章介绍AnimationDrawable逐帧动画对象，使用AnimationDrawable+ImageView实现帧动画显示。
安卓 AnimationDrawable 逐帧动画的使用
春水碧于天的博客
02-18 1286
一些不同的图片连续起来快速播放给人眼一种动画的错觉，这就是我所理解的逐帧动画。首先看一下运行效果：AnimationDrawable 类的继承关系：下面看一下具体的实现方式： 在res下的drawable目录下创建 bird_fly_animation.xml 用来放置逐帧动画的图片素材 根节点是animation-list（动画列表），里面有一个或者多个item节点组成，oneshot属性表示是
android 位移动画路径,Android动画之——AnimationDrawable
weixin_42508058的博客
05-26 262
最近在学Android的AnimationDrawable，简单的写一个动画的实现过程。简单介绍Animation代表一个动画，目前Android支持逐帧动画(就是所谓的老电影哪样一张一张放映出来)也支持补间动画(就是通过平移、变化计算出来的动画)。代码片段定义动画的XML文件应该放在/res/anim路径下，注意创建的XML类型是TweenAnimation类型的。下面首先定义一个XML文件：a...
Drawable动画实现
xingzhong128的博客
05-07 3297
前言 Android中有很多有趣的简单几何元素自定义动画效果，比如圆形转圈这类加载动画都是很常见的，如果使用自定义的View来实现这种动画效果实际比较复杂而且很难在其他的View中复用。有种思路就是使用Drawable来实现动画效果，在把它作为View的前景或背景图设置上去，这样的动画效果就被封装到一个简单的Drawable，可以在不同的View之间重复使用。 属性动画实现 既然使用Dr...
Android AnimationDrawable动画实例
08-09
`AnimationDrawable`是Android提供的一种帧动画实现方式，适用于简单的序列帧动画，比如按钮按下、加载动效等。本篇将深入探讨`AnimationDrawable`的使用方法及其背后的原理。 首先，我们要了解`AnimationDrawable`...
AnimationDrawable动画
11-15
`AnimationDrawable`是Android系统提供的一种帧动画实现方式，它允许开发者将一系列的静态图片串连起来，形成连续播放的效果，类似于我们常见的GIF图像。本篇文章将深入探讨如何使用`AnimationDrawable`来创建动态的...
Android之AnimationDrawable简单模拟动态图
09-01
在Android开发中，有时我们需要创建简单的动画效果，这时可以利用`AnimationDrawable`来实现。`AnimationDrawable`是一个可动画的Drawable对象，它允许你通过序列播放一组Drawable来创建帧动画。下面将详细介绍如何...
Android应用通过AnimationDrawable实现View的动画效果
04-18
AnimationDrawable是实现Drawable animations的基本类。推荐用XML文件的方法实现Drawable动画，不推荐在代码中实现。这种XML文件存放在工程中res/drawable/目录下。XML文件的指令(即属性)为动画播放的顺序和时间间隔...
点击动画AnimationDrawable、无限转动RotateAnimation
09-01
本文将深入探讨两种常见的动画技术：`AnimationDrawable`和`RotateAnimation`，以及它们如何应用于点击图片动画效果。 首先，我们来看`AnimationDrawable`，这是一种帧动画类，适用于创建一系列连续的图片来形成...
Android播放动画之使用AnimationDrawable播放帧动画工程
02-10
使用系统带的AnimationDrawable类来播放动画必须将你需要播放的动画打成一帧一帧的图片保存起来，然后在xml文件中表示出每帧图片，这样就可以提前将资源图片加载内存中了。...
帧动画(Drawable Animation)示例源码
06-26
AnimationDrawable animation = (AnimationDrawable) animationView.getBackground(); // 开始动画 animation.start(); // 停止动画 animation.stop(); ``` 4. 动画监听： 可以通过实现`AnimationDrawable...
如何完美监听帧动画？AnimationDrawable深度解析
qq_34231329的博客
06-05 1140
作为苦逼的程序员，产品和设计提出来的需求咱也没法拒绝，这不，前两天设计就给提了个需求，要求在帧动画结束后，把原位置的动画替换成一段文字，我们该怎么监听AnimationDrawable的结束事件呢
Android 动画（二）帧动画 AnimationDrawable
Markus
07-14 690
使用AnimationDrawable实现帧动画 帧动画是一种比较传统的动画，它是由一系列不同的图像创建的，按照顺序播放，就像播放电影一样。 虽然可以使用AnimationDrawable类在代码中定义与使用动画，但使用单个XML文件定义帧动画会更简单。 XML文件由一个元素作为根节点和一系列子节点组成，每个子节点定义一个框架：一个可绘制的框架资源和帧持续时间。 注意：不能在onCr...
Android 编程下 AnimationDrawable (动画)的实现
practicemperfect的博客
03-09 408
Drawable Animation 可以让我们按顺序加载一系列的资源来创建一个动画。动画的创建和传统意义上电影胶卷的播放一样，是通过加载不同的图片，然后按顺序进行播放来实现的。在代 码的实现上 AnimationDrawable 类是基于 Drawable animations 来实现的。 虽然我们可以通过 AnimationDrawable 类的 API 在代码中定义一个动画的所有帧，但
编程回忆之Android回忆（AnimationDrawable的使用）
stop_pig的专栏
03-18 4169
AnimationDrawable的使用 Drawable animation可以加载Drawable资源实现帧动画。AnimationDrawable是实现Drawable animations的基本类。 一、什么是AnimationDrawable AnimationDrawable代表一个动画，首先来说说补间动画，补间动画就是设置图片的首末状态，在指定的时间里面完成动画的变化。 定义
animationdrawable帧动画
最新发布
08-25
AnimationDrawable是一个用于实现帧动画的类。它允许您将多张图片以特定的顺序显示在屏幕上，从而创建连续的动画效果。 要使用AnimationDrawable，首先需要在XML或Java代码中定义一个AnimationDrawable对象，并将每...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值