zoukankan      html  css  js  c++  java

  • 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

    [java] view plaincopyprint?
    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

    [java] view plaincopyprint?
    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
  • 相关阅读:
    玩转JavaScript module pattern精髓
    玩转Javascript 给JS写测试
    Feature Toggle JUnit
    状态机模式实战
    Java静态类
    Guava增强for循环
    Spring Security使用心得
    听个响
    Geoserver2.16.2初步使用
    GeoWebCache1.10.5发布arcgis瓦片服务
  • 原文地址：https://www.cnblogs.com/wanqieddy/p/2484531.html
Copyright © 2011-2022 走看看