原帖：
http://www.jianshu.com/p/f7add443cd32
Device Year Class 的主要功能是根据 CPU核数、时钟频率 以及 内存大小 对设备进行分级。
下表是 Facebook 公司提供的分级标准，其中 Year 栏表示分级结果。
以下类就是从Facebook 的开源项目 Device Year Class 中拿出来的
使用方法：
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:
* <p>
* <pre>
* int yearClass = YearClass.get(context);
* </pre>
*/
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<Integer> 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<Integer> componentYears = new ArrayList<Integer>();
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:
* <table border="1">
* <thead>
* <tr><th width="50%">Amount</th><th>Year</th></tr>
* <thead>
* <tbody>
* <tr><td>>4 or More</td><td>2012</td></tr>
* <tr><td>2 or 3</td><td>2011</td></tr>
* <tr><td>1</td><td>2008</td></tr>
* </tbody>
* </table>
*
* @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:
* <table border="1">
* <thead>
* <tr><th width="50%">Amount</th><th>Year</th></tr>
* <thead>
* <tbody>
* <tr><td>>2GHz</td><td>2014</td></tr>
* <tr><td><=2GHz</td><td>2013</td></tr>
* <tr><td><=1.5GHz</td><td>2012</td></tr>
* <tr><td><=1.2GHz</td><td>2011</td></tr>
* <tr><td><=1GHz</td><td>2010</td></tr>
* <tr><td><=600MHz</td><td>2009</td></tr>
* <tr><td><=528MHz</td><td>2008</td></tr>
* </tbody>
* </table>
*
* @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:
* <table border="1">
* <thead>
* <tr><th width="50%">Amount</th><th>Year</th></tr>
* <thead>
* <tbody>
* <tr><td>>2GB</td><td>2014</td></tr>
* <tr><td><=2GB</td><td>2013</td></tr>
* <tr><td><=1.5GB</td><td>2012</td></tr>
* <tr><td><=1GB</td><td>2011</td></tr>
* <tr><td><=512MB</td><td>2010</td></tr>
* <tr><td><=256MB</td><td>2009</td></tr>
* <tr><td><=128MB</td><td>2008</td></tr>
* </tbody>
* </table>
*
* @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;
}
}
使用方法：
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<Void, Void, Integer> {
@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));
}
}
}
