android 获取设备信息类

public class DeviceUtils {

    //没有网络连接
    public static final String NETWORN_NONE = "none";
    //wifi连接
    public static final String NETWORN_WIFI = "wifi";
    public static final String UnCon_WIFI = "wifi";
    //手机网络数据连接类型
    public static final String NETWORN_2G = "2G";
    public static final String NETWORN_3G = "3G";
    public static final String NETWORN_4G = "4G";
    public static final String NETWORN_MOBILE = "3G";
    public static final String NETWORN_ETHERNET="3G";

    private Context mContext;
    public DeviceUtils(Context context){
        mContext = context;
    }

    /**
     * 获取CPU使用率
     * @return
     */
    public double getCPURate(){
        String path = "/proc/stat";// 系统CPU信息文件
        long totalJiffies[]=new long[2];
        long totalIdle[]=new long[2];
        int firstCPUNum=0;//设置这个参数，这要是防止两次读取文件获知的CPU数量不同，导致不能计算。这里统一以第一次的CPU数量为基准
        FileReader fileReader = null;
        BufferedReader bufferedReader = null;
        Pattern pattern=Pattern.compile(" [0-9]+");
        for(int i=0;i<2;i++) {
            totalJiffies[i]=0;
            totalIdle[i]=0;
            try {
                fileReader = new FileReader(path);
                bufferedReader = new BufferedReader(fileReader, 8192);
                int currentCPUNum=0;
                String str;
                while ((str = bufferedReader.readLine()) != null&&(i==0||currentCPUNum<firstCPUNum)) {
                    if (str.toLowerCase().startsWith("cpu")) {
                        currentCPUNum++;
                        int index = 0;
                        Matcher matcher = pattern.matcher(str);
                        while (matcher.find()) {
                            try {
                                long tempJiffies = Long.parseLong(matcher.group(0).trim());
                                totalJiffies[i] += tempJiffies;
                                if (index == 3) {//空闲时间为该行第4条栏目
                                    totalIdle[i] += tempJiffies;
                                }
                                index++;
                            } catch (NumberFormatException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    if(i==0){
                        firstCPUNum=currentCPUNum;
                        try {//暂停50毫秒，等待系统更新信息。
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        double rate=-1;
        if (totalJiffies[0]>0&&totalJiffies[1]>0&&totalJiffies[0]!=totalJiffies[1]){
            rate=1.0*((totalJiffies[1]-totalIdle[1])-(totalJiffies[0]-totalIdle[0]))/(totalJiffies[1]-totalJiffies[0]);
        }

        return format(rate);
    }

    /**
     * 获取android当前可用运行内存大小
     */
    public double getAvailMemory() {
        ActivityManager am = (ActivityManager)mContext.getSystemService(Context.ACTIVITY_SERVICE);
        ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
        am.getMemoryInfo(mi);
        // mi.availMem; 当前系统的可用内存
//        return Formatter.formatFileSize(mContext, mi.availMem);// 将获取的内存大小规格化
        return format(mi.availMem/1024.0/1024.0/1024.0);
    }

    /**
     *   获取android总运行内存大小
     *
     */
    public double getTotalMemory() {
        String str1 = "/proc/meminfo";// 系统内存信息文件
        String str2;
        String[] arrayOfString;
        long initial_memory = 0;
        try {
            FileReader localFileReader = new FileReader(str1);
            BufferedReader localBufferedReader = new BufferedReader(localFileReader, 8192);
            str2 = localBufferedReader.readLine();// 读取meminfo第一行，系统总内存大小
            arrayOfString = str2.split("\\s+");

            // 获得系统总内存，单位是KB
            int i = Integer.valueOf(arrayOfString[1]).intValue();
            //int值乘以1024转换为long类型
            initial_memory = new Long((long) i * 1024);
            localBufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return format(initial_memory/1024.0/1024.0/1024.0);
    }

    /**
     * 保留小数点后三位数字
     * @param initial_memory
     */
    private double format(double initial_memory) {
        BigDecimal bg = new BigDecimal(initial_memory);
        double f1 = bg.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
        return f1;
    }


    /**
     * 获取手机内部空间总大小
     * @return 大小，字节为单位
     */
    public double getTotalInternalMemorySize() {
        //获取内部存储根目录
        File path = Environment.getDataDirectory();
        //系统的空间描述类
        StatFs stat = new StatFs(path.getPath());
        //每个区块占字节数
        long blockSize = stat.getBlockSize();
        //区块总数
        long totalBlocks = stat.getBlockCount();
//        return Formatter.formatFileSize(mContext, totalBlocks * blockSize);
        return format( (totalBlocks * blockSize)/1024.0/1024.0/1024.0);
    }

    /**
     * 获取手机内部可用空间大小
     *
     * @return 大小，字节为单位
     */
    public double getAvailableInternalMemorySize() {
        File path = Environment.getDataDirectory();
        StatFs stat = new StatFs(path.getPath());
        long blockSize = stat.getBlockSize();
        //获取可用区块数量
        long availableBlocks = stat.getAvailableBlocks();
//        return Formatter.formatFileSize(mContext, availableBlocks * blockSize);
        return format( (availableBlocks * blockSize)/1024.0/1024.0/1024.0);
    }

    /**
     * 获取IMEI 唯一的设备ID： GSM手机的 IMEI 和 CDMA手机的 MEID
     * International Mobile Equipment Identity，国际移动设备身份码的缩写。是由15位数字组成的“电子串号”，它与每台手机一一对应，每个IMEI在世界上都是唯一的。
     */
    public String getIMEI() {
        String imei = "";
        try {
            TelephonyManager tm = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
            imei = tm.getDeviceId();
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (TextUtils.isEmpty(imei)) {
            imei = "unknown";
        }
        return imei;
    }

    /**
     * 获取UUID
     * @return
     */
    public String getUUid() {
        String macAddress = new String();

        // The IMEI: 仅仅只对Android手机有效:
        TelephonyManager TelephonyMgr = (TelephonyManager) mContext
                .getSystemService(Context.TELEPHONY_SERVICE);
        String m_szImei = TelephonyMgr.getDeviceId(); // Requires
        // READ_PHONE_STATE
        // Pseudo-Unique ID, 这个在任何Android手机中都有效

        String m_szDevIDShort = "35" + Build.BOARD.length() % 10
                + Build.BRAND.length() % 10 + Build.CPU_ABI.length() % 10
                + Build.DEVICE.length() % 10 + Build.DISPLAY.length() % 10
                + Build.HOST.length() % 10 + Build.ID.length() % 10
                + Build.MANUFACTURER.length() % 10 + Build.MODEL.length() % 10
                + Build.PRODUCT.length() % 10 + Build.TAGS.length() % 10
                + Build.TYPE.length() % 10 + Build.USER.length() % 10; // 13
        // digits
        // 3. The Android ID
        String m_szAndroidID = Settings.Secure.getString(mContext.getContentResolver(), Settings.Secure.ANDROID_ID);
        // The WLAN MAC Address string, 是另一个唯一ID。但是你需要为你的工程加入
        WifiManager wm = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
        String m_szWLANMAC = wm.getConnectionInfo().getMacAddress();
        // The BT MAC Address string, 只在有蓝牙的设备上运行。并且要加入
        String m_szBTMAC = "";
        try {
            BluetoothAdapter m_BluetoothAdapter = null; // Local Bluetooth
            // adapter
            m_BluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
            m_szBTMAC = m_BluetoothAdapter.getAddress();
        } catch (Exception e) {
            e.printStackTrace();
            m_szBTMAC = "";

        }
        String m_szLongID = m_szImei + m_szDevIDShort + m_szAndroidID
                + m_szWLANMAC + m_szBTMAC;
        // compute md5
        MessageDigest m = null;
        try {
            m = MessageDigest.getInstance("MD5");
            // m.update(m_szLongID.getBytes(), 0, m_szLongID.length());
            m.update(m_szLongID.getBytes());
            // get md5 bytes
            byte p_md5Data[] = m.digest();
            // create a hex string
            for (int i = 0; i < p_md5Data.length; i++) {
                int b = (0xFF & p_md5Data[i]);
                if (b <= 0xF) {
                    macAddress += "0";
                }
                macAddress += Integer.toHexString(b);
                macAddress = macAddress.toUpperCase();
            }
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            macAddress = m_szLongID.substring(0, 32);
        }

        return macAddress;
    }


    /**
     * 获取mac地址
     * @return mac地址
     */
    public String getMacAddresss() {
        String macAddress = PrefsTool.getMacAddress();
        if(!isGetMacAddressSuccess(macAddress)) {
            boolean isWifiOpen = true;
            try {
                // WifiManager wm = (WifiManager) mContext
                // .getSystemService(Context.WIFI_SERVICE);
                // WifiInfo wifiInfo = wm.getConnectionInfo();
                // macAddress = wifiInfo.getMacAddress();
                //android 6.0以上系统通过以上方法获取mac地址时系统api返回02：00：00：00：00等虚假地址，故使用其他方式获取真实mac地址 获取不到时获取uuid
                // get all the interfaces
                int tryGetMacTime = 0;
                while (!isGetMacAddressSuccess(macAddress)) {
                    List<NetworkInterface> all = Collections.list(NetworkInterface
                            .getNetworkInterfaces());
                    // find network interface wlan0
                    for (NetworkInterface networkInterface : all) {
                        if (!networkInterface.getName().equalsIgnoreCase("wlan0"))
                            continue;
                        // get the hardware address (MAC) of the interface
                        byte[] macBytes = networkInterface.getHardwareAddress();
                        if (macBytes == null) {
                            return "";
                        }

                        StringBuilder res1 = new StringBuilder();
                        for (byte b : macBytes) {
                            // gets the last byte of b
                            if (Integer.toHexString(b & 0xFF).length() < 2) {
                                res1.append("0");
                            }//此方式下可能得到一位的mac地址数值，不符合要求，应该是两位的格式，故有上段代码 carmack
                            res1.append(Integer.toHexString(b & 0xFF) + ":");
                        }

                        if (res1.length() > 0) {
                            res1.deleteCharAt(res1.length() - 1);
                        }
                        macAddress = res1.toString();
                    }
                    //Log.d("macAddress", "macAddress:"+macAddress);

                    if(!isGetMacAddressSuccess(macAddress)) {
                        tryGetMacTime++;
                        if (tryGetMacTime > 10)//最多执行10次，避免死循环
                            break;

                        WifiManager wm = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
                        if (!wm.isWifiEnabled()) {
                            isWifiOpen = false;
                            wm.setWifiEnabled(true);
                            Thread.sleep(100);
                        }
                    }else{
                        PrefsTool.setMacAddress(macAddress);
                    }

                }

            } catch (Exception ex) {
                ex.printStackTrace();
            } finally {

                if (!isGetMacAddressSuccess(macAddress)) {
                    macAddress = getUUid();
                }


                if(!isWifiOpen){
                    WifiManager wm = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
                    wm.setWifiEnabled(false);
                }

            }
        }

        return macAddress;
    }

    private boolean isGetMacAddressSuccess(String macAddress){
        if (macAddress == null || macAddress.length() == 0
                || "02:00:00:00:00:00".equals(macAddress)
                || "  :  :  :  :  :  ".equals(macAddress)
                || "00:00:00:00:00:00".equals(macAddress)
                || !checkMacAddressFormat(macAddress)
        )
            return  false;
        return true;
    }
    private boolean checkMacAddressFormat(String macStr) {
        if (null != macStr) {
            macStr = macStr.replace(":", "").trim();
            String format = "(((?!0{10})([0-9A-Fa-f]{12})))";
            if (macStr.matches(format)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取连接WIFI的SSID
     *
     * @return
     */
    public String getWifiSSID() {
        String ssid = "";
        try {
            WifiManager mWifi = (WifiManager) mContext
                    .getSystemService(Context.WIFI_SERVICE);
            WifiInfo wifiInfo = mWifi.getConnectionInfo();
            ConnectivityManager connec = (ConnectivityManager) mContext
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            if ((connec.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
                    .getState() == NetworkInfo.State.CONNECTED)
                    && wifiInfo.getSSID() != null) {
                ssid = wifiInfo.getSSID();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (TextUtils.isEmpty(ssid))
            return "unknown";
        return ssid;
    }
    /**
     * 获取品牌
     * @return
     */
    public String getModel() {
        return Build.MODEL;
    }

    /**
     * 获取主板
     * @return
     */
    public String getBoard() {
        return Build.BOARD;
    }

    /**
     * 获取网络IP地址(优先获取wifi地址)
     * @return
     */
    public String getIP() {
        WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
        return wifiManager.isWifiEnabled() ? getWifiIP(wifiManager) : getGPRSIP();
    }

    /**
     * 是否wifi
     */
    public boolean isWifi() {
        WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
        return wifiManager.isWifiEnabled();
    }
    /**
     * 获取WIFI连接下的ip地址
     *
     * @param wifiManager
     * @return
     */
    public String getWifiIP(WifiManager wifiManager) {
        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
        String ip = intToIp(wifiInfo.getIpAddress());
        return ip != null ? ip : "";
    }
    private static String intToIp(int i) {
        return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF) + "." + (i >> 24 & 0xFF);
    }
    /**
     * 获取GPRS连接下的ip地址 此方法获取到的是ipv6地址
     *
     * @return
     */
    public 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() && !inetAddress.isLinkLocalAddress()) {
                        ip = inetAddress.getHostAddress();
                    }
                }
            }
        } catch (SocketException e) {
            e.printStackTrace();
            ip = null;
        }
        return ip;
    }

    /*
     * 服务商名称： 例如：中国移动、联通 SIM卡的状态必须是 SIM_STATE_READY(使用getSimState()判断).
     * 中国移动：46000 46002 // 中国联通：46001 // 中国电信：46003 // 举例，一个典型的I
     */
    public String getSimOperatorName() {
        String operator = "";
        try {
            TelephonyManager tm = (TelephonyManager) mContext
                    .getSystemService(Context.TELEPHONY_SERVICE);
            operator = tm.getNetworkOperatorName();
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (TextUtils.isEmpty(operator))
            return "unknown";
        return operator;
    }
    /**
     * 唯一的用户ID： 例如：IMSI(国际移动用户识别码) for a GSM phone. 需要权限：READ_PHONE_STATE
     */
    public String getSimIMSI() {
        String imsi = "";
        try {
            TelephonyManager tm = (TelephonyManager) mContext
                    .getSystemService(Context.TELEPHONY_SERVICE);
            imsi = tm.getSubscriberId();
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (TextUtils.isEmpty(imsi))
            return "unknown";
        return imsi;
    }

    /**
     * SIM卡的串号： 例如： ICCID是卡的标识，IMSI是用户的标识
     * <p>
     * ICCID：Integrate circuit card identity 集成电路卡识别码（固化在SIM卡中）
     * ICCID为IC卡的唯一识别号码，共有20位数字组成，其编码格式为：XXXXXX 0MFSS YYGXX XXXXX。分别介绍如下：
     * 前六位运营商代码：中国移动的为：898600；898602 ，中国联通的为：898601、898606
     * 、898609，中国电信898603，手机SIM卡及卡托上印有iccid号码 需要权限：READ_PHONE_STATE
     */
    @SuppressLint("MissingPermission")
    public String getSimICCID() {
        String iccid = "";
        try {
            TelephonyManager tm = (TelephonyManager) mContext
                    .getSystemService(Context.TELEPHONY_SERVICE);
            iccid = tm.getSimSerialNumber();
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (TextUtils.isEmpty(iccid))
            return "unknown";
        return iccid;
    }

    /**
     * 获取蓝牙是否开启
     * @return
     */
    public boolean getBlueState(){
        BluetoothAdapter blueadapter=BluetoothAdapter.getDefaultAdapter();
        return blueadapter.isEnabled();
    }

    /**
     * 获取闪光灯是否开启
     * @return
     */
    public String getFlashState() {
        Camera mCamera = null;
        try {
            mCamera = Camera.open(0);
            Camera.Parameters mParameters = mCamera.getParameters();
            return mParameters.getFlashMode();
        } catch (Exception e) {

        }
        return "";
    }


    /**
     * 摄像头是否可用
     * @return
     */
    public boolean isCameraCanUse() {

        boolean canUse = false;
        Camera mCamera = null;

        try {
            mCamera = Camera.open(0);
            Camera.Parameters mParameters = mCamera.getParameters();
            mCamera.setParameters(mParameters);
        } catch (Exception e) {
            canUse = false;
        }

        if (mCamera != null) {
            mCamera.release();
            canUse = true;
        }
        return canUse;

    }

    /**
     * 获取wifi强度
     * @return
     */
    public int getWifiLevel() {
        WifiManager wifiManager = (WifiManager) mContext.getSystemService(mContext.WIFI_SERVICE);
        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
        if (wifiInfo.getBSSID() != null) {
            //wifi信号强度
            int signalLevel = WifiManager.calculateSignalLevel(wifiInfo.getRssi(), 5);
            return signalLevel;
        }
        return 0;
    }
    /**
     * 获取wifi速度
     */
    public String getWifiSpeed() {
        WifiManager wifiManager = (WifiManager) mContext.getSystemService(mContext.WIFI_SERVICE);
        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
        if (wifiInfo.getBSSID() != null) {
            //wifi速度
            int speed = wifiInfo.getLinkSpeed();
            //wifi速度单位
            String units = WifiInfo.LINK_SPEED_UNITS;
            return speed+units;
        }
        return "";
    }

    /**
     * 获取版本号
     * @return
     */
    public String getVersionName() {

        PackageManager packageManager = mContext.getPackageManager();
        PackageInfo packInfo = null;
        try {
            packInfo = packageManager.getPackageInfo(mContext.getPackageName(),0);
            String version = packInfo.versionName;
            return version;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return "";
    }
    public String getNetW() {
        ConnectivityManager connManager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
        //如果当前没有网络
        if (null == connManager)
            return NETWORN_NONE;
        //获取当前网络类型，如果为空，返回无网络
        NetworkInfo activeNetInfo = connManager.getActiveNetworkInfo();
        if (activeNetInfo == null || !activeNetInfo.isAvailable()) {
            return NETWORN_NONE;
        }
        // 判断是不是连接的是不是wifi
        NetworkInfo wifiInfo = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        if (null != wifiInfo) {
            NetworkInfo.State state = wifiInfo.getState();
            if (null != state)
                if (state == NetworkInfo.State.CONNECTED
                        || state == NetworkInfo.State.CONNECTING) {
                    return NETWORN_WIFI;
                }else if(state == NetworkInfo.State.DISCONNECTED){
                    return UnCon_WIFI;
                }
        }
        // 如果不是wifi，则判断当前连接的是运营商的哪种网络2g、3g、4g等
        NetworkInfo networkInfo = connManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
        if (null != networkInfo) {
            NetworkInfo.State state = networkInfo.getState();
            String strSubTypeName = networkInfo.getSubtypeName();
            if (null != state)
                if (state == NetworkInfo.State.CONNECTED
                        || state == NetworkInfo.State.CONNECTING) {
                    switch (activeNetInfo.getSubtype()) {
                        //如果是2g类型
                        case TelephonyManager.NETWORK_TYPE_GPRS: // 联通2g
                        case TelephonyManager.NETWORK_TYPE_CDMA: // 电信2g
                        case TelephonyManager.NETWORK_TYPE_EDGE: // 移动2g
                        case TelephonyManager.NETWORK_TYPE_1xRTT:
                        case TelephonyManager.NETWORK_TYPE_IDEN:
                            return NETWORN_2G;
                        //如果是3g类型
                        case TelephonyManager.NETWORK_TYPE_EVDO_A: // 电信3g
                        case TelephonyManager.NETWORK_TYPE_UMTS:
                        case TelephonyManager.NETWORK_TYPE_EVDO_0:
                        case TelephonyManager.NETWORK_TYPE_HSDPA:
                        case TelephonyManager.NETWORK_TYPE_HSUPA:
                        case TelephonyManager.NETWORK_TYPE_HSPA:
                        case TelephonyManager.NETWORK_TYPE_EVDO_B:
                        case TelephonyManager.NETWORK_TYPE_EHRPD:
                        case TelephonyManager.NETWORK_TYPE_HSPAP:
                            return NETWORN_3G;
                        //如果是4g类型
                        case TelephonyManager.NETWORK_TYPE_LTE:
                            return NETWORN_4G;
                        default:
                            //中国移动 联通 电信 三种3G制式
                            if (strSubTypeName.equalsIgnoreCase("TD-SCDMA")
                                    || strSubTypeName.equalsIgnoreCase("WCDMA")
                                    || strSubTypeName.equalsIgnoreCase("CDMA2000")) {
                                return NETWORN_3G;
                            } else {
                                return NETWORN_MOBILE;
                            }
                    }
                }
        }
        NetworkInfo EthernetInfo = connManager.getNetworkInfo(ConnectivityManager.TYPE_ETHERNET);
        if (null != EthernetInfo){
            NetworkInfo.State state = EthernetInfo.getState();
            if (null != state)
                if (state == NetworkInfo.State.CONNECTED || state == NetworkInfo.State.CONNECTING) {
                    return NETWORN_ETHERNET;
                }
        }
        return NETWORN_NONE;
    }

    /**
     * 获取屏幕尺寸
     * @return
     */
    public String getScreenSize() {
        Rect outSize = new Rect();
        ((Activity)mContext).getWindowManager().getDefaultDisplay().getRectSize(outSize);
        int left = outSize.left;
        int top = outSize.top;
        int right = outSize.right;
        int bottom = outSize.bottom;
        return right+"*"+bottom;
    }

    /**
     * 获取状态栏高度 小白屏状态栏高度48
     * @return
     */
    public int getNavigationBarHeight() {
        Resources resources = mContext.getResources();
        int resourceId = resources.getIdentifier("navigation_bar_height","dimen", "android");
        //获取NavigationBar的高度
        int height = resources.getDimensionPixelSize(resourceId);
        return height;
    }

    /**
     * 语言
     */
    public static String getSystemLanguage() {
        return Locale.getDefault().getLanguage();
    }
    /**
     * 获取当前手机系统版本号
     *
     * @return  系统版本号
     */
    public static String getSystemVersion() {
        return android.os.Build.VERSION.RELEASE;
    }
    /**
     * 获取手机型号
     *
     * @return  手机型号
     */
    public static String getSystemModel() {
        return android.os.Build.MODEL;
    }

 /**
     * dp转像素
     * @param context
     * @param dp
     * @return
     */
    public static int Dp2Px(Context context, float dp) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dp * scale + 0.5f);
    }

    /**
     * 像素转dp
     * @param context
     * @param px
     * @return
     */
    public static int Px2Dp(Context context, float px) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (px / scale + 0.5f);
    }

    /**
     * 获取屏幕密度 小白屏密度160
     * @param context
     * @return
     */
    public int getDpi(Context context) {
        DisplayMetrics dm = new DisplayMetrics();
        dm = context.getResources().getDisplayMetrics();
        float density = dm.density;//屏幕密度（像素比例：1.0, 1.5, 2.0,3.0）
        int densityDPI = dm.densityDpi;//屏幕密度（每寸像素：160, 240, 320, 480）
        return densityDPI;
    }
    
}