Android小功能 -- 获取系统内存信息以及进程信息

通过ActivityManager我们可以获得系统里正在运行的activities，包括进程(Process)等、应用程序/包、服务(Service)、任务(Task)信息。
第一部分：获取系统可用内存以及所有的正在运行的进程信息 ; 
第二部分：获取每个进程里运行的应用程序信息和所有正在运行的应用程序;
第三部分：获取正在运行的服务和任务信息。
知识准备：Android 应用程序模块: 应用、任务、进程的知识介绍：
1、 一个android 包(简称.apk) ：里面包含应用程序的代码以及资源。这是一个应用发布，用户能下载并安装他们设备上的文件。
2、 一个任务 ：通常用户能当它为一个“应用程序”来启动：通常在桌面上会有一个图标可以来启动任务，这是一个上层的应用，可以将你的任务切换到前台来。
3、 一个进程 ：是一个底层的代码运行级别的核心进程。通常.apk包里所有代码运行在一个进程里，一个进程对于一个.apk包；然而,进程 标签常用来改变代码运行的位置，可以是全部的.apk包 或者是独立的活动,接收器,服务, 或者提供器组件。
进程
在Android中，进程是应用程序的完整实现，而不是用户通常了解的那样。他们主要用途很简单：
1、提高稳定性和安全性，将不信任或者不稳定的代码移动到其他进程。
2、可将多个.apk包运行在同一个进程里减少系统开销。
3、帮助系统管理资源，将重要的代码放在一个单独的进程里，这样就可以单独销毁应用程序的其他部分。为了完成某一任务或者减少系统资源的开销，一个进程里可以运行一个或多个应用程序。

ActivityManager 类：
           获取方法 ActivityManager mActivityManager (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
          常用的静态内部类如下(下面具体介绍):
                      ActivityManager.MemoryInfo： 系统可用内存信息
                      ActivityManager.RecentTaskInfo： 最近的任务信息
                      ActivityManager.RunningAppProcessInfo： 正在运行的进程信息
                      ActivityManager.RunningServiceInfo： 正在运行的服务信息
                      ActivityManager.RunningTaskInfo： 正在运行的任务信息
常用方法：
public void getMemoryInfo(ActivityManager.MemoryInfo outInfo)
                说明：获取系统可用内存信息，数据封装在outInfo对象上
public Debug.MemoryInfo getProcessMemoryInfo(int[ ] pids
     说明：获取每个进程ID(集合)占用的内存大小(集合), pid和MemoryInfo是一一对应的。
     参数： pids 进程ID的集合            
PS :我们可以通过调用Debug.MemoryInfo 的dalvikPrivateDirty字段获取进程占用的内存大小(单位为KB)

public List<ActivityManager.RunningAppProcessInfo>getRunningAppProcess()
    说明： 获取系统里正在运行的进程
public List<ActivityManager.RunningServiceInfo>getRunningServices(int maxNum)
     说明： 获取系统里所有正在运行的服务         
     参数：可能服务的最大值(赋予一常数即可，20、50都OK)
public List<ActivityManager.RunningTaskInfoo>getRunningTasks(int maxNum)
               说明：获取系统里正在运行的服务
               参数： 同上
public List<ActivityManager.RecentTaskInfo>getRecentTasks(int maxNum, int flags)
             说明：获取系统里最近启动的任务
             参数： 同上，flags一般为0即可
public voidkillBackgroundProcess(String packageName)
            说明：立即杀掉给定包名的进程，释放进程占用的资源(内存等)，如果需要，系统会再次重新启动该进程。系统
            PS：系统进程是杀不死的，只能杀死用户进程。但我没有找到好的方法辨别系统进程还是用户进程。但可以肯定的是，
                   能够杀死的一定是用户进程。
            public void restartPackage(String packageName)
            说明：该方法已弃用，等同于killBackgroundProcess 。


ActivityManager.MemoryInfo类
    常用字段：
            long availMem 系统可用内存
            long threshold系统内存不足的阀值，即临界值
            boolean lowMemory 如果当前可用内存<=threshold，该值为真

ActivityManager.RunningAppProcessInfo类
   常用字段：
          int pid                             进程ID
          int uid                             进程所在的用户ID
          String processName    进程名，默认是包名或者由android:process=””属性指定
          String [ ] pkgList           运行在该进程下的所有应用程序包名

DEMO说明：
       通过ActivityManager获取了系统的可用内存信息以及正在运行在系统里的进程具体信息，当然你也可以选择手动杀死这些进程，不过前提是用户进程，因为系统进程是杀不死的。


获取系统可用内存的代码：MainActivity.java

1. package com.example.activitymanager;
   
2. 
   
3. import android.app.Activity;
   
4. import android.app.ActivityManager;
   
5. import android.app.ActivityManager.MemoryInfo;
   
6. import android.content.Context;
   
7. import android.content.Intent;
   
8. import android.os.Bundle;
   
9. import android.text.format.Formatter;
   
10. import android.util.Log;
    
11. import android.view.View;
    
12. import android.widget.Button;
    
13. import android.widget.TextView;
    
14. 
    
15. public class MainActivity extends Activity {
    
16. 
    
17.         private static String TAG = "AM_MEMORYIPROCESS";
    
18. 
    
19.         private ActivityManager mActivityManager = null;
    
20. 
    
21.         private TextView tvAvailMem;
    
22.         private Button btProcessInfo;
    
23. 
    
24.         /** Called when the activity is first created. */
    
25.         @Override
    
26.         public void onCreate(Bundle savedInstanceState) {
    
27.                 super.onCreate(savedInstanceState);
    
28.                 setContentView(R.layout.activity_main);
    
29. 
    
30.                 tvAvailMem = (TextView) findViewById(R.id.tvAvailMemory);
    
31.                 btProcessInfo = (Button) findViewById(R.id.btProcessInfo);
    
32.                 // 跳转到显示进程信息界面
    
33.                 btProcessInfo.setOnClickListener(new View.OnClickListener() {
    
34. 
    
35.                         @Override
    
36.                         public void onClick(View v) {
    
37.                                 // TODO Auto-generated method stub
    
38.                                 Intent intent = new Intent(MainActivity.this,
    
39.                                                 BrowseProcessInfoActivity.class);
    
40.                                 startActivity(intent);
    
41.                         }
    
42.                 });
    
43. 
    
44.                 // 获得ActivityManager服务的对象
    
45.                 mActivityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    
46. 
    
47.                 // 获得可用内存信息
    
48.                 String availMemStr = getSystemAvaialbeMemorySize();
    
49.                 Log.i(TAG, "The Availabel Memory Size is" + availMemStr);
    
50.                 // 显示
    
51.                 tvAvailMem.setText("系统可用内存为: " + availMemStr);
    
52. 
    
53.         }
    
54. 
    
55.         // 获得系统可用内存信息
    
56.         private String getSystemAvaialbeMemorySize() {
    
57.                 // 获得MemoryInfo对象
    
58.                 MemoryInfo memoryInfo = new MemoryInfo();
    
59.                 // 获得系统可用内存，保存在MemoryInfo对象上
    
60.                 mActivityManager.getMemoryInfo(memoryInfo);
    
61.                 long memSize = memoryInfo.availMem;
    
62. 
    
63.                 // 字符类型转换
    
64.                 String availMemStr = formateFileSize(memSize);
    
65. 
    
66.                 return availMemStr;
    
67.         }
    
68. 
    
69.         // 调用系统函数，字符串转换 long -String KB/MB
    
70.         private String formateFileSize(long size) {
    
71.                 return Formatter.formatFileSize(MainActivity.this, size);
    
72.         }
    
73. 
    
74. }
    

复制代码

获取系统进程信息的代码 ：BrowseProcessInfoActivity .java

1. package com.example.activitymanager;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. import android.app.Activity;
   
7. import android.app.ActivityManager;
   
8. import android.app.AlertDialog;
   
9. import android.content.Context;
   
10. import android.content.DialogInterface;
    
11. import android.os.Bundle;
    
12. import android.os.Debug;
    
13. import android.util.Log;
    
14. import android.view.ContextMenu;
    
15. import android.view.ContextMenu.ContextMenuInfo;
    
16. import android.view.MenuItem;
    
17. import android.view.View;
    
18. import android.widget.AdapterView;
    
19. import android.widget.AdapterView.OnItemClickListener;
    
20. import android.widget.ListView;
    
21. import android.widget.TextView;
    
22. 
    
23. public class BrowseProcessInfoActivity extends Activity implements
    
24.                 OnItemClickListener {
    
25. 
    
26.         private static String TAG = "ProcessInfo";
    
27.         private static final int KILL_PORCESS = 1;
    
28.         private static final int SEARCH_RUNNING_APP = 2;
    
29. 
    
30.         private ActivityManager mActivityManager = null;
    
31.         // ProcessInfo Model类 用来保存所有进程信息
    
32.         private List<ProcessInfo> processInfoList = null;
    
33. 
    
34.         private ListView listviewProcess;
    
35.         private TextView tvTotalProcessNo;
    
36. 
    
37.         public void onCreate(Bundle savedInstanceState) {
    
38.                 super.onCreate(savedInstanceState);
    
39. 
    
40.                 setContentView(R.layout.browse_process_info);
    
41. 
    
42.                 listviewProcess = (ListView) findViewById(R.id.listviewProcess);
    
43.                 listviewProcess.setOnItemClickListener(this);
    
44. 
    
45.                 tvTotalProcessNo = (TextView) findViewById(R.id.tvTotalProcessNo);
    
46. 
    
47.                 this.registerForContextMenu(listviewProcess);
    
48.                 // 获得ActivityManager服务的对象
    
49.                 mActivityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    
50.                 // 获得系统进程信息
    
51.                 getRunningAppProcessInfo();
    
52.                 // 为ListView构建适配器对象
    
53.                 BrowseProcessInfoAdapter mprocessInfoAdapter = new BrowseProcessInfoAdapter(
    
54.                                 this, processInfoList);
    
55.                 listviewProcess.setAdapter(mprocessInfoAdapter);
    
56. 
    
57.                 tvTotalProcessNo.setText("当前系统进程共有：" + processInfoList.size());
    
58.         }
    
59. 
    
60.         // 杀死该进程，并且刷新
    
61.         @Override
    
62.         public void onItemClick(AdapterView<?> arg0, View arg1, final int position,
    
63.                         long arg3) {
    
64.                 // TODO Auto-generated method stub
    
65.                 new AlertDialog.Builder(this)
    
66.                                 .setMessage("是否杀死该进程")
    
67.                                 .setPositiveButton("确定", new DialogInterface.OnClickListener() {
    
68. 
    
69.                                         @Override
    
70.                                         public void onClick(DialogInterface dialog, int which) {
    
71.                                                 // TODO Auto-generated method stub
    
72.                                                 // 杀死该进程，释放进程占用的空间
    
73.                                                 mActivityManager
    
74.                                                                 .killBackgroundProcesses(processInfoList.get(
    
75.                                                                                 position).getProcessName());
    
76.                                                 // 刷新界面
    
77.                                                 getRunningAppProcessInfo();
    
78.                                                 BrowseProcessInfoAdapter mprocessInfoAdapter = new BrowseProcessInfoAdapter(
    
79.                                                                 BrowseProcessInfoActivity.this, processInfoList);
    
80.                                                 listviewProcess.setAdapter(mprocessInfoAdapter);
    
81.                                                 tvTotalProcessNo.setText("当前系统进程共有："
    
82.                                                                 + processInfoList.size());
    
83. 
    
84.                                         }
    
85.                                 })
    
86.                                 .setNegativeButton("取消", new DialogInterface.OnClickListener() {
    
87. 
    
88.                                         @Override
    
89.                                         public void onClick(DialogInterface dialog, int which) {
    
90.                                                 // TODO Auto-generated method stub
    
91.                                                 dialog.cancel();
    
92.                                         }
    
93.                                 }).create().show();
    
94.         }
    
95. 
    
96.         // 获得系统进程信息
    
97.         private void getRunningAppProcessInfo() {
    
98.                 // ProcessInfo Model类 用来保存所有进程信息
    
99.                 processInfoList = new ArrayList<ProcessInfo>();
    
100. 
     
101.                 // 通过调用ActivityManager的getRunningAppProcesses()方法获得系统里所有正在运行的进程
     
102.                 List<ActivityManager.RunningAppProcessInfo> appProcessList = mActivityManager
     
103.                                 .getRunningAppProcesses();
     
104. 
     
105.                 for (ActivityManager.RunningAppProcessInfo appProcessInfo : appProcessList) {
     
106.                         // 进程ID号
     
107.                         int pid = appProcessInfo.pid;
     
108.                         // 用户ID 类似于Linux的权限不同，ID也就不同 比如 root等
     
109.                         int uid = appProcessInfo.uid;
     
110.                         // 进程名，默认是包名或者由属性android：process=""指定
     
111.                         String processName = appProcessInfo.processName;
     
112.                         // 获得该进程占用的内存
     
113.                         int[] myMempid = new int[] { pid };
     
114.                         // 此MemoryInfo位于android.os.Debug.MemoryInfo包中，用来统计进程的内存信息
     
115.                         Debug.MemoryInfo[] memoryInfo = mActivityManager
     
116.                                         .getProcessMemoryInfo(myMempid);
     
117.                         // 获取进程占内存用信息 kb单位
     
118.                         int memSize = memoryInfo[0].dalvikPrivateDirty;
     
119. 
     
120.                         Log.i(TAG, "processName: " + processName + "  pid: " + pid
     
121.                                         + " uid:" + uid + " memorySize is -->" + memSize + "kb");
     
122.                         // 构造一个ProcessInfo对象
     
123.                         ProcessInfo processInfo = new ProcessInfo();
     
124.                         processInfo.setPid(pid);
     
125.                         processInfo.setUid(uid);
     
126.                         processInfo.setMemSize(memSize);
     
127.                         processInfo.setProcessName(processName);
     
128.                         processInfoList.add(processInfo);
     
129. 
     
130.                         // 获得每个进程里运行的应用程序(包),即每个应用程序的包名
     
131.                         String[] packageList = appProcessInfo.pkgList;
     
132.                         Log.i(TAG, "process id is " + pid + "has " + packageList.length);
     
133.                         for (String pkg : packageList) {
     
134.                                 Log.i(TAG, "packageName " + pkg + " in process id is -->" + pid);
     
135.                         }
     
136.                 }
     
137.         }
     
138. 
     
139.         public void onCreateContextMenu(ContextMenu menu, View v,
     
140.                         ContextMenuInfo menuInfo) {
     
141.                 menu.add(0, KILL_PORCESS, KILL_PORCESS, "杀死该进程");
     
142.                 menu.add(0, KILL_PORCESS, SEARCH_RUNNING_APP, "运行在该进程的应用程序");
     
143.                 super.onCreateContextMenu(menu, v, menuInfo);
     
144. 
     
145.         }
     
146. 
     
147.         public boolean onContextItemSelected(MenuItem item) {
     
148.                 switch (item.getItemId()) {
     
149.                 case KILL_PORCESS: // 杀死该进程 ， 重新加载界面
     
150.                         new AlertDialog.Builder(this)
     
151.                                         .setMessage("是否杀死该进程")
     
152.                                         .setPositiveButton("确定",
     
153.                                                         new DialogInterface.OnClickListener() {
     
154. 
     
155.                                                                 @Override
     
156.                                                                 public void onClick(DialogInterface dialog,
     
157.                                                                                 int which) {
     
158.                                                                         // TODO Auto-generated method stub
     
159. 
     
160.                                                                 }
     
161.                                                         })
     
162.                                         .setNegativeButton("取消",
     
163.                                                         new DialogInterface.OnClickListener() {
     
164. 
     
165.                                                                 @Override
     
166.                                                                 public void onClick(DialogInterface dialog,
     
167.                                                                                 int which) {
     
168.                                                                         // TODO Auto-generated method stub
     
169.                                                                         dialog.cancel();
     
170.                                                                 }
     
171.                                                         }).create().show();
     
172.                         break;
     
173.                 case SEARCH_RUNNING_APP: // 查看运行在该进程的应用程序信息
     
174.                         break;
     
175.                 default:
     
176.                         break;
     
177.                 }
     
178.                 return super.onContextItemSelected(item);
     
179.         }
     
180. }
     

复制代码

最后还要加个权限：

1. <uses-permission android:name="android.permission.KILL_BACKGROUND_PROCESSES"/>

复制代码

运行截图：