经典好文推荐，通过阅读本文，您将收获以下知识点:
一、获取手机基本信息(厂商、型号等参数)
二、设备信息获取实现图
三、获取手机设备 宽、高、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. }
9. /**
10. * 获取设备高度（px）
11. */
12. public static int getDeviceHeight(Context context) {
13. return context.getResources().getDisplayMetrics().heightPixels;
14. }
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.
2. 如果是Android 6.0 之后的代码请使用动态申请权限的方法申请权限，否认会报安全异常的错误SecurityException，进而导致运行报错。
如需了解更多 系统安全权限的内容，请看 之前写的文章 Android 系统权限使用详解
四、 获取手机厂商名、产品名、手机品牌、手机型号、主板名、设备名的方法
获取手机厂商名、产品名、手机品牌、手机型号、主板名、设备名的方法如下:
1. /**
2. * 获取厂商名
3. * **/
4. public static String getDeviceManufacturer() {
5. return android.os.Build.MANUFACTURER;
6. }
8. /**
9. * 获取产品名
10. * **/
11. public static String getDeviceProduct() {
12. return android.os.Build.PRODUCT;
13. }
15. /**
16. * 获取手机品牌
17. */
18. public static String getDeviceBrand() {
19. return android.os.Build.BRAND;
20. }
22. /**
23. * 获取手机型号
24. */
25. public static String getDeviceModel() {
26. return android.os.Build.MODEL;
27. }
29. /**
30. * 获取手机主板名
31. */
32. public static String getDeviceBoard() {
33. return android.os.Build.BOARD;
34. }
36. /**
37. * 设备名
38. * **/
39. public static String getDeviceDevice() {
40. return android.os.Build.DEVICE;
41. }
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. }
9. /**
10. * 主机
11. *
12. * **/
13. public static String getDeviceHost() {
14. return android.os.Build.HOST;
15. }
17. /**
18. *
19. * 显示ID
20. * **/
21. public static String getDeviceDisplay() {
22. return android.os.Build.DISPLAY;
23. }
25. /**
26. * ID
27. *
28. * **/
29. public static String getDeviceId() {
30. return android.os.Build.ID;
31. }
33. /**
34. * 获取手机用户名
35. *
36. * **/
37. public static String getDeviceUser() {
38. return android.os.Build.USER;
39. }
41. /**
42. * 获取手机 硬件序列号
43. * **/
44. public static String getDeviceSerial() {
45. return android.os.Build.SERIAL;
46. }
48. /**
49. * 获取手机Android 系统SDK
50. *
51. * @return
52. */
53. public static int getDeviceSDK() {
54. return android.os.Build.VERSION.SDK_INT;
55. }
57. /**
58. * 获取手机Android 版本
59. *
60. * @return
61. */
62. public static String getDeviceAndroidVersion() {
63. return android.os.Build.VERSION.RELEASE;
64. }
66. /**
67. * 获取当前手机系统语言。
68. */
69. public static String getDeviceDefaultLanguage() {
70. return Locale.getDefault().getLanguage();
71. }
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. } 六、 获取 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) {
12. String path = getStoragePath(context, type);
13. /**
14. * 无外置SD 卡判断
15. * **/
16. if (isSDCardMount() == false || TextUtils.isEmpty(path) || path == null) {
17. return "无外置SD卡";
18. }
20. File file = new File(path);
21. StatFs statFs = new StatFs(file.getPath());
22. String stotageInfo;
24. long blockCount = statFs.getBlockCountLong();
25. long bloackSize = statFs.getBlockSizeLong();
26. long totalSpace = bloackSize * blockCount;
28. long availableBlocks = statFs.getAvailableBlocksLong();
29. long availableSpace = availableBlocks * bloackSize;
31. stotageInfo = "可用/总共："
32. + Formatter.formatFileSize(context, availableSpace) + "/"
33. + Formatter.formatFileSize(context, totalSpace);
35. return stotageInfo;
37. }
3. 获取手机ROM （内置存储，外置存储）存储路径的方法
获取手机ROM 存储信息的方法如下：
1. /**
2. * 使用反射方法 获取手机存储路径
3. *
4. * **/
5. public static String getStoragePath(Context context, int type) {
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);
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. }
24. default:
25. break;
26. }
28. } catch (Exception e) {
29. e.printStackTrace();
30. }
31. return null;
32. }
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;
45. return Formatter.formatFileSize(context, size);
46. }
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) {
65. totalRam = (int) Math.ceil((new Float(Float.valueOf(firstLine)
66. / (1024 * 1024)).doubleValue()));
68. long totalBytes = 0;
70. }
72. return Formatter.formatFileSize(context, totalRam);
73. }
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;
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;
8. ActivityManager activityManager = (ActivityManager) context
9. .getSystemService(context.ACTIVITY_SERVICE);
11. MemoryInfo memoryInfo = new MemoryInfo();
12. activityManager.getMemoryInfo(memoryInfo);
13. totalSize = memoryInfo.totalMem;
14. availableSize = memoryInfo.availMem;
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) {
12. String path = getStoragePath(context, type);
13. /**
14. * 无外置SD 卡判断
15. * **/
16. if (isSDCardMount() == false || TextUtils.isEmpty(path) || path == null) {
17. return "无外置SD卡";
18. }
20. File file = new File(path);
21. StatFs statFs = new StatFs(file.getPath());
22. String stotageInfo;
24. long blockCount = statFs.getBlockCountLong();
25. long bloackSize = statFs.getBlockSizeLong();
26. long totalSpace = bloackSize * blockCount;
28. long availableBlocks = statFs.getAvailableBlocksLong();
29. long availableSpace = availableBlocks * bloackSize;
31. stotageInfo = "可用/总共："
32. + Formatter.formatFileSize(context, availableSpace) + "/"
33. + Formatter.formatFileSize(context, totalSpace);
35. return stotageInfo;
37. }
八、DeviceInfoUtils 封装类
为了方便查询使用设备信息，小编已经封装成一个Utils类。代码如下：
1. package com.programandroid.Utils;
3. import java.util.Locale;
5. import android.R.string;
6. import android.content.Context;
7. import android.telephony.TelephonyManager;
8. import android.util.Log;
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 {
24. /**
25. * 获取设备宽度（px）
26. *
27. */
28. public static int getDeviceWidth(Context context) {
29. return context.getResources().getDisplayMetrics().widthPixels;
30. }
32. /**
33. * 获取设备高度（px）
34. */
35. public static int getDeviceHeight(Context context) {
36. return context.getResources().getDisplayMetrics().heightPixels;
37. }
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. }
53. /**
54. * 获取厂商名
55. * **/
56. public static String getDeviceManufacturer() {
57. return android.os.Build.MANUFACTURER;
58. }
60. /**
61. * 获取产品名
62. * **/
63. public static String getDeviceProduct() {
64. return android.os.Build.PRODUCT;
65. }
67. /**
68. * 获取手机品牌
69. */
70. public static String getDeviceBrand() {
71. return android.os.Build.BRAND;
72. }
74. /**
75. * 获取手机型号
76. */
77. public static String getDeviceModel() {
78. return android.os.Build.MODEL;
79. }
81. /**
82. * 获取手机主板名
83. */
84. public static String getDeviceBoard() {
85. return android.os.Build.BOARD;
86. }
88. /**
89. * 设备名
90. * **/
91. public static String getDeviceDevice() {
92. return android.os.Build.DEVICE;
93. }
95. /**
96. *
97. *
98. * fingerprit 信息
99. * **/
100. public static String getDeviceFubgerprint() {
101. return android.os.Build.FINGERPRINT;
102. }
104. /**
105. * 硬件名
106. *
107. * **/
108. public static String getDeviceHardware() {
109. return android.os.Build.HARDWARE;
110. }
112. /**
113. * 主机
114. *
115. * **/
116. public static String getDeviceHost() {
117. return android.os.Build.HOST;
118. }
120. /**
121. *
122. * 显示ID
123. * **/
124. public static String getDeviceDisplay() {
125. return android.os.Build.DISPLAY;
126. }
128. /**
129. * ID
130. *
131. * **/
132. public static String getDeviceId() {
133. return android.os.Build.ID;
134. }
136. /**
137. * 获取手机用户名
138. *
139. * **/
140. public static String getDeviceUser() {
141. return android.os.Build.USER;
142. }
144. /**
145. * 获取手机 硬件序列号
146. * **/
147. public static String getDeviceSerial() {
148. return android.os.Build.SERIAL;
149. }
151. /**
152. * 获取手机Android 系统SDK
153. *
154. * @return
155. */
156. public static int getDeviceSDK() {
157. return android.os.Build.VERSION.SDK_INT;
158. }
160. /**
161. * 获取手机Android 版本
162. *
163. * @return
164. */
165. public static String getDeviceAndroidVersion() {
166. return android.os.Build.VERSION.RELEASE;
167. }
169. /**
170. * 获取当前手机系统语言。
171. */
172. public static String getDeviceDefaultLanguage() {
173. return Locale.getDefault().getLanguage();
174. }
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. }
194. public static String getDeviceAllInfo(Context context) {
196. return "nn1. IMEI:ntt" + getIMEI(context)
198. + "nn2. 设备宽度:ntt" + getDeviceWidth(context)
200. + "nn3. 设备高度:ntt" + getDeviceHeight(context)
202. + "nn4. 是否有内置SD卡:ntt" + SDCardUtils.isSDCardMount()
204. + "nn5. RAM 信息:ntt" + SDCardUtils.getRAMInfo(context)
206. + "nn6. 内部存储信息ntt" + SDCardUtils.getStorageInfo(context, 0)
208. + "nn7. SD卡 信息:ntt" + SDCardUtils.getStorageInfo(context, 1)
210. + "nn8. 是否联网:ntt" + Utils.isNetworkConnected(context)
212. + "nn9. 网络类型:ntt" + Utils.GetNetworkType(context)
214. + "nn10. 系统默认语言:ntt" + getDeviceDefaultLanguage()
216. + "nn11. 硬件序列号(设备名):ntt" + android.os.Build.SERIAL
218. + "nn12. 手机型号:ntt" + android.os.Build.MODEL
220. + "nn13. 生产厂商:ntt" + android.os.Build.MANUFACTURER
222. + "nn14. 手机Fingerprint标识:ntt" + android.os.Build.FINGERPRINT
224. + "nn15. Android 版本:ntt" + android.os.Build.VERSION.RELEASE
226. + "nn16. Android SDK版本:ntt" + android.os.Build.VERSION.SDK_INT
228. + "nn17. 安全patch 时间:ntt" + android.os.Build.VERSION.SECURITY_PATCH
230. + "nn18. 发布时间:ntt" + Utils.Utc2Local(android.os.Build.TIME)
232. + "nn19. 版本类型:ntt" + android.os.Build.TYPE
234. + "nn20. 用户名:ntt" + android.os.Build.USER
236. + "nn21. 产品名:ntt" + android.os.Build.PRODUCT
238. + "nn22. ID:ntt" + android.os.Build.ID
240. + "nn23. 显示ID:ntt" + android.os.Build.DISPLAY
242. + "nn24. 硬件名:ntt" + android.os.Build.HARDWARE
244. + "nn25. 产品名:ntt" + android.os.Build.DEVICE
246. + "nn26. Bootloader:ntt" + android.os.Build.BOOTLOADER
248. + "nn27. 主板名:ntt" + android.os.Build.BOARD
250. + "nn28. CodeName:ntt" + android.os.Build.VERSION.CODENAME
251. + "nn29. 语言支持:ntt" + getDeviceSupportLanguage();
253. }
254. } 九、SDCardUtils 封装类
为了方便查询使用设备信息，小编已经封装成一个Utils类。代码如下：
1. package com.programandroid.Utils;
3. import java.io.BufferedReader;
4. import java.io.File;
5. import java.io.FileReader;
6. import java.lang.reflect.Method;
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;
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 {
32. private static final int INTERNAL_STORAGE = 0;
33. private static final int EXTERNAL_STORAGE = 1;
35. /**
36. * 获取 手机 RAM 信息
37. * */
38. public static String getRAMInfo(Context context) {
39. long totalSize = 0;
40. long availableSize = 0;
42. ActivityManager activityManager = (ActivityManager) context
43. .getSystemService(context.ACTIVITY_SERVICE);
45. MemoryInfo memoryInfo = new MemoryInfo();
46. activityManager.getMemoryInfo(memoryInfo);
47. totalSize = memoryInfo.totalMem;
48. availableSize = memoryInfo.availMem;
50. return "可用/总共：" + Formatter.formatFileSize(context, availableSize)
51. + "/" + Formatter.formatFileSize(context, totalSize);
52. }
54. /**
55. * 判断SD是否挂载
56. */
57. public static boolean isSDCardMount() {
58. return Environment.getExternalStorageState().equals(
59. Environment.MEDIA_MOUNTED);
60. }
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) {
73. String path = getStoragePath(context, type);
74. /**
75. * 无外置SD 卡判断
76. * **/
77. if (isSDCardMount() == false || TextUtils.isEmpty(path) || path == null) {
78. return "无外置SD卡";
79. }
81. File file = new File(path);
82. StatFs statFs = new StatFs(file.getPath());
83. String stotageInfo;
85. long blockCount = statFs.getBlockCountLong();
86. long bloackSize = statFs.getBlockSizeLong();
87. long totalSpace = bloackSize * blockCount;
89. long availableBlocks = statFs.getAvailableBlocksLong();
90. long availableSpace = availableBlocks * bloackSize;
92. stotageInfo = "可用/总共："
93. + Formatter.formatFileSize(context, availableSpace) + "/"
94. + Formatter.formatFileSize(context, totalSpace);
96. return stotageInfo;
98. }
100. /**
101. * 使用反射方法 获取手机存储路径
102. *
103. * **/
104. public static String getStoragePath(Context context, int type) {
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);
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. }
123. default:
124. break;
125. }
127. } catch (Exception e) {
128. e.printStackTrace();
129. }
130. return null;
131. }
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;
144. return Formatter.formatFileSize(context, size);
145. }
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) {
164. totalRam = (int) Math.ceil((new Float(Float.valueOf(firstLine)
165. / (1024 * 1024)).doubleValue()));
167. long totalBytes = 0;
169. }
171. return Formatter.formatFileSize(context, totalRam);
172. }
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;
185. return Formatter.formatFileSize(context, size);
186. }
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. }
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. }
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. }
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. }
248. /**
249. *
250. * SD 卡信息
251. * */
253. public static String getSDCardInfo() {
255. SDCardInfo sd = new SDCardInfo();
256. if (!isSDCardMount())
257. return "SD card 未挂载!";
259. sd.isExist = true;
260. StatFs sf = new StatFs(Environment.getExternalStorageDirectory()
261. .getPath());
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. }
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;
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. }
293. // add start by wangjie for SDCard TotalStorage
294. public static String getSDCardTotalStorage(long totalByte) {
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;
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. }
334. return totalStorage + "GB";
335. }
336. // add end by wangjie for SDCard TotalStorage
338. }