Android 一键清理、内存清理功能实现

来源：互联网发布：java怎么做对外接口编辑：程序博客网时间：2024/04/29 20:31

360桌面、金山清理大师等都提供了一键清理、一键加速等功能，其实就是杀一些后台进程来达到释放内存的目的。

基本思路就是列出所有运行的进程，查看其重要值（RunningAppProcessInfo.importance，值越大说明进程重要程度越低），可以设定一个阈值，

如果该进程的重要值大于该阈值，就可以杀掉该进程。

进程的重要值有以下几个等级：

[java] view plaincopy
/** 
         * Constant for {@link #importance}: this is a persistent process. 
         * Only used when reporting to process observers. 
         * @hide 
         */  
        public static final int IMPORTANCE_PERSISTENT = 50;  
  
        /** 
         * Constant for {@link #importance}: this process is running the 
         * foreground UI. 
         */  
        public static final int IMPORTANCE_FOREGROUND = 100;  
          
        /** 
         * Constant for {@link #importance}: this process is running something 
         * that is actively visible to the user, though not in the immediate 
         * foreground. 
         */  
        public static final int IMPORTANCE_VISIBLE = 200;  
          
        /** 
         * Constant for {@link #importance}: this process is running something 
         * that is considered to be actively perceptible to the user.  An 
         * example would be an application performing background music playback. 
         */  
        public static final int IMPORTANCE_PERCEPTIBLE = 130;  
          
        /** 
         * Constant for {@link #importance}: this process is running an 
         * application that can not save its state, and thus can't be killed 
         * while in the background. 
         * @hide 
         */  
        public static final int IMPORTANCE_CANT_SAVE_STATE = 170;  
          
        /** 
         * Constant for {@link #importance}: this process is contains services 
         * that should remain running. 
         */  
        public static final int IMPORTANCE_SERVICE = 300;  
          
        /** 
         * Constant for {@link #importance}: this process process contains 
         * background code that is expendable. 
         */  
        public static final int IMPORTANCE_BACKGROUND = 400;  
          
        /** 
         * Constant for {@link #importance}: this process is empty of any 
         * actively running code. 
         */  
        public static final int IMPORTANCE_EMPTY = 500;  

直接上代码：

[java] view plaincopy
package com.android.clearmemory;  
  
import android.app.Activity;  
import android.app.ActivityManager;  
import android.app.ActivityManager.MemoryInfo;  
import android.app.ActivityManager.RunningAppProcessInfo;  
import android.content.Context;  
import android.os.Bundle;  
import android.util.Log;  
import android.view.View;  
import android.widget.Button;  
import android.widget.Toast;  
  
import java.util.List;  
  
public class ClearMemoryActivity extends Activity {  
    private static final String TAG = "ClearMemoryActivity";  
  
    /** 
     * Called when the activity is first created. 
     */  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
  
        Button clear = (Button) findViewById(R.id.clear);  
        clear.setOnClickListener(new View.OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                //To change body of implemented methods use File | Settings | File Templates.  
                ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);  
                List<RunningAppProcessInfo> infoList = am.getRunningAppProcesses();  
                List<ActivityManager.RunningServiceInfo> serviceInfos = am.getRunningServices(100);  
  
                long beforeMem = getAvailMemory(ClearMemoryActivity.this);  
                Log.d(TAG, "-----------before memory info : " + beforeMem);  
                int count = 0;  
                if (infoList != null) {  
                    for (int i = 0; i < infoList.size(); ++i) {  
                        RunningAppProcessInfo appProcessInfo = infoList.get(i);  
                        Log.d(TAG, "process name : " + appProcessInfo.processName);  
                        //importance 该进程的重要程度  分为几个级别，数值越低就越重要。  
                        Log.d(TAG, "importance : " + appProcessInfo.importance);  
  
                        // 一般数值大于RunningAppProcessInfo.IMPORTANCE_SERVICE的进程都长时间没用或者空进程了  
                        // 一般数值大于RunningAppProcessInfo.IMPORTANCE_VISIBLE的进程都是非可见进程，也就是在后台运行着  
                        if (appProcessInfo.importance > RunningAppProcessInfo.IMPORTANCE_VISIBLE) {  
                            String[] pkgList = appProcessInfo.pkgList;  
                            for (int j = 0; j < pkgList.length; ++j) {//pkgList 得到该进程下运行的包名  
                                Log.d(TAG, "It will be killed, package name : " + pkgList[j]);  
                                am.killBackgroundProcesses(pkgList[j]);  
                                count++;  
                            }  
                        }  
  
                    }  
                }  
  
                long afterMem = getAvailMemory(ClearMemoryActivity.this);  
                Log.d(TAG, "----------- after memory info : " + afterMem);  
                Toast.makeText(ClearMemoryActivity.this, "clear " + count + " process, "  
                            + (afterMem - beforeMem) + "M", Toast.LENGTH_LONG).show();  
            }  
        });  
  
        ClearMemoryFloatView.instance(getApplicationContext()).createView();  
    }  
  
    //获取可用内存大小  
    private long getAvailMemory(Context context) {  
        // 获取android当前可用内存大小  
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
        MemoryInfo mi = new MemoryInfo();  
        am.getMemoryInfo(mi);  
        //mi.availMem; 当前系统的可用内存  
        //return Formatter.formatFileSize(context, mi.availMem);// 将获取的内存大小规格化  
        Log.d(TAG, "可用内存---->>>" + mi.availMem / (1024 * 1024));  
        return mi.availMem / (1024 * 1024);  
    }  
}  

注意：

我这里选择阈值是IMPORTANCE_VISIBLE级别的，也就是非可见的后台进程和服务会被杀掉（一些系统进程肯定除外）。

清理的效果跟金山清理大师和360桌面的一键清理效果差不多。

如果不想杀的太凶，可以选择IMPORTANCE_SERVICE级别，杀掉那些长时间没用或者空进程了，

这个级别的清理力度不够大，达不到金山清理大师的效果。

2 0