无网不进  
软硬件开发
关于手机系统管理的工具类utils

关于手机系统以及应用管理的工具类_总有你想要的

做系统管理或者软件应用管理如手机卫士类软件会用到,可以拿来直接用~比较简单不多说直接上代码：
[java] view plain copy
 
 print?
  1. public class MSUtils {  
  2.   
  3.     /** 
  4.      * 显示文本小提示 
  5.      * @param context 
  6.      * @param string 
  7.      */  
  8.     public static void showMsg(Context context, String msg) {  
  9.         Toast.makeText(context, msg, 0).show();  
  10.     }  
  11.       
  12.     /** 
  13.      * 将一个字符串(明文)用md5加密, 返回密文 
  14.      * @param string 
  15.      * @return 
  16.      */  
  17.     public static String md5(String string) {  
  18.         StringBuffer sb = new StringBuffer();  
  19.         try {  
  20.             // 创建用于加密的加密对象  
  21.             MessageDigest digest = MessageDigest.getInstance("md5");  
  22.             // 将字符串转换为一个16位的byte[]  
  23.             byte[] bytes = digest.digest(string.getBytes("utf-8"));  
  24.             for (byte b : bytes) {// 遍历  
  25.                 // 与255(0xff)做与运算(&)后得到一个255以内的数值  
  26.                 int number = b & 255;// 也可以& 0xff  
  27.                 // 转化为16进制形式的字符串, 不足2位前面补0  
  28.                 String numberString = Integer.toHexString(number);  
  29.                 if (numberString.length() == 1) {  
  30.                     numberString = 0 + numberString;  
  31.                 }  
  32.                 // 连接成密文  
  33.                 sb.append(numberString);  
  34.             }  
  35.         } catch (Exception e) {  
  36.             e.printStackTrace();  
  37.         }  
  38.         return sb.toString();  
  39.     }  
  40.   
  41.     /** 
  42.      * 得到SIM卡的序列号 
  43.      * @param context 
  44.      * @return 
  45.      */  
  46.     public static String getSimNumber(Context context) {  
  47.         TelephonyManager manager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);  
  48.         return manager.getSimSerialNumber();  
  49.           
  50.     }  
  51.   
  52.     /** 
  53.      * 发送短信 
  54.      * @param safeNumber 
  55.      */  
  56.     public static void sendSms(String safeNumber) {  
  57.         SmsManager smsManager = SmsManager.getDefault();  
  58.         smsManager.sendTextMessage(safeNumber, null, "Sim chaged, care!", null, null);  
  59.     }  
  60.       
  61.     /** 
  62.      * 发送短信 
  63.      * @param safeNumber 
  64.      */  
  65.     public static void sendSms(String safeNumber, String msg) {  
  66.         SmsManager smsManager = SmsManager.getDefault();  
  67.         smsManager.sendTextMessage(safeNumber, null, msg, null, null);  
  68.     }  
  69.   
  70.     /** 
  71.      * 对手机锁屏 
  72.      * @param context 
  73.      */  
  74.     public static void lock(Context context) {  
  75.         DevicePolicyManager manager = (DevicePolicyManager)   
  76.                 context.getSystemService(Context.DEVICE_POLICY_SERVICE);  
  77.         manager.resetPassword("123456", 0);//设置密码  
  78.         manager.lockNow();//立即锁屏  
  79.     }  
  80.   
  81.     /** 
  82.      * 播放警报音乐 
  83.      * @param context 
  84.      */  
  85.     public static void playAlarm(Context context) {  
  86.         MediaPlayer mediaPlayer = MediaPlayer.create(context, R.raw.alert);  
  87.         mediaPlayer.setLooping(true);//循环播放  
  88.         mediaPlayer.setVolume(1, 1);//设置音量最大  
  89.         mediaPlayer.start();//播放  
  90.     }  
  91.   
  92.     /** 
  93.      * 删除手机数据 
  94.      * @param context 
  95.      */  
  96.     public static void reset(Context context) {  
  97.         DevicePolicyManager manager = (DevicePolicyManager) context  
  98.                 .getSystemService(Context.DEVICE_POLICY_SERVICE);  
  99.         //清理数据  
  100.         manager.wipeData(0);  
  101.   
  102.     }  
  103.       
  104.     /** 
  105.      * 判断指定的服务是否开启 
  106.      * @param context 
  107.      * @param className 
  108.      * @return 
  109.      */  
  110.     public static boolean isServiceRunning(Context context, String className) {  
  111.         ActivityManager am = (ActivityManager) context  
  112.                 .getSystemService(Context.ACTIVITY_SERVICE);  
  113.         List<RunningServiceInfo> runningServices = am  
  114.                 .getRunningServices(Integer.MAX_VALUE); // 取出所有运行的  
  115.         for (RunningServiceInfo info : runningServices) {  
  116.             String serviceClassName = info.service.getClassName();  
  117.             if (serviceClassName.equals(className)) {  
  118.                 return true;  
  119.             }  
  120.         }  
  121.         return false;  
  122.     }  
  123.       
  124.     /** 
  125.      * 得到手机中所有应用信息的集合 
  126.      */  
  127.     public static Map<Boolean, List<AppInfo>> getAllAppInfos(Context context) {  
  128.           
  129.         SystemClock.sleep(1000);  
  130.           
  131.         Map<Boolean, List<AppInfo>> map = new HashMap<Boolean, List<AppInfo>>();  
  132.         List<AppInfo> systemInfos = new ArrayList<AppInfo>();  
  133.         map.put(true, systemInfos);  
  134.         List<AppInfo> userInfos = new ArrayList<AppInfo>();  
  135.         map.put(false, userInfos);  
  136.           
  137.         //读取手机中所有应用信息数据  
  138.         PackageManager packageManager = context.getPackageManager();  
  139.         Intent intent = new Intent();  
  140.         intent.setAction(Intent.ACTION_MAIN);  
  141.         intent.addCategory(Intent.CATEGORY_LAUNCHER);  
  142.         List<ResolveInfo> resolveInfos = packageManager.queryIntentActivities(intent, 0);  
  143.         for(ResolveInfo ri : resolveInfos) {  
  144.             //packageName  
  145.             String packageName = ri.activityInfo.packageName;  
  146.             //appName  
  147.             String appName = ri.loadLabel(packageManager).toString();  
  148.             //icon  
  149.             Drawable icon = ri.loadIcon(packageManager);  
  150.             //isSystem  
  151.             boolean isSystem = true;  
  152.             try {  
  153.                 isSystem = isSystemApp(packageManager, packageName);  
  154.             } catch (Exception e) {  
  155.                 e.printStackTrace();  
  156.             }  
  157.             AppInfo appInfo = new AppInfo(packageName, appName, icon, isSystem);  
  158.             if(isSystem) {  
  159.                 systemInfos.add(appInfo);  
  160.             } else {  
  161.                 userInfos.add(appInfo);  
  162.             }  
  163.         }  
  164.   
  165.         return map;  
  166.     }  
  167.       
  168.     /** 
  169.      * 判断指定包名所对应的应用是否是系统应用 
  170.      * @param pm 
  171.      * @param packageName 
  172.      * @return 
  173.      * @throws Exception 
  174.      */  
  175.     private static boolean isSystemApp(PackageManager pm, String packageName) throws Exception {  
  176.         PackageInfo packageInfo = pm.getPackageInfo(packageName, 0);  
  177.         return (packageInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) > 0;  
  178.     }  
  179.   
  180.   
  181.     /** 
  182.      * 得到所有正在运行的进程的信息集合 
  183.      * @param context 
  184.      * @param systemtaskInfos 
  185.      * @param usertaskInfos 
  186.      */  
  187.     public static void getAllTaskInfos(Context context,  
  188.             List<TaskInfo> systemtaskInfos, List<TaskInfo> usertaskInfos) {  
  189.   
  190.         ActivityManager am = (ActivityManager) context  
  191.                 .getSystemService(Context.ACTIVITY_SERVICE);  
  192.         List<RunningAppProcessInfo> processInfos = am.getRunningAppProcesses();  
  193.         PackageManager pm = context.getPackageManager();  
  194.   
  195.         for (RunningAppProcessInfo processInfo : processInfos) {  
  196.             TaskInfo taskInfo = new TaskInfo();  
  197.             // 包名  
  198.             String packageName = processInfo.processName;  
  199.             //过滤当前应用  
  200.             if(packageName.equals(context.getPackageName())) {  
  201.                 continue;//当前应用的进程信息不要保存到集合中  
  202.             }  
  203.               
  204.             taskInfo.setPackageName(packageName);  
  205.             // 应用占用的内存  
  206.             MemoryInfo memoryInfo = am  
  207.                     .getProcessMemoryInfo(new int[] { processInfo.pid })[0];  
  208.             long memInfoSize = memoryInfo.getTotalPrivateDirty() * 1024; //memory  byte  
  209.             taskInfo.setMemInfoSize(memInfoSize);  
  210.             try {  
  211.                 // 图标  
  212.                 Drawable icon = pm.getPackageInfo(packageName, 0).applicationInfo.loadIcon(pm);  
  213.                 taskInfo.setIcon(icon);  
  214.                 // 应用名称  
  215.                 String name = pm.getPackageInfo(packageName, 0).applicationInfo.loadLabel(pm).toString();  
  216.                 taskInfo.setAppName(name);  
  217.                 // 是否是系统应用进程  
  218.                 int flag = pm.getPackageInfo(packageName, 0).applicationInfo.flags;  
  219.                 if ((flag & ApplicationInfo.FLAG_SYSTEM) == 0) {// 用户进程  
  220.                     taskInfo.setSystem(false);  
  221.                 } else {// 系统进程  
  222.                     taskInfo.setSystem(true);  
  223.                 }  
  224.             } catch (NameNotFoundException e) {//根据包名得到不到PackageInfo  
  225.                 //e.printStackTrace();  
  226.                 taskInfo.setIcon(context.getResources().getDrawable(R.drawable.ic_launcher));  
  227.                 taskInfo.setAppName(packageName);  
  228.                 taskInfo.setSystem(true);  
  229.             }  
  230.             //不同类型的Info保存到不同的集合中  
  231.             if(taskInfo.isSystem()) {  
  232.                 systemtaskInfos.add(taskInfo);  
  233.             } else {  
  234.                 usertaskInfos.add(taskInfo);  
  235.             }  
  236.         }  
  237.     }  
  238.       
  239.     /** 
  240.      * 得到可用内存的总大小 
  241.      */  
  242.     public static long getAvailMem(Context context) {  
  243.         ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  244.         ActivityManager.MemoryInfo outInfo = new ActivityManager.MemoryInfo();  
  245.         am.getMemoryInfo(outInfo);  
  246.         return outInfo.availMem;  
  247.     }  
  248.   
  249.     /** 
  250.      * 得到总内存大小 
  251.      */  
  252.     @TargetApi(Build.VERSION_CODES.JELLY_BEAN)  
  253.     public static long getTotalMem(Context context) {  
  254.         long totalMem = 0;  
  255.         int sysVersion = VERSION.SDK_INT; // 得到当前系统的版本号  
  256.         // 下面的方式只能在JELLY_BEAN(16)及以上版本才有用  
  257.         if (sysVersion >= Build.VERSION_CODES.JELLY_BEAN) {  
  258.             ActivityManager am = (ActivityManager) context  
  259.                     .getSystemService(Context.ACTIVITY_SERVICE);  
  260.             ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();  
  261.             am.getMemoryInfo(memoryInfo);  
  262.             totalMem = memoryInfo.totalMem;  
  263.         } else {  
  264.             try { // 在版本小于16时, 读取/proc/meminfo文件的第一行来获取总大小  
  265.                 File file = new File("/proc/meminfo");  
  266.                 FileInputStream fis = new FileInputStream(file);  
  267.                 BufferedReader reader = new BufferedReader(  
  268.                         new InputStreamReader(fis));  
  269.   
  270.                 String result = reader.readLine();// MemTotal: 510484 kB  
  271.                 result = result.substring(result.indexOf(":") + 1,  
  272.                         result.indexOf("k")).trim();// 510484  
  273.   
  274.                 reader.close();  
  275.                 totalMem = Integer.parseInt(result) * 1024;  
  276.             } catch (Exception e) {  
  277.                 e.printStackTrace();  
  278.             }  
  279.         }  
  280.         return totalMem;   
  281.     }  
  282.       
  283.     /** 
  284.      * 将大小格式化 
  285.      * @param context 
  286.      * @param byteSize 
  287.      * @return 
  288.      */  
  289.     public static String formatSize(Context context, long byteSize) {  
  290.         return Formatter.formatFileSize(context, byteSize);  
  291.     }  
  292.   
  293.     /** 
  294.      * 杀死指定进程 
  295.      */  
  296.     public static void killProcess(Context context, String packageName) {  
  297.         ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  298.         am.killBackgroundProcesses(packageName);  
  299.     }  
  300.       
  301.     /** 
  302.      * 得到运行的进程数 
  303.      * @param context 
  304.      * @return 
  305.      */  
  306.     public static int getProcessSize(Context context) {  
  307.         ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  308.         List<RunningAppProcessInfo> processInfos = am.getRunningAppProcesses();  
  309.           
  310.         return processInfos.size();  
  311.     }  
  312.   
  313.     /** 
  314.      * 杀死所有进程 
  315.      * @param context 
  316.      */  
  317.     public static void killAllProcess(Context context) {  
  318.         ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  319.         List<RunningAppProcessInfo> processInfos = am.getRunningAppProcesses();  
  320.         PackageManager pm = context.getPackageManager();  
  321.   
  322.         for (RunningAppProcessInfo processInfo : processInfos) {  
  323.             // 包名  
  324.             String packageName = processInfo.processName;  
  325.             //过滤当前应用  
  326.             if(packageName.equals(context.getPackageName())) {  
  327.                 continue;//当前应用的进程信息不要保存到集合中  
  328.             }  
  329.               
  330.             killProcess(context, packageName);  
  331.         }  
  332.     }  
  333.       
  334.     /** 
  335.      * 得到应用的所有流量信息 
  336.     */  
  337.     public static List<TrafficInfo> getAllTrafficInfos(Context context) {  
  338.   
  339.         List<TrafficInfo> list = new ArrayList<TrafficInfo>();  
  340.         PackageManager pm = context.getPackageManager();  
  341.          //安装的所有应用(包含没有主界面的)  
  342.         List<ApplicationInfo> infos = pm.getInstalledApplications(0);   
  343.         for(ApplicationInfo info : infos) {  
  344.             TrafficInfo trafficInfo = new TrafficInfo();  
  345.             //appName  
  346.             String appName = info.loadLabel(pm).toString();  
  347.             trafficInfo.setName(appName);  
  348.             //icon  
  349.             Drawable icon = info.loadIcon(pm);  
  350.             trafficInfo.setIcon(icon);  
  351.               
  352.             int uid = info.uid;   //userID  
  353.             //inSize 下载流量  
  354.             long inSize = TrafficStats.getUidRxBytes(uid); //receive  
  355.             trafficInfo.setInSize(inSize);  
  356.             //outSize 上传流量  
  357.             long outSize = TrafficStats.getUidTxBytes(uid);  
  358.             trafficInfo.setOutSize(outSize);  
  359.             list.add(trafficInfo);  
  360.         }  
  361.         return list;  
  362.     }  
  363.   
  364. }  
posted on 2017-12-21 15:58  无网不进  阅读(246)  评论(0)  编辑  收藏  举报
 
Copyright © 2024 无网不进
Powered by .NET 8.0 on Kubernetes
博客园