资讯专栏INFORMATION COLUMN

获取App应用信息

Loong_T / 1261人阅读

摘要:安卓开发一般都需要进行的更新管理,常用操作老司机已为你封装完毕,经常有小伙伴问怎么进行管理,那我告诉你,你可以用这份工具进行管理,具体可以查看源码,现在为你开车,传送门。

  安卓开发一般都需要进行apk的更新管理,常用操作老司机已为你封装完毕,经常有小伙伴问怎么进行管理,那我告诉你,你可以用这份工具进行管理,具体可以查看源码,现在为你开车,Demo传送门。

站点 获取App应用版本信息 → AppApplicationMgr

</>复制代码

  1. getAppName : 获取本地apk的名称
  2. getVersionName : 获取本地Apk版本名称
  3. getVersionCode : 获取本地Apk版本号
  4. getMetaData : 根据key获取xml中Meta的值
  5. getAppIcon : 获取应用图标
  6. getAppFirstInstallTime : 获取应用第一次安装日期
  7. getAppLastUpdateTime : 获取应用更新日期
  8. getAppSize : 获取应用大小
  9. getAppApk : 获取应用apk文件
  10. getAppInstaller : 获取应用的安装市场
  11. getAppSign : 获取应用签名
  12. getAppTargetSdkVersion : 获取应用兼容sdk
  13. getAppUid : 获取应用uid
  14. getNumCores : 获取Cpu内核数
  15. getRootPermission : 获得root权限
  16. getAppPermissions : 获取应用的所有权限
  17. hasPermission : 是否有权限
  18. isInstalled : 应用是否安装
  19. installApk : 安装应用
  20. uninstallApk : 卸载应用
  21. isSystemApp : 是否是系统应用
  22. isServiceRunning : 服务是否在运行
  23. stopRunningService : 停止服务
  24. killProcesses : 结束进程
  25. runScript : 运行脚本
  26. runApp : 启动应用
  27. getPackageName : 获得包名
  28. getApplicationMetaData : 获取application层级的metadata
具体路线

@SuppressWarnings("rawtypes")
public class AppApplicationMgr {

</>复制代码

  1. /**
  2. * 获取本地apk的名称
  3. * @param context 上下文
  4. * @return String
  5. */
  6. public static String getAppName(Context context) {
  7. try {
  8. PackageManager e = context.getPackageManager();
  9. PackageInfo packageInfo = e.getPackageInfo(context.getPackageName(), 0);
  10. int labelRes = packageInfo.applicationInfo.labelRes;
  11. return context.getResources().getString(labelRes);
  12. } catch (NameNotFoundException var4) {
  13. var4.printStackTrace();
  14. return "unKnown";
  15. }
  16. }
  17. /**
  18. * 获取本地Apk版本名称
  19. * @param context 上下文
  20. * @return String
  21. */
  22. public static String getVersionName(Context context) {
  23. String verName = "";
  24. try {
  25. verName = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
  26. } catch (NameNotFoundException e) {
  27. AppLogMessageMgr.e("AppApplicationMgr-->>getVerName()", e.getMessage() + "获取本地Apk版本名称失败!");
  28. e.printStackTrace();
  29. }
  30. return verName;
  31. }
  32. /**
  33. * 获取本地Apk版本号
  34. * @param context 上下文
  35. * @return int
  36. */
  37. public static int getVersionCode(Context context) {
  38. int verCode = -1;
  39. try {
  40. verCode = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionCode;
  41. } catch (NameNotFoundException e) {
  42. AppLogMessageMgr.e("AppApplicationMgr-->>getVerCode()", e.getMessage() + "获取本地Apk版本号失败!");
  43. e.printStackTrace();
  44. }
  45. return verCode;
  46. }
  47. /**
  48. * 根据key获取xml中Meta的值
  49. * @param context 上下文
  50. * @param key
  51. * @return
  52. */
  53. public static String getMetaData(Context context, String key) {
  54. String value = "";
  55. try {
  56. ApplicationInfo e = context.getPackageManager().getApplicationInfo(context.getPackageName(), 128);
  57. if(null != e) {
  58. Bundle metaData = e.metaData;
  59. if(null != metaData) {
  60. value = metaData.getString(key);
  61. if(null == value || value.length() == 0) {
  62. value = "";
  63. }
  64. }
  65. }
  66. } catch (NameNotFoundException var5) {
  67. var5.printStackTrace();
  68. }
  69. return value;
  70. }
  71. /**
  72. * 获取应用图标
  73. * @param context
  74. * @param packageName
  75. * @return
  76. */
  77. public static Drawable getAppIcon(Context context, String packageName) {
  78. PackageManager pm = context.getPackageManager();
  79. Drawable appIcon = null;
  80. try {
  81. ApplicationInfo applicationInfo = pm.getApplicationInfo(packageName, 0);
  82. appIcon = applicationInfo.loadIcon(pm);
  83. } catch (PackageManager.NameNotFoundException e) {
  84. e.printStackTrace();
  85. }
  86. return appIcon;
  87. }
  88. /**
  89. * 获取应用第一次安装日期
  90. * @param context
  91. * @param packageName
  92. * @return
  93. */
  94. public static long getAppFirstInstallTime(Context context, String packageName) {
  95. long lastUpdateTime = 0;
  96. try {
  97. PackageInfo packageInfo = context.getPackageManager().getPackageInfo(packageName, 0);
  98. lastUpdateTime = packageInfo.firstInstallTime;
  99. } catch (PackageManager.NameNotFoundException e) {
  100. e.printStackTrace();
  101. }
  102. return lastUpdateTime;
  103. }
  104. /**
  105. * 获取应用更新日期
  106. * @param context
  107. * @param packageName
  108. * @return
  109. */
  110. public static long getAppLastUpdateTime(Context context, String packageName) {
  111. long lastUpdateTime = 0;
  112. try {
  113. PackageInfo packageInfo = context.getPackageManager().getPackageInfo(packageName, 0);
  114. lastUpdateTime = packageInfo.lastUpdateTime;
  115. } catch (PackageManager.NameNotFoundException e) {
  116. e.printStackTrace();
  117. }
  118. return lastUpdateTime;
  119. }
  120. /**
  121. * 获取应用大小
  122. * @param context
  123. * @param packageName
  124. * @return
  125. */
  126. public static long getAppSize(Context context, String packageName) {
  127. long appSize = 0;
  128. try {
  129. ApplicationInfo applicationInfo = context.getPackageManager().getApplicationInfo(packageName, 0);
  130. appSize = new File(applicationInfo.sourceDir).length();
  131. } catch (PackageManager.NameNotFoundException e) {
  132. e.printStackTrace();
  133. }
  134. return appSize;
  135. }
  136. /**
  137. * 获取应用apk文件
  138. * @param context
  139. * @param packageName
  140. * @return
  141. */
  142. public static String getAppApk(Context context, String packageName) {
  143. String sourceDir = null;
  144. try {
  145. ApplicationInfo applicationInfo = context.getPackageManager().getApplicationInfo(packageName, 0);
  146. sourceDir = applicationInfo.sourceDir;
  147. } catch (PackageManager.NameNotFoundException e) {
  148. e.printStackTrace();
  149. }
  150. return sourceDir;
  151. }
  152. /**
  153. * 获取应用的安装市场
  154. * @param context
  155. * @param packageName
  156. * @return
  157. */
  158. public static String getAppInstaller(Context context, String packageName) {
  159. return context.getPackageManager().getInstallerPackageName(packageName);
  160. }
  161. /**
  162. * 获取应用签名
  163. * @param context
  164. * @param packageName
  165. * @return
  166. */
  167. public static String getAppSign(Context context, String packageName) {
  168. try {
  169. PackageInfo pis = context.getPackageManager().getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
  170. return hexdigest(pis.signatures[0].toByteArray());
  171. } catch (PackageManager.NameNotFoundException e) {
  172. throw new RuntimeException(AppApplicationMgr.class.getName() + "the " + packageName + ""s application not found");
  173. }
  174. }
  175. public static String hexdigest(byte[] paramArrayOfByte) {
  176. final char[] hexDigits = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102};
  177. try {
  178. MessageDigest localMessageDigest = MessageDigest.getInstance("MD5");
  179. localMessageDigest.update(paramArrayOfByte);
  180. byte[] arrayOfByte = localMessageDigest.digest();
  181. char[] arrayOfChar = new char[32];
  182. for (int i = 0, j = 0; ; i++, j++) {
  183. if (i >= 16) {
  184. return new String(arrayOfChar);
  185. }
  186. int k = arrayOfByte[i];
  187. arrayOfChar[j] = hexDigits[(0xF & k >>> 4)];
  188. arrayOfChar[++j] = hexDigits[(k & 0xF)];
  189. }
  190. } catch (Exception e) {
  191. e.printStackTrace();
  192. }
  193. return "";
  194. }
  195. /**
  196. * 获取应用兼容sdk
  197. * @param context
  198. * @param packageName
  199. * @return
  200. */
  201. public static int getAppTargetSdkVersion(Context context, String packageName) {
  202. try {
  203. PackageInfo packageInfo = context.getPackageManager().getPackageInfo(packageName, 0);
  204. ApplicationInfo applicationInfo = packageInfo.applicationInfo;
  205. return applicationInfo.targetSdkVersion;
  206. } catch (PackageManager.NameNotFoundException e) {
  207. e.printStackTrace();
  208. return 0;
  209. }
  210. }
  211. /**
  212. * 获取应用uid
  213. * @param context
  214. * @param packageName
  215. * @return
  216. */
  217. public static int getAppUid(Context context, String packageName) {
  218. try {
  219. PackageInfo packageInfo = context.getPackageManager().getPackageInfo(packageName, 0);
  220. ApplicationInfo applicationInfo = packageInfo.applicationInfo;
  221. return applicationInfo.uid;
  222. } catch (PackageManager.NameNotFoundException e) {
  223. e.printStackTrace();
  224. return 0;
  225. }
  226. }
  227. /**
  228. * 获取Cpu内核数
  229. * @return
  230. */
  231. public static int getNumCores() {
  232. try {
  233. File dir = new File("/sys/devices/system/cpu/");
  234. File[] files = dir.listFiles(new FileFilter() {
  235. @Override
  236. public boolean accept(File pathname) {
  237. return Pattern.matches("cpu[0-9]", pathname.getName());
  238. }
  239. });
  240. return files.length;
  241. } catch (Exception e) {
  242. e.printStackTrace();
  243. return 1;
  244. }
  245. }
  246. /**
  247. * 获得root权限
  248. * @param context
  249. * @return
  250. */
  251. public static boolean getRootPermission(Context context) {
  252. String packageCodePath = context.getPackageCodePath();
  253. Process process = null;
  254. DataOutputStream os = null;
  255. try {
  256. String cmd = "chmod 777 " + packageCodePath;
  257. process = Runtime.getRuntime().exec("su");
  258. os = new DataOutputStream(process.getOutputStream());
  259. os.writeBytes(cmd + "
  260. ");
  261. os.writeBytes("exit
  262. ");
  263. os.flush();
  264. process.waitFor();
  265. } catch (Exception e) {
  266. return false;
  267. } finally {
  268. try {
  269. if (os != null) {
  270. os.close();
  271. }
  272. process.destroy();
  273. } catch (Exception e) {
  274. e.printStackTrace();
  275. }
  276. }
  277. return true;
  278. }
  279. /**
  280. * 获取应用的所有权限
  281. * @param context
  282. * @param packname
  283. * @return
  284. */
  285. public static String[] getAppPermissions(Context context, String packname) {
  286. String[] requestedPermissions = null;
  287. try {
  288. PackageInfo info = context.getPackageManager().getPackageInfo(packname, PackageManager.GET_PERMISSIONS);
  289. requestedPermissions = info.requestedPermissions;
  290. } catch (PackageManager.NameNotFoundException e) {
  291. e.printStackTrace();
  292. }
  293. return requestedPermissions;
  294. }
  295. /**
  296. * 是否有权限
  297. * @param context
  298. * @param permission
  299. * @return
  300. */
  301. public static boolean hasPermission(Context context, String permission) {
  302. if (context != null && !TextUtils.isEmpty(permission)) {
  303. try {
  304. PackageManager packageManager = context.getPackageManager();
  305. if (packageManager != null) {
  306. if (PackageManager.PERMISSION_GRANTED == packageManager.checkPermission(permission, context
  307. .getPackageName())) {
  308. return true;
  309. }
  310. Log.d("AppUtils", "Have you declared permission " + permission + " in AndroidManifest.xml ?");
  311. }
  312. } catch (Exception e) {
  313. e.printStackTrace();
  314. return false;
  315. }
  316. }
  317. return false;
  318. }
  319. /**
  320. * 应用是否安装
  321. * @param context
  322. * @param packageName
  323. * @return
  324. */
  325. public static boolean isInstalled(Context context, String packageName) {
  326. boolean installed = false;
  327. if (TextUtils.isEmpty(packageName)) {
  328. return false;
  329. }
  330. List installedApplications = context.getPackageManager().getInstalledApplications(0);
  331. for (ApplicationInfo in : installedApplications) {
  332. if (packageName.equals(in.packageName)) {
  333. installed = true;
  334. break;
  335. } else {
  336. installed = false;
  337. }
  338. }
  339. return installed;
  340. }
  341. /**
  342. * 安装应用
  343. * @param context
  344. * @param filePath
  345. * @return
  346. */
  347. public static boolean installApk(Context context, String filePath) {
  348. File file = new File(filePath);
  349. if (!file.exists() || !file.isFile() || file.length() <= 0) {
  350. return false;
  351. }
  352. Intent i = new Intent(Intent.ACTION_VIEW);
  353. i.setDataAndType(Uri.parse("file://" + filePath), "application/vnd.android.package-archive");
  354. i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  355. context.startActivity(i);
  356. return true;
  357. }
  358. /**
  359. * 卸载应用
  360. * @param context
  361. * @param packageName
  362. * @return
  363. */
  364. public static boolean uninstallApk(Context context, String packageName) {
  365. if (TextUtils.isEmpty(packageName)) {
  366. return false;
  367. }
  368. Intent i = new Intent(Intent.ACTION_DELETE, Uri.parse("package:" + packageName));
  369. i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  370. context.startActivity(i);
  371. return true;
  372. }
  373. /**
  374. * 是否是系统应用
  375. * @param context
  376. * @param packageName
  377. * @return
  378. */
  379. public static boolean isSystemApp(Context context, String packageName) {
  380. boolean isSys = false;
  381. PackageManager pm = context.getPackageManager();
  382. try {
  383. ApplicationInfo applicationInfo = pm.getApplicationInfo(packageName, 0);
  384. if (applicationInfo != null && (applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) > 0) {
  385. isSys = true;
  386. }
  387. } catch (PackageManager.NameNotFoundException e) {
  388. e.printStackTrace();
  389. isSys = false;
  390. }
  391. return isSys;
  392. }
  393. /**
  394. * 服务是否在运行
  395. * @param context
  396. * @param className
  397. * @return
  398. */
  399. public static boolean isServiceRunning(Context context, String className) {
  400. boolean isRunning = false;
  401. ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
  402. List servicesList = activityManager.getRunningServices(Integer.MAX_VALUE);
  403. for (RunningServiceInfo si : servicesList) {
  404. if (className.equals(si.service.getClassName())) {
  405. isRunning = true;
  406. }
  407. }
  408. return isRunning;
  409. }
  410. /**
  411. * 停止服务
  412. * @param context
  413. * @param className
  414. * @return
  415. */
  416. public static boolean stopRunningService(Context context, String className) {
  417. Intent intent_service = null;
  418. boolean ret = false;
  419. try {
  420. intent_service = new Intent(context, Class.forName(className));
  421. } catch (Exception e) {
  422. e.printStackTrace();
  423. }
  424. if (intent_service != null) {
  425. ret = context.stopService(intent_service);
  426. }
  427. return ret;
  428. }
  429. /**
  430. * 结束进程
  431. * @param context
  432. * @param pid
  433. * @param processName
  434. */
  435. public static void killProcesses(Context context, int pid, String processName) {
  436. ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
  437. String packageName;
  438. try {
  439. if (!processName.contains(":")) {
  440. packageName = processName;
  441. } else {
  442. packageName = processName.split(":")[0];
  443. }
  444. activityManager.killBackgroundProcesses(packageName);
  445. Method forceStopPackage = activityManager.getClass().getDeclaredMethod("forceStopPackage", String.class);
  446. forceStopPackage.setAccessible(true);
  447. forceStopPackage.invoke(activityManager, packageName);
  448. } catch (Exception e) {
  449. e.printStackTrace();
  450. }
  451. }
  452. /**
  453. * 运行脚本
  454. * @param script
  455. * @return
  456. */
  457. public static String runScript(String script) {
  458. String sRet;
  459. try {
  460. final Process m_process = Runtime.getRuntime().exec(script);
  461. final StringBuilder sbread = new StringBuilder();
  462. Thread tout = new Thread(new Runnable() {
  463. public void run() {
  464. BufferedReader bufferedReader = new BufferedReader(
  465. new InputStreamReader(m_process.getInputStream()),
  466. 8192);
  467. String ls_1;
  468. try {
  469. while ((ls_1 = bufferedReader.readLine()) != null) {
  470. sbread.append(ls_1).append("
  471. ");
  472. }
  473. } catch (IOException e) {
  474. e.printStackTrace();
  475. } finally {
  476. try {
  477. bufferedReader.close();
  478. } catch (IOException e) {
  479. e.printStackTrace();
  480. }
  481. }
  482. }
  483. });
  484. tout.start();
  485. final StringBuilder sberr = new StringBuilder();
  486. Thread terr = new Thread(new Runnable() {
  487. public void run() {
  488. BufferedReader bufferedReader = new BufferedReader(
  489. new InputStreamReader(m_process.getErrorStream()),
  490. 8192);
  491. String ls_1;
  492. try {
  493. while ((ls_1 = bufferedReader.readLine()) != null) {
  494. sberr.append(ls_1).append("
  495. ");
  496. }
  497. } catch (IOException e) {
  498. e.printStackTrace();
  499. } finally {
  500. try {
  501. bufferedReader.close();
  502. } catch (IOException e) {
  503. e.printStackTrace();
  504. }
  505. }
  506. }
  507. });
  508. terr.start();
  509. m_process.waitFor();
  510. while (tout.isAlive()) {
  511. Thread.sleep(50);
  512. }
  513. if (terr.isAlive())
  514. terr.interrupt();
  515. String stdout = sbread.toString();
  516. String stderr = sberr.toString();
  517. sRet = stdout + stderr;
  518. } catch (Exception e) {
  519. e.printStackTrace();
  520. return null;
  521. }
  522. return sRet;
  523. }
  524. /**
  525. * 启动应用
  526. * @param context
  527. * @param packagename
  528. */
  529. public static void runApp(Context context, String packagename) {
  530. context.startActivity(new Intent(context.getPackageManager().getLaunchIntentForPackage(packagename)));
  531. }

// /**
// * 获得当前版本信息
// * @param keyValues key信息
// * @return RequestParams
// */
// public static RequestParams getRequestParams(HashMap keyValues){
// RequestParams params = new RequestParams();
// Iterator iterator = keyValues.entrySet().iterator();
// while(iterator.hasNext()){
// Map.Entry entry = (Map.Entry) iterator.next();
// Object key = entry.getKey();
// params.put((String) key, entry.getValue().toString());
// }
// return params;
// }

</>复制代码

  1. /**
  2. * 获得包名
  3. *
  4. * @param context 上下文
  5. * @return 包名
  6. */
  7. public static String getPackageName(Context context) {
  8. try {
  9. return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).packageName;
  10. } catch (PackageManager.NameNotFoundException e) {
  11. e.printStackTrace();
  12. }
  13. return null;
  14. }
  15. /**
  16. * 获取application层级的metadata
  17. *
  18. * @param context 上下文
  19. * @param key key
  20. * @return value
  21. */
  22. public static String getApplicationMetaData(Context context, String key) {
  23. try {
  24. Bundle metaData = context.getPackageManager().getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA).metaData;
  25. return metaData.get(key).toString();
  26. } catch (PackageManager.NameNotFoundException e) {
  27. e.printStackTrace();
  28. }
  29. return null;
  30. }
  31. /**
  32. * 获得应用申明的所有权限列表
  33. * @param context 上下文
  34. * @return 获得应用申明的所有权限列表
  35. */
  36. public static List getPermissions(Context context){
  37. List permissions=new ArrayList();
  38. try {
  39. PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), PackageManager.GET_PERMISSIONS);
  40. permissions.addAll(Arrays.asList(packageInfo.requestedPermissions));
  41. } catch (PackageManager.NameNotFoundException e) {
  42. e.printStackTrace();
  43. }
  44. return permissions;
  45. }

}

终点站

  好了,终点站到了,如果对本次旅途满意的话,请给五星好评哦,没关注的小伙伴轻轻点个上方的关注,毕竟老司机牺牲了很多时间才换来这么一份工具类,如果该工具类依赖其他工具类,都可以在我的史上最全的常用开发工具类收集(持续更新中)中找到。

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/67566.html

相关文章

  • 使用 Electron 获取应用和用户系统信息

    摘要:使用获取应用和用户系统信息此系列文章的应用示例已发布于可以或下载后运行查看欢迎使用几个和模块您可以收集有关用户系统应用程序或屏幕的信息相关文档的链接位于下面的示例中获取应用信息支持进程主进程的模块可用于获取应用程序在用户计算机上的位置 使用 Electron 获取应用和用户系统信息 此系列文章的应用示例已发布于 GitHub: electron-api-demos-Zh_CN. 可以 ...

    xuxueli 评论0 收藏0
  • 微信网页授权并获取用户信息

    摘要:写在最后我前端刚入门没多久,最近在公司实习,受到身边同事影响,所以也开始写文章来记录自己的学习心得,这是我第一次写文章,所以可能写的不太好,大家对文章和代码有什么建议欢迎提出来一起交流,谢谢 微信网页授权并获取用户信息 介绍 在很多微信H5应用里,当用户访问第三方应用时就需要进行微信网页授权,并且很多涉及安全的操作我们必须要先获取用户信息才能继续,本文章简单介绍了微信授权流程,并通过申...

    CrazyCodes 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<