Android 设备有唯一的 ID 吗？

Question

Android 设备是否有唯一的 ID？如果有，使用 Java 访问它的简单方法是什么？

Answer 1

在 Google I/O 上，Reto Meier 发布了关于如何解决此问题的可靠答案，这应该可以满足大多数开发人员跟踪的需求跨安装的用户。安东尼·诺兰在他的答案中展示了方向，但我想我应该写出完整的方法，以便其他人可以轻松地了解如何做到这一点（我花了一段时间才弄清楚细节）。

这种方法将为您提供一个匿名、安全的用户 ID，该 ID 对于用户在不同设备（基于主要 Google 帐户）和安装之间的持久性。基本方法是生成随机用户 ID 并将其存储在应用程序的共享首选项中。然后，您可以使用 Google 的备份代理将链接到云中 Google 帐户的共享首选项存储起来。

让我们看一下完整的方法。首先，我们需要使用 Android 备份服务为 SharedPreferences 创建备份。首先通过 http://developer.android.com/google/backup/signup.html 注册您的应用。

Google 将为您提供一个备份服务密钥，您需要将其添加到清单中。您还需要告诉应用程序使用 BackupAgent，如下所示：

<application android:label="MyApplication"
         android:backupAgent="MyBackupAgent">
    ...
    <meta-data android:name="com.google.android.backup.api_key"
        android:value="your_backup_service_key" />
</application>

然后您需要创建备份代理并告诉它使用共享首选项的帮助代理：

public class MyBackupAgent extends BackupAgentHelper {
    // The name of the SharedPreferences file
    static final String PREFS = "user_preferences";

    // A key to uniquely identify the set of backup data
    static final String PREFS_BACKUP_KEY = "prefs";

    // Allocate a helper and add it to the backup agent
    @Override
    public void onCreate() {
        SharedPreferencesBackupHelper helper = new SharedPreferencesBackupHelper(this,          PREFS);
        addHelper(PREFS_BACKUP_KEY, helper);
    }
}

要完成备份，您需要在主 Activity 中创建 BackupManager 的实例：

BackupManager backupManager = new BackupManager(context);

最后创建一个用户 ID（如果尚不存在），并将其存储在 SharedPreferences 中：

  public static String getUserID(Context context) {
            private static String uniqueID = null;
        private static final String PREF_UNIQUE_ID = "PREF_UNIQUE_ID";
    if (uniqueID == null) {
        SharedPreferences sharedPrefs = context.getSharedPreferences(
                MyBackupAgent.PREFS, Context.MODE_PRIVATE);
        uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
        if (uniqueID == null) {
            uniqueID = UUID.randomUUID().toString();
            Editor editor = sharedPrefs.edit();
            editor.putString(PREF_UNIQUE_ID, uniqueID);
            editor.commit();

            //backup the changes
            BackupManager mBackupManager = new BackupManager(context);
            mBackupManager.dataChanged();
        }
    }

    return uniqueID;
}

此 User_ID 现在将在各个安装中保持不变，即使用户移动设备也是如此。

有关此方法的详细信息，请参阅 雷托的谈话。

有关如何实现备份代理的完整详细信息，请参阅数据备份。我特别推荐底部有关测试的部分，因为备份不会立即发生，因此要测试您必须强制备份。

Answer 2

我认为这是为唯一 ID 构建骨架的可靠方法...检查一下。

伪唯一 ID，适用于所有 Android 设备
有些设备没有手机（例如平板电脑），或者由于某种原因，您不想包含 READ_PHONE_STATE 权限。您仍然可以读取 ROM 版本、制造商名称、CPU 类型和其他硬件详细信息等详细信息，如果您想将 ID 用于串行密钥检查或其他一般用途，这些信息将非常适合。以这种方式计算的 ID 不会是唯一的：可以找到具有相同 ID 的两个设备（基于相同的硬件和 ROM 映像），但实际应用程序中的变化可以忽略不计。为此，您可以使用 Build 类：

String m_szDevIDShort = "35" + //we make this look like a valid IMEI
            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

大多数 Build 成员都是字符串，我们在这里所做的是获取它们的长度并通过数字模进行转换。我们有 13 个这样的数字，并且在前面添加了两个数字 (35)，以使其 ID 大小与 IMEI（15 位数字）相同。这里还有其他可能性，只需看看这些字符串即可。
返回类似 355715565309247 的内容。不需要特殊许可，使得这种方法非常方便。

---

（额外信息：上面给出的技术是从 Pocket Magic 上的一篇文章复制的。）

Answer 3

以下代码使用隐藏的 Android API 返回设备序列号。但是，此代码不适用于 Samsung Galaxy Tab，因为此设备上未设置“ro.serialno”。

String serial = null;

try {
    Class<?> c = Class.forName("android.os.SystemProperties");
    Method get = c.getMethod("get", String.class);
    serial = (String) get.invoke(c, "ro.serialno");
}
catch (Exception ignored) {

}

Answer 4

使用下面的代码，您可以获取 Android 操作系统设备的唯一设备 ID 作为字符串。

deviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID); 

Answer 5

我要补充的一件事是——我遇到了其中一种独特的情况。

使用：

deviceId = Secure.getString(this.getContext().getContentResolver(), Secure.ANDROID_ID);

事实证明，即使我的 Viewsonic G Tablet 报告的 DeviceID 不为 Null，但每台 G Tablet 都报告相同的编号。

玩“Pocket Empires”会很有趣，它可以让您根据“唯一”DeviceID 即时访问某人的帐户。

我的设备没有手机无线电。

Answer 6

Serial 字段已添加到 Build API 级别 9 中的类（Android 2.3 - Gingerbread）。文档称它代表硬件序列号。因此，如果它存在于设备上，它应该是唯一的。

我不知道 API 级别 >= 9 的所有设备是否真正支持它（=not null）。

Answer 7

有关如何获取安装应用程序的每个 Android 设备的唯一标识符的详细说明，请参阅官方 Android 开发人员博客文章 识别应用程序安装。

似乎最好的方法是您在安装时自己生成一个，然后在应用程序重新启动时读取它。

我个人认为这是可以接受的，但并不理想。 Android 提供的任何标识符都不适用于所有情况，因为大多数标识符取决于手机的无线电状态（Wi-Fi 开/关、蜂窝网络开/关、蓝牙开/关）。其他的，例如 Settings.Secure.ANDROID_ID 必须由制造商实现，并且不保证是唯一的。

以下是将数据写入安装文件的示例，该文件将与应用程序在本地保存的任何其他数据一起存储。

public class Installation {
    private static String sID = null;
    private static final String INSTALLATION = "INSTALLATION";

    public synchronized static String id(Context context) {
        if (sID == null) {
            File installation = new File(context.getFilesDir(), INSTALLATION);
            try {
                if (!installation.exists())
                    writeInstallationFile(installation);
                sID = readInstallationFile(installation);
            } 
            catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return sID;
    }

    private static String readInstallationFile(File installation) throws IOException {
        RandomAccessFile f = new RandomAccessFile(installation, "r");
        byte[] bytes = new byte[(int) f.length()];
        f.readFully(bytes);
        f.close();
        return new String(bytes);
    }

    private static void writeInstallationFile(File installation) throws IOException {
        FileOutputStream out = new FileOutputStream(installation);
        String id = UUID.randomUUID().toString();
        out.write(id.getBytes());
        out.close();
    }
}

Answer 8

在类文件中添加以下代码：

final TelephonyManager tm = (TelephonyManager) getBaseContext()
            .getSystemService(SplashActivity.TELEPHONY_SERVICE);
    final String tmDevice, tmSerial, androidId;
    tmDevice = "" + tm.getDeviceId();
    Log.v("DeviceIMEI", "" + tmDevice);
    tmSerial = "" + tm.getSimSerialNumber();
    Log.v("GSM devices Serial Number[simcard] ", "" + tmSerial);
    androidId = "" + android.provider.Settings.Secure.getString(getContentResolver(),
            android.provider.Settings.Secure.ANDROID_ID);
    Log.v("androidId CDMA devices", "" + androidId);
    UUID deviceUuid = new UUID(androidId.hashCode(),
            ((long) tmDevice.hashCode() << 32) | tmSerial.hashCode());
    String deviceId = deviceUuid.toString();
    Log.v("deviceIdUUID universally unique identifier", "" + deviceId);
    String deviceModelName = android.os.Build.MODEL;
    Log.v("Model Name", "" + deviceModelName);
    String deviceUSER = android.os.Build.USER;
    Log.v("Name USER", "" + deviceUSER);
    String devicePRODUCT = android.os.Build.PRODUCT;
    Log.v("PRODUCT", "" + devicePRODUCT);
    String deviceHARDWARE = android.os.Build.HARDWARE;
    Log.v("HARDWARE", "" + deviceHARDWARE);
    String deviceBRAND = android.os.Build.BRAND;
    Log.v("BRAND", "" + deviceBRAND);
    String myVersion = android.os.Build.VERSION.RELEASE;
    Log.v("VERSION.RELEASE", "" + myVersion);
    int sdkVersion = android.os.Build.VERSION.SDK_INT;
    Log.v("VERSION.SDK_INT", "" + sdkVersion);

在AndroidManifest.xml中添加：

<uses-permission android:name="android.permission.READ_PHONE_STATE" />

Answer 9

有很多不同的方法可以解决这些 ANDROID_ID 问题（有时可能为 null 或者特定型号的设备总是返回相同的 ID），各有利弊

• ：自定义 ID 生成算法（基于应该是静态且不会更改的设备属性 -> 谁知道）
• 滥用其他 ID，例如 IMEI、序列号、Wi-Fi/蓝牙 MAC 地址（它们不会存在于所有设备上，或者需要额外的权限）

我自己更喜欢使用现有的 OpenUDID 实现（请参阅https://github.com/ylechelle/OpenUDID）适用于 Android（请参阅 https://github.com/vieux/OpenUDID）。它很容易集成并利用 ANDROID_ID 以及针对上述问题的后备方案。

Answer 10

我的两分钱 - 注意，这是针对设备（错误）唯一 ID - 不是 Android 开发者博客。

值得注意的是，@emmby 提供的解决方案会回退到每个应用程序 ID，因为 SharedPreferences 未跨进程同步（请参阅此处和此处）。所以我完全避免了这种情况。

相反，我将获取（设备）ID 的各种策略封装在枚举中 - 更改枚举常量的顺序会影响获取 ID 的各种方式的优先级。返回第一个非 null ID 或引发异常（按照不赋予 null 含义的良好 Java 实践）。例如，我首先有 TELEPHONY - 但一个好的默认选择是 ANDROID_ID
测试版：

import android.Manifest.permission;
import android.bluetooth.BluetoothAdapter;
import android.content.Context;
import android.content.pm.PackageManager;
import android.net.wifi.WifiManager;
import android.provider.Settings.Secure;
import android.telephony.TelephonyManager;
import android.util.Log;

// TODO : hash
public final class DeviceIdentifier {

    private DeviceIdentifier() {}

    /** @see http://code.google.com/p/android/issues/detail?id=10603 */
    private static final String ANDROID_ID_BUG_MSG = "The device suffers from "
        + "the Android ID bug - its ID is the emulator ID : "
        + IDs.BUGGY_ANDROID_ID;
    private static volatile String uuid; // volatile needed - see EJ item 71
    // need lazy initialization to get a context

    /**
     * Returns a unique identifier for this device. The first (in the order the
     * enums constants as defined in the IDs enum) non null identifier is
     * returned or a DeviceIDException is thrown. A DeviceIDException is also
     * thrown if ignoreBuggyAndroidID is false and the device has the Android ID
     * bug
     *
     * @param ctx
     *            an Android constant (to retrieve system services)
     * @param ignoreBuggyAndroidID
     *            if false, on a device with the android ID bug, the buggy
     *            android ID is not returned instead a DeviceIDException is
     *            thrown
     * @return a *device* ID - null is never returned, instead a
     *         DeviceIDException is thrown
     * @throws DeviceIDException
     *             if none of the enum methods manages to return a device ID
     */
    public static String getDeviceIdentifier(Context ctx,
            boolean ignoreBuggyAndroidID) throws DeviceIDException {
        String result = uuid;
        if (result == null) {
            synchronized (DeviceIdentifier.class) {
                result = uuid;
                if (result == null) {
                    for (IDs id : IDs.values()) {
                        try {
                            result = uuid = id.getId(ctx);
                        } catch (DeviceIDNotUniqueException e) {
                            if (!ignoreBuggyAndroidID)
                                throw new DeviceIDException(e);
                        }
                        if (result != null) return result;
                    }
                    throw new DeviceIDException();
                }
            }
        }
        return result;
    }

    private static enum IDs {
        TELEPHONY_ID {

            @Override
            String getId(Context ctx) {
                // TODO : add a SIM based mechanism ? tm.getSimSerialNumber();
                final TelephonyManager tm = (TelephonyManager) ctx
                        .getSystemService(Context.TELEPHONY_SERVICE);
                if (tm == null) {
                    w("Telephony Manager not available");
                    return null;
                }
                assertPermission(ctx, permission.READ_PHONE_STATE);
                return tm.getDeviceId();
            }
        },
        ANDROID_ID {

            @Override
            String getId(Context ctx) throws DeviceIDException {
                // no permission needed !
                final String andoidId = Secure.getString(
                    ctx.getContentResolver(),
                    android.provider.Settings.Secure.ANDROID_ID);
                if (BUGGY_ANDROID_ID.equals(andoidId)) {
                    e(ANDROID_ID_BUG_MSG);
                    throw new DeviceIDNotUniqueException();
                }
                return andoidId;
            }
        },
        WIFI_MAC {

            @Override
            String getId(Context ctx) {
                WifiManager wm = (WifiManager) ctx
                        .getSystemService(Context.WIFI_SERVICE);
                if (wm == null) {
                    w("Wifi Manager not available");
                    return null;
                }
                assertPermission(ctx, permission.ACCESS_WIFI_STATE); // I guess
                // getMacAddress() has no java doc !!!
                return wm.getConnectionInfo().getMacAddress();
            }
        },
        BLUETOOTH_MAC {

            @Override
            String getId(Context ctx) {
                BluetoothAdapter ba = BluetoothAdapter.getDefaultAdapter();
                if (ba == null) {
                    w("Bluetooth Adapter not available");
                    return null;
                }
                assertPermission(ctx, permission.BLUETOOTH);
                return ba.getAddress();
            }
        }
        // TODO PSEUDO_ID
        // http://www.pocketmagic.net/2011/02/android-unique-device-id/
        ;

        static final String BUGGY_ANDROID_ID = "9774d56d682e549c";
        private final static String TAG = IDs.class.getSimpleName();

        abstract String getId(Context ctx) throws DeviceIDException;

        private static void w(String msg) {
            Log.w(TAG, msg);
        }

        private static void e(String msg) {
            Log.e(TAG, msg);
        }
    }

    private static void assertPermission(Context ctx, String perm) {
        final int checkPermission = ctx.getPackageManager().checkPermission(
            perm, ctx.getPackageName());
        if (checkPermission != PackageManager.PERMISSION_GRANTED) {
            throw new SecurityException("Permission " + perm + " is required");
        }
    }

    // =========================================================================
    // Exceptions
    // =========================================================================
    public static class DeviceIDException extends Exception {

        private static final long serialVersionUID = -8083699995384519417L;
        private static final String NO_ANDROID_ID = "Could not retrieve a "
            + "device ID";

        public DeviceIDException(Throwable throwable) {
            super(NO_ANDROID_ID, throwable);
        }

        public DeviceIDException(String detailMessage) {
            super(detailMessage);
        }

        public DeviceIDException() {
            super(NO_ANDROID_ID);
        }
    }

    public static final class DeviceIDNotUniqueException extends
            DeviceIDException {

        private static final long serialVersionUID = -8940090896069484955L;

        public DeviceIDNotUniqueException() {
            super(ANDROID_ID_BUG_MSG);
        }
    }
}

Answer 11

这里有 30 多个答案，有些是相同的，有些是独特的。这个答案是基于其中的一些答案。其中之一是@Lenn Dolling 的回答。

它组合 3 个 ID 并创建一个 32 位十六进制字符串。它对我来说非常有效。

3 个 ID 是：
伪ID - 根据物理设备规格生成
ANDROID_ID - Settings.Secure.ANDROID_ID
蓝牙地址 - 蓝牙适配器地址

它将返回如下内容：551F27C060712A72730B0A0F734064B1

注意：您始终可以向longId 字符串添加更多ID。例如，序列号。 wifi 适配器地址。 IMEI。通过这种方式，您可以使其在每个设备上变得更加独特。

@SuppressWarnings("deprecation")
@SuppressLint("HardwareIds")
public static String generateDeviceIdentifier(Context context) {

        String pseudoId = "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;

        String androidId = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);

        BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        String btId = "";

        if (bluetoothAdapter != null) {
            btId = bluetoothAdapter.getAddress();
        }

        String longId = pseudoId + androidId + btId;

        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            messageDigest.update(longId.getBytes(), 0, longId.length());

            // get md5 bytes
            byte md5Bytes[] = messageDigest.digest();

            // creating a hex string
            String identifier = "";

            for (byte md5Byte : md5Bytes) {
                int b = (0xFF & md5Byte);

                // if it is a single digit, make sure it have 0 in front (proper padding)
                if (b <= 0xF) {
                    identifier += "0";
                }

                // add number to string
                identifier += Integer.toHexString(b);
            }

            // hex string to uppercase
            identifier = identifier.toUpperCase();
            return identifier;
        } catch (Exception e) {
            Log.e("TAG", e.toString());
        }
        return "";
}

Answer 12

IMEI 怎么样。这对于 Android 或其他移动设备来说是独一无二的。

Answer 13

Android 操作系统设备的唯一设备 ID 作为字符串，使用 TelephonyManager 和 ANDROID_ID 获取：

String deviceId;
final TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
if (mTelephony.getDeviceId() != null) {
    deviceId = mTelephony.getDeviceId();
}
else {
    deviceId = Secure.getString(
                   getApplicationContext().getContentResolver(),
                   Secure.ANDROID_ID);
}

但我强烈推荐 Google 建议的方法，请参阅< a href="http://android-developers.blogspot.mx/2011/03/identifying-app-installations.html" rel="noreferrer">识别应用程序安装。

Answer 14

以下是我生成唯一 id 的方法：

public static String getDeviceId(Context ctx)
{
    TelephonyManager tm = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);

    String tmDevice = tm.getDeviceId();
    String androidId = Secure.getString(ctx.getContentResolver(), Secure.ANDROID_ID);
    String serial = null;
    if(Build.VERSION.SDK_INT > Build.VERSION_CODES.FROYO) serial = Build.SERIAL;

    if(tmDevice != null) return "01" + tmDevice;
    if(androidId != null) return "02" + androidId;
    if(serial != null) return "03" + serial;
    // other alternatives (i.e. Wi-Fi MAC, Bluetooth MAC, etc.)

    return null;
}

Answer 15

另一种方法是在应用程序中使用 /sys/class/android_usb/android0/iSerial 而无需任何权限。

user@creep:~$ adb shell ls -l /sys/class/android_usb/android0/iSerial
-rw-r--r-- root     root         4096 2013-01-10 21:08 iSerial
user@creep:~$ adb shell cat /sys/class/android_usb/android0/iSerial
0A3CXXXXXXXXXX5

要在 Java 中执行此操作，只需使用 FileInputStream 打开 iSerial 文件并读出字符。请确保将其包装在异常处理程序中，因为并非所有设备都有此文件。

至少已知以下设备具有此文件：

• Galaxy Nexus
• Nexus S
• Motorola Xoom 3G
• Toshiba AT300
• HTC One V
• Mini MK802
• Samsung Galaxy S II

您还可以查看我的博客文章 将 Android 硬件序列号泄露给非特权应用，我在其中讨论了什么其他文件可供参考。

Answer 16

对于特定 Android 设备的硬件识别，您可以检查 MAC 地址。

你可以这样做：

在 AndroidManifest.xml

现在在你的代码中：

List<NetworkInterface> interfacesList = Collections.list(NetworkInterface.getNetworkInterfaces());

for (NetworkInterface interface : interfacesList) {
   // This will give you the interface MAC ADDRESS
   interface.getHardwareAddress();
}

在每个 Android 设备中，它们至少是“wlan0”接口是 WI-FI 芯片。
即使 WI-FI 未打开，此代码也能工作。

聚苯乙烯
您可以从包含 MACS 的列表中获得许多其他接口，但这可能会在手机之间发生变化。

Answer 17

当设备不具备电话功能时，我使用以下代码获取 IMEI 或使用 Secure.ANDROID_ID 作为替代方案：

String identifier = null;
TelephonyManager tm = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE));
if (tm != null)
      identifier = tm.getDeviceId();
if (identifier == null || identifier .length() == 0)
      identifier = Secure.getString(activity.getContentResolver(),Secure.ANDROID_ID);

Answer 18

TelephonyManger.getDeviceId() 返回唯一的设备 ID，例如 GSM 的 IMEI 和 CDMA 手机的 MEID 或 ESN。

final TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);            
String myAndroidDeviceId = mTelephony.getDeviceId(); 

但我建议使用：

Settings.Secure.ANDROID_ID，它将 Android ID 作为唯一的 64 位十六进制字符串返回。

    String   myAndroidDeviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID); 

有时 TelephonyManger.getDeviceId() 将返回 null，因此为了确保唯一的 id，您将使用此方法：

public String getUniqueID(){    
    String myAndroidDeviceId = "";
    TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
    if (mTelephony.getDeviceId() != null){
        myAndroidDeviceId = mTelephony.getDeviceId(); 
    }else{
         myAndroidDeviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID); 
    }
    return myAndroidDeviceId;
}

Answer 19

Google 实例 ID

在 I/O 2015 上发布；在 Android 上需要播放服务 7.5。

https://developers.google.com/instance-id/
https://developers.google.com/instance-id/guides/android-implementation

InstanceID iid = InstanceID.getInstance( context );   // Google docs are wrong - this requires context
String id = iid.getId();  // blocking call

Google 似乎打算使用此 ID 来识别 Android、Chrome 和 iOS 上的安装。

它标识的是安装而不是设备，但话又说回来，ANDROID_ID（这是公认的答案）现在也不再标识设备。使用 ARC 运行时，每次安装都会生成新的 ANDROID_ID (详细信息此处），就像这个新实例 ID 一样。另外，我认为识别安装（而不是设备）是我们大多数人实际上正在寻找的。

实例 ID 的优点

在我看来，Google 打算将其用于此目的（识别您的安装），它是跨平台的，并且可用于许多其他目的（请参阅上面的链接）。

如果您使用 GCM，那么您最终将需要使用此实例 ID，因为您需要它才能获取 GCM 令牌（取代旧的 GCM 注册 ID）。

缺点/问题

在当前实现 (GPS 7.5) 中，当您的应用请求实例 ID 时，会从服务器检索实例 ID。这意味着上面的调用是一个阻塞调用 - 在我不科学的测试中，如果设备在线，则需要 1-3 秒，如果离线则需要 0.5 - 1.0 秒（大概这是它在放弃并生成一个之前等待的时间）随机 ID）。这是在北美使用 Android 5.1.1 和 GPS 7.5 的 Nexus 5 进行测试的。

如果您将 ID 用于他们预期的目的 - 例如。应用程序身份验证、应用程序识别、GCM - 我认为这 1-3 秒可能会很麻烦（当然取决于您的应用程序）。

Answer 20

借助以下函数获取设备设备 UUID、带有品牌名称的型号及其版本号。

在 Android 10 中完美运行，无需允许读取手机状态权限。

代码片段：

private void fetchDeviceInfo() {
    String uniquePseudoID = "35" +
            Build.BOARD.length() % 10 +
            Build.BRAND.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;

    String serial = Build.getRadioVersion();
    String uuid=new UUID(uniquePseudoID.hashCode(), serial.hashCode()).toString();
    String brand=Build.BRAND;
    String modelno=Build.MODEL;
    String version=Build.VERSION.RELEASE;
    Log.e(TAG, "fetchDeviceInfo: \n "+
            "\n uuid is : "+uuid+
            "\n brand is: "+brand+
            "\n model is: "+modelno+
            "\n version is: "+version);
}

调用上述函数并检查上述代码的输出。请在 android studio 中查看您的日志猫。它如下所示：

Answer 21

Google 现在拥有广告 ID。
这也可以使用，但要注意：

广告ID是特定于用户的、唯一的、可重置的ID

ID

使用户能够重置其标识符或选择退出 Google Play 应用中基于兴趣的广告。

因此，尽管这个 id 可能会改变，但似乎很快就会 我们可能别无选择，具体取决于此 ID 的用途。

更多信息@develper.android

在此处复制粘贴代码

HTH

Answer 22

Settings.Secure#ANDROID_ID 以每个用户唯一的 Android ID 返回< /a> 64 位十六进制字符串。

import android.provider.Settings.Secure;

private String android_id = Secure.getString(getContext().getContentResolver(),
                                                        Secure.ANDROID_ID);

另请阅读唯一标识符的最佳实践：https:// developer.android.com/training/articles/user-data-ids

Answer 23

更新：从最新版本的 Android 开始，ANDROID_ID 的许多问题已得到解决，我相信不再需要这种方法。请查看安东尼的回答。

完全披露：我的应用程序最初使用以下方法，但不再使用此方法，我们现在使用 Android 开发者博客 条目，emmby 的回答 链接到（即，生成并保存 UUID#randomUUID()）。

---

这个问题有很多答案，其中大多数只能在“某些”时间起作用，不幸的是，这还不够好。

根据我对设备的测试（所有手机，至少其中一部未激活）：

1. 所有测试的设备均返回 TelephonyManager.getDeviceId() 的值
2. 所有 GSM 设备（均使用 SIM 卡进行测试）均返回TelephonyManager.getSimSerialNumber() 的值
3. 所有 CDMA 设备都为 getSimSerialNumber() 返回 null（如预期）
4. 所有添加了 Google 帐户的设备都返回 ANDROID_ID 的值
5. 所有 CDMA 设备都为 ANDROID_ID 和 TelephonyManager.getDeviceId() 返回相同的值（或相同值的派生值） - 只要 在设置过程中已添加 Google 帐户。
6. 我还没有机会测试没有 SIM 卡的 GSM 设备、没有添加 Google 帐户的 GSM 设备或任何处于飞行模式的设备。

因此，如果您想要设备本身独有的东西，TM.getDeviceId()应该就足够了。显然，某些用户比其他用户更加偏执，因此对这些标识符中的 1 个或多个进行哈希处理可能会很有用，这样该字符串实际上对于设备来说仍然是唯一的，但不会明确标识用户的实际设备。例如，使用 String.hashCode() 与 UUID: 结合使用

final TelephonyManager tm = (TelephonyManager) getBaseContext().getSystemService(Context.TELEPHONY_SERVICE);

final String tmDevice, tmSerial, androidId;
tmDevice = "" + tm.getDeviceId();
tmSerial = "" + tm.getSimSerialNumber();
androidId = "" + android.provider.Settings.Secure.getString(getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);

UUID deviceUuid = new UUID(androidId.hashCode(), ((long)tmDevice.hashCode() << 32) | tmSerial.hashCode());
String deviceId = deviceUuid.toString();

可能会产生如下结果： 00000000-54b3-e7c7-0000-000046bffd97

它对我来说足够好了。

正如 Richard 在下面提到的，不要忘记您需要读取 TelephonyManager 属性的权限，因此将其添加到您的清单中：

<uses-permission android:name="android.permission.READ_PHONE_STATE" />

导入库

import android.content.Context;
import android.telephony.TelephonyManager;
import android.view.View;

Answer 24

#最后更新时间：2015 年 6 月 2 日

---

在阅读了所有关于创建唯一 ID 的 Stack Overflow 帖子、Google 开发者博客和 Android 文档后，我觉得“伪 ID”是最好的选择。

主要问题：硬件与软件

硬件

• 用户可以更改他们的硬件、Android 平板电脑或手机，因此基于硬件的唯一 ID 对于
• 跟踪用户来说并不是一个好主意。这是一个好主意

软件

• 用户如果获得 root 权限，可以擦除/更改他们的 ROM
• 您可以跨平台（iOS、Android、Windows 和 Web）跟踪用户
• 最想要跟踪个人用户的用户同意只是让他们登录（使用 OAuth 实现无缝）

---

#Android 的总体细分

###- 保证 API 的唯一性（包括已 root 的设备）>= 9/10（99.5% 的 Android）设备）
###- 没有额外的权限

伪代码：

if API >= 9/10: (99.5% of devices)

return unique ID containing serial id (rooted devices may be different)

else

return the unique ID of build information (may overlap data - API < 9)

感谢@stansult 发布我们的所有选项（在这个 Stack Overflow 问题中）。

##选项列表 - 为什么/为什么不使用它们的原因：

• 用户电子邮件 - 软件

• 用户可以更改电子邮件 - 极不可能

• API 5+ 或

• API 14+ (如何获取 Android 设备的主电子邮件地址)

• 用户电话号码 - 软件

• 用户可以更改电话号码 - 极不可能

• IMEI - 硬件（仅限手机，需要 android.permission.READ_PHONE_STATE）

• 大多数用户讨厌它说“电话”在许可中。一些用户给出差评是因为他们认为您只是在窃取他们的个人信息，而您真正想做的只是跟踪设备安装。很明显您正在收集数据。

• Android ID - 硬件（可以为空，可以在恢复出厂设置时更改） ，可以在 root 设备上更改）

• 由于它可以为“null”，因此我们可以检查“null”并更改它的价值，但这意味着它不再是唯一的。

• 如果您的用户拥有恢复出厂设置的设备，则该值可能已在已取得 root 权限的设备上更改或更改，因此如果您正在跟踪用户安装，则可能会出现重复条目​​。

• WLAN MAC 地址 - 硬件（需要 android.permission.ACCESS_WIFI_STATE）

• 这可能是第二好的选择，但您仍然收集并存储直接来自用户的唯一标识符。很明显您正在收集数据。

• 蓝牙 MAC 地址 - 硬件（具有蓝牙功能的设备，需要 android.permission.BLUETOOTH）

• 市面上大多数应用程序不使用蓝牙，因此，如果您的应用程序不使用蓝牙，而您将其包含在内，则用户可能会产生怀疑。

• 伪唯一 ID - 软件（适用于所有 Android 设备）

• 非常有可能，可能包含冲突 - 请参阅下面发布的我的方法！

• 这使您可以从用户那里获得“几乎唯一”的 ID，而无需获取任何私人信息。您可以根据设备信息创建您自己的匿名 ID。

---

我知道没有任何“完美”的方法可以在不使用权限的情况下获得唯一的 ID；然而，有时我们只需要跟踪设备安装。在创建唯一 ID 时，我们可以仅根据 Android API 提供给我们的信息创建“伪唯一 ID”，而无需使用额外的权限。这样，我们可以表达对用户的尊重，并尽力提供良好的用户体验。

使用伪唯一 ID，您实际上只会遇到这样一个事实：由于存在相似的设备，因此可能存在重复项。您可以调整组合方法以使其更加独特；然而，一些开发人员需要跟踪设备安装，这将根据类似设备实现技巧或性能。

##API >= 9：

如果他们的 Android 设备是 API 9 或更高版本，则由于“Build.SERIAL”字段，这保证是唯一的。

记住，从技术上讲，您只错过了大约 0.5% 的用户谁拥有 API < 9.。所以您可以专注于其余的：这是 99.5% 的用户！

##API < 9：

如果用户的Android设备低于API 9；希望他们没有恢复出厂设置，并且他们的“Secure.ANDROID_ID”将被保留或不为“null”。 （请参阅http://developer.android.com/about/dashboards/index.html)

##如果所有其他方法都失败：

如果所有其他方法都失败，如果用户的 API 低于 9（低于 Gingerbread），已重置其设备，或者“Secure.ANDROID_ID”返回“null”，则只需 ID返回将仅基于其 Android 设备信息。这就是可能发生碰撞的地方。

更改：

• 删除了“Android.SECURE_ID”，因为恢复出厂设置可能会导致值发生变化
• 编辑了 API 上的代码以进行更改
• 更改了 Pseudo

请查看以下方法：

/**
 * Return pseudo unique ID
 * @return ID
 */
public static String getUniquePsuedoID() {
    // If all else fails, if the user does have lower than API 9 (lower
    // than Gingerbread), has reset their device or 'Secure.ANDROID_ID'
    // returns 'null', then simply the ID returned will be solely based
    // off their Android device information. This is where the collisions
    // can happen.
    // Thanks http://www.pocketmagic.net/?p=1662!
    // Try not to use DISPLAY, HOST or ID - these items could change.
    // If there are collisions, there will be overlapping data
    String m_szDevIDShort = "35" + (Build.BOARD.length() % 10) + (Build.BRAND.length() % 10) + (Build.CPU_ABI.length() % 10) + (Build.DEVICE.length() % 10) + (Build.MANUFACTURER.length() % 10) + (Build.MODEL.length() % 10) + (Build.PRODUCT.length() % 10);

    // Thanks to @Roman SL!
    // https://stackoverflow.com/a/4789483/950427
    // Only devices with API >= 9 have android.os.Build.SERIAL
    // http://developer.android.com/reference/android/os/Build.html#SERIAL
    // If a user upgrades software or roots their device, there will be a duplicate entry
    String serial = null;
    try {
        serial = android.os.Build.class.getField("SERIAL").get(null).toString();

        // Go ahead and return the serial for api => 9
        return new UUID(m_szDevIDShort.hashCode(), serial.hashCode()).toString();
    } catch (Exception exception) {
        // String needs to be initialized
        serial = "serial"; // some value
    }

    // Thanks @Joe!
    // https://stackoverflow.com/a/2853253/950427
    // Finally, combine the values we have found by using the UUID class to create a unique identifier
    return new UUID(m_szDevIDShort.hashCode(), serial.hashCode()).toString();
}

---

#New（适用于带有广告和 Google Play 服务的应用程序）：

< strong>从 Google Play 开发者控制台：

自 2014 年 8 月 1 日起，Google Play 开发者计划政策
需要上传和更新全新的应用程序才能使用广告 ID
代替用于任何广告目的的任何其他持久标识符。
了解更多

实现：

权限：

<uses-permission android:name="android.permission.INTERNET" />

代码：

import com.google.android.gms.ads.identifier.AdvertisingIdClient;
import com.google.android.gms.ads.identifier.AdvertisingIdClient.Info;
import com.google.android.gms.common.GooglePlayServicesAvailabilityException;
import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
import java.io.IOException;
...

// Do not call this function from the main thread. Otherwise, 
// an IllegalStateException will be thrown.
public void getIdThread() {

  Info adInfo = null;
  try {
    adInfo = AdvertisingIdClient.getAdvertisingIdInfo(mContext);

  } catch (IOException exception) {
    // Unrecoverable error connecting to Google Play services (e.g.,
    // the old version of the service doesn't support getting AdvertisingId).
 
  } catch (GooglePlayServicesAvailabilityException exception) {
    // Encountered a recoverable error connecting to Google Play services. 

  } catch (GooglePlayServicesNotAvailableException exception) {
    // Google Play services is not available entirely.
  }
  final String id = adInfo.getId();
  final boolean isLAT = adInfo.isLimitAdTrackingEnabled();
}

源代码/文档：

http://developer.android.com/google/play-services/id.html
http://developer.android.com/reference /com/google/android/gms/ads/identifier/AdvertisingIdClient.html

##重要：

广告 ID 的目的是完全取代现有的
使用其他标识符用于广告目的（例如使用 ANDROID_ID
当 Google Play 服务可用时。案例
Google Play 服务不可用的地方由
GooglePlayServicesNotAvailableException 被抛出
getAdvertisingIdInfo()。

##警告，用户可以重置：

http://en.kioskea .net/faq/34732-android-reset-your-advertising-id

我尝试引用我从中获取信息的每个链接。如果有遗漏需要补充的请评论！

Google 播放器服务实例 ID

https://developers.google.com/instance-id/

Answer 25

正如 Dave Webb 提到的，Android 开发者博客有一篇文章 涵盖了这一点。他们首选的解决方案是跟踪应用程序安装而不是设备，这对于大多数用例都适用。这篇博客文章将向您展示实现该功能所需的代码，我建议您查看一下。

但是，如果您需要设备标识符而不是应用程序安装标识符，该博客文章将继续讨论解决方案。我与 Google 的某人进行了交谈，以便在您需要时对一些项目进行一些额外的说明。以下是我在上述博客文章中未提及的有关设备标识符的发现：

• ANDROID_ID 是首选设备标识符。 ANDROID_ID 在 Android <=2.1 或 >=2.3 版本上完全可靠。只有2.2有帖子中提到的问题。
• 多个制造商的多个设备受到 2.2 中 ANDROID_ID 错误的影响。
• 据我所知，所有受影响的设备都具有相同的 ANDROID_ID，即9774d56d682e549c。顺便说一句，这也是模拟器报告的相同设备 ID。
• Google 相信 OEM 厂商已经为他们的许多或大部分设备修复了这个问题，但我能够证实，至少截至 2011 年 4 月上旬，仍然很容易找到 ANDROID_ID 损坏的设备。

根据 Google 的建议，我实现了一个类，该类将为每个设备生成唯一的 UUID，在适当的情况下使用 ANDROID_ID 作为种子，必要时依靠 TelephonyManager.getDeviceId() ，如果失败，则诉诸随机生成的唯一 UUID该信息在应用程序重新启动后仍然存在（但不影响应用程序重新安装）。

请注意，对于必须回退设备 ID 的设备，唯一 ID将在恢复出厂设置后仍然保留。这是需要注意的事情。如果您需要确保恢复出厂设置会重置您的唯一 ID，您可能需要考虑直接回退到随机 UUID，而不是设备 ID。

同样，此代码用于设备 ID，而不是应用程序安装 ID。在大多数情况下，您可能需要的是应用程序安装 ID。但如果您确实需要设备 ID，那么以下代码可能适合您。

import android.content.Context;
import android.content.SharedPreferences;
import android.provider.Settings.Secure;
import android.telephony.TelephonyManager;

import java.io.UnsupportedEncodingException;
import java.util.UUID;

public class DeviceUuidFactory {

    protected static final String PREFS_FILE = "device_id.xml";
    protected static final String PREFS_DEVICE_ID = "device_id";
    protected volatile static UUID uuid;

    public DeviceUuidFactory(Context context) {
        if (uuid == null) {
            synchronized (DeviceUuidFactory.class) {
                if (uuid == null) {
                    final SharedPreferences prefs = context
                            .getSharedPreferences(PREFS_FILE, 0);
                    final String id = prefs.getString(PREFS_DEVICE_ID, null);
                    if (id != null) {
                        // Use the ids previously computed and stored in the
                        // prefs file
                        uuid = UUID.fromString(id);
                    } else {
                        final String androidId = Secure.getString(
                            context.getContentResolver(), Secure.ANDROID_ID);
                        // Use the Android ID unless it's broken, in which case
                        // fallback on deviceId,
                        // unless it's not available, then fallback on a random
                        // number which we store to a prefs file
                        try {
                            if (!"9774d56d682e549c".equals(androidId)) {
                                uuid = UUID.nameUUIDFromBytes(androidId
                                        .getBytes("utf8"));
                            } else {
                                final String deviceId = (
                                    (TelephonyManager) context
                                    .getSystemService(Context.TELEPHONY_SERVICE))
                                    .getDeviceId();
                                uuid = deviceId != null ? UUID
                                    .nameUUIDFromBytes(deviceId
                                            .getBytes("utf8")) : UUID
                                    .randomUUID();
                            }
                        } catch (UnsupportedEncodingException e) {
                            throw new RuntimeException(e);
                        }
                        // Write the value out to the prefs file
                        prefs.edit()
                                .putString(PREFS_DEVICE_ID, uuid.toString())
                                .commit();
                    }
                }
            }
        }
    }

    /**
     * Returns a unique UUID for the current android device. As with all UUIDs,
     * this unique ID is "very highly likely" to be unique across all Android
     * devices. Much more so than ANDROID_ID is.
     * 
     * The UUID is generated by using ANDROID_ID as the base key if appropriate,
     * falling back on TelephonyManager.getDeviceID() if ANDROID_ID is known to
     * be incorrect, and finally falling back on a random UUID that's persisted
     * to SharedPreferences if getDeviceID() does not return a usable value.
     * 
     * In some rare circumstances, this ID may change. In particular, if the
     * device is factory reset a new device ID may be generated. In addition, if
     * a user upgrades their phone from certain buggy implementations of Android
     * 2.2 to a newer, non-buggy version of Android, the device ID may change.
     * Or, if a user uninstalls your app on a device that has neither a proper
     * Android ID nor a Device ID, this ID may change on reinstallation.
     * 
     * Note that if the code falls back on using TelephonyManager.getDeviceId(),
     * the resulting ID will NOT change after a factory reset. Something to be
     * aware of.
     * 
     * Works around a bug in Android 2.2 for many devices when using ANDROID_ID
     * directly.
     * 
     * @see http://code.google.com/p/android/issues/detail?id=10603
     * 
     * @return a UUID that may be used to uniquely identify your device for most
     *         purposes.
     */
    public UUID getDeviceUuid() {
        return uuid;
    }
}

Answer 26

以下是 Reto Meier 在今年的 Google I/O 演示中使用的代码，用于获取唯一 ID用户：

private static String uniqueID = null;
private static final String PREF_UNIQUE_ID = "PREF_UNIQUE_ID";

public synchronized static String id(Context context) {
    if (uniqueID == null) {
        SharedPreferences sharedPrefs = context.getSharedPreferences(
                PREF_UNIQUE_ID, Context.MODE_PRIVATE);
        uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
        if (uniqueID == null) {
            uniqueID = UUID.randomUUID().toString();
            Editor editor = sharedPrefs.edit();
            editor.putString(PREF_UNIQUE_ID, uniqueID);
            editor.commit();
        }
    }
    return uniqueID;
}

如果您将此与备份策略结合起来以将首选项发送到云（Reto 的 talk，您应该有一个与用户关联的 id，并在设备被擦除甚至更换后保留下来。我打算使用这个在未来的分析中（换句话说，我还没有做到这一点:)。

Answer 27

这是一个简单的问题，没有简单的答案。

此外，这里所有现有的答案要么已经过时，要么不可靠。

因此，如果您正在寻找 2020 年之后的解决方案。

以下是需要记住的一些事项：

所有基于硬件的标识符（IMEI、MAC、序列号等）对于非 Google 设备（Pixel 和 Nexus 除外）来说都是不可靠的，统计数据全球大多数 Android 活跃设备。因此，官方 Android 标识符最佳实践明确指出：

避免使用硬件标识符，例如 IMEI、MAC 地址等...

这使得此处的大多数答案无效。另外，由于不同的 Android 安全更新，其中一些需要更新且更严格的运行时权限，而用户可以简单地拒绝这些权限。

例如，CVE-2018-9489 会影响上述所有基于 WIFI 的技术。

这使得这些标识符不仅不可靠，而且在许多情况下也无法访问。

简而言之：不要使用这些技术。

这里的许多其他答案都建议使用 AdvertisingIdClient，它也是不兼容的，因为它的设计仅用于广告分析。 官方参考中也有说明

仅将广告 ID 用于用户分析或广告用例

这不仅对于设备识别而言不可靠，而且您还必须遵循 有关广告跟踪的用户隐私政策，该政策明确规定用户可以随时重置或阻止该政策。

所以也不要使用它。

因为您无法拥有所需的静态全局唯一且可靠的设备标识符。 Android官方参考建议：

对于除支付欺诈预防和电话之外的所有其他用例，尽可能使用 Firebase 安装 ID (FID) 或私人存储的 GUID。

它对于设备上的应用程序安装来说是独一无二的，因此当用户卸载该应用程序时，它就会被清除，因此它不是 100% 可靠，但它是退而求其次的。

注意 从今天开始，FirebaseInstanceId 已弃用，您应该使用 FirebaseInstallations 代替。

要使用 FirebaseInstallations，请添加最新的 firebase-messaging 依赖项 进入你的 gradle

implementation 'com.google.firebase:firebase-messaging:23.0.0'

并使用下面的代码来获取 firebase ID：

FirebaseInstallations.getInstance().getId().addOnCompleteListener(task -> {
     if (task.isSuccessful()) {
        String firebaseIdentifier = task.getResult();
        // Do what you need with firebaseIdentifier
     }
});

如果你需要将设备标识存储在远程服务器上，那么不要按原样存储（纯文本），而是 加盐哈希。

如今，这不仅是最佳实践，实际上您还必须根据 GDPR - 标识符 和类似规定。

Answer 28

您还可以考虑 Wi-Fi 适配器的 MAC 地址。像这样检索：

WifiManager wm = (WifiManager)Ctxt.getSystemService(Context.WIFI_SERVICE);
return wm.getConnectionInfo().getMacAddress();

需要清单中的权限android.permission.ACCESS_WIFI_STATE。

据报道，即使未连接 Wi-Fi 也可用。如果上面答案中的乔在他的许多设备上尝试一下，那就太好了。

在某些设备上，当 Wi-Fi 关闭时该功能不可用。

注意：从 Android 6.x 开始，它返回一致的假 MAC 地址：02:00:00:00:00:00

Answer 29

这里有相当有用的信息。

它涵盖五种不同的 ID 类型：

1. IMEI（仅适用于使用手机的 Android 设备；需要 android.permission.READ_PHONE_STATE）
2. 伪唯一 ID（对于所有 Android 设备）
3. Android ID（可以为空，可以在恢复出厂设置时更改，可以在 root 后的手机上更改）
4. WLAN MAC 地址字符串（需要 android. permission.ACCESS_WIFI_STATE)
5. BT MAC Address 字符串（具有蓝牙功能的设备，需要 android.permission.BLUETOOTH）

Answer 30

官方 Android 开发者博客现在有一篇关于这个主题的完整文章，识别应用程序安装。