如何获取 Android(安卓)设备的CPU核数、时钟频率以及内存大小

阅读更多原帖：
http://www.jianshu.com/p/f7add443cd32

Device Year Class 的主要功能是根据 CPU核数、时钟频率以及内存大小对设备进行分级。
下表是 Facebook 公司提供的分级标准，其中 Year 栏表示分级结果。

以下类就是从Facebook 的开源项目 Device Year Class中拿出来的

package com.yirui.youbao.util;import android.annotation.TargetApi;import android.app.ActivityManager;import android.content.Context;import android.os.Build;import java.io.*;/** * Helper class for accessing hardware specifications, including the number of CPU cores, CPU clock speed * and total available RAM. */public class DeviceInfo {  /**   * The default return value of any method in this class when an   * error occurs or when processing fails (Currently set to -1). Use this to check if   * the information about the device in question was successfully obtained.   */  public static final int DEVICEINFO_UNKNOWN = -1;  /**   * Reads the number of CPU cores from {@code /sys/devices/system/cpu/}.   *   * @return Number of CPU cores in the phone, or DEVICEINFO_UKNOWN = -1 in the event of an error.   */  public static int getNumberOfCPUCores() {    if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.GINGERBREAD_MR1) {      // Gingerbread doesn't support giving a single application access to both cores, but a      // handful of devices (Atrix 4G and Droid X2 for example) were released with a dual-core      // chipset and Gingerbread; that can let an app in the background run without impacting      // the foreground application. But for our purposes, it makes them single core.      return 1;    }    int cores;    try {      cores = new File("/sys/devices/system/cpu/").listFiles(CPU_FILTER).length;    } catch (SecurityException e) {      cores = DEVICEINFO_UNKNOWN;    } catch (NullPointerException e) {      cores = DEVICEINFO_UNKNOWN;    }    return cores;  }  private static final FileFilter CPU_FILTER = new FileFilter() {    @Override    public boolean accept(File pathname) {      String path = pathname.getName();      //regex is slow, so checking char by char.      if (path.startsWith("cpu")) {        for (int i = 3; i < path.length(); i++) {          if (path.charAt(i) < '0' || path.charAt(i) > '9') {            return false;          }        }        return true;      }      return false;    }  };  /**   * Method for reading the clock speed of a CPU core on the device. Will read from either   * {@code /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq} or {@code /proc/cpuinfo}.   *   * @return Clock speed of a core on the device, or -1 in the event of an error.   */  public static int getCPUMaxFreqKHz() {    int maxFreq = DEVICEINFO_UNKNOWN;    try {      for (int i = 0; i < getNumberOfCPUCores(); i++) {        String filename =            "/sys/devices/system/cpu/cpu" + i + "/cpufreq/cpuinfo_max_freq";        File cpuInfoMaxFreqFile = new File(filename);        if (cpuInfoMaxFreqFile.exists()) {          byte[] buffer = new byte[128];          FileInputStream stream = new FileInputStream(cpuInfoMaxFreqFile);          try {            stream.read(buffer);            int endIndex = 0;            //Trim the first number out of the byte buffer.            while (buffer[endIndex] >= '0' && buffer[endIndex] <= '9'                && endIndex < buffer.length) endIndex++;            String str = new String(buffer, 0, endIndex);            Integer freqBound = Integer.parseInt(str);            if (freqBound > maxFreq) maxFreq = freqBound;          } catch (NumberFormatException e) {            //Fall through and use /proc/cpuinfo.          } finally {            stream.close();          }        }      }      if (maxFreq == DEVICEINFO_UNKNOWN) {        FileInputStream stream = new FileInputStream("/proc/cpuinfo");        try {          int freqBound = parseFileForValue("cpu MHz", stream);          freqBound *= 1000; //MHz -> kHz          if (freqBound > maxFreq) maxFreq = freqBound;        } finally {          stream.close();        }      }    } catch (IOException e) {      maxFreq = DEVICEINFO_UNKNOWN; //Fall through and return unknown.    }    return maxFreq;  }  /**   * Calculates the total RAM of the device through Android API or /proc/meminfo.   *   * @param c - Context object for current running activity.   * @return Total RAM that the device has, or DEVICEINFO_UNKNOWN = -1 in the event of an error.   */  @TargetApi(Build.VERSION_CODES.JELLY_BEAN)  public static long getTotalMemory(Context c) {    // memInfo.totalMem not supported in pre-Jelly Bean APIs.    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {      ActivityManager.MemoryInfo memInfo = new ActivityManager.MemoryInfo();      ActivityManager am = (ActivityManager) c.getSystemService(Context.ACTIVITY_SERVICE);      am.getMemoryInfo(memInfo);      if (memInfo != null) {        return memInfo.totalMem;      } else {        return DEVICEINFO_UNKNOWN;      }    } else {      long totalMem = DEVICEINFO_UNKNOWN;      try {        FileInputStream stream = new FileInputStream("/proc/meminfo");        try {          totalMem = parseFileForValue("MemTotal", stream);          totalMem *= 1024;        } finally {          stream.close();        }      } catch (IOException e) {      }      return totalMem;    }  }  /**   * Helper method for reading values from system files, using a minimised buffer.   *   * @param textToMatch - Text in the system files to read for.   * @param stream      - FileInputStream of the system file being read from.   * @return A numerical value following textToMatch in specified the system file.   * -1 in the event of a failure.   */  private static int parseFileForValue(String textToMatch, FileInputStream stream) {    byte[] buffer = new byte[1024];    try {      int length = stream.read(buffer);      for (int i = 0; i < length; i++) {        if (buffer[i] == '\n' || i == 0) {          if (buffer[i] == '\n') i++;          for (int j = i; j < length; j++) {            int textIndex = j - i;            //Text doesn't match query at some point.            if (buffer[j] != textToMatch.charAt(textIndex)) {              break;            }            //Text matches query here.            if (textIndex == textToMatch.length() - 1) {              return extractValue(buffer, j);            }          }        }      }    } catch (IOException e) {      //Ignore any exceptions and fall through to return unknown value.    } catch (NumberFormatException e) {    }    return DEVICEINFO_UNKNOWN;  }  /**   * Helper method used by {@link #parseFileForValue(String, FileInputStream) parseFileForValue}. Parses   * the next available number after the match in the file being read and returns it as an integer.   * @param index - The index in the buffer array to begin looking.   * @return The next number on that line in the buffer, returned as an int. Returns   * DEVICEINFO_UNKNOWN = -1 in the event that no more numbers exist on the same line.   */  private static int extractValue(byte[] buffer, int index) {    while (index < buffer.length && buffer[index] != '\n') {      if (buffer[index] >= '0' && buffer[index] <= '9') {        int start = index;        index++;        while (index < buffer.length && buffer[index] >= '0' && buffer[index] <= '9') {          index++;        }        String str = new String(buffer, 0, start, index - start);        return Integer.parseInt(str);      }      index++;    }    return DEVICEINFO_UNKNOWN;  }}

package com.yirui.youbao.util;import java.util.ArrayList;import java.util.Collections;import android.content.Context;public class YearClass {  // Year definitions  public static final int CLASS_UNKNOWN = -1;  public static final int CLASS_2008 = 2008;  public static final int CLASS_2009 = 2009;  public static final int CLASS_2010 = 2010;  public static final int CLASS_2011 = 2011;  public static final int CLASS_2012 = 2012;  public static final int CLASS_2013 = 2013;  public static final int CLASS_2014 = 2014;  private static final long MB = 1024 * 1024;  private static final int MHZ_IN_KHZ = 1000;  private volatile static Integer mYearCategory;  /**   * Entry Point of YearClass. Extracts YearClass variable with memoizing.   * Example usage:   *    * 
   *   int yearClass = YearClass.get(context);   * 
   */  public static int get(Context c) {    if (mYearCategory == null) {      synchronized(YearClass.class) {        if (mYearCategory == null) {          mYearCategory = categorizeByYear(c);        }      }    }    return mYearCategory;  }  private static void conditionallyAdd(ArrayList list, int value) {    if (value != CLASS_UNKNOWN) {      list.add(value);    }  }  /**   * Calculates the "best-in-class year" of the device. This represents the top-end or flagship   * devices of that year, not the actual release year of the phone. For example, the Galaxy Duos   * S was released in 2012, but its specs are very similar to the Galaxy S that was released in   * 2010 as a then top-of-the-line phone, so it is a 2010 device.   *   * @return The year when this device would have been considered top-of-the-line.   */  private static int categorizeByYear(Context c) {    ArrayList componentYears = new ArrayList();    conditionallyAdd(componentYears, getNumCoresYear());    conditionallyAdd(componentYears, getClockSpeedYear());    conditionallyAdd(componentYears, getRamYear(c));    if (componentYears.isEmpty())      return CLASS_UNKNOWN;    Collections.sort(componentYears);    if ((componentYears.size() & 0x01) == 1) {  // Odd number; pluck the median.      return componentYears.get(componentYears.size() / 2);    } else { // Even number. Average the two "center" values.      int baseIndex = componentYears.size() / 2 - 1;      // There's an implicit rounding down in here; 2011.5 becomes 2011.      return componentYears.get(baseIndex) +          (componentYears.get(baseIndex + 1) - componentYears.get(baseIndex)) / 2;    }  }  /**   * Calculates the year class by the number of processor cores the phone has.   * Evaluations are based off the table below:   *    *    *    *    *    *    *    *    *    * Amount Year
>4 or More 2012
2 or 3 2011
1 2008
   *   * @return the year in which top-of-the-line phones had the same number of processors as this phone.   */  private static int getNumCoresYear() {    int cores = DeviceInfo.getNumberOfCPUCores();    if (cores < 1) return CLASS_UNKNOWN;    if (cores == 1) return CLASS_2008;    if (cores <= 3) return CLASS_2011;    return CLASS_2012;  }  /**   * Calculates the year class by the clock speed of the cores in the phone.   * Evaluations are based off the table below:   *    *    *    *    *    *    *    *    *    *    *    *    *    * Amount Year
>2GHz 2014
<=2GHz 2013
<=1.5GHz 2012
<=1.2GHz 2011
<=1GHz 2010
<=600MHz 2009
<=528MHz 2008
   *   * @return the year in which top-of-the-line phones had the same clock speed.   */  private static int getClockSpeedYear() {    long clockSpeedKHz = DeviceInfo.getCPUMaxFreqKHz();    if (clockSpeedKHz == DeviceInfo.DEVICEINFO_UNKNOWN) return CLASS_UNKNOWN;    // These cut-offs include 20MHz of "slop" because my "1.5GHz" Galaxy S3 reports    // its clock speed as 1512000. So we add a little slop to keep things nominally correct.    if (clockSpeedKHz <= 528 * MHZ_IN_KHZ) return CLASS_2008;    if (clockSpeedKHz <= 620 * MHZ_IN_KHZ) return CLASS_2009;    if (clockSpeedKHz <= 1020 * MHZ_IN_KHZ) return CLASS_2010;    if (clockSpeedKHz <= 1220 * MHZ_IN_KHZ) return CLASS_2011;    if (clockSpeedKHz <= 1520 * MHZ_IN_KHZ) return CLASS_2012;    if (clockSpeedKHz <= 2020 * MHZ_IN_KHZ) return CLASS_2013;    return CLASS_2014;  }  /**   * Calculates the year class by the amount of RAM the phone has.   * Evaluations are based off the table below:   *    *    *    *    *    *    *    *    *    *    *    *    *    * Amount Year
>2GB 2014
<=2GB 2013
<=1.5GB 2012
<=1GB 2011
<=512MB 2010
<=256MB 2009
<=128MB 2008
   *   * @return the year in which top-of-the-line phones had the same amount of RAM as this phone.   */  private static int getRamYear(Context c) {    long totalRam = DeviceInfo.getTotalMemory(c);    if (totalRam <= 0) return CLASS_UNKNOWN;    if (totalRam <= 192 * MB) return CLASS_2008;    if (totalRam <= 290 * MB) return CLASS_2009;    if (totalRam <= 512 * MB) return CLASS_2010;    if (totalRam <= 1024 * MB) return CLASS_2011;    if (totalRam <= 1536 * MB) return CLASS_2012;    if (totalRam <= 2048 * MB) return CLASS_2013;    return CLASS_2014;  }}

Amount	Year
>4 or More	2012
2 or 3	2011
1	2008

Amount	Year
>2GHz	2014
<=2GHz	2013
<=1.5GHz	2012
<=1.2GHz	2011
<=1GHz	2010
<=600MHz	2009
<=528MHz	2008

Amount	Year
>2GB	2014
<=2GB	2013
<=1.5GB	2012
<=1GB	2011
<=512MB	2010
<=256MB	2009
<=128MB	2008

使用方法：

import android.app.Activity;import android.content.SharedPreferences;import android.os.AsyncTask;import android.os.Bundle;import android.widget.TextView;import com.facebook.device.yearclass.YearClass;public class MainActivity extends Activity {  private static final String PREF_FILE = "YearClass";  private static final String PREF_NAME = "yearclass";  private TextView mYearClass;  @Override  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_main);    GetOrComputeYearClass findYearClass = new GetOrComputeYearClass();    findYearClass.execute();    mYearClass = (TextView) findViewById(R.id.year_class);  }  private class GetOrComputeYearClass extends AsyncTask {    @Override    protected Integer doInBackground(Void... voids) {      int yearClass = YearClass.CLASS_UNKNOWN;      SharedPreferences prefs = getSharedPreferences(PREF_FILE, 0);      if (prefs.contains(PREF_NAME)) {        yearClass = prefs.getInt(PREF_NAME, YearClass.CLASS_UNKNOWN);      }      //Try again if device was previously unknown.      if (yearClass == YearClass.CLASS_UNKNOWN) {        yearClass = YearClass.get(getApplicationContext());        SharedPreferences.Editor editor = prefs.edit();        editor.putInt(PREF_NAME, yearClass);        editor.apply();      }      return yearClass;    }    @Override    protected void onPostExecute(Integer yearClass) {      //update UI      mYearClass.setText(Integer.toString(yearClass));    }  }}

运行在Android设备上，启动本程序之后，在任何窗口可显示当前CPU工作频率等状态，显示当前电压电流电池容量等信息
https://github.com/will86/android-runninginfo

查看图片附件

更多相关文章

随机推荐