【转】Android中获取系统内存信息以及进程信息-----ActivityManager的使用

转载请注明出处：http://blog.csdn.net/qinjuning

本节内容主要是讲解ActivityManager的使用，通过ActivityManager我们可以获得系统里正在运行的activities，包括

进程(Process)等、应用程序/包、服务(Service)、任务(Task)信息。

计划如下：

第一部分：获取系统可用内存以及所有的正在运行的进程信息 ;

第二部分：获取每个进程里运行的应用程序信息和所有正在运行的应用程序

第三部分：获取正在运行的服务和任务信息。

每部分都准备了相应的Demo，助您更深的理解.

知识准备：Android 应用程序模块: 应用、任务、进程的知识介绍：

1 一个android 包(简称.apk) ：里面包含应用程序的代码以及资源。这是一个应用发布，用户能下载并安装他们

设备上的文件。

2 一个任务：通常用户能当它为一个“应用程序”来启动：通常在桌面上会有一个图标可以来启动任务，这是一个

上层的应用，可以将你的任务切换到前台来。

3 一个进程：是一个底层的代码运行级别的核心进程。通常.apk包里所有代码运行在一个进程里，一个进程对于

一个.apk包；然而,进程标签常用来改变代码运行的位置，可以是全部的.apk包或者是独立的活动,接收器,服务, 或者

提供器组件。

进程

在Android中，进程是应用程序的完整实现，而不是用户通常了解的那样。他们主要用途很简单：

1、提高稳定性和安全性，将不信任或者不稳定的代码移动到其他进程。

2、可将多个.apk包运行在同一个进程里减少系统开销。

3、帮助系统管理资源，将重要的代码放在一个单独的进程里，这样就可以单独销毁应用程序的其他部分。

于是，为了完成某一任务或者减少系统资源的开销，一个进程里可以运行一个或多个应用程序。

更多知识点获取，请访问：《Android 应用程序模块: 应用, 任务, 进程, 和线程》

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 运行在该进程下的所有应用程序包名

对ActivityManager.RecentTaskInfo、ActivityManager.RunningServiceInfo、ActivityManager.RunningTaskInfo

类的介绍留在后文介绍。

DEMO说明：

我们通过ActivityManager获取了系统的可用内存信息以及正在运行在系统里的进程具体信息，当然你也可以选择

手动杀死这些进程，不过前提是用户进程，因为系统进程是杀不死的。

模拟器上的截图如下：

资源文件什么的就不再贴代码了，直接列出逻辑文件。

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

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

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

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

我们可以通过进程占用内存大小来进而获取占用cpu大小，直接换算还是很简单的。

源代码地址：http://download.csdn.net/detail/qinjuning/3803314

posted @ 2012-11-21 11:36 沙发土豆阅读(1379) 评论(0) 收藏举报

刷新页面返回顶部

沙发土豆

【转】Android中获取系统内存信息以及进程信息-----ActivityManager的使用

进程

ActivityManager 类：

ActivityManager.MemoryInfo类

ActivityManager.RunningAppProcessInfo类

公告