chenshaodong
/
tidal-air-peisong-android
Volgen 1
Ster 0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Tree: 3f9dcf5dfd
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van '3f9dcf5dfd'
${ noResults }
tidal-air-peisong-android/app/src/main/java/com/example/tidalairpeisong/utils/OSUtils.java

369 lines
18KB
Ruw Blame Geschiedenis 

  1. package com.example.tidalairpeisong.utils;

  2. 

  3. import android.os.Environment;

  4. import android.text.TextUtils;

  5. 

  6. import java.io.File;

  7. import java.io.FileInputStream;

  8. import java.io.IOException;

  9. import java.util.Properties;

  10. import java.util.regex.Matcher;

  11. import java.util.regex.Pattern;

  12. 

  13. /**

  14.  * @ClassName OSUtils

  15.  * @Antuor Administrator

  16.  * @Date 2021/10/12

  17.  * @Version 1.0

  18.  * desc   : 工具类: OS 系统相关

  19.  *              简介  : 由于国内定制系统的泛滥, 不同定制系统的一些功能或实现方法会有所不同, 如果需要做到足够好的适配工作, 需要

  20.  *                      对不同的定制系统做一些专门的适配.

  21.  *              API  : 获取 ROM 类型等

  22.  *

  23.  *  Deprecated :

  24.  *               在工具类中对 ROM 类型进行判断，显得有些力不从心，所以单独创建了新的项目，用于判断 ROM，获取其版本号。

  25.  */

  26. public class OSUtils {

  27.     private static final String KEY_DISPLAY_ID = "ro.build.display.id";

  28.     private static final String KEY_BASE_OS_VERSION = "ro.build.version.base_os";

  29.     private static final String KEY_CLIENT_ID_BASE = "ro.com.google.clientidbase";

  30.     // 小米 : MIUI

  31.     private static final String KEY_MIUI_VERSION = "ro.build.version.incremental"; // "7.6.15"

  32.     private static final String KEY_MIUI_VERSION_NANE = "ro.miui.ui.version.name"; // "V8"

  33.     private static final String KEY_MIUI_VERSION_CODE = "ro.miui.ui.version.code"; // "6"

  34.     private static final String VALUE_MIUI_CLIENT_ID_BASE = "android-xiaomi";

  35.     // 华为 : EMUI

  36.     private static final String KEY_EMUI_VERSION = "ro.build.version.emui"; // "EmotionUI_3.0"

  37.     private static final String KEY_EMUI_API_LEVEL = "ro.build.hw_emui_api_level"; //

  38.     private static final String KEY_EMUI_SYSTEM_VERSION = "ro.confg.hw_systemversion"; //

  39.     // "T1-A21wV100R001C233B008_SYSIMG"

  40.     // 魅族 : Flyme

  41.     private static final String KEY_FLYME_PUBLISHED = "ro.flyme.published"; // "true"

  42.     private static final String KEY_FLYME_SETUP = "ro.meizu.setupwizard.flyme"; // "true"

  43.     private static final String VALUE_FLYME_DISPLAY_ID_CONTAIN = "Flyme"; // "Flyme OS 4.5.4.2U"

  44.     // OPPO : ColorOS

  45.     private static final String KEY_COLOROS_VERSION = "ro.oppo.theme.version"; // "703"

  46.     private static final String KEY_COLOROS_THEME_VERSION = "ro.oppo.version"; // ""

  47.     private static final String KEY_COLOROS_ROM_VERSION = "ro.rom.different.version"; //

  48.     private static final String VALUE_COLOROS_BASE_OS_VERSION_CONTAIN = "OPPO"; // "OPPO/R7sm

  49.     // "ColorOS2.1"

  50.     // /R7sm:5.1.1/LMY47V/1440928800:user/release-keys"

  51.     private static final String VALUE_COLOROS_CLIENT_ID_BASE = "android-oppo";

  52.     // vivo : FuntouchOS

  53.     private static final String KEY_FUNTOUCHOS_BOARD_VERSION = "ro.vivo.board.version"; // "MD"

  54.     private static final String KEY_FUNTOUCHOS_OS_NAME = "ro.vivo.os.name"; // "Funtouch"

  55.     private static final String KEY_FUNTOUCHOS_OS_VERSION = "ro.vivo.os.version"; // "3.0"

  56.     private static final String KEY_FUNTOUCHOS_DISPLAY_ID = "ro.vivo.os.build.display.id"; //

  57.     // "FuntouchOS_3.0"

  58.     private static final String KEY_FUNTOUCHOS_ROM_VERSION = "ro.vivo.rom.version"; // "rom_3.1"

  59.     private static final String VALUE_FUNTOUCHOS_CLIENT_ID_BASE = "android-vivo";

  60.     // Samsung

  61.     private static final String VALUE_SAMSUNG_BASE_OS_VERSION_CONTAIN = "samsung"; // "samsung

  62.     // /zeroltezc/zeroltechn:6.0.1/MMB29K/G9250ZCU2DQD1:user/release-keys"

  63.     private static final String VALUE_SAMSUNG_CLIENT_ID_BASE = "android-samsung";

  64.     // Sony

  65.     private static final String KEY_SONY_PROTOCOL_TYPE = "ro.sony.irremote.protocol_type"; // "2"

  66.     private static final String KEY_SONY_ENCRYPTED_DATA = "ro.sony.fota.encrypteddata"; //

  67.     private static final String VALUE_SONY_CLIENT_ID_BASE = "android-sonyericsson";

  68.     // "supported"

  69.     // 乐视 : eui

  70.     private static final String KEY_EUI_VERSION = "ro.letv.release.version"; // "5.9.023S"

  71.     private static final String KEY_EUI_VERSION_DATE = "ro.letv.release.version_date"; // "5.9

  72.     // .023S_03111"

  73.     private static final String KEY_EUI_NAME = "ro.product.letv_name"; // "乐1s"

  74.     private static final String KEY_EUI_MODEL = "ro.product.letv_model"; // "Letv X500"

  75.     // 金立 : amigo

  76.     private static final String KEY_AMIGO_ROM_VERSION = "ro.gn.gnromvernumber"; // "GIONEE ROM5.0

  77.     // .16"

  78.     private static final String KEY_AMIGO_SYSTEM_UI_SUPPORT = "ro.gn.amigo.systemui.support"; //

  79.     private static final String VALUE_AMIGO_DISPLAY_ID_CONTAIN = "amigo"; // "amigo3.5.1"

  80.     // "yes"

  81.     private static final String VALUE_AMIGO_CLIENT_ID_BASE = "android-gionee";

  82.     // 酷派 : yulong

  83.     private static final String KEY_YULONG_VERSION_RELEASE = "ro.yulong.version.release"; // "5.1

  84.     // .046.P1.150921.8676_M01"

  85.     private static final String KEY_YULONG_VERSION_TAG = "ro.yulong.version.tag"; // "LC"

  86.     private static final String VALUE_YULONG_CLIENT_ID_BASE = "android-coolpad";

  87.     // HTC : Sense

  88.     private static final String KEY_SENSE_BUILD_STAGE = "htc.build.stage"; // "2"

  89.     private static final String KEY_SENSE_BLUETOOTH_SAP = "ro.htc.bluetooth.sap"; // "true"

  90.     private static final String VALUE_SENSE_CLIENT_ID_BASE = "android-htc-rev";

  91.     // LG : LG

  92.     private static final String KEY_LG_SW_VERSION = "ro.lge.swversion"; // "D85720b"

  93.     private static final String KEY_LG_SW_VERSION_SHORT = "ro.lge.swversion_short"; // "V20b"

  94.     private static final String KEY_LG_FACTORY_VERSION = "ro.lge.factoryversion"; // "LGD857AT-00

  95.     // -V20b-CUO-CN-FEB-17-2015+0"

  96.     // 联想

  97.     private static final String KEY_LENOVO_DEVICE = "ro.lenovo.device"; // "phone"

  98.     private static final String KEY_LENOVO_PLATFORM = "ro.lenovo.platform"; // "qualcomm"

  99.     private static final String KEY_LENOVO_ADB = "ro.lenovo.adb"; // "apkctl,speedup"

  100.     private static final String VALUE_LENOVO_CLIENT_ID_BASE = "android-lenovo";

  101.     /**

  102.      * ROM 类型

  103.      */

  104.     private static final ROM ROM_TYPE = initRomType();

  105. 

  106.     /**

  107.      * 获取 ROM 类型

  108.      *

  109.      * @return ROM

  110.      */

  111.     public static ROM getRomType() {

  112.         return ROM_TYPE;

  113.     }

  114. 

  115.     /**

  116.      * 初始化 ROM 类型

  117.      */

  118.     private static ROM initRomType() {

  119.         ROM rom = ROM.Other;

  120.         FileInputStream is = null;

  121.         try {

  122.             Properties buildProperties = new Properties();

  123.             is = new FileInputStream(new File(Environment.getRootDirectory(), "build.prop"));

  124.             buildProperties.load(is);

  125. 

  126.             if (buildProperties.containsKey(KEY_MIUI_VERSION_NANE) || buildProperties.containsKey(KEY_MIUI_VERSION_CODE)) {

  127.                 // MIUI

  128.                 rom = ROM.MIUI;

  129.                 if (buildProperties.containsKey(KEY_MIUI_VERSION_NANE)) {

  130.                     String versionName = buildProperties.getProperty(KEY_MIUI_VERSION_NANE);

  131.                     if (!TextUtils.isEmpty(versionName) && versionName.matches("[Vv]\\d+")) { // V8

  132.                         try {

  133.                             rom.setBaseVersion(Integer.parseInt(versionName.split("[Vv]")[1]));

  134.                         } catch (Exception e) {

  135.                             e.printStackTrace();

  136.                         }

  137.                     }

  138.                 }

  139.                 if (buildProperties.containsKey(KEY_MIUI_VERSION)) {

  140.                     String versionStr = buildProperties.getProperty(KEY_MIUI_VERSION);

  141.                     if (!TextUtils.isEmpty(versionStr) && versionStr.matches("[\\d.]+")) {

  142.                         rom.setVersion(versionStr);

  143.                     }

  144.                 }

  145.             } else if (buildProperties.containsKey(KEY_EMUI_VERSION) || buildProperties.containsKey(KEY_EMUI_API_LEVEL)

  146.                     || buildProperties.containsKey(KEY_EMUI_SYSTEM_VERSION)) {

  147.                 // EMUI

  148.                 rom = ROM.EMUI;

  149.                 if (buildProperties.containsKey(KEY_EMUI_VERSION)) {

  150.                     String versionStr = buildProperties.getProperty(KEY_EMUI_VERSION);

  151.                     Matcher matcher = Pattern.compile("EmotionUI_([\\d.]+)").matcher(versionStr); // EmotionUI_3.0

  152.                     if (!TextUtils.isEmpty(versionStr) && matcher.find()) {

  153.                         try {

  154.                             String version = matcher.group(1);

  155.                             rom.setVersion(version);

  156.                             rom.setBaseVersion(Integer.parseInt(version.split("\\.")[0]));

  157.                         } catch (Exception e) {

  158.                             e.printStackTrace();

  159.                         }

  160.                     }

  161.                 }

  162.             } else if (buildProperties.containsKey(KEY_FLYME_SETUP) || buildProperties.containsKey(KEY_FLYME_PUBLISHED)) {

  163.                 // Flyme

  164.                 rom = ROM.Flyme;

  165.                 if (buildProperties.containsKey(KEY_DISPLAY_ID)) {

  166.                     String versionStr = buildProperties.getProperty(KEY_DISPLAY_ID);

  167.                     Matcher matcher =

  168.                             Pattern.compile("Flyme[^\\d]*([\\d.]+)[^\\d]*").matcher(versionStr);

  169.                     // Flyme OS 4.5.4.2U

  170.                     if (!TextUtils.isEmpty(versionStr) && matcher.find()) {

  171.                         try {

  172.                             String version = matcher.group(1);

  173.                             rom.setVersion(version);

  174.                             rom.setBaseVersion(Integer.parseInt(version.split("\\.")[0]));

  175.                         } catch (Exception e) {

  176.                             e.printStackTrace();

  177.                         }

  178.                     }

  179.                 }

  180.             } else if (buildProperties.containsKey(KEY_COLOROS_VERSION) || buildProperties.containsKey(KEY_COLOROS_THEME_VERSION)

  181.                     || buildProperties.containsKey(KEY_COLOROS_ROM_VERSION)) {

  182.                 // ColorOS

  183.                 rom = ROM.ColorOS;

  184.                 if (buildProperties.containsKey(KEY_COLOROS_ROM_VERSION)) {

  185.                     String versionStr = buildProperties.getProperty(KEY_COLOROS_ROM_VERSION);

  186.                     Matcher matcher = Pattern.compile("ColorOS([\\d.]+)").matcher(versionStr); //

  187.                     // ColorOS2.1

  188.                     if (!TextUtils.isEmpty(versionStr) && matcher.find()) {

  189.                         try {

  190.                             String version = matcher.group(1);

  191.                             rom.setVersion(version);

  192.                             rom.setBaseVersion(Integer.parseInt(version.split("\\.")[0]));

  193.                         } catch (Exception e) {

  194.                             e.printStackTrace();

  195.                         }

  196.                     }

  197.                 }

  198.             } else if (buildProperties.containsKey(KEY_FUNTOUCHOS_OS_NAME) || buildProperties.containsKey(KEY_FUNTOUCHOS_OS_VERSION)

  199.                     || buildProperties.containsKey(KEY_FUNTOUCHOS_DISPLAY_ID)) {

  200.                 // FuntouchOS

  201.                 rom = ROM.FuntouchOS;

  202.                 if (buildProperties.containsKey(KEY_FUNTOUCHOS_OS_VERSION)) {

  203.                     String versionStr = buildProperties.getProperty(KEY_FUNTOUCHOS_OS_VERSION);

  204.                     if (!TextUtils.isEmpty(versionStr) && versionStr.matches("[\\d.]+")) { // 3.0

  205.                         try {

  206.                             rom.setVersion(versionStr);

  207.                             rom.setBaseVersion(Integer.parseInt(versionStr.split("\\.")[0]));

  208.                         } catch (Exception e) {

  209.                             e.printStackTrace();

  210.                         }

  211.                     }

  212.                 }

  213.             } else if (buildProperties.containsKey(KEY_EUI_VERSION) || buildProperties.containsKey(KEY_EUI_NAME)

  214.                     || buildProperties.containsKey(KEY_EUI_MODEL)) {

  215.                 // EUI

  216.                 rom = ROM.EUI;

  217.                 if (buildProperties.containsKey(KEY_EUI_VERSION)) {

  218.                     String versionStr = buildProperties.getProperty(KEY_EUI_VERSION);

  219.                     Matcher matcher = Pattern.compile("([\\d.]+)[^\\d]*").matcher(versionStr); //

  220.                     // 5.9.023S

  221.                     if (!TextUtils.isEmpty(versionStr) && matcher.find()) {

  222.                         try {

  223.                             String version = matcher.group(1);

  224.                             rom.setVersion(version);

  225.                             rom.setBaseVersion(Integer.parseInt(version.split("\\.")[0]));

  226.                         } catch (Exception e) {

  227.                             e.printStackTrace();

  228.                         }

  229.                     }

  230.                 }

  231.             } else if (buildProperties.containsKey(KEY_AMIGO_ROM_VERSION) || buildProperties.containsKey(KEY_AMIGO_SYSTEM_UI_SUPPORT)) {

  232.                 // amigo

  233.                 rom = ROM.AmigoOS;

  234.                 if (buildProperties.containsKey(KEY_DISPLAY_ID)) {

  235.                     String versionStr = buildProperties.getProperty(KEY_DISPLAY_ID);

  236.                     Matcher matcher =

  237.                             Pattern.compile("amigo([\\d.]+)[a-zA-Z]*").matcher(versionStr); //

  238.                     // "amigo3.5.1"

  239.                     if (!TextUtils.isEmpty(versionStr) && matcher.find()) {

  240.                         try {

  241.                             String version = matcher.group(1);

  242.                             rom.setVersion(version);

  243.                             rom.setBaseVersion(Integer.parseInt(version.split("\\.")[0]));

  244.                         } catch (Exception e) {

  245.                             e.printStackTrace();

  246.                         }

  247.                     }

  248.                 }

  249.             } else if (buildProperties.containsKey(KEY_SONY_PROTOCOL_TYPE) || buildProperties.containsKey(KEY_SONY_ENCRYPTED_DATA)) {

  250.                 // Sony

  251.                 rom = ROM.Sony;

  252.             } else if (buildProperties.containsKey(KEY_YULONG_VERSION_RELEASE) || buildProperties.containsKey(KEY_YULONG_VERSION_TAG)) {

  253.                 // YuLong

  254.                 rom = ROM.YuLong;

  255.             } else if (buildProperties.containsKey(KEY_SENSE_BUILD_STAGE) || buildProperties.containsKey(KEY_SENSE_BLUETOOTH_SAP)) {

  256.                 // Sense

  257.                 rom = ROM.Sense;

  258.             } else if (buildProperties.containsKey(KEY_LG_SW_VERSION) || buildProperties.containsKey(KEY_LG_SW_VERSION_SHORT)

  259.                     || buildProperties.containsKey(KEY_LG_FACTORY_VERSION)) {

  260.                 // LG

  261.                 rom = ROM.LG;

  262.             } else if (buildProperties.containsKey(KEY_LENOVO_DEVICE) || buildProperties.containsKey(KEY_LENOVO_PLATFORM)

  263.                     || buildProperties.containsKey(KEY_LENOVO_ADB)) {

  264.                 // Lenovo

  265.                 rom = ROM.Lenovo;

  266.             } else if (buildProperties.containsKey(KEY_DISPLAY_ID)) {

  267.                 String displayId = buildProperties.getProperty(KEY_DISPLAY_ID);

  268.                 if (!TextUtils.isEmpty(displayId)) {

  269.                     if (displayId.contains(VALUE_FLYME_DISPLAY_ID_CONTAIN)) {

  270.                         return ROM.Flyme;

  271.                     } else if (displayId.contains(VALUE_AMIGO_DISPLAY_ID_CONTAIN)) {

  272.                         return ROM.AmigoOS;

  273.                     }

  274.                 }

  275.             } else if (buildProperties.containsKey(KEY_BASE_OS_VERSION)) {

  276.                 String baseOsVersion = buildProperties.getProperty(KEY_BASE_OS_VERSION);

  277.                 if (!TextUtils.isEmpty(baseOsVersion)) {

  278.                     if (baseOsVersion.contains(VALUE_COLOROS_BASE_OS_VERSION_CONTAIN)) {

  279.                         return ROM.ColorOS;

  280.                     } else if (baseOsVersion.contains(VALUE_SAMSUNG_BASE_OS_VERSION_CONTAIN)) {

  281.                         return ROM.SamSung;

  282.                     }

  283.                 }

  284.             } else if (buildProperties.containsKey(KEY_CLIENT_ID_BASE)) {

  285.                 String clientIdBase = buildProperties.getProperty(KEY_CLIENT_ID_BASE);

  286.                 switch (clientIdBase) {

  287.                     case VALUE_MIUI_CLIENT_ID_BASE:

  288.                         return ROM.MIUI;

  289.                     case VALUE_COLOROS_CLIENT_ID_BASE:

  290.                         return ROM.ColorOS;

  291.                     case VALUE_FUNTOUCHOS_CLIENT_ID_BASE:

  292.                         return ROM.FuntouchOS;

  293.                     case VALUE_SAMSUNG_CLIENT_ID_BASE:

  294.                         return ROM.SamSung;

  295.                     case VALUE_SONY_CLIENT_ID_BASE:

  296.                         return ROM.Sony;

  297.                     case VALUE_YULONG_CLIENT_ID_BASE:

  298.                         return ROM.YuLong;

  299.                     case VALUE_SENSE_CLIENT_ID_BASE:

  300.                         return ROM.Sense;

  301.                     case VALUE_LENOVO_CLIENT_ID_BASE:

  302.                         return ROM.Lenovo;

  303.                     case VALUE_AMIGO_CLIENT_ID_BASE:

  304.                         return ROM.AmigoOS;

  305.                     default:

  306.                         break;

  307.                 }

  308.             }

  309. 

  310.         } catch (IOException e) {

  311.             e.printStackTrace();

  312.         } finally {

  313.             if (is != null) {

  314.                 try {

  315.                     is.close();

  316.                 } catch (IOException e) {

  317.                     e.printStackTrace();

  318.                 }

  319.             }

  320.         }

  321.         return rom;

  322.     }

  323. 

  324.     public enum ROM {

  325.         MIUI, // 小米

  326.         Flyme, // 魅族

  327.         EMUI, // 华为

  328.         ColorOS, // OPPO

  329.         FuntouchOS, // vivo

  330.         SmartisanOS, // 锤子

  331.         EUI, // 乐视

  332.         Sense, // HTC

  333.         AmigoOS, // 金立

  334.         _360OS, // 奇酷360

  335.         NubiaUI, // 努比亚

  336.         H2OS, // 一加

  337.         YunOS, // 阿里巴巴

  338.         YuLong, // 酷派

  339. 

  340.         SamSung, // 三星

  341.         Sony, // 索尼

  342.         Lenovo, // 联想

  343.         LG, // LG

  344. 

  345.         Google, // 原生

  346. 

  347.         Other; // CyanogenMod, Lewa OS, 百度云OS, Tencent OS, 深度OS, IUNI OS, Tapas OS, Mokee

  348. 

  349.         private int baseVersion = -1;

  350.         private String version;

  351. 

  352.         public int getBaseVersion() {

  353.             return baseVersion;

  354.         }

  355. 

  356.         void setBaseVersion(int baseVersion) {

  357.             this.baseVersion = baseVersion;

  358.         }

  359. 

  360.         public String getVersion() {

  361.             return version;

  362.         }

  363. 

  364.         void setVersion(String version) {

  365.             this.version = version;

  366.         }

  367.     }

  368. }