Android APP内存优化之图片优化

网上有很多大拿分享的关于Android性能优化的文章,主要是通过各种工具分析,使用合理的技巧优化APP的体验,提升APP的流畅度,但关于内存优化的文章很少有看到。在Android设备内存动不动就上G的情况下,的确没有必要去太在意APP对Android系统内存的消耗,但在实际工作中我做的是教育类的小学APP,APP中的按钮、背景、动画变换基本上全是图片,在2K屏上(分辨率2048*1536)一张背景图片就会占用内存12M,来回切换几次内存占用就会增涨到上百兆,为了在不影响APP的视觉效果的前提下,有必要通过各种手段来降低APP对内存的消耗,下面是我在实践过程中使用的一些方法,很多都是不太成熟的项目,也不够深入,只是将其作为一种处理方式分享给大家。

  通过DDMS的APP内存占用查看工具分析发现,APP中占用内存最多的是图片,每个Activity中图片占用内存占大半,本文重点分享对图片的内存优化。

不要将Button的背景设置为selector

  在布局文件和代码中,都可以为Button设置background为selector,这样方便实现按钮的正反选效果,但实际跟踪发现,如果是将Button的背景设置为selector,在初始化Button的时候会将正反选图片都加载在内存中(具体可以查看Android源码,在类Drawable.java的createFromXmlInner方法中对图片进行解析,最终调用Drawable的inflate方法),相当于一个按钮占用了两张相同大小图片所使用的内存,如果一个界面上按钮很多或者是按钮很大,光是按钮占用的内存就会很大,可以通过在布局文件中给按钮只设置正常状态下的背景图片,然后在代码中监听按钮的点击状态,当按下按钮时为按钮设置反选效果的图片,抬起时重新设置为正常状态下的背景,具体实现方式如下:

    public class ImageButtonClickUtils {
        private ImageButtonClickUtils(){

        }

        /**
         * 设置按钮的正反选效果
         * 
         * */
        public static void setClickState(View view, final int normalResId, final int pressResId){
            view.setOnTouchListener(new OnTouchListener() {
                @Override
                public boolean onTouch(View v, MotionEvent event) {
                    switch(event.getAction()){
                    case MotionEvent.ACTION_DOWN:{
                        v.setBackgroundResource(pressResId);
                    }
                    break;
                    case MotionEvent.ACTION_MOVE:{
                        v.setBackgroundResource(pressResId);
                    }
                    break;
                    case MotionEvent.ACTION_UP:{
                        v.setBackgroundResource(normalResId);
                    }
                    break;
                    default:{

                    }
                    break;
                    }

                    // 为了不影响监听按钮的onClick回调,返回值应为false
                    return false;
                }
            });
        }
}

  通过上面这种方式就可以解决同一个按钮占用两倍内存的问题,如果你觉得为一个按钮提供正反选两张图片会导致APK的体积变大,可以通过如下方式实现按钮点击的反选效果,这种方式既不会存在Button占用两倍内存的情况,又减小了APK的体积(Android 5.0中的tintColor也可以实现类似的效果):

    ImageButton personalInfoBtn = (ImageButton)findViewById(R.id.personalBtnId);
    personalInfoBtn.setOnTouchListener(new OnTouchListener() {
        @SuppressLint("ClickableViewAccessibility")
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            int action = event.getAction();

            if(action == MotionEvent.ACTION_DOWN){
                ((ImageButton)v).setColorFilter(getResources().getColor(0X50000000));
            }else if(action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL){
                ((ImageButton)v).clearColorFilter();
            }

            // 为了不影响监听按钮的onClick回调,返回值应为false
            return false;
        }
    });

将背景图片放在非UI线程绘制,提升APP的效率

  在高分辨率的平板设备上,绘制大背景的图片会影响程序的运行效率,严重情况下就和没有开硬件加速的时候使用手写功能一样,相当地卡,最后我们的解决方案是将背景图片通过SurfaceView来绘制,这样相当于是在非UI线程绘制,不会影响到UI线程做其它事情:

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.PixelFormat;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

import com.eebbk.hanziLearning.activity.R;

public class RootSurfaceView extends SurfaceView implements SurfaceHolder.Callback, Runnable{
    private float mViewWidth = 0;
    private float mViewHeight = 0;
    private int mResourceId = 0;
    private Context mContext = null;
    private volatile boolean isRunning = false;
    private SurfaceHolder mSurfaceHolder = null;

    public RootSurfaceView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        initRootSurfaceView(context, attrs, defStyleAttr, 0);
    }

    public RootSurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
        initRootSurfaceView(context, attrs, 0, 0);
    }

    private void initRootSurfaceView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes){
        mContext = context;
        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RootSurfaceView, defStyleAttr, defStyleRes);
        int n = a.getIndexCount();
        mViewWidth = displayMetrics.widthPixels;
        mViewHeight = displayMetrics.heightPixels;
        for(int index=0; index<n; index++){
            int attr = a.getIndex(index);
            switch(attr){
            case R.styleable.RootSurfaceView_background:{
                mResourceId = a.getResourceId(attr, 0);
            }
            break;
            case R.styleable.RootSurfaceView_view_width:{
                mViewWidth = a.getDimension(attr, displayMetrics.widthPixels);
            }
            break;
            case R.styleable.RootSurfaceView_view_height:{
                mViewHeight = a.getDimension(attr, displayMetrics.heightPixels);
            }
            break;
            default:{

            }
            break;
            }
        }
        a.recycle();
        mSurfaceHolder = getHolder();
        mSurfaceHolder.addCallback(this);
        mSurfaceHolder.setFormat(PixelFormat.TRANSLUCENT);
    }

    private Bitmap getDrawBitmap(Context context, float width, float height) {
        Bitmap bitmap = BitmapFactory.decodeResource(getResources(), mResourceId);
        Bitmap resultBitmap = zoomImage(bitmap, width, height);
        return resultBitmap;
    }

    @Override
    public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
        System.out.println("RootSurfaceView surfaceChanged");
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        drawBackGround(holder);
        System.out.println("RootSurfaceView surfaceCreated");
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        isRunning = false;
        System.out.println("RootSurfaceView surfaceDestroyed");
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        System.out.println("RootSurfaceView onAttachedToWindow");
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        System.out.println("RootSurfaceView onDetachedFromWindow");
    }

    @Override
    public void run(){  
        while(isRunning){  
            synchronized (mSurfaceHolder) { 
                if(!mSurfaceHolder.getSurface().isValid()){
                    continue;
                }
                drawBackGround(mSurfaceHolder);
            }
            isRunning = false;
            break;
        }  
    }

    private void drawBackGround(SurfaceHolder holder) {
        Canvas canvas = holder.lockCanvas();
        Bitmap bitmap = getDrawBitmap(mContext, mViewWidth, mViewHeight);
        canvas.drawBitmap(bitmap, 0, 0, null);
        bitmap.recycle();
        holder.unlockCanvasAndPost(canvas);
    }

    public static Bitmap zoomImage( Bitmap bgimage , float newWidth , float newHeight ) {
        float width = bgimage.getWidth( );
        float height = bgimage.getHeight( );
        Matrix matrix = new Matrix();
        float scaleWidth = newWidth/width;
        float scaleHeight = newHeight/height;
        matrix.postScale( scaleWidth, scaleHeight );
        Bitmap bitmap = Bitmap.createBitmap( bgimage, 0, 0, ( int ) width , ( int ) height, matrix, true );
        if( bitmap != bgimage ){
            bgimage.recycle();
            bgimage = null;
        }
        return bitmap;
    }
}

  在res/values/attr.xml文件中定义自定义View的自定义属性:

<declare-styleable name="RootSurfaceView">
    <attr name="background" format="reference" />
    <attr name="view_width" format="dimension" />
    <attr name="view_height" format="dimension" />
</declare-styleable>

没有必要使用硬件加速的界面建议关掉硬件加速

  通过DDMS的heap跟踪发现,相比于关闭硬件加速,在打开硬件加速的情况下会消耗更多的内存,但有的界面打开或者关闭硬件加速对程序的运行效率并没有太大的影响,此种情况下可以考虑在AndroidManifest.xml文件中关闭掉对应Activity的硬件加速,like this:

<!-- 设置界面 -->
<activity
    android:name=".SettingActivity"
    android:hardwareAccelerated="false"
    android:screenOrientation="sensorLandscape"
    android:theme="@style/Translucent_NoTitle">
</activity>

注意:如果使用到WebView、视频播放、手写、动画等功能时,关掉硬件加速会严重音效程序的运行效率,这种情况可以只关闭掉Activity中某些view的硬件加速,整个Activity的硬件加速不关闭。

  如果Activity中某个View需要关闭硬件加速,但整个Activity不能关闭,可以调用view层级关闭硬件加速的方法:

// view.setLayerType || 在定义view的构造方法中调用该方法
setLayerType(View.LAYER_TYPE_SOFTWARE, null);

尽量少用AnimationDrawable,如果必须要可以自定义图片切换器代替AnimationDrawable

  AnimationDrawable也是一个耗内存大户,图片帧数越多耗内存越大,具体可以查看AnimationDrawable的源码,在AnimationDrawable实例化的时候,Drawable的createFromXmlInner方法会调用AnimationDrawable的inflate方法,该方法里面有一个while循环去一次性将所有帧都读取出来,也就是在初始化的时候就将所有的帧读在内存中了,有多少张图片,它就要消耗对应大小的内存。

  虽然可以通过如下方式释放AnimationDrawable占用的内存,但是当退出使用AnimationDrawable的界面,再次进入使用其播放动画时,会报使用已经回收了的图片的异常,这个应该是Android对图片的处理机制导致的,虽然Activity被finish掉了,但是这个Activity中使用到的图片还是在内存中,如果被回收,下次进入时就会报异常信息:

/**
 * 释放AnimationDrawable占用的内存
 * 
 * 
 * */
@SuppressWarnings("unused")
private void freeAnimationDrawable(AnimationDrawable animationDrawable) {
    animationDrawable.stop(); 
    for (int i = 0; i < animationDrawable.getNumberOfFrames(); ++i){
        Drawable frame = animationDrawable.getFrame(i);
        if (frame instanceof BitmapDrawable) {
            ((BitmapDrawable)frame).getBitmap().recycle();
        } 
        frame.setCallback(null);
    } 

    animationDrawable.setCallback(null);
}

  通常情况下我会自定义一个ImageView来实现AnimationDrawable的功能,根据图片之间切换的时间间隔来定时设置ImageView的背景图片,这样始终只是一个ImageView实例,更换的只是其背景,占用内存会比AnimationDrawable小很多:

/**
 * 图片动态切换器
 * 
 * */
public class AnimImageView {
    private static final int MSG_START = 0xf1;
    private static final int MSG_STOP  = 0xf2;
    private static final int STATE_STOP = 0xf3;
    private static final int STATE_RUNNING = 0xf4;

    /* 运行状态*/
    private int mState = STATE_RUNNING;
    private ImageView mImageView;
    /* 图片资源ID列表*/
    private List<Integer> mResourceIdList = null;
    /* 定时任务*/
    private Timer mTimer = null;
    private AnimTimerTask mTimeTask = null;
    /* 记录播放位置*/
    private int mFrameIndex = 0;
    /* 播放形式*/
    private boolean isLooping = false;

    public AnimImageView( ){
        mTimer = new Timer();
    }

    /**
     * 设置动画播放资源
     * 
     * */
    public void setAnimation( HanziImageView imageview, List<Integer> resourceIdList ){
        mImageView = imageview;
        mResourceIdList = resourceIdList;
    }

    /**
     *  开始播放动画
     *  @param loop 时候循环播放
     *  @param duration 动画播放时间间隔
     * */
    public void start(boolean loop, int duration){
        stop();
        isLooping = loop;
        mFrameIndex = 0;
        mState = STATE_RUNNING;
        mTimeTask = new AnimTimerTask( );
        mTimer.schedule(mTimeTask, 0, duration);
    }

    /**
     * 停止动画播放
     * 
     * */
    public void stop(){
        if (mTimeTask != null) {
            mFrameIndex = 0;
            mState = STATE_STOP;
            mTimer.purge();
            mTimeTask.cancel();
            mTimeTask = null;
            mImageView.setBackgroundResource(0);
        }
    }

    /**
     * 定时器任务
     * 
     * 
     */
    class AnimTimerTask extends TimerTask {
        @Override
        public void run() {
            if(mFrameIndex < 0 || mState == STATE_STOP){
                return;
            }

            if( mFrameIndex < mResourceIdList.size() ){
                Message msg = AnimHanlder.obtainMessage(MSG_START,0,0,null);
                msg.sendToTarget();
            }else{
                mFrameIndex = 0;
                if(!isLooping){
                    Message msg = AnimHanlder.obtainMessage(MSG_STOP,0,0,null);
                    msg.sendToTarget();
                }
            }
        }
    }

    private Handler AnimHanlder = new Handler(){
         public void handleMessage(android.os.Message msg) {
                switch (msg.what) {
                case MSG_START:{
                    if(mFrameIndex >=0 && mFrameIndex < mResourceIdList.size() && mState == STATE_RUNNING){
                        mImageView.setImageResource(mResourceIdList.get(mFrameIndex));
                        mFrameIndex++;
                    }
                }
                    break;
                case MSG_STOP:{
                    if (mTimeTask != null) {
                        mFrameIndex = 0;
                        mTimer.purge();
                        mTimeTask.cancel();
                        mState = STATE_STOP;
                        mTimeTask = null;
                        mImageView.setImageResource(0);
                    }
                }
                    break;
                default:
                    break;
                }
         }
    };
}

其它优化方式

  • 尽量将Activity中的小图片和背景合并,一张小图片既浪费布局的时间,又平白地增加了内存占用;
  • 不要在Activity的主题中为Activity设置默认的背景图片,这样会导致Activity占用的内存翻倍:

    <!--千万不要在主题中为Activity设置默认背景

    <style name="Activity_Style" parent="@android:Theme.Holo.Light.NoActionBar">
    <item name="android:background">@drawable/*</item>
    </style>

  • 对于在需要时才显示的图片或者布局,可以使用ViewStub标签,通过sdk/tools目录下的hierarchyviewer.bat查看布局文件会发现,使用viewstub标签的组件几乎不消耗布局的时间,在代码中当需要显示时再去实例化有助于提高Activity的布局效率和节省Activity消耗的内存。
时间: 2024-10-29 19:07:19

Android APP内存优化之图片优化的相关文章

Android手机内存管理与性能优化

Android手机内存管理与性能优化&JNI.NDK高级编程(JNI.Dalvik.内存监测) 课程分类:Android 适合人群:中级 课时数量:34小节课时 用到技术:Dalvik,DDMS,File Explorer,Adapter和图片处理,查询数据库和Static关键字使用及线程,JNI和NDK等 涉及项目:Android手机内存管理与性能优化,玩转JNI与NDK手机编程 咨询qq:1840215592 Android手机内存管理与性能优化详细介绍:http://www.dwz.cn/

Android手机内存管理与性能优化视频教程

课程讲师:xiao_q 课程分类:Android 适合人群:中级 课时数量:34小节 用到技术:Dalvik,DDMS,File Explorer,Adapter和图片处理,查询数据库和Static关键字使用及线程,JNI和NDK等 涉及项目:Android手机内存管理与性能优化,玩转JNI与NDK手机编程 咨询QQ:1609173918 链接:http://pan.baidu.com/s/1i3gnLEt密码:55a0

一个给开发者使用的Android App内存清理、监控工具

MemoryMonitor 一个给开发者使用的Android App内存清理.监控工具,可以获取当前手机的内存使用比率,可用内存大小,检查一个APP是否存在内存泄漏. 并且整理了一些优化内存的方式. 0.GitHub地址 https://github.com/cundong/MemoryMonitor 1.内存清理 类似360卫士的 加速球,获取系统已用内存比率.可用内存大小,一键清理. 可以用于测试自己开发的Activity.Fragment健壮性,模拟Activity.Fragment被回收

Android App 内存泄露之Thread

Thread 内存泄露 线程也是造成内存泄露的一个重要的源头.线程产生内存泄露的主要原因在于线程生命周期的不可控. 1.看一下下面是否存在问题 <span style="white-space:pre"> </span>/** * * @version 1.0.0 * @author Abay Zhuang <br/> * Create at 2014-7-17 */ public class ThreadActivity extends Activ

Android App 内存泄露之调试工具(1)

Android App 内存泄露之工具(1) 使用内存监测工具 DDMS –> Heap 操作步骤 启动eclipse后,切换到DDMS透视图,并确认Devices视图.Heap视图都是打开的,没打开的直接Window>ShowView>自己选 将手机通过USB链接至电脑,链接时需要确认手机是处于"USB调试"模式 链接成功后,在DDMS的Devices视图中将会显示手机设备的序列号,以及设备中正在运行的部分进程信息: 点击选中想要监测的进程,如果在进程列表中未出现你

Android App 内存泄露之Handler

Android App 内存泄露之Handler Handler也是造成内存泄露的一个重要的源头,主要Handler属于TLS(Thread Local Storage)变量,生命周期和Activity是不一致的 ,Handler引用Activity会存在内存泄露. 看一下如下代码 /** * * 实现的主要功能. * @version 1.0.0 * @author Abay Zhuang <br/> * Create at 2014-7-28 */ public class Handler

android app 开发过程中 对于性能优化的总结

一款手机应用  从开发过程中就要做好 性能优化,这样才能 让用户体验度 提升, 假如 我们打开一个应用 出现卡顿, 不流畅,则会很影响 用户对该应用的态度,产品狗 都很注意这些人机交互方面的 体验. 谷歌官方也是一直在优化 android 系统,不论是  碎片化处理 还是 系能 上面,这方面 ios 就做的比较好,配置比 android 低,但是流畅度却比android高,体验效果更好. 官方推荐方案:http://www.oschina.net/news/60157/android-perfo

Android优化之图片优化

1. 对图片本身进行操作 尽量不要使用 setImageBitmap.setImageResource. BitmapFactory.decodeResource 来设置一张大图,因为这些方法在完成 decode 后,最终都是通过 Java 层的 createBitmap 来完成的,需要消耗更多内存.因此,改用先通过 BitmapFactory.decodeStream 方法,创建出一个 bitmap,再将其设为 ImageView 的 source,decodeStream 最大的秘密在于其直

Web性能优化:图片优化

程序员都是懒孩子,想直接看自动优化的点:传送门 我自己的Blog:http://blog.cabbit.me/web-image-optimization/ HTTP Archieve有个统计,图片内容已经占到了互联网内容总量的62%,也就是说超过一半的流量和时间都用来下载图片.从性能优化的角度看,图片也绝对是优化的热点和重点之一,Google PageSpeed或者Yahoo的14条性能优化规则无不把图片优化作为重要的优化手段,本文覆盖了Web图片优化的方方面面,从基本的图片格式选择.到尚未被