碼上快樂

相關內容    簡體    繁體

Android中獲取系統內存信息以及進程信息-----ActivityManager的使用(一)

本文轉載自   查看原文   2012-05-05 10:05   3980    android solve


 

                                                                                                            轉載請注明出處：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 plain copy print ?
  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 plain copy print ?
  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


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Android 5.0以上獲取系統運行進程信息 Android中獲取正在運行的應用程序-----ActivityManager.RunningAppProcessInfo類詳解 Android系統信息獲取 使用python獲取CPU和內存信息的思路與實現(linux系統) C#實現進程內存信息獲取 MFC下獲取系統內存和當前進程的內存使用情況 Android開發之ActivityManager python——psutil的使用（獲取進程信息） Linux 中查看系統進程信息 python獲取GPU，CPU，硬盤，內存，系統，用戶使用情況信息
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM