content: package com.jingewenku.abrahamcaijin.commonutil;
  
  
  import android.Manifest;
  import android.accounts.Account;
  import android.accounts.AccountManager;
  import android.app.Activity;
  import android.bluetooth.BluetoothAdapter;
  import android.content.Context;
  import android.content.pm.PackageManager;
  import android.database.Cursor;
  import android.graphics.BitmapFactory;
  import android.net.Uri;
  import android.net.wifi.WifiInfo;
  import android.net.wifi.WifiManager;
  import android.os.Build;
  import android.os.Vibrator;
  import android.provider.Settings;
  import android.telephony.CellLocation;
  import android.telephony.TelephonyManager;
  import android.util.DisplayMetrics;
  import android.view.WindowManager;
  import android.webkit.WebView;
  
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.LineNumberReader;
  import java.net.InetAddress;
  import java.net.NetworkInterface;
  import java.net.SocketException;
  import java.util.Enumeration;
  import java.util.Locale;
  import java.util.UUID;
  
  
  /**
   * 主要功能: 获取App应用系统基本信息
   *
   * @Prject: CommonUtilLibrary
   * @Package: com.jingewenku.abrahamcaijin.commonutil
   * @author: AbrahamCaiJin
   * @date: 2017年05月04日 14:13
   * @Copyright: 个人版权所有
   * @Company:
   * @version: 1.0.0
   */
  @SuppressWarnings("deprecation")
  public class AppSysMgr {
  
  
  	public static final int DEFAULT_THREAD_POOL_SIZE = getSysDefaultThreadPoolSize();
  	
  	
  	 /**
       * 获得客户端操作系统名称
       * @return
       */
      public static String getSysClientOs() {
          String OsName = android.os.Build.ID;
          return OsName;
      }
  	
  	/**
  	 * 获取当前操作系统的sdk版本
  	 * @return String 系统SDK版本
  	 */
  	public static String getSysSdk() {
  	    String sdkVersion = android.os.Build.VERSION.SDK;
  	    AppLogMessageMgr.i("AppSysMgr-->>getSysLanguage", sdkVersion);
  	    return sdkVersion;
  	}
  	
  	/**
  	 * 获取当前操作系统的语言
  	 * @return String 系统语言
  	 */
  	public static String getSysLanguage() {
  		String language = Locale.getDefault().getLanguage();
  		AppLogMessageMgr.i("AppSysMgr-->>getSysLanguage",  language);
  		return language;
  	}
  
  	/**
  	 * 获取当前系统上的语言列表(Locale列表)
  	 *
  	 * @return  语言列表
  	 */
  	public static Locale[] getSystemLanguageList() {
  		return Locale.getAvailableLocales();
  	}
  
  	
  	/**
  	 * 获取手机型号
  	 * @return String 手机型号
  	 */
  	public static String getSysModel() {
  		String model = android.os.Build.MODEL;
  		AppLogMessageMgr.i("AppSysMgr-->>getSysModel",  model);
  		return model;
  	}
  
  	
  	/**
  	 * 获取操作系统的版本号
  	 * @return String 系统版本号
  	 */
  	public static String getSysRelease() {
  		String release = android.os.Build.VERSION.RELEASE;
  		AppLogMessageMgr.i("AppSysMgr-->>getSysRelease",  release);
  		return release;
  	}
  
  	
  	/**
  	 * 读取SIM卡序列号
  	 * @param content 上下文
  	 * @return String SIM卡序列号
  	 */
  	public static String getSysSIMSerialNum(Context content) {
  		String simSerialNumber = getSysTelephonyManager(content).getSimSerialNumber();
  		AppLogMessageMgr.i("AppSysMgr-->>getSysSIMSerialNum",  simSerialNumber);
  		return simSerialNumber;
  	}
  
  
      /**
       * 获取手机CPU序列号
       * @return String cpu序列号(16位) 读取失败为"0000000000000000"  
       */
      public static String getSysCPUSerialNum() {
          String str = "", strCPU = "", cpuSerialNum = "0000000000000000";
          try {
              //读取CPU信息
              Process pp = Runtime.getRuntime().exec("cat/proc/cpuinfo");
              InputStreamReader ir = new InputStreamReader(pp.getInputStream());
              LineNumberReader input = new LineNumberReader(ir);
              //查找CPU序列号
              for (int i = 1; i < 100; i++) {
                  str = input.readLine();
                  if (str != null) {
                      //查找到序列号所在行
                      if (str.indexOf("Serial") > -1) {
                          //提取序列号
                          strCPU = str.substring(str.indexOf(":") + 1,
                          str.length());
                          //去空格
                          cpuSerialNum = strCPU.trim();
                          break;
                      }
                  }else{
                      break;
                  }
              }
          } catch (IOException e) {
              e.printStackTrace();
              AppLogMessageMgr.e("AppSysMgr-->>getSysCPUSerialNum",  e.getMessage().toString());
          }
          	return cpuSerialNum;
      }
  	
  
  	/**
  	 * 获得电话管理实例对象
  	 * @param content  上下文
  	 * @return TelephonyManager 电话管理实例对象
  	 */
  	private static TelephonyManager getSysTelephonyManager(Context content) {
  		TelephonyManager telephonyManager = null;
  		telephonyManager = (TelephonyManager) content.getSystemService(Context.TELEPHONY_SERVICE);
  		AppLogMessageMgr.i("AppSysMgr-->>getSysTelephonyManager",  telephonyManager + "");
  		return telephonyManager;
  	}
  
  
  
  	/**
  	 * 读唯一的设备ID(唯一的设备ID【GSM手机的IMEI】和【CDMA手机的 MEID】,如果获取不到返回一个默认字符串)
  	 * @param content 上下文
  	 * @return String 获取设备序列号
  	 */
  	public static String getSysTelephoneSerialNum(Context content) {
  		String deviceId = getSysTelephonyManager(content).getDeviceId();
  		AppLogMessageMgr.i("AppSysMgr-->>getSysTelephoneSerialNum",  deviceId + "");
  		return deviceId;
  	}
  
  
  
  	/**
  	 * 获取运营商信息(三大运营商)
  	 * @param content 上下文
  	 * @return String 获取运营商名称
  	 */
  	public static String getSysCarrier(Context content) {
  		String moblieType = "";
  		TelephonyManager telephonyManager = (TelephonyManager) content.getSystemService(Context.TELEPHONY_SERVICE);
  		String imsi = telephonyManager.getSubscriberId();
  		if (imsi != null && imsi.length() > 0) {
  			//因为移动网络编号46000下的IMSI已经用完，所以虚拟了一个46002编号，134/159号段使用了此编号
  			if (imsi.startsWith("46000") || imsi.startsWith("46002")) {
  				//中国移动
  				moblieType = "China Mobile";
  			} else if (imsi.startsWith("46001")) {
  				//中国联通
  				moblieType = "China Unicom";
  			} else if (imsi.startsWith("46003")) {
  				//中国电信
  				moblieType = "China Telecom";
  			}
  		}
  		AppLogMessageMgr.i("AppSysMgr-->>getSysCarrier",  moblieType);
  		return moblieType;
  	}
  
  
  	/**
  	 * 获取手机状态(0：无活动 1：响铃 2：待机)
  	 * @param  context 上下文
  	 * @return Integer 手机状态
  	 */
  	public static Integer getSysPhoneState(Context context) {
  		Integer callState = getSysTelephonyManager(context).getCallState();
  		AppLogMessageMgr.i("AppSysMgr-->>getSysPhoneState",  callState + "");
  		return callState;
  	}
  
  	
  	/**
  	 * 获得手机方位
  	 * @param context 上下文
  	 * @return CellLocation 手机方位
  	 */
  	public static CellLocation getSysPhoneLoaction(Context context) {
  		CellLocation cellLocation = getSysTelephonyManager(context).getCellLocation();
  		AppLogMessageMgr.i("AppSysMgr-->>getSysPhoneLoaction",  cellLocation + "");
  		return cellLocation;
  	}
  
  	
  	/**
  	 * 获得设备的软件版本号(注：the IMEI/SV(software version) for GSM phones 不支持返回“not available”)
  	 * @param context 上下文
  	 * @return String 设备软件版本号
  	 */
  	public static String getSysDeviceSoftVersion(Context context) {
  		String deviceSoftwareVersion = getSysTelephonyManager(context).getDeviceSoftwareVersion();
  		AppLogMessageMgr.i("AppSysMgr-->>getSysDeviceSoftVersion",  deviceSoftwareVersion + "");
  		return deviceSoftwareVersion;
  	}
  
  
  	/**
  	 * 获得手机号
  	 * @param context 上下文
  	 * @return String 手机号
  	 */
  	public static String getSysPhoneNumber(Context context) {
  		String phoneNumber = getSysTelephonyManager(context).getLine1Number();
  		AppLogMessageMgr.i("AppSysMgr-->>getSysPhoneNumber",  phoneNumber + "");
  		return phoneNumber;
  	}
  
  	
  	/**
  	 * 获得SIM卡提供的移动国家码和移动网络码.5或6位的十进制数字。(注：SIM卡的状态必须是 SIM_STATE_READY(使用getSimState()判断))
  	 * @param context 上下文
  	 * @return String SIM移动国家编码和移动网络编码
  	 */
  	public static String getSysSimCode(Context context) {
  		String code = "";
  		if (getSysTelephonyManager(context).getSimState() == 5) {
  			code = getSysTelephonyManager(context).getSimOperator();
  		}
  		AppLogMessageMgr.i("AppSysMgr-->>getSysSimCode",  code + "");
  		return code;
  	}
  
  
  	/**
  	 * 服务商名称(注:例如：中国移动、联通SIM卡的状态必须是 SIM_STATE_READY(使用getSimState()判断)).
  	 * @param context 上下文
  	 * @return String 服务商名称
  	 */
  	public static String getSysSimPrivatorName(Context context) {
  		String simOperatorName = "";
  		if (getSysTelephonyManager(context).getSimState() == 5) {
  			simOperatorName = getSysTelephonyManager(context).getSimOperatorName();
  		}
  		AppLogMessageMgr.i("AppSysMgr-->>getSysSimPrivatorName",  simOperatorName);
  		return simOperatorName;
  	}
  
  
  
  	/**
  	 * 唯一的用户ID (注：例如：IMSI(国际移动用户识别码) for a GSM phone. 需要权限：READ_PHONE_STATE)
  	 * @param context 上下文
  	 * @return String 获取国际移动用户GSM识别码
  	 */
  	public static String getSysUserPhoneId(Context context) {
  		String subscriberId = getSysTelephonyManager(context).getSubscriberId();
  		AppLogMessageMgr.i("AppSysMgr-->>getSysUserPhoneId",  subscriberId);
  		return subscriberId;
  	}
  	
  
  	/**
  	 * 获取WindowManager对象
  	 * @param context 上下文对象
  	 * @return WindowManager
  	 */
  	public static WindowManager getWindowManager(Context context){
  		return (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  	}
  	
  	
  	/**
  	 * 获取屏幕管理类
  	 * @param activity activity对象
  	 * @return DisplayMetrics 屏幕管理实例
  	 */
  	public static DisplayMetrics getSysDisplayMetrics(Activity activity) {
  		DisplayMetrics displayMetrics = null;
  		if (displayMetrics == null) {
  			displayMetrics = new DisplayMetrics();
  		}
  		activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
  		AppLogMessageMgr.i("AppSysMgr-->>getSysDisplayMetrics",  "获取屏幕管理对象为：" + displayMetrics);
  		return displayMetrics;
  	}
  	
  	
  	/**
  	 * 获取屏幕宽度和高度并返回数组
       * @param  context 上下文对象
       * @return int[] 宽和高
  	 */
  	public static int[] getScreenDispaly(Context context) {
  		WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  		//手机屏幕的宽度
  		int width = wm.getDefaultDisplay().getWidth();
  		//手机屏幕的高度
  		int height = wm.getDefaultDisplay().getHeight();
  		AppLogMessageMgr.i("AppSysMgr-->>getScreenDispaly-->>width",  "获取屏幕宽度为：" + width);
  		AppLogMessageMgr.i("AppSysMgr-->>getScreenDispaly-->>height",  "获取屏幕高度为：" + height);
  		int result[] = { width, height };
  		return result;
  	}
  	
  	
      
  	/**
  	 * 获取屏幕宽度和高度并返回数组
       * @param  context 上下文对象
       * @return int[] 宽和高
  	 */
      public static int[] getScreenDispaly8(Context context) {
  		WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  		//手机屏幕的宽度
  		int width = wm.getDefaultDisplay().getWidth() /10 * 8;
  		//手机屏幕的高度
  		int height = wm.getDefaultDisplay().getHeight() /10 * 8;
  		AppLogMessageMgr.i("AppSysMgr-->>getScreenDispaly-->>width",  "获取屏幕宽度为：" + width);
  		AppLogMessageMgr.i("AppSysMgr-->>getScreenDispaly-->>height",  "获取屏幕高度为：" + height);
  		int result[] = { width, height };
  		return result;
  	}
  	
  
  	/**
  	 * 获取屏幕宽度
       * @param  context 上下文对象
       * @return Integer 屏幕宽度
  	 */
      public static Integer getSysScreenWidth(Context context) {  
          WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);  
          DisplayMetrics displayMetrics = new DisplayMetrics();  
          wm.getDefaultDisplay().getMetrics(displayMetrics);  
          AppLogMessageMgr.i("AppSysMgr-->>getSysScreenWidth",  "获取屏幕宽度为：" + displayMetrics.widthPixels);
          return displayMetrics.widthPixels;  
      }  
  	
      
  	/**
  	 * 获取屏幕高度
       * @param  context 上下文对象
       * @return Integer 屏幕高度
  	 */
      public static Integer getSysScreenHeight(Context context)  {  
          WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);  
          DisplayMetrics displayMetrics = new DisplayMetrics();  
          wm.getDefaultDisplay().getMetrics(displayMetrics);  
          AppLogMessageMgr.i("AppSysMgr-->>getSysScreenHeight",  "获取屏幕高度为：" + displayMetrics.heightPixels);
          return displayMetrics.heightPixels;  
      }  
      
  	
  
      /**
       * 获取屏幕状态栏目高度
       * @param  context 上下文对象
       * @return Integer 状态栏高度
       */
      public static Integer getSysScreenStatusHeight(Context context)  {  
          int statusHeight = 0;  
          try {  
              Class<?> clazz = Class.forName("com.android.internal.R$dimen");  
              Object object = clazz.newInstance();  
              int height = Integer.parseInt(clazz.getField("status_bar_height").get(object).toString());  
              statusHeight = context.getResources().getDimensionPixelSize(height);  
              AppLogMessageMgr.i("AppSysMgr-->>getSysScreenStatusHeight",  "获取屏幕状态栏高度为：" + statusHeight);
          } catch (Exception e) {  
              e.printStackTrace();  
              AppLogMessageMgr.e("AppSysMgr-->>getSysScreenStatusHeight",  "获取屏幕状态栏高度失败！" + e.getMessage());
          }  
          	return statusHeight;  
      } 
      
      
  	/**
  	 * 获得系统配置相符的线程池大小
  	 * @return Integer 返回系统配置相符合线程大小
  	 */
  	public static Integer getSysDefaultThreadPoolSize() {
  		Integer availableProcessors = 2 * Runtime.getRuntime().availableProcessors() + 1;
  		availableProcessors = availableProcessors > 8 ? 8 : availableProcessors;
  		AppLogMessageMgr.i("AppSysMgr-->>getSysDefaultThreadPoolSize",  availableProcessors + "");
  		return availableProcessors;
  	}
  
  	
  	
  	
  
  	/**
  	 * 获取当前APP应用的SampleSize大小
  	 * @param options BitmapFactory.Options对象
  	 * @param minSideLength  计算最小值
  	 * @param maxNumOfPixels 计算最大值
  	 * @return Integer  返回SampleSize大小
  	 */
      public static Integer getSysSampleSize(BitmapFactory.Options options, int minSideLength, int maxNumOfPixels) {  
      	Integer initialSize = calculateSysInitialSampleSize(options, minSideLength, maxNumOfPixels);  
      	Integer roundedSize;  
          if (initialSize <= 8 ) {  
              roundedSize = 1;  
              while (roundedSize < initialSize) {  
                  roundedSize <<= 1;  
              }  
          }else{  
          		roundedSize = (initialSize + 7) / 8 * 8;  
          }  
          AppLogMessageMgr.i("AppSysMgr-->>getSysSampleSize",  roundedSize + "");
          return roundedSize;  
      }  
        
      
      /**
       * 计算公式
       * @param options BitmapFactory.Options对象
  	 * @param minSideLength  计算最小值
  	 * @param maxNumOfPixels 计算最大值
       * @return Integer   
       */
      private static Integer calculateSysInitialSampleSize(BitmapFactory.Options options,int minSideLength, int maxNumOfPixels) {  
          double w = options.outWidth;  
          double h = options.outHeight;  
          Integer lowerBound = (maxNumOfPixels == -1) ? 1 :  (int) Math.ceil(Math.sqrt(w * h / maxNumOfPixels));  
          Integer upperBound = (minSideLength == -1) ? 128 : (int) Math.min(Math.floor(w / minSideLength), Math.floor(h / minSideLength));  
          if (upperBound < lowerBound) {  
              return lowerBound;  
          }  
          if ((maxNumOfPixels == -1) && (minSideLength == -1)) {  
              return 1;  
          } else if (minSideLength == -1) {  
              return lowerBound;  
          } else {  
              return upperBound;  
          }  
      }
      
      
      /**
       * 获取震动器对象
       * @param context 上下文对象
       * @return Vibrator 震动器对象
       */
      public static Vibrator getVibrator(Context context){
      	return (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
      }
  
      
      /**
       * 获取手机IP地址
       * @return String 手机IP地址
       */
      public String getSysLocalIpAddress() {
      	String hostAddress = null;
          try {
              for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
                  NetworkInterface intf = en.nextElement();
                  for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
                      InetAddress inetAddress = enumIpAddr.nextElement();
                      if (!inetAddress.isLoopbackAddress()) {
                      	hostAddress = inetAddress.getHostAddress();
                      }
                  }
              }
          } catch (SocketException e) {
          	e.printStackTrace();
          	AppLogMessageMgr.e("AppSysMgr-->>getSysLocalIpAddress",  e.getMessage().toString());
          }
          	AppLogMessageMgr.i("AppSysMgr-->>getSysLocalIpAddress",  hostAddress);
          	return hostAddress;
      }
  
  	/**
  	 *获取AndroidID
  	 * @param ctx
  	 * @return
  	 */
  	public static String getAndroidID(Context ctx) {
  		return Settings.Secure.getString(ctx.getContentResolver(), Settings.Secure.ANDROID_ID);
  	}
  
  	/**
  	 * 获取设备IMSI码
  	 * @param ctx
  	 * @return
  	 */
  	public static String getIMSI(Context ctx) {
  		TelephonyManager tm = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
  		return tm.getSubscriberId() != null ? tm.getSubscriberId() : null;
  	}
  
  	/**
  	 * 获取网络IP地址(优先获取wifi地址)
  	 * @param ctx
  	 * @return
  	 */
  	public static String getIP(Context ctx) {
  		WifiManager wifiManager = (WifiManager) ctx.getSystemService(Context.WIFI_SERVICE);
  		return wifiManager.isWifiEnabled() ? getWifiIP(wifiManager) : getGPRSIP();
  	}
  
  	/**
  	 * 获取WIFI连接下的ip地址
  	 * @param wifiManager
  	 * @return
  	 */
  	public static String getWifiIP(WifiManager wifiManager) {
  		WifiInfo wifiInfo = wifiManager.getConnectionInfo();
  		String ip = intToIp(wifiInfo.getIpAddress());
  		return ip != null ? ip : "";
  	}
  
  	/**
  	 * 获取GPRS连接下的ip地址
  	 * @return
  	 */
  	public static String getGPRSIP() {
  		String ip = null;
  		try {
  			for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
  				for (Enumeration<InetAddress> enumIpAddr = en.nextElement().getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
  					InetAddress inetAddress = enumIpAddr.nextElement();
  					if (!inetAddress.isLoopbackAddress()) {
  						ip = inetAddress.getHostAddress();
  					}
  				}
  			}
  		} catch (SocketException e) {
  			e.printStackTrace();
  			ip = null;
  		}
  		return ip;
  	}
  
  	private static String intToIp(int i) {
  		return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF) + "." + (i >> 24 & 0xFF);
  	}
  
  	/**
  	 * 获取设备序列号
  	 * @return
  	 */
  	public static String getSerial() {
  		return Build.SERIAL;
  	}
  
  	/**
  	 * 获取SIM序列号
  	 * @param ctx
  	 * @return
  	 */
  	public static String getSIMSerial(Context ctx) {
  		TelephonyManager tm = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
  		return tm.getSimSerialNumber();
  	}
  
  	/**
  	 * 获取网络运营商 46000,46002,46007 中国移动,46001 中国联通,46003 中国电信
  	 * @param ctx
  	 * @return
  	 */
  	public static String getMNC(Context ctx) {
  		String providersName = "";
  		TelephonyManager telephonyManager = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
  		if (telephonyManager.getSimState() == TelephonyManager.SIM_STATE_READY) {
  			providersName = telephonyManager.getSimOperator();
  			providersName = providersName == null ? "" : providersName;
  		}
  		return providersName;
  	}
  
  	/**
  	 * 获取网络运营商：中国电信,中国移动,中国联通
  	 * @param ctx
  	 * @return
  	 */
  	public static String getCarrier(Context ctx) {
  		TelephonyManager tm = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
  		return tm.getNetworkOperatorName().toLowerCase(Locale.getDefault());
  	}
  
  	/**
  	 * 获取硬件型号
  	 * @return
  	 */
  	public static String getModel() {
  		return Build.MODEL;
  	}
  
  	/**
  	 * 获取编译厂商
  	 * @return
  	 */
  	public static String getBuildBrand() {
  		return Build.BRAND;
  	}
  
  	/**
  	 *获取编译服务器主机
  	 * @return
  	 */
  	public static String getBuildHost() {
  		return Build.HOST;
  	}
  
  	/**
  	 *获取描述Build的标签
  	 * @return
  	 */
  	public static String getBuildTags() {
  		return Build.TAGS;
  	}
  
  	/**
  	 *获取系统编译时间
  	 * @return
  	 */
  	public static long getBuildTime() {
  		return Build.TIME;
  	}
  
  	/**
  	 *获取系统编译作者
  	 * @return
  	 */
  	public static String getBuildUser() {
  		return Build.USER;
  	}
  
  	/**
  	 *获取编译系统版本(5.1)
  	 * @return
  	 */
  	public static String getBuildVersionRelease() {
  		return Build.VERSION.RELEASE;
  	}
  
  	/**
  	 *获取开发代号
  	 * @return
  	 */
  	public static String getBuildVersionCodename() {
  		return Build.VERSION.CODENAME;
  	}
  
  	/**
  	 * 获取源码控制版本号
  	 * @return
  	 */
  	public static String getBuildVersionIncremental() {
  		return Build.VERSION.INCREMENTAL;
  	}
  
  	/**
  	 *获取编译的SDK
  	 * @return
  	 */
  	public static int getBuildVersionSDK() {
  		return Build.VERSION.SDK_INT;
  	}
  
  	/**
  	 *获取修订版本列表(LMY47D)
  	 * @return
  	 */
  	public static String getBuildID() {
  		return Build.ID;
  	}
  
  	/**
  	 *CPU指令集
  	 * @return
  	 */
  	public static String[] getSupportedABIS() {
  		String[] result = new String[]{"-"};
  		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  			result = Build.SUPPORTED_ABIS;
  		}
  		if (result == null || result.length == 0) {
  			result = new String[]{"-"};
  		}
  		return result;
  	}
  
  	/**
  	 *获取硬件制造厂商
  	 * @return
  	 */
  	public static String getManufacturer() {
  		return Build.MANUFACTURER;
  	}
  
  	/**
  	 *获取系统启动程序版本号
  	 * @return
  	 */
  	public static String getBootloader() {
  		return Build.BOOTLOADER;
  	}
  
  	/**
  	 *
  	 * @param ctx
  	 * @return
  	 */
  	public static String getScreenDisplayID(Context ctx) {
  		WindowManager wm = (WindowManager) ctx.getSystemService(Context.WINDOW_SERVICE);
  		return String.valueOf(wm.getDefaultDisplay().getDisplayId());
  	}
  
  	/**
  	 * 获取系统版本号
  	 * @return
  	 */
  	public static String getDisplayVersion() {
  		return Build.DISPLAY;
  	}
  
  	/**
  	 *获取语言
  	 * @return
  	 */
  	public static String getLanguage() {
  		return Locale.getDefault().getLanguage();
  	}
  
  	/**
  	 * 获取国家
  	 * @param ctx
  	 * @return
  	 */
  	public static String getCountry(Context ctx) {
  		TelephonyManager tm = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
  		Locale locale = Locale.getDefault();
  		return tm.getSimState() == TelephonyManager.SIM_STATE_READY ? tm.getSimCountryIso().toLowerCase(Locale.getDefault()) : locale.getCountry().toLowerCase(locale);
  	}
  
  	/**
  	 *获取系统版本:5.1.1
  	 * @return
  	 */
  	public static String getOSVersion() {
  		return Build.VERSION.RELEASE;
  	}
  
  	/**
  	 *获取GSF序列号
  	 * @param context
  	 * @return
  	 */
  	//<uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES"/>
  	public static String getGSFID(Context context) {
  		String result;
  		final Uri URI = Uri.parse("content://com.google.android.gsf.gservices");
  		final String ID_KEY = "android_id";
  		String[] params = {ID_KEY};
  		Cursor c = context.getContentResolver().query(URI, null, null, params, null);
  		if (c == null || !c.moveToFirst() || c.getColumnCount() < 2) {
  			return null;
  		} else {
  			result = Long.toHexString(Long.parseLong(c.getString(1)));
  		}
  		c.close();
  		return result;
  	}
  
  	/**
  	 * 获取蓝牙地址
  	 * @param context
  	 * @return
  	 */
  	//<uses-permission android:name="android.permission.BLUETOOTH"/>
  	@SuppressWarnings("MissingPermission")
  	public static String getBluetoothMAC(Context context) {
  		String result = null;
  		try {
  			if (context.checkCallingOrSelfPermission(Manifest.permission.BLUETOOTH)
  				== PackageManager.PERMISSION_GRANTED) {
  				BluetoothAdapter bta = BluetoothAdapter.getDefaultAdapter();
  				result = bta.getAddress();
  			}
  		} catch (Exception e) {
  			e.printStackTrace();
  		}
  		return result;
  	}
  
  	/**
  	 * Android设备物理唯一标识符
  	 * @return
  	 */
  	public static String getPsuedoUniqueID() {
  		String devIDShort = "35" + (Build.BOARD.length() % 10) + (Build.BRAND.length() % 10);
  		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  			devIDShort += (Build.SUPPORTED_ABIS[0].length() % 10);
  		} else {
  			devIDShort += (Build.CPU_ABI.length() % 10);
  		}
  		devIDShort += (Build.DEVICE.length() % 10) + (Build.MANUFACTURER.length() % 10) + (Build.MODEL.length() % 10) + (Build.PRODUCT.length() % 10);
  		String serial;
  		try {
  			serial = Build.class.getField("SERIAL").get(null).toString();
  			return new UUID(devIDShort.hashCode(), serial.hashCode()).toString();
  		} catch (Exception e) {
  			serial = "ESYDV000";
  		}
  		return new UUID(devIDShort.hashCode(), serial.hashCode()).toString();
  	}
  
  	/**
  	 * 构建标识,包括brand,name,device,version.release,id,version.incremental,type,tags这些信息
  	 * @return
  	 */
  	public static String getFingerprint() {
  		return Build.FINGERPRINT;
  	}
  
  	/**
  	 * 获取硬件信息
  	 * @return
  	 */
  	public static String getHardware() {
  		return Build.HARDWARE;
  	}
  
  	/**
  	 * 获取产品信息
  	 * @return
  	 */
  	public static String getProduct() {
  		return Build.PRODUCT;
  	}
  
  	/**
  	 *  获取设备信息
  	 * @return
  	 */
  	public static String getDevice() {
  		return Build.DEVICE;
  	}
  
  	/**
  	 * 获取主板信息
  	 * @return
  	 */
  	public static String getBoard() {
  		return Build.BOARD;
  	}
  
  	/**
  	 *  获取基带版本(无线电固件版本 Api14以上)
  	 * @return
  	 */
  	public static String getRadioVersion() {
  		return Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH ? Build.getRadioVersion() : "";
  	}
  
  	/**
  	 * 获取的浏览器指纹(User-Agent)
  	 * @param ctx
  	 * @return
  	 */
  	public static String getUA(Context ctx) {
  		final String system_ua = System.getProperty("http.agent");
  		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
  			return new WebView(ctx).getSettings().getDefaultUserAgent(ctx) + "__" + system_ua;
  		} else {
  			return new WebView(ctx).getSettings().getUserAgentString() + "__" + system_ua;
  		}
  	}
  
  	/**
  	 * 获取得屏幕密度
  	 * @param ctx
  	 * @return
  	 */
  	public static String getDensity(Context ctx) {
  		String densityStr = null;
  		final int density = ctx.getResources().getDisplayMetrics().densityDpi;
  		switch (density) {
  			case DisplayMetrics.DENSITY_LOW:
  				densityStr = "LDPI";
  				break;
  			case DisplayMetrics.DENSITY_MEDIUM:
  				densityStr = "MDPI";
  				break;
  			case DisplayMetrics.DENSITY_TV:
  				densityStr = "TVDPI";
  				break;
  			case DisplayMetrics.DENSITY_HIGH:
  				densityStr = "HDPI";
  				break;
  			case DisplayMetrics.DENSITY_XHIGH:
  				densityStr = "XHDPI";
  				break;
  			case DisplayMetrics.DENSITY_400:
  				densityStr = "XMHDPI";
  				break;
  			case DisplayMetrics.DENSITY_XXHIGH:
  				densityStr = "XXHDPI";
  				break;
  			case DisplayMetrics.DENSITY_XXXHIGH:
  				densityStr = "XXXHDPI";
  				break;
  		}
  		return densityStr;
  	}
  
  	/**
  	 * 获取google账号
  	 * @param ctx
  	 * @return
  	 */
  	//<uses-permission android:name="android.permission.GET_ACCOUNTS"/>
  	@SuppressWarnings("MissingPermission")
  	public static String[] getGoogleAccounts(Context ctx) {
  		if (ctx.checkCallingOrSelfPermission(Manifest.permission.GET_ACCOUNTS) == PackageManager.PERMISSION_GRANTED) {
  			Account[] accounts = AccountManager.get(ctx).getAccountsByType("com.google");
  			String[] result = new String[accounts.length];
  			for (int i = 0; i < accounts.length; i++) {
  				result[i] = accounts[i].name;
  			}
  			return result;
  		}
  		return null;
  	}
  
  }
  