Android6.0获取进程和进程数目的方法

最新推荐文章于 2022-04-24 14:07:40 发布
最新推荐文章于 2022-04-24 14:07:40 发布
阅读量1.2k 收藏
点赞数
分类专栏： Android

Android5.0之后使用

ActivityManager activityManager= (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
//获取进程的集合
runningAppProcesses= activityManager.getRunningAppProcesses();
size = runningAppProcesses.size();
这种方法获取进程数，已经不可能了android开发越来越艰难，前天写进程管理的代码。在这里加以总结

1.若用户未开启权限，需要先开启权限：
[java]  view plain  copy
  1. protected void oncreat(){  
  2. if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {  
  3.             if (!hasPermission()) {  
  4.                 startActivityForResult(  
  5.                         new Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS),  
  6.                         MY_PERMISSIONS_REQUEST_PACKAGE_USAGE_STATS);  
  7.             }  
  8. }  
  9.  @Override  
  10.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {  
  11.         if (requestCode == MY_PERMISSIONS_REQUEST_PACKAGE_USAGE_STATS) {  
  12.             if (!hasPermission()) {  
  13.                 ##若用户未开启权限，则引导用户开启“Apps with usage access”权限  
  14.                 startActivityForResult(  
  15.                         new Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS),  
  16.                         MY_PERMISSIONS_REQUEST_PACKAGE_USAGE_STATS);  
  17.             }  
  18.         }  
  19.     }  
  20. ##//检测用户是否对本app开启了“Apps with usage access”权限  
  21.   private boolean hasPermission() {  
  22.         AppOpsManager appOps = (AppOpsManager)  
  23.                 getSystemService(Context.APP_OPS_SERVICE);  
  24.         int mode = 0;  
  25.         if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP) {  
  26.             mode = appOps.checkOpNoThrow(AppOpsManager.OPSTR_GET_USAGE_STATS,  
  27.                     android.os.Process.myUid(), getPackageName());  
  28.         }  
  29.         return mode == AppOpsManager.MODE_ALLOWED;  
  30.     }      
2.提供的方法的集合
[java]  view plain  copy
  1. public static int size;  
  2.   
  3.    /** 
  4.     * 获取进程数的方法 
  5.     * @param context 
  6.     * @return 
  7.     */  
  8.    public static int getProcessCount(Context context){  
  9.        List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = null;  
  10.        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP){  
  11.            size = getTopApp(context);  
  12.        }else {  
  13.            ActivityManager activityManager= (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  14.            //获取进程的集合  
  15.            runningAppProcesses= activityManager.getRunningAppProcesses();  
  16.            size = runningAppProcesses.size();  
  17.   
  18.        }  
  19.        return size;  
  20.   
  21.    }  
  22.   
  23.    /** 
  24.     * 6.0获取进程数 
  25.     * @param context 
  26.     * @return 
  27.     */  
  28.    private static int getTopApp(Context context) {  
  29.        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {  
  30.            UsageStatsManager m = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);  
  31.            if (m != null) {  
  32.                long now = System.currentTimeMillis();  
  33.                //获取60秒之内的应用数据  
  34.                List<UsageStats> stats = m.queryUsageStats(UsageStatsManager.INTERVAL_BEST, now - 60 * 1000, now);  
  35.                Log.i(TAG, "Running app number in last 60 seconds : " + stats.size());  
  36.                String topActivity = "";  
  37.                //取得最近运行的一个app，即当前运行的app  
  38.                if ((stats != null) && (!stats.isEmpty())) {  
  39.                    int j = 0;  
  40.                    for (int i = 0; i < stats.size(); i++) {  
  41.                        if (stats.get(i).getLastTimeUsed() > stats.get(j).getLastTimeUsed()) {  
  42.                            j = i;  
  43.                        }  
  44.                        topActivity = stats.get(j).getPackageName();  
  45.                        Log.i(TAG, "top running app is : "+topActivity);  
  46.                    }  
  47.   
  48.                }  
  49.                return stats.size();  
  50.            }  
  51.        }  
  52.        return 0;  
  53.    }  
  54.   
  55.    /** 
  56.     *获取栈顶的包名 
  57.     */  
  58.   
  59.    public static String getTopActivityApp(Context context) {  
  60.        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {  
  61.            UsageStatsManager m = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);  
  62.            if (m != null) {  
  63.                long now = System.currentTimeMillis();  
  64.                //获取60秒之内的应用数据  
  65.                List<UsageStats> stats = m.queryUsageStats(UsageStatsManager.INTERVAL_BEST, now - 60 * 1000, now);  
  66.                Log.i(TAG, "Running app number in last 60 seconds : " + stats.size());  
  67.   
  68.                String topActivity = "";  
  69.   
  70.                //取得最近运行的一个app，即当前运行的app  
  71.                if ((stats != null) && (!stats.isEmpty())) {  
  72.                    int j = 0;  
  73.                    for (int i = 0; i < stats.size(); i++) {  
  74.                        if (stats.get(i).getLastTimeUsed() > stats.get(j).getLastTimeUsed()) {  
  75.                            j = i;  
  76.                        }  
  77.                    }  
  78.                    topActivity = stats.get(j).getPackageName();  
  79.                    return topActivity;  
  80.                }  
  81.                Log.i(TAG, "top running app is : "+topActivity);  
  82.            }  
  83.        }  
  84.        return null;  
  85.    }  
  86.    /** 
  87.     * 获取可用内存的数据大小 ，单位为byte 
  88.     * @param context 
  89.     * @return 
  90.     */  
  91.    public static long getAvailSpace(Context context){  
  92.        //获取activityManager  
  93.        ActivityManager activityManager= (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  94.        //构建可用内存对象  
  95.        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();  
  96.   
  97.   
  98.   
  99.        activityManager.getMemoryInfo(memoryInfo);  
  100.   
  101.        long availMem = memoryInfo.availMem;  
  102.        return availMem;  
  103.    }  
  104.   
  105.    public static long getTotalSpace(Context context){  
  106.        //获取activityManager  
  107.        ActivityManager activityManager= (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  108.        //构建可用内存对象  
  109.        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();  
  110.   
  111.        activityManager.getMemoryInfo(memoryInfo);  
  112.   
  113.        return memoryInfo.totalMem;  
  114.    }  
  115.   
  116.    /** 
  117.     * 获取全部的内存空间 
  118.     * @return 
  119.     */  
  120.    public static long getTotalSpace(){  
  121.        FileReader fileReader=null;  
  122.        BufferedReader bufferedReader=null;  
  123.        try {  
  124.            fileReader=new FileReader("proc/meminfo");  
  125.   
  126.            bufferedReader=new BufferedReader(fileReader);  
  127.   
  128.            String lineOne = bufferedReader.readLine();  
  129.   
  130.            char[] chars = lineOne.toCharArray();  
  131.            StringBuffer stringBuffer = new StringBuffer();  
  132.            for (char aChar : chars) {  
  133.                if (aChar>='0'&&aChar<='9'){  
  134.                    stringBuffer.append(aChar);  
  135.                }  
  136.            }  
  137.            return Long.parseLong(stringBuffer.toString())*1024;  
  138.        } catch (Exception e) {  
  139.            e.printStackTrace();  
  140.   
  141.        }finally {  
  142.            if (fileReader!=null&&bufferedReader!=null){  
  143.                try {  
  144.                    bufferedReader.close();  
  145.                    fileReader.close();  
  146.                } catch (IOException e) {  
  147.                    e.printStackTrace();  
  148.                }  
  149.            }  
  150.        }  
  151.        return 0;  
  152.    }  
  153.   
  154.    /** 
  155.     * 获取进程的信息 
  156.     * @param context 
  157.     * @return 
  158.     */  
  159.    public  static List<ProcessInfoBean> getProcessInfo(Context context){  
  160.   
  161.        ArrayList<ProcessInfoBean> processInfoList = new ArrayList<>();  
  162.        ActivityManager systemService = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  163.   
  164.        List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = systemService.getRunningAppProcesses();  
  165.   
  166.        PackageManager PM = context.getPackageManager();  
  167.   
  168.        for (ActivityManager.RunningAppProcessInfo runningAppProcess : runningAppProcesses) {  
  169.   
  170.            ProcessInfoBean processInfo=new ProcessInfoBean();  
  171.   
  172.            processInfo.packageName= runningAppProcess.processName;  
  173.   
  174.            //获取系统占用的内存大小  
  175.            int pid = runningAppProcess.pid;  
  176.            Debug.MemoryInfo[] processMemoryInfo = systemService.getProcessMemoryInfo(new int[]{pid});  
  177.   
  178.            //获取已使用的大小：  
  179.            processInfo.memeSize= processMemoryInfo[0].getTotalPrivateDirty()*1024;  
  180.   
  181.            //获取应用的名称  
  182.            try {  
  183.                ApplicationInfo applicationInfo = PM.getApplicationInfo(processInfo.getPackageName(), 0);  
  184.   
  185.                processInfo.name= applicationInfo.loadLabel(PM).toString();  
  186.   
  187.                processInfo.icon= applicationInfo.loadIcon(PM);  
  188.   
  189.                if ((applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM)==ApplicationInfo.FLAG_SYSTEM){  
  190.                    processInfo.isSystem=true;  
  191.                }else {  
  192.                    processInfo.isSystem=false;  
  193.                }  
  194.            } catch (PackageManager.NameNotFoundException e) {  
  195.                processInfo.name=processInfo.packageName;  
  196.                processInfo.icon=context.getResources().getDrawable(R.mipmap.ic_launcher);  
  197.                processInfo.isSystem=true;  
  198.                e.printStackTrace();  
  199.            }  
  200.            processInfoList.add(processInfo);  
  201.        }  
  202.        return processInfoList;  
  203.    }  
  204.   
  205.    /** 
  206.     * 6.0版本获取相应的进程信息 
  207.     * @param context 
  208.     * @return 
  209.     */  
  210.    public static List<ProcessInfoBean> getProcess6Info(Context context){  
  211.        ArrayList<ProcessInfoBean> processInfoList = new ArrayList<>();  
  212.        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {  
  213.            UsageStatsManager m = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);  
  214.            if (m != null) {  
  215.                long now = System.currentTimeMillis();  
  216.                //获取60秒之内的应用数据  
  217.                List<UsageStats> stats = m.queryUsageStats(UsageStatsManager.INTERVAL_BEST, now - 60 * 1000, now);  
  218.                ActivityManager systemService = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  219.                Log.i(TAG, "Running app number in last 60 seconds : " + stats.size());  
  220.                //取得最近运行的一个app，即当前运行的app  
  221.                if ((stats != null) && (!stats.isEmpty())) {  
  222.                    for (int i = 0; i < stats.size(); i++) {  
  223.                       /* if (stats.get(i).getLastTimeUsed() > stats.get(j).getLastTimeUsed()) { 
  224.                            j = i; 
  225.                        }*/  
  226.                        int i1 = stats.get(i).describeContents();  
  227.                        String processName = stats.get(i).getPackageName();  
  228.                        Log.i(TAG, "top running app is : " + processName);  
  229.                        PackageManager PM = context.getPackageManager();  
  230.                        ProcessInfoBean processInfo=new ProcessInfoBean();  
  231.                        int uidForName = Process.getUidForName(processName);  
  232.                        /*** 
  233.                         * 此方法未能成功获取进程的内存信息 
  234.                         */  
  235.                        Debug.MemoryInfo[] processMemoryInfo = systemService.getProcessMemoryInfo(new int[]{uidForName});  
  236.                        //获取已使用的大小：  
  237.                        processInfo.memeSize= processMemoryInfo[0].getTotalPrivateDirty()*1024;  
  238.                        processInfo.packageName= processName;  
  239.                        processInfo.appPid=uidForName;  
  240.                        //获取应用的名称  
  241.                        try {  
  242.                            ApplicationInfo applicationInfo = PM.getApplicationInfo(processInfo.getPackageName(), 0);  
  243.   
  244.                            processInfo.name= applicationInfo.loadLabel(PM).toString();  
  245.   
  246.                            processInfo.icon= applicationInfo.loadIcon(PM);  
  247.   
  248.                            if ((applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM)==ApplicationInfo.FLAG_SYSTEM){  
  249.                                processInfo.isSystem=true;  
  250.                            }else {  
  251.                                processInfo.isSystem=false;  
  252.                            }  
  253.                        } catch (PackageManager.NameNotFoundException e) {  
  254.                            processInfo.name=processInfo.packageName;  
  255.                            processInfo.icon=context.getResources().getDrawable(R.mipmap.ic_launcher);  
  256.                            processInfo.isSystem=true;  
  257.                            e.printStackTrace();  
  258.                        }  
  259.                        processInfoList.add(processInfo);  
  260.                    }  
  261.                }  
  262.            }  
  263.        }  
  264.   
  265.        return processInfoList;  
  266.    }  
Android7.0 init进程源码分析
ZhangJian的博客
08-07 1万+
主要对Android 7.0中，init进程的源码进行分析。
android 应用uid,如何在Android上使用uid获取用户名
weixin_31124869的博客
05-27 1288
我编写了一个实用程序类来通过硬编码来自android_filesystem_config.h的值来获取UID / GID名称.String uid = AndroidFilesystemConfig.getNameForId(1000);AndroidFilesystemConfig.javaimport android.os.Build;import android.util.SparseArr...
Android 获取可有进程的数量
Cricket_7的博客
03-12 407
/** * 获取可有进程的数量 * * @param context * @return */ public static int getAllProcessNum(Context context) { PackageManager packageManager = context.getPackageManager(); ...
Android之——获取进程总数、内存、任务列表
冰河的专栏
08-03 8520
如今，基于Android平台的应用越来越多，不乏这样一些应用程序，这些应用可以多手机中的进程，内存和任务列表进行管理。Android系统中没有自带的应用程序对这些数据进行管理。大家不禁会说，Android的应用设置里面有这些功能啊！是的，虽然应用设置里面有，但是我们如果想看一下系统的进程，还要跑到系统设置里面去看吗？这样是不是很麻烦？是不是很挫呢？那获取Android系统的进程总数、内存、任务列表
Android ProcessStats流程分析
wang 恒 的博客
04-20 756
本文基于qcom msm8953 android7.1.2 涉及文件： packages/apps/Settings/src/com/android/settings/applications/ProcessStatsSummary.java 本文先从系统app settings 开始跟踪，先找到settings 一级菜单，查看内存使用情况的Fragment --ProcessSta...
Android获取正在运行的进程列表
就酱的博客
03-27 7989
Android 获取正在运行的进程 private static List<String> getProcessList(Context context) { List<String> resultList = new ArrayList<>(); if (context == null) { return resultList; } List<AndroidAppProce
Android6.0获取进程和进程数目的方法：
qq_37363920的博客
06-26 627
Android5.0之后使用 ActivityManager activityManager= (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); //获取进程的集合 runningAppProcesses= activityManager.getRunningAppProcesses(); size = ru...
Android6.0以上获取前台进程的方法
木叶57的博客
11-10 937
原文地址：http://www.jianshu.com/p/43078a0c18e5 今天遇到个问题， 使用action为“Android.media.action.IMAGE_CAPTURE“打不开Android6.0系统的小米4手机照相机， 问题是你不知道到底是否启动了相机。 我试了很多种方法， 最终只想到一个土办法：点击拍照按钮后延迟1秒判断是否执行了onStop函数或自己是否前台进程，方
ActivityManager的getRunningTasks方法如何同时获取多个进程，需要什么权限
最新发布
08-29
这个权限是用于获取正在运行的任务栈信息的，并且在Android6.0及以上版本需要动态申请。可以使用以下代码来向用户申请权限： ```java if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { if ...
android5.0以上获取系统进程信息
BruceTao的博客
08-28 612
在Android 5.0以上系统,调用getRunningAppProcesses 方法返回的列表为空,这是因为谷歌考虑到安全原因,已经把这个方法移除掉了, 那以后要获取系统运行的后台进程这个方法用不了了，谷歌了一大把，终于找到了解决的方法，获取系统运行的进程代码如下所示： //这是一个实体类,就是描述应用的一些信息public class TaskInfo { //
手机APP跳转到系统设置各个页面
我的剑就是你的剑
04-03 2751
跳转实现：Intent intent=new Intent(Settings.ACTION_WIFI_SETTINGS);intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);startActivity(intent);常量字段示意ACTION_SETTINGS系统设置界面ACTION_APN_SETTINGSAPN设置界面ACTION_LOCATION_S...
android 5.0 以上获取栈顶应用包名以及程序锁的实现
dhl_1986的博客
05-03 3861
在这里我们只考虑5.0以上的系统，首先我们需要5.0的sdK，并且要申请权限，代码如下： private String getTaskPackname() { String currentApp = "CurrentNULL"; if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VER
Android 设备管理器和有权查看使用情况的应用详解
lancelots的博客
11-12 4476
Android中有很多的应用想要取得设备管理器权限,成为系统设备管理器之后可以实现锁屏、擦除用户数据等功能,项目中客户希望自己的app能够默认成为系统的设备管理器,如何操作呢?,下面来介绍一下: DevicePolicyManager mDPM = (DevicePolicyManager)mContext.getSystemService(Context.DEVICE_POL...
Android 获取当前进程
xqw8922的专栏
10-28 890
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Button button = (Button)findViewById(R.id.btn_getID
Android消息处理机制（阻塞和唤醒）
omyrobin的专栏
04-26 1732
前置知识1： 学习任何知识都是要有一定的前置条件的，比如你要先识字才能“看懂”我这篇文章… 在全面了解Android消息处理机制之前，我希望读者对该机制最好要有一定的了解，至少知道主要由哪些类实现了该机制。 如果你还能看得懂c/c++代码，精通Linux内核，对pipe、eventfd和IO多路复用epoll机制都有深入的了解，那么我劝你就别看了… 本文的侧重点主要在于消息机制中的阻塞和唤醒上，对于Java层面的组成关系会简单的带过，这部分的内容已经烂大街了，如果想对于Java层的源码逐行分析请看下面的源码
android permission权限与安全机制解析（下）
热门推荐
Shawn_Dut的专栏
12-30 6万+
刚建了一个QQ群，感兴趣的大家一起多多交流：544645972 　　在android permission权限与安全机制解析（上）篇博客中，我已经详细介绍了android相关系统permission和自定义permission，以及一些权限机制和安全机制。这篇博客主要将会介绍到android 6.0的相关权限更改，原理和相关的处理方式，解决方法等。 　　就以我以前的一个仿最新版微信相册为例子来分
Android 查看当前应用的线程数是否超限
Wang_WY的博客
04-24 5257
1.查看某个应用(以com.wwy.setup为例)的进程号 使用包名查找 adb shell "ps | grep packageName“，packageName 也可以是包名的一部分进行模糊查找。 C:\Users\user>adb shell "ps |grep com.wwy.setup" u0_a39 14985 13378 32836072 217984 SyS_epoll_wait 0 S com.wwy.setup 或者使用adb shell ps直接列
Android权限探究——获取正在运行的应用/进程列表
学不可以已
07-19 2万+
Android5.0以前，可以通过ActivityManagerService.getRunningAppProcesses接口获取系统中正在运行的app进程信息。 但之后的Android版本，此接口只能获取到调用者自己的进程信息，这是为什么呢？本文将一探究竟。 1. ActivityManagerService源码分析 首先看一下Android 8.1 的ActivityManagerSe...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>