devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 设备信息获取详解

作者：从前慢现在也慢 | 2024-03-15 15:08:44

赞

踩

android 获取设备信息

和你一起终身学习，这里是程序员Android

经典好文推荐，通过阅读本文，您将收获以下知识点:

一、获取手机基本信息(厂商、型号等参数)
二、设备信息获取实现图
三、获取手机设备 宽、高、IMEI 信息
四、获取手机厂商名、产品名、手机品牌、手机型号、主板名、设备名
五、获取手机硬件名、SDK版本、android版本 、语言支持、默认语言
六、获取 SD 卡存储信息
七、获取手机 RAM、ROM存储信息
八、DeviceInfoUtils 封装类
九、SDCardUtils 封装类

下面将讲解以上信息的获取方法。

一、 获取手机基本信息(厂商、型号等参数)

以小米手机为例，手机常用的基本信息可以在Settings--> About Phone中看到，
例如下图：

小米手机设备信息图

那么如何获取这些设备信息呢？ Android中 通常通过 android.os.Build类方法可以获取更多手机设备信息。

二、 设备信息获取实现图

获取手机IMEI、宽、高、是否有SD卡，RAM、ROM、SD卡、是否联网、网络类型

默认语言，设备名，型号、厂商、Fingerprint、Android 版本、SDK版本、Google 安全patch、发布时间、版本类型、用户名

产品名、ID、产品名、主板名

三、 获取手机设备 宽、高、IMEI 信息方法

获取手机宽、高、IMEI信息方法如下：

  1.     /**
  2.      * 获取设备宽度（px）
  3.      * 
  4.      */
  5.     public static int getDeviceWidth(Context context) {
  6.         return context.getResources().getDisplayMetrics().widthPixels;
  7.     }
  8.  
  9.     /**
  10.      * 获取设备高度（px）
  11.      */
  12.     public static int getDeviceHeight(Context context) {
  13.         return context.getResources().getDisplayMetrics().heightPixels;
  14.     }
  15.  
  16.     /**
  17.      * 获取设备的唯一标识， 需要 “android.permission.READ_Phone_STATE”权限
  18.      */
  19.     public static String getIMEI(Context context) {
  20.         TelephonyManager tm = (TelephonyManager) context
  21.                 .getSystemService(Context.TELEPHONY_SERVICE);
  22.         String deviceId = tm.getDeviceId();
  23.         if (deviceId == null) {
  24.             return "UnKnown";
  25.         } else {
  26.             return deviceId;
  27.         }
  28.     }

注意：获取IMEI 需要获取手机状态权限

  1.  <!-- 读取手机IMEI的设备权限 -->
  2.     <uses-permission android:name="android.permission.READ_PHONE_STATE" />

如果是Android 6.0 之后的代码请使用动态申请权限的方法申请权限，否认会报安全异常的错误SecurityException，进而导致运行报错。

如需了解更多 系统安全权限的内容，请看 之前写的文章 Android 系统权限使用详解

四、 获取手机厂商名、产品名、手机品牌、手机型号、主板名、设备名的方法

获取手机厂商名、产品名、手机品牌、手机型号、主板名、设备名的方法如下:

  1.     /**
  2.      * 获取厂商名
  3.      * **/
  4.     public static String getDeviceManufacturer() {
  5.         return android.os.Build.MANUFACTURER;
  6.     }
  7.  
  8.     /**
  9.      * 获取产品名
  10.      * **/
  11.     public static String getDeviceProduct() {
  12.         return android.os.Build.PRODUCT;
  13.     }
  14.  
  15.     /**
  16.      * 获取手机品牌
  17.      */
  18.     public static String getDeviceBrand() {
  19.         return android.os.Build.BRAND;
  20.     }
  21.  
  22.     /**
  23.      * 获取手机型号
  24.      */
  25.     public static String getDeviceModel() {
  26.         return android.os.Build.MODEL;
  27.     }
  28.  
  29.     /**
  30.      * 获取手机主板名
  31.      */
  32.     public static String getDeviceBoard() {
  33.         return android.os.Build.BOARD;
  34.     }
  35.  
  36.     /**
  37.      * 设备名
  38.      * **/
  39.     public static String getDeviceDevice() {
  40.         return android.os.Build.DEVICE;
  41.     }
  42.  
  43.     /**
  44.      * 
  45.      * 
  46.      * fingerprit 信息
  47.      * **/
  48.     public static String getDeviceFubgerprint() {
  49.         return android.os.Build.FINGERPRINT;
  50.     }

五、 获取手机硬件名、SDK版本、android版本 、语言支持、默认语言等方法

获取手机硬件名、SDK版本、android版本 、语言支持、默认语言等方法如下:

  1.     /**
  2.      * 硬件名
  3.      * 
  4.      * **/
  5.     public static String getDeviceHardware() {
  6.         return android.os.Build.HARDWARE;
  7.     }
  8.  
  9.     /**
  10.      * 主机
  11.      * 
  12.      * **/
  13.     public static String getDeviceHost() {
  14.         return android.os.Build.HOST;
  15.     }
  16.  
  17.     /**
  18.      * 
  19.      * 显示ID
  20.      * **/
  21.     public static String getDeviceDisplay() {
  22.         return android.os.Build.DISPLAY;
  23.     }
  24.  
  25.     /**
  26.      * ID
  27.      * 
  28.      * **/
  29.     public static String getDeviceId() {
  30.         return android.os.Build.ID;
  31.     }
  32.  
  33.     /**
  34.      * 获取手机用户名
  35.      * 
  36.      * **/
  37.     public static String getDeviceUser() {
  38.         return android.os.Build.USER;
  39.     }
  40.  
  41.     /**
  42.      * 获取手机 硬件序列号
  43.      * **/
  44.     public static String getDeviceSerial() {
  45.         return android.os.Build.SERIAL;
  46.     }
  47.  
  48.     /**
  49.      * 获取手机Android 系统SDK
  50.      * 
  51.      * @return
  52.      */
  53.     public static int getDeviceSDK() {
  54.         return android.os.Build.VERSION.SDK_INT;
  55.     }
  56.  
  57.     /**
  58.      * 获取手机Android 版本
  59.      * 
  60.      * @return
  61.      */
  62.     public static String getDeviceAndroidVersion() {
  63.         return android.os.Build.VERSION.RELEASE;
  64.     }
  65.  
  66.     /**
  67.      * 获取当前手机系统语言。
  68.      */
  69.     public static String getDeviceDefaultLanguage() {
  70.         return Locale.getDefault().getLanguage();
  71.     }
  72.  
  73.     /**
  74.      * 获取当前系统上的语言列表(Locale列表)
  75.      */
  76.     public static String getDeviceSupportLanguage() {
  77.         Log.e("wangjie", "Local:" + Locale.GERMAN);
  78.         Log.e("wangjie", "Local:" + Locale.ENGLISH);
  79.         Log.e("wangjie", "Local:" + Locale.US);
  80.         Log.e("wangjie", "Local:" + Locale.CHINESE);
  81.         Log.e("wangjie", "Local:" + Locale.TAIWAN);
  82.         Log.e("wangjie", "Local:" + Locale.FRANCE);
  83.         Log.e("wangjie", "Local:" + Locale.FRENCH);
  84.         Log.e("wangjie", "Local:" + Locale.GERMANY);
  85.         Log.e("wangjie", "Local:" + Locale.ITALIAN);
  86.         Log.e("wangjie", "Local:" + Locale.JAPAN);
  87.         Log.e("wangjie", "Local:" + Locale.JAPANESE);
  88.         return Locale.getAvailableLocales().toString();
  89.     }
  90.

六、 获取 SD 卡存储信息

SD卡信息

1.判断SD是否挂载方法

判断SD是否挂载方法如下:

  1.     /**
  2.      * 判断SD是否挂载
  3.      */
  4.     public static boolean isSDCardMount() {
  5.         return Environment.getExternalStorageState().equals(
  6.                 Environment.MEDIA_MOUNTED);
  7.     }

2. 获取SD 存储信息的方法

获取SD 存储信息的方法如下:

  1. /**
  2.      * 获取手机存储 ROM 信息
  3.      * 
  4.      * type：用于区分内置存储于外置存储的方法
  5.      * 
  6.      * 内置SD卡 ：INTERNAL_STORAGE = 0;
  7.      * 
  8.      * 外置SD卡：EXTERNAL_STORAGE = 1;
  9.      * **/
  10.     public static String getStorageInfo(Context context, int type) {
  11.  
  12.         String path = getStoragePath(context, type);
  13.         /**
  14.          * 无外置SD 卡判断
  15.          * **/
  16.         if (isSDCardMount() == false || TextUtils.isEmpty(path) || path == null) {
  17.             return "无外置SD卡";
  18.         }
  19.  
  20.         File file = new File(path);
  21.         StatFs statFs = new StatFs(file.getPath());
  22.         String stotageInfo;
  23.  
  24.         long blockCount = statFs.getBlockCountLong();
  25.         long bloackSize = statFs.getBlockSizeLong();
  26.         long totalSpace = bloackSize * blockCount;
  27.  
  28.         long availableBlocks = statFs.getAvailableBlocksLong();
  29.         long availableSpace = availableBlocks * bloackSize;
  30.  
  31.         stotageInfo = "可用/总共："
  32.                 + Formatter.formatFileSize(context, availableSpace) + "/"
  33.                 + Formatter.formatFileSize(context, totalSpace);
  34.  
  35.         return stotageInfo;
  36.  
  37.     }

3. 获取手机ROM （内置存储，外置存储）存储路径的方法

获取手机ROM 存储信息的方法如下：

  1. /**
  2.      * 使用反射方法 获取手机存储路径
  3.      * 
  4.      * **/
  5.     public static String getStoragePath(Context context, int type) {
  6.  
  7.         StorageManager sm = (StorageManager) context
  8.                 .getSystemService(Context.STORAGE_SERVICE);
  9.         try {
  10.             Method getPathsMethod = sm.getClass().getMethod("getVolumePaths",
  11.                     null);
  12.             String[] path = (String[]) getPathsMethod.invoke(sm, null);
  13.  
  14.             switch (type) {
  15.             case INTERNAL_STORAGE:
  16.                 return path[type];
  17.             case EXTERNAL_STORAGE:
  18.                 if (path.length > 1) {
  19.                     return path[type];
  20.                 } else {
  21.                     return null;
  22.                 }
  23.  
  24.             default:
  25.                 break;
  26.             }
  27.  
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         }
  31.         return null;
  32.     }
  33.  
  34.     /**
  35.      * 获取 手机 RAM 信息 方法 一
  36.      * */
  37.     public static String getTotalRAM(Context context) {
  38.         long size = 0;
  39.         ActivityManager activityManager = (ActivityManager) context
  40.                 .getSystemService(context.ACTIVITY_SERVICE);
  41.         MemoryInfo outInfo = new MemoryInfo();
  42.         activityManager.getMemoryInfo(outInfo);
  43.         size = outInfo.totalMem;
  44.  
  45.         return Formatter.formatFileSize(context, size);
  46.     }
  47.  
  48.     /**
  49.      * 手机 RAM 信息 方法 二
  50.      * */
  51.     public static String getTotalRAMOther(Context context) {
  52.         String path = "/proc/meminfo";
  53.         String firstLine = null;
  54.         int totalRam = 0;
  55.         try {
  56.             FileReader fileReader = new FileReader(path);
  57.             BufferedReader br = new BufferedReader(fileReader, 8192);
  58.             firstLine = br.readLine().split("\\s+")[1];
  59.             br.close();
  60.         } catch (Exception e) {
  61.             e.printStackTrace();
  62.         }
  63.         if (firstLine != null) {
  64.  
  65.             totalRam = (int) Math.ceil((new Float(Float.valueOf(firstLine)
  66.                     / (1024 * 1024)).doubleValue()));
  67.  
  68.             long totalBytes = 0;
  69.  
  70.         }
  71.  
  72.         return Formatter.formatFileSize(context, totalRam);
  73.     }
  74.  
  75.     /**
  76.      * 获取 手机 可用 RAM
  77.      * */
  78.     public static String getAvailableRAM(Context context) {
  79.         long size = 0;
  80.         ActivityManager activityManager = (ActivityManager) context
  81.                 .getSystemService(context.ACTIVITY_SERVICE);
  82.         MemoryInfo outInfo = new MemoryInfo();
  83.         activityManager.getMemoryInfo(outInfo);
  84.         size = outInfo.availMem;
  85.  
  86.         return Formatter.formatFileSize(context, size);
  87.     }

七、获取手机 RAM、ROM存储信息

1.RAM:

运行时内存，此大小直接决定手机运行的流畅度，相当于电脑内存。

2.ROM :

手机存储（分内置SD卡，外置SD卡），此大小直接决定着手机可以存储资源的大小，相当于电脑硬盘。

以红米手机为例：
RAM= 1904716KB= 1.82G

红米4 手机 RAM、ROM存储信息

红米4 memory 信息 meminfo

3.获取 RAM存储信息的方法如下：

  1.     /**
  2.      * 获取 手机 RAM 信息
  3.      * */
  4.     public static String getRAMInfo(Context context) {
  5.         long totalSize = 0;
  6.         long availableSize = 0;
  7.  
  8.         ActivityManager activityManager = (ActivityManager) context
  9.                 .getSystemService(context.ACTIVITY_SERVICE);
  10.  
  11.         MemoryInfo memoryInfo = new MemoryInfo();
  12.         activityManager.getMemoryInfo(memoryInfo);
  13.         totalSize = memoryInfo.totalMem;
  14.         availableSize = memoryInfo.availMem;
  15.  
  16.         return "可用/总共：" + Formatter.formatFileSize(context, availableSize)
  17.                 + "/" + Formatter.formatFileSize(context, totalSize);
  18.     }

4. 获取手机ROM存储信息的方法如下：

  1. /**
  2.      * 获取手机存储 ROM 信息
  3.      * 
  4.      * type：用于区分内置存储于外置存储的方法
  5.      * 
  6.      * 内置SD卡 ：INTERNAL_STORAGE = 0;
  7.      * 
  8.      * 外置SD卡：EXTERNAL_STORAGE = 1;
  9.      * **/
  10.     public static String getStorageInfo(Context context, int type) {
  11.  
  12.         String path = getStoragePath(context, type);
  13.         /**
  14.          * 无外置SD 卡判断
  15.          * **/
  16.         if (isSDCardMount() == false || TextUtils.isEmpty(path) || path == null) {
  17.             return "无外置SD卡";
  18.         }
  19.  
  20.         File file = new File(path);
  21.         StatFs statFs = new StatFs(file.getPath());
  22.         String stotageInfo;
  23.  
  24.         long blockCount = statFs.getBlockCountLong();
  25.         long bloackSize = statFs.getBlockSizeLong();
  26.         long totalSpace = bloackSize * blockCount;
  27.  
  28.         long availableBlocks = statFs.getAvailableBlocksLong();
  29.         long availableSpace = availableBlocks * bloackSize;
  30.  
  31.         stotageInfo = "可用/总共："
  32.                 + Formatter.formatFileSize(context, availableSpace) + "/"
  33.                 + Formatter.formatFileSize(context, totalSpace);
  34.  
  35.         return stotageInfo;
  36.  
  37.     }

八、DeviceInfoUtils 封装类

为了方便查询使用设备信息，小编已经封装成一个Utils类。代码如下：

  1. package com.programandroid.Utils;
  2.  
  3. import java.util.Locale;
  4.  
  5. import android.R.string;
  6. import android.content.Context;
  7. import android.telephony.TelephonyManager;
  8. import android.util.Log;
  9.  
  10. /*
  11.  * DeviceInfoUtils.java
  12.  *
  13.  *  Created on: 2017-11-16
  14.  *      Author: wangjie
  15.  * 
  16.  *  Welcome attention to weixin public number get more info
  17.  *
  18.  *  WeiXin Public Number : ProgramAndroid
  19.  *  微信公众号 ：程序员Android
  20.  *
  21.  */
  22. public class DeviceInfoUtils {
  23.  
  24.     /**
  25.      * 获取设备宽度（px）
  26.      * 
  27.      */
  28.     public static int getDeviceWidth(Context context) {
  29.         return context.getResources().getDisplayMetrics().widthPixels;
  30.     }
  31.  
  32.     /**
  33.      * 获取设备高度（px）
  34.      */
  35.     public static int getDeviceHeight(Context context) {
  36.         return context.getResources().getDisplayMetrics().heightPixels;
  37.     }
  38.  
  39.     /**
  40.      * 获取设备的唯一标识， 需要 “android.permission.READ_Phone_STATE”权限
  41.      */
  42.     public static String getIMEI(Context context) {
  43.         TelephonyManager tm = (TelephonyManager) context
  44.                 .getSystemService(Context.TELEPHONY_SERVICE);
  45.         String deviceId = tm.getDeviceId();
  46.         if (deviceId == null) {
  47.             return "UnKnown";
  48.         } else {
  49.             return deviceId;
  50.         }
  51.     }
  52.  
  53.     /**
  54.      * 获取厂商名
  55.      * **/
  56.     public static String getDeviceManufacturer() {
  57.         return android.os.Build.MANUFACTURER;
  58.     }
  59.  
  60.     /**
  61.      * 获取产品名
  62.      * **/
  63.     public static String getDeviceProduct() {
  64.         return android.os.Build.PRODUCT;
  65.     }
  66.  
  67.     /**
  68.      * 获取手机品牌
  69.      */
  70.     public static String getDeviceBrand() {
  71.         return android.os.Build.BRAND;
  72.     }
  73.  
  74.     /**
  75.      * 获取手机型号
  76.      */
  77.     public static String getDeviceModel() {
  78.         return android.os.Build.MODEL;
  79.     }
  80.  
  81.     /**
  82.      * 获取手机主板名
  83.      */
  84.     public static String getDeviceBoard() {
  85.         return android.os.Build.BOARD;
  86.     }
  87.  
  88.     /**
  89.      * 设备名
  90.      * **/
  91.     public static String getDeviceDevice() {
  92.         return android.os.Build.DEVICE;
  93.     }
  94.  
  95.     /**
  96.      * 
  97.      * 
  98.      * fingerprit 信息
  99.      * **/
  100.     public static String getDeviceFubgerprint() {
  101.         return android.os.Build.FINGERPRINT;
  102.     }
  103.  
  104.     /**
  105.      * 硬件名
  106.      * 
  107.      * **/
  108.     public static String getDeviceHardware() {
  109.         return android.os.Build.HARDWARE;
  110.     }
  111.  
  112.     /**
  113.      * 主机
  114.      * 
  115.      * **/
  116.     public static String getDeviceHost() {
  117.         return android.os.Build.HOST;
  118.     }
  119.  
  120.     /**
  121.      * 
  122.      * 显示ID
  123.      * **/
  124.     public static String getDeviceDisplay() {
  125.         return android.os.Build.DISPLAY;
  126.     }
  127.  
  128.     /**
  129.      * ID
  130.      * 
  131.      * **/
  132.     public static String getDeviceId() {
  133.         return android.os.Build.ID;
  134.     }
  135.  
  136.     /**
  137.      * 获取手机用户名
  138.      * 
  139.      * **/
  140.     public static String getDeviceUser() {
  141.         return android.os.Build.USER;
  142.     }
  143.  
  144.     /**
  145.      * 获取手机 硬件序列号
  146.      * **/
  147.     public static String getDeviceSerial() {
  148.         return android.os.Build.SERIAL;
  149.     }
  150.  
  151.     /**
  152.      * 获取手机Android 系统SDK
  153.      * 
  154.      * @return
  155.      */
  156.     public static int getDeviceSDK() {
  157.         return android.os.Build.VERSION.SDK_INT;
  158.     }
  159.  
  160.     /**
  161.      * 获取手机Android 版本
  162.      * 
  163.      * @return
  164.      */
  165.     public static String getDeviceAndroidVersion() {
  166.         return android.os.Build.VERSION.RELEASE;
  167.     }
  168.  
  169.     /**
  170.      * 获取当前手机系统语言。
  171.      */
  172.     public static String getDeviceDefaultLanguage() {
  173.         return Locale.getDefault().getLanguage();
  174.     }
  175.  
  176.     /**
  177.      * 获取当前系统上的语言列表(Locale列表)
  178.      */
  179.     public static String getDeviceSupportLanguage() {
  180.         Log.e("wangjie", "Local:" + Locale.GERMAN);
  181.         Log.e("wangjie", "Local:" + Locale.ENGLISH);
  182.         Log.e("wangjie", "Local:" + Locale.US);
  183.         Log.e("wangjie", "Local:" + Locale.CHINESE);
  184.         Log.e("wangjie", "Local:" + Locale.TAIWAN);
  185.         Log.e("wangjie", "Local:" + Locale.FRANCE);
  186.         Log.e("wangjie", "Local:" + Locale.FRENCH);
  187.         Log.e("wangjie", "Local:" + Locale.GERMANY);
  188.         Log.e("wangjie", "Local:" + Locale.ITALIAN);
  189.         Log.e("wangjie", "Local:" + Locale.JAPAN);
  190.         Log.e("wangjie", "Local:" + Locale.JAPANESE);
  191.         return Locale.getAvailableLocales().toString();
  192.     }
  193.  
  194.     public static String getDeviceAllInfo(Context context) {
  195.  
  196.         return "\n\n1. IMEI:\n\t\t" + getIMEI(context)
  197.  
  198.         + "\n\n2. 设备宽度:\n\t\t" + getDeviceWidth(context)
  199.  
  200.         + "\n\n3. 设备高度:\n\t\t" + getDeviceHeight(context)
  201.  
  202.         + "\n\n4. 是否有内置SD卡:\n\t\t" + SDCardUtils.isSDCardMount()
  203.  
  204.         + "\n\n5. RAM 信息:\n\t\t" + SDCardUtils.getRAMInfo(context)
  205.  
  206.         + "\n\n6. 内部存储信息\n\t\t" + SDCardUtils.getStorageInfo(context, 0)
  207.  
  208.         + "\n\n7. SD卡 信息:\n\t\t" + SDCardUtils.getStorageInfo(context, 1)
  209.  
  210.         + "\n\n8. 是否联网:\n\t\t" + Utils.isNetworkConnected(context)
  211.  
  212.         + "\n\n9. 网络类型:\n\t\t" + Utils.GetNetworkType(context)
  213.  
  214.         + "\n\n10. 系统默认语言:\n\t\t" + getDeviceDefaultLanguage()
  215.  
  216.         + "\n\n11. 硬件序列号(设备名):\n\t\t" + android.os.Build.SERIAL
  217.  
  218.         + "\n\n12. 手机型号:\n\t\t" + android.os.Build.MODEL
  219.  
  220.         + "\n\n13. 生产厂商:\n\t\t" + android.os.Build.MANUFACTURER
  221.  
  222.         + "\n\n14. 手机Fingerprint标识:\n\t\t" + android.os.Build.FINGERPRINT
  223.  
  224.         + "\n\n15. Android 版本:\n\t\t" + android.os.Build.VERSION.RELEASE
  225.  
  226.         + "\n\n16. Android SDK版本:\n\t\t" + android.os.Build.VERSION.SDK_INT
  227.  
  228.         + "\n\n17. 安全patch 时间:\n\t\t" + android.os.Build.VERSION.SECURITY_PATCH
  229.  
  230.         + "\n\n18. 发布时间:\n\t\t" + Utils.Utc2Local(android.os.Build.TIME)
  231.  
  232.         + "\n\n19. 版本类型:\n\t\t" + android.os.Build.TYPE
  233.  
  234.         + "\n\n20. 用户名:\n\t\t" + android.os.Build.USER
  235.  
  236.         + "\n\n21. 产品名:\n\t\t" + android.os.Build.PRODUCT
  237.  
  238.         + "\n\n22. ID:\n\t\t" + android.os.Build.ID
  239.  
  240.         + "\n\n23. 显示ID:\n\t\t" + android.os.Build.DISPLAY
  241.  
  242.         + "\n\n24. 硬件名:\n\t\t" + android.os.Build.HARDWARE
  243.  
  244.         + "\n\n25. 产品名:\n\t\t" + android.os.Build.DEVICE
  245.  
  246.         + "\n\n26. Bootloader:\n\t\t" + android.os.Build.BOOTLOADER
  247.  
  248.         + "\n\n27. 主板名:\n\t\t" + android.os.Build.BOARD
  249.  
  250.         + "\n\n28. CodeName:\n\t\t" + android.os.Build.VERSION.CODENAME
  251.                 + "\n\n29. 语言支持:\n\t\t" + getDeviceSupportLanguage();
  252.  
  253.     }
  254. }
  255.

九、SDCardUtils 封装类

为了方便查询使用设备信息，小编已经封装成一个Utils类。代码如下：

  1. package com.programandroid.Utils;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.File;
  5. import java.io.FileReader;
  6. import java.lang.reflect.Method;
  7.  
  8. import android.app.ActivityManager;
  9. import android.app.ActivityManager.MemoryInfo;
  10. import android.content.Context;
  11. import android.os.Build;
  12. import android.os.Environment;
  13. import android.os.StatFs;
  14. import android.os.storage.StorageManager;
  15. import android.text.TextUtils;
  16. import android.text.format.Formatter;
  17.  
  18. /*
  19.  * SDCardUtils.java
  20.  *
  21.  *  Created on: 2017-11-22
  22.  *      Author: wangjie
  23.  * 
  24.  *  Welcome attention to weixin public number get more info
  25.  *
  26.  *  WeiXin Public Number : ProgramAndroid
  27.  *  微信公众号 ：程序员Android
  28.  *
  29.  */
  30. public class SDCardUtils {
  31.  
  32.     private static final int INTERNAL_STORAGE = 0;
  33.     private static final int EXTERNAL_STORAGE = 1;
  34.  
  35.     /**
  36.      * 获取 手机 RAM 信息
  37.      * */
  38.     public static String getRAMInfo(Context context) {
  39.         long totalSize = 0;
  40.         long availableSize = 0;
  41.  
  42.         ActivityManager activityManager = (ActivityManager) context
  43.                 .getSystemService(context.ACTIVITY_SERVICE);
  44.  
  45.         MemoryInfo memoryInfo = new MemoryInfo();
  46.         activityManager.getMemoryInfo(memoryInfo);
  47.         totalSize = memoryInfo.totalMem;
  48.         availableSize = memoryInfo.availMem;
  49.  
  50.         return "可用/总共：" + Formatter.formatFileSize(context, availableSize)
  51.                 + "/" + Formatter.formatFileSize(context, totalSize);
  52.     }
  53.  
  54.     /**
  55.      * 判断SD是否挂载
  56.      */
  57.     public static boolean isSDCardMount() {
  58.         return Environment.getExternalStorageState().equals(
  59.                 Environment.MEDIA_MOUNTED);
  60.     }
  61.  
  62.     /**
  63.      * 获取手机存储 ROM 信息
  64.      * 
  65.      * type：用于区分内置存储于外置存储的方法
  66.      * 
  67.      * 内置SD卡 ：INTERNAL_STORAGE = 0;
  68.      * 
  69.      * 外置SD卡：EXTERNAL_STORAGE = 1;
  70.      * **/
  71.     public static String getStorageInfo(Context context, int type) {
  72.  
  73.         String path = getStoragePath(context, type);
  74.         /**
  75.          * 无外置SD 卡判断
  76.          * **/
  77.         if (isSDCardMount() == false || TextUtils.isEmpty(path) || path == null) {
  78.             return "无外置SD卡";
  79.         }
  80.  
  81.         File file = new File(path);
  82.         StatFs statFs = new StatFs(file.getPath());
  83.         String stotageInfo;
  84.  
  85.         long blockCount = statFs.getBlockCountLong();
  86.         long bloackSize = statFs.getBlockSizeLong();
  87.         long totalSpace = bloackSize * blockCount;
  88.  
  89.         long availableBlocks = statFs.getAvailableBlocksLong();
  90.         long availableSpace = availableBlocks * bloackSize;
  91.  
  92.         stotageInfo = "可用/总共："
  93.                 + Formatter.formatFileSize(context, availableSpace) + "/"
  94.                 + Formatter.formatFileSize(context, totalSpace);
  95.  
  96.         return stotageInfo;
  97.  
  98.     }
  99.  
  100.     /**
  101.      * 使用反射方法 获取手机存储路径
  102.      * 
  103.      * **/
  104.     public static String getStoragePath(Context context, int type) {
  105.  
  106.         StorageManager sm = (StorageManager) context
  107.                 .getSystemService(Context.STORAGE_SERVICE);
  108.         try {
  109.             Method getPathsMethod = sm.getClass().getMethod("getVolumePaths",
  110.                     null);
  111.             String[] path = (String[]) getPathsMethod.invoke(sm, null);
  112.  
  113.             switch (type) {
  114.             case INTERNAL_STORAGE:
  115.                 return path[type];
  116.             case EXTERNAL_STORAGE:
  117.                 if (path.length > 1) {
  118.                     return path[type];
  119.                 } else {
  120.                     return null;
  121.                 }
  122.  
  123.             default:
  124.                 break;
  125.             }
  126.  
  127.         } catch (Exception e) {
  128.             e.printStackTrace();
  129.         }
  130.         return null;
  131.     }
  132.  
  133.     /**
  134.      * 获取 手机 RAM 信息 方法 一
  135.      * */
  136.     public static String getTotalRAM(Context context) {
  137.         long size = 0;
  138.         ActivityManager activityManager = (ActivityManager) context
  139.                 .getSystemService(context.ACTIVITY_SERVICE);
  140.         MemoryInfo outInfo = new MemoryInfo();
  141.         activityManager.getMemoryInfo(outInfo);
  142.         size = outInfo.totalMem;
  143.  
  144.         return Formatter.formatFileSize(context, size);
  145.     }
  146.  
  147.     /**
  148.      * 手机 RAM 信息 方法 二
  149.      * */
  150.     public static String getTotalRAMOther(Context context) {
  151.         String path = "/proc/meminfo";
  152.         String firstLine = null;
  153.         int totalRam = 0;
  154.         try {
  155.             FileReader fileReader = new FileReader(path);
  156.             BufferedReader br = new BufferedReader(fileReader, 8192);
  157.             firstLine = br.readLine().split("\\s+")[1];
  158.             br.close();
  159.         } catch (Exception e) {
  160.             e.printStackTrace();
  161.         }
  162.         if (firstLine != null) {
  163.  
  164.             totalRam = (int) Math.ceil((new Float(Float.valueOf(firstLine)
  165.                     / (1024 * 1024)).doubleValue()));
  166.  
  167.             long totalBytes = 0;
  168.  
  169.         }
  170.  
  171.         return Formatter.formatFileSize(context, totalRam);
  172.     }
  173.  
  174.     /**
  175.      * 获取 手机 可用 RAM
  176.      * */
  177.     public static String getAvailableRAM(Context context) {
  178.         long size = 0;
  179.         ActivityManager activityManager = (ActivityManager) context
  180.                 .getSystemService(context.ACTIVITY_SERVICE);
  181.         MemoryInfo outInfo = new MemoryInfo();
  182.         activityManager.getMemoryInfo(outInfo);
  183.         size = outInfo.availMem;
  184.  
  185.         return Formatter.formatFileSize(context, size);
  186.     }
  187.  
  188.     /**
  189.      * 获取手机内部存储空间
  190.      * 
  191.      * @param context
  192.      * @return 以M,G为单位的容量
  193.      */
  194.     public static String getTotalInternalMemorySize(Context context) {
  195.         File file = Environment.getDataDirectory();
  196.         StatFs statFs = new StatFs(file.getPath());
  197.         long blockSizeLong = statFs.getBlockSizeLong();
  198.         long blockCountLong = statFs.getBlockCountLong();
  199.         long size = blockCountLong * blockSizeLong;
  200.         return Formatter.formatFileSize(context, size);
  201.     }
  202.  
  203.     /**
  204.      * 获取手机内部可用存储空间
  205.      * 
  206.      * @param context
  207.      * @return 以M,G为单位的容量
  208.      */
  209.     public static String getAvailableInternalMemorySize(Context context) {
  210.         File file = Environment.getDataDirectory();
  211.         StatFs statFs = new StatFs(file.getPath());
  212.         long availableBlocksLong = statFs.getAvailableBlocksLong();
  213.         long blockSizeLong = statFs.getBlockSizeLong();
  214.         return Formatter.formatFileSize(context, availableBlocksLong
  215.                 * blockSizeLong);
  216.     }
  217.  
  218.     /**
  219.      * 获取手机外部存储空间
  220.      * 
  221.      * @param context
  222.      * @return 以M,G为单位的容量
  223.      */
  224.     public static String getTotalExternalMemorySize(Context context) {
  225.         File file = Environment.getExternalStorageDirectory();
  226.         StatFs statFs = new StatFs(file.getPath());
  227.         long blockSizeLong = statFs.getBlockSizeLong();
  228.         long blockCountLong = statFs.getBlockCountLong();
  229.         return Formatter
  230.                 .formatFileSize(context, blockCountLong * blockSizeLong);
  231.     }
  232.  
  233.     /**
  234.      * 获取手机外部可用存储空间
  235.      * 
  236.      * @param context
  237.      * @return 以M,G为单位的容量
  238.      */
  239.     public static String getAvailableExternalMemorySize(Context context) {
  240.         File file = Environment.getExternalStorageDirectory();
  241.         StatFs statFs = new StatFs(file.getPath());
  242.         long availableBlocksLong = statFs.getAvailableBlocksLong();
  243.         long blockSizeLong = statFs.getBlockSizeLong();
  244.         return Formatter.formatFileSize(context, availableBlocksLong
  245.                 * blockSizeLong);
  246.     }
  247.  
  248.     /**
  249.      * 
  250.      * SD 卡信息
  251.      * */
  252.  
  253.     public static String getSDCardInfo() {
  254.  
  255.         SDCardInfo sd = new SDCardInfo();
  256.         if (!isSDCardMount())
  257.             return "SD card 未挂载!";
  258.  
  259.         sd.isExist = true;
  260.         StatFs sf = new StatFs(Environment.getExternalStorageDirectory()
  261.                 .getPath());
  262.  
  263.         sd.totalBlocks = sf.getBlockCountLong();
  264.         sd.blockByteSize = sf.getBlockSizeLong();
  265.         sd.availableBlocks = sf.getAvailableBlocksLong();
  266.         sd.availableBytes = sf.getAvailableBytes();
  267.         sd.freeBlocks = sf.getFreeBlocksLong();
  268.         sd.freeBytes = sf.getFreeBytes();
  269.         sd.totalBytes = sf.getTotalBytes();
  270.         return sd.toString();
  271.     }
  272.  
  273.     public static class SDCardInfo {
  274.         boolean isExist;
  275.         long totalBlocks;
  276.         long freeBlocks;
  277.         long availableBlocks;
  278.         long blockByteSize;
  279.         long totalBytes;
  280.         long freeBytes;
  281.         long availableBytes;
  282.  
  283.         @Override
  284.         public String toString() {
  285.             return "isExist=" + isExist + "\ntotalBlocks=" + totalBlocks
  286.                     + "\nfreeBlocks=" + freeBlocks + "\navailableBlocks="
  287.                     + availableBlocks + "\nblockByteSize=" + blockByteSize
  288.                     + "\ntotalBytes=" + totalBytes + "\nfreeBytes=" + freeBytes
  289.                     + "\navailableBytes=" + availableBytes;
  290.         }
  291.     }
  292.  
  293.     // add start by wangjie for SDCard TotalStorage
  294.     public static String getSDCardTotalStorage(long totalByte) {
  295.  
  296.         double byte2GB = totalByte / 1024.00 / 1024.00 / 1024.00;
  297.         double totalStorage;
  298.         if (byte2GB > 1) {
  299.             totalStorage = Math.ceil(byte2GB);
  300.             if (totalStorage > 1 && totalStorage < 3) {
  301.                 return 2.0 + "GB";
  302.             } else if (totalStorage > 2 && totalStorage < 5) {
  303.                 return 4.0 + "GB";
  304.             } else if (totalStorage >= 5 && totalStorage < 10) {
  305.                 return 8.0 + "GB";
  306.             } else if (totalStorage >= 10 && totalStorage < 18) {
  307.                 return 16.0 + "GB";
  308.             } else if (totalStorage >= 18 && totalStorage < 34) {
  309.                 return 32.0 + "GB";
  310.             } else if (totalStorage >= 34 && totalStorage < 50) {
  311.                 return 48.0 + "GB";
  312.             } else if (totalStorage >= 50 && totalStorage < 66) {
  313.                 return 64.0 + "GB";
  314.             } else if (totalStorage >= 66 && totalStorage < 130) {
  315.                 return 128.0 + "GB";
  316.             }
  317.         } else {
  318.             // below 1G return get values
  319.             totalStorage = totalByte / 1024.00 / 1024.00;
  320.  
  321.             if (totalStorage >= 515 && totalStorage < 1024) {
  322.                 return 1 + "GB";
  323.             } else if (totalStorage >= 260 && totalStorage < 515) {
  324.                 return 512 + "MB";
  325.             } else if (totalStorage >= 130 && totalStorage < 260) {
  326.                 return 256 + "MB";
  327.             } else if (totalStorage > 70 && totalStorage < 130) {
  328.                 return 128 + "MB";
  329.             } else if (totalStorage > 50 && totalStorage < 70) {
  330.                 return 64 + "MB";
  331.             }
  332.         }
  333.  
  334.         return totalStorage + "GB";
  335.     }
  336.     // add end by wangjie for SDCard TotalStorage
  337.  
  338. }

至此，本篇已结束。转载网络的文章，小编觉得很优秀，欢迎点击阅读原文，支持原创作者，如有侵权，恳请联系小编删除。同时感谢您的阅读，期待您的关注。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/242143
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号