Android 一鍵清理、內存清理功能實現

 360桌面、金山清理大師等都提供了一鍵清理、一鍵加速等功能，其實就是殺一些后臺進程來達到釋放內存的目的。

   基本思路就是列出所有運行的進程，查看其重要值（RunningAppProcessInfo.importance，值越大說明進程重要程度越低），可以設定一個閾值，

如果該進程的重要值大于該閾值，就可以殺掉該進程。

進程的重要值有以下幾個等級：

     /** 
             * 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;  

     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級別，殺掉那些長時間沒用或者空進程了，

這個級別的清理力度不夠大，達不到金山清理大師的效果。