Android设备有唯一的ID吗？如果有，使用Java访问它的简单方法是什么？
Settings.Secure#ANDROID_ID返回每个用户64位十六进制字符串的唯一ANDROID ID。
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
更新：在最近的Android版本中，Android_ID的许多问题已经得到解决，我相信这种方法不再是必要的。请看一下安东尼的回答。
完整披露：我的应用程序最初使用了以下方法，但现在不再使用这种方法，我们现在使用了emmby的答案链接所指向的Android开发者博客条目中概述的方法（即，生成并保存UUID#randomUUID（））。
这个问题有很多答案，其中大多数只在“某些”时间有效，不幸的是，这还不够好。
根据我对设备的测试（所有手机，至少有一部未激活）：
所有测试的设备都返回了TelephonyManager.getDeviceId（）的值所有GSM设备（均使用SIM进行测试）都返回了TelephonyManager.getSimSerialNumber（）的值对于getSimSerialNumber（），所有CDMA设备均返回null（如预期）添加了Google帐户的所有设备都返回了ANDROID_ID的值所有CDMA设备都为ANDROID_ID和TelephonyManager.getDeviceId（）返回相同的值（或相同值的派生）——只要在安装过程中添加了Google帐户。我还没有机会测试没有SIM卡的GSM设备，没有添加谷歌账户的GSM设备或任何处于飞行模式的设备。
因此，如果您想要设备本身独有的东西，TM.getDeviceId（）就足够了。显然，有些用户比其他用户更偏执，因此对这些标识符中的一个或多个进行散列可能会很有用，这样该字符串对于设备来说实际上仍然是唯一的，但不会明确标识用户的实际设备。例如，使用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;
此外，您还可以考虑Wi-Fi适配器的MAC地址。检索方式如下：
WifiManager wm = (WifiManager)Ctxt.getSystemService(Context.WIFI_SERVICE);
return wm.getConnectionInfo().getMacAddress();
清单中需要权限android.permission.ACCESS_WIFI_STATE。
据报道，即使未连接Wi-Fi，也可用。如果上面的答案中的乔在他的许多设备上尝试一下，那就太好了。
在某些设备上，当Wi-Fi关闭时，它不可用。
注意：从Android6.x，它返回一致的假mac地址：02:00:00:00:00
以下代码使用隐藏的Android API返回设备序列号。但是，这个代码在三星Galaxy Tab上不起作用，因为这个设备上没有设置“ro.seriano”。
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) {
}
API级别9（Android 2.3-姜饼）中的Build类中添加了一个Serial字段。文档表示它代表硬件序列号。因此，如果设备上存在，它应该是唯一的。
我不知道API级别>=9的所有设备是否都支持（=不为空）。
我要补充一点，我有一种独特的情况。
使用：
deviceId = Secure.getString(this.getContext().getContentResolver(), Secure.ANDROID_ID);
事实证明，即使我的优派G平板电脑报告的DeviceID不为空，但每个G平板电脑都报告相同的数字。
玩“Pocket Empires”很有趣，它可以让您基于“唯一”DeviceID即时访问某人的帐户。
我的设备没有手机收音机。
我认为这是建立一个独特身份的骨架的最佳方式……看看吧。
伪唯一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），以具有与IMEI相同的大小ID（15个数字）。这里还有其他的可能性，好吧，看看这些字符串。返回355715565309247。无需特别许可，这使得该方法非常方便。
（额外信息：上面给出的技术是从Pocket Magic上的一篇文章中复制的。）
正如DaveWebb提到的，Android开发者博客有一篇文章介绍了这一点。他们的首选解决方案是跟踪应用程序安装而不是设备，这对于大多数使用情况都很有效。博客文章将向您展示实现这一功能所需的代码，我建议您查看一下。
然而，如果您需要设备标识符而不是应用程序安装标识符，博客文章将继续讨论解决方案。我与谷歌的某位人士进行了交谈，以获得一些额外的澄清，以防您需要这样做。以下是我发现的有关设备标识符的信息，这些信息在上述博客文章中没有提及：
ANDROID_ID是首选设备标识符。ANDROID_ID在ANDROID<=2.1或>=2.3版本上非常可靠。只有2.2存在帖子中提到的问题。多个制造商的多个设备受到2.2中ANDROID_ID错误的影响。据我所知，所有受影响的设备都具有相同的ANDROID_ID，即9774d56d682e549c。顺便说一下，这也是模拟器报告的相同设备id。谷歌相信，原始设备制造商已经为他们的许多或大部分设备修补了这个问题，但我能够证实，至少在2011年4月初，找到ANDROID_ID损坏的设备仍然很容易。
根据谷歌的建议，我实现了一个类，该类将为每个设备生成一个唯一的UUID，在适当的情况下使用ANDROID_ID作为种子，必要时返回TelephonyManager.getDeviceId（），如果失败，则使用随机生成的唯一UUID，该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;
}
}
使用下面的代码，您可以以字符串形式获取Android OS设备的唯一设备ID。
deviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID);
有关如何为安装应用程序的每个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();
}
}
这是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的演讲中也有描述），你应该有一个与用户相关的id，在设备被擦除甚至更换后，它会一直存在。我计划在未来的分析中使用此项（换句话说，我还没有做过这一点：）。
这里有相当有用的信息。
它包括五种不同的ID类型：
IMEI（仅适用于使用手机的Android设备；需要Android.permission.READ_Phone_STATE）伪唯一ID（适用于所有Android设备）Android ID（可以为空，可以在工厂重置时更改，可以在根手机上更改）WLAN MAC地址字符串（需要android.permission.ACCESS_WIFI_STATE）BT MAC地址字符串（带蓝牙的设备，需要android.permission.蓝牙）
有很多不同的方法可以解决ANDROID_ID问题（有时可能为空，或者特定型号的设备总是返回相同的ID），有利弊：
实现自定义ID生成算法（基于应该是静态且不会更改的设备财产->谁知道呢）滥用其他ID，如IMEI、序列号、Wi-Fi/蓝牙MAC地址（它们不会存在于所有设备上，或者需要额外的权限）
我自己更喜欢使用现有的OpenUDID实现（请参见https://github.com/ylechelle/OpenUDID)适用于Android（请参见https://github.com/vieux/OpenUDID). 它很容易集成并利用ANDROID_ID和上述问题的回退。
在Google I/O上，Reto Meier发布了一个关于如何实现这一点的有力答案，这应该能满足大多数开发人员在安装过程中跟踪用户的需求。安东尼·诺兰（Anthony Nolan）在他的回答中指明了方向，但我想我应该写出完整的方法，这样其他人就可以很容易地看到如何做到这一点（我花了一段时间才弄清楚细节）。
这种方法将为您提供一个匿名、安全的用户ID，该ID将在不同设备（基于主要的Google帐户）和不同安装中为用户持久保存。基本方法是生成一个随机用户ID，并将其存储在应用程序的共享偏好中。然后使用Google的备份代理将链接到Google帐户的共享首选项存储在云中。
让我们了解一下完整的方法。首先，我们需要使用Android备份服务为SharedPreferences创建备份。通过注册应用程序开始http://developer.android.com/google/backup/signup.html.
谷歌会给你一个备份服务密钥，你需要将其添加到清单中。您还需要告诉应用程序使用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>
然后，您需要创建备份代理，并告诉它使用helper代理进行共享引用：
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);
}
}
要完成备份，您需要在主活动中创建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现在也将在安装过程中保持不变。
有关此方法的更多信息，请参阅Reto的演讲。
有关如何实施备份代理的详细信息，请参阅数据备份。我特别推荐底部的测试部分，因为备份不会立即发生，所以为了测试，必须强制备份。
另一种方法是在没有任何权限的应用程序中使用/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文件并读取字符。只需确保将其包装在异常处理程序中，因为并非所有设备都有此文件。
已知至少以下设备具有此文件世界可读性：
银河天枢Nexus S公司摩托罗拉Xoom 3G东芝AT300HTC一V迷你MK802三星Galaxy S II
你也可以看到我的博客文章“泄露Android硬件序列号给未经授权的应用程序”，在这里我讨论了哪些其他文件可供参考。
在类文件中添加以下代码：
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" />
当设备没有电话功能时，我使用以下代码获取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);
以下是我如何生成唯一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;
}
#上次更新时间：2015年6月2日
在阅读了每一篇StackOverflow关于创建唯一ID的帖子、Google开发者博客和Android文档后，我觉得“伪ID”似乎是最好的选择。
主要问题：硬件与软件
硬件
用户可以改变他们的硬件、Android平板电脑或手机，因此基于硬件的唯一ID对于追踪用户来说不是好主意对于跟踪硬件，这是一个好主意
软件
用户可以擦除/更改他们的ROM，如果他们是根用户您可以跨平台（iOS、Android、Windows和Web）跟踪用户在个人用户同意的情况下跟踪他们的最佳方式是让他们登录（使用OAuth实现无缝）
#Android系统的总体故障
###-保证API的唯一性（包括根设备）>=9/10（99.5%的Android设备）###-无额外权限
Psuedo代码：
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发布我们的所有选项（在堆栈溢出问题中）。
##选项列表-为什么/为什么不使用它们：
用户电子邮件-软件用户可以更改电子邮件-极不可能API 5+<使用权限android:name=“android.permission.GET_ACCOUNTS”/>或API 14+<uses permission android:name=“android.ppermission.READ_PROFILE”/><uses权限android:nname=“android.prpermission.RREAD_CONTACTS”/>（如何获取android设备的主电子邮件地址）用户电话号码-软件用户可以更改电话号码-极不可能<uses permission android:name=“android.ppermission.READ_PHONE_STATE”/>IMEI-硬件（仅限手机，需要android。permission.READ_PHONE_STATE）大多数用户讨厌在权限中显示“电话呼叫”。一些用户给出了糟糕的评级，因为他们认为你只是在窃取他们的个人信息，而你真正想做的只是跟踪设备安装。很明显，您正在收集数据。<uses permission android:name=“android.ppermission.READ_PHONE_STATE”/>Android ID-硬件（可以为空，可以在工厂重置时更改，可以在根设备上更改）由于它可以是“null”，我们可以检查“null”并更改其值，但这意味着它将不再是唯一的。如果您的用户具有出厂重置设备，则根设备上的值可能已更改或更改，因此如果您正在跟踪用户安装，则可能存在重复条目。WLAN MAC地址-硬件（需要android.permission.ACCESS_WIFI_STATE）这可能是第二个最佳选项，但您仍在收集和存储直接来自用户的唯一标识符。很明显，您正在收集数据。<uses permission android:name=“android.permission.ACCESS_WIFI_STATE”/>蓝牙MAC地址-硬件（带蓝牙的设备，需要android.permission.蓝牙）市场上的大多数应用程序都不使用蓝牙，因此如果您的应用程序不使用蓝牙并且您包含了这一功能，用户可能会变得可疑。<uses permission android:name=“android.permission.BLUETOOTH”/>伪唯一ID-软件（适用于所有Android设备）很有可能，可能包含冲突-请参阅下面发布的我的方法！这允许您从用户那里获得一个“几乎唯一”的ID，而无需获取任何私人信息。您可以根据设备信息创建自己的匿名ID。
我知道没有任何“完美”的方法可以在不使用权限的情况下获得唯一的ID；然而，有时我们只需要跟踪设备安装。在创建唯一ID时，我们可以仅基于Android API提供的信息创建“伪唯一ID”，而无需使用额外的权限。通过这种方式，我们可以表现出对用户的尊重，并尝试提供良好的用户体验。
使用伪唯一id，您实际上只会遇到这样一个事实：基于存在类似设备的事实，可能存在重复项。您可以调整组合方法，使其更独特；然而，一些开发人员需要跟踪设备的安装情况，这将根据类似的设备来完成技巧或性能。
##API>=9：
如果他们的Android设备是API 9或更高版本，则由于“Build.SSERIAL”字段，这是唯一的。
记住，从技术上讲，你只错过了大约0.5%的API＜9的用户。所以你可以专注于剩下的：这是99.5%的用户！
##API＜9：
如果用户的Android设备低于API 9；希望他们没有进行工厂重置，他们的“Secure.ANDROID_ID”将被保留或不为“null”。（参见http://developer.android.com/about/dashboards/index.html)
##如果所有其他操作都失败：
如果所有其他操作都失败了，如果用户的API低于API 9（低于姜饼），重置了设备，或者“Secure.ANDROID_ID”返回“null”，那么返回的ID将仅基于他们的ANDROID设备信息。这就是碰撞可能发生的地方。
变化：
删除了“Android.SECURE_ID”，因为工厂重置可能会导致值更改在API上编辑要更改的代码更改了伪
请查看以下方法：
/**
* 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();
}
#新增（适用于带有广告和Google Play服务的应用程序）：
从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.htmlhttp://developer.android.com/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.html
##重要信息：
广告ID旨在完全取代现有的为广告目的使用其他标识符（例如使用ANDROID_ID在Settings.Secure中）。案例Google Play服务不可用的位置由引发的GooglePlayServicesNotAvailableException获取广告IdInfo（）。
##警告，用户可以重置：
http://en.kioskea.net/faq/34732-android-reset-your-advertising-id
我试图引用我从中获取信息的每个链接。如果你失踪了，需要加入，请评论！
Google Player服务实例ID
https://developers.google.com/instance-id/
我的两美分-注意，这是一个设备（错误）唯一ID，而不是Android开发者博客中讨论的安装ID。
值得注意的是，@emmby提供的解决方案在每个应用程序ID中都有所不同，因为SharedPreferences没有跨进程同步（请参阅此处和此处）。所以我完全避免了这一点。
相反，我封装了在枚举中获取（设备）ID的各种策略-更改枚举常量的顺序会影响获取ID的各种方式的优先级。返回第一个非空ID或抛出异常（根据不赋予空含义的良好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);
}
}
}
谷歌现在有一个广告ID。这也可以使用，但请注意：
广告ID是用户特定的、唯一的、可重置的ID
and
使用户可以在Google Play应用程序中重置其标识符或选择退出基于兴趣的广告。
因此，尽管这个id可能会改变，但似乎很快我们就没有选择了，这取决于这个id的用途。
更多信息@develper.android
在此处复制粘贴代码
HTH
检查系统信息设备唯一标识符
文档：http://docs.unity3d.com/Documentation/ScriptReference/SystemInfo-deviceUniqueIdentifier.html
唯一的设备标识符。它保证对每个设备都是唯一的（只读）。
iOS:在iOS7之前的设备上，它将返回MAC地址的哈希。在iOS7设备上，它将是UIDevice identifierForVendor，如果由于任何原因失败，则是ASIdentifierManager advertisingIdentifier。
使用TelephonyManager和Android_ID，通过以下方式获得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);
}
但我强烈推荐谷歌建议的方法，参见识别应用程序安装。
TelephonyManager.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);
有时TelephonyManager.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;
}
Google实例ID
2015年I/O发布；在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
谷歌似乎打算使用这个ID来识别Android、Chrome和iOS的安装。
它标识的是安装而不是设备，但同样，ANDROID_ID（这是公认的答案）现在也不再标识设备。使用ARC运行时，会为每个安装生成一个新的ANDROID_ID（此处详细信息），就像这个新的实例ID一样。此外，我认为识别安装（而不是设备）是我们大多数人真正需要的。
实例ID的优点
在我看来，谷歌打算将其用于此目的（识别您的安装），它是跨平台的，可以用于许多其他目的（请参阅上面的链接）。
如果您使用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秒可能会令人讨厌（当然，这取决于您的应用程序）。
对于特定Android设备的硬件识别，您可以检查MAC地址。
你可以这样做：
在AndroidManifest.xml中
<uses permission android:name=“android.ppermission.INTERNET”/>
现在在您的代码中：
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的列表中获得，但这可以在手机之间改变。
Android设备mac id也是唯一的id。即使设备本身被格式化，它也不会改变。
使用以下代码获取mac id：
WifiManager manager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
WifiInfo info = manager.getConnectionInfo();
String address = info.getMacAddress();
此外，不要忘记将适当的权限添加到AndroidManifest.xml：
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
这里有30多个答案，有些是相同的，有些是独特的。这个答案是基于这些答案中的一些。其中一个是Lenn Dolling的回答。
它组合3个ID并创建32位十六进制字符串。这对我来说效果很好。
3个ID为：伪ID-根据物理设备规范生成ANDROID_ID-设置.Securite.ANDROID-ID蓝牙地址-蓝牙适配器地址
它将返回如下内容：551F27C060712A72730B0F734064B1
注意：您始终可以向longId字符串添加更多ID。例如，序列号。wifi适配器地址。伊梅。通过这种方式，您可以使每个设备都更独特。
@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 "";
}
只是提醒大家阅读更多最新信息。对于Android O，系统管理这些ID的方式有一些变化。
https://android-developers.googleblog.com/2017/04/changes-to-device-identifiers-in.html
tl；dr Serial将需要PHONE权限，Android ID将根据不同的应用程序的包名和签名进行更改。
此外，谷歌还编制了一份很好的文档，提供了有关何时使用硬件和软件ID的建议。
https://developer.android.com/training/articles/user-data-ids.html
通常，我的应用程序使用设备唯一id。但有时我会使用IMEI。两者都是唯一的数字。
获取IMEI（国际移动设备标识符）
public String getIMEI(Activity activity) {
TelephonyManager telephonyManager = (TelephonyManager) activity
.getSystemService(Context.TELEPHONY_SERVICE);
return telephonyManager.getDeviceId();
}
获取设备唯一id
public String getDeviceUniqueID(Activity activity){
String device_unique_id = Secure.getString(activity.getContentResolver(),
Secure.ANDROID_ID);
return device_unique_id;
}
我几年前就遇到过这个问题，并学会了基于各种答案来实现一个通用的解决方案。
我已经在一个真实世界的产品中使用通用解决方案好几年了。到目前为止，这对我来说很好。以下是基于提供的各种答案的代码片段。
注意，getEmail大多数时候都会返回null，因为我们没有明确请求权限。
private static UniqueId getUniqueId() {
MyApplication app = MyApplication.instance();
// Our prefered method of obtaining unique id in the following order.
// (1) Advertising id
// (2) Email
// (2) ANDROID_ID
// (3) Instance ID - new id value, when reinstall the app.
////////////////////////////////////////////////////////////////////////////////////////////
// ADVERTISING ID
////////////////////////////////////////////////////////////////////////////////////////////
AdvertisingIdClient.Info adInfo = null;
try {
adInfo = AdvertisingIdClient.getAdvertisingIdInfo(app);
} catch (IOException e) {
Log.e(TAG, "", e);
} catch (GooglePlayServicesNotAvailableException e) {
Log.e(TAG, "", e);
} catch (GooglePlayServicesRepairableException e) {
Log.e(TAG, "", e);
}
if (adInfo != null) {
String aid = adInfo.getId();
if (!Utils.isNullOrEmpty(aid)) {
return UniqueId.newInstance(aid, UniqueId.Type.aid);
}
}
////////////////////////////////////////////////////////////////////////////////////////////
// EMAIL
////////////////////////////////////////////////////////////////////////////////////////////
final String email = Utils.getEmail();
if (!Utils.isNullOrEmpty(email)) {
return UniqueId.newInstance(email, UniqueId.Type.eid);
}
////////////////////////////////////////////////////////////////////////////////////////////
// ANDROID ID
////////////////////////////////////////////////////////////////////////////////////////////
final String sid = Settings.Secure.getString(app.getContentResolver(), Settings.Secure.ANDROID_ID);
if (!Utils.isNullOrEmpty(sid)) {
return UniqueId.newInstance(sid, UniqueId.Type.sid);
}
////////////////////////////////////////////////////////////////////////////////////////////
// INSTANCE ID
////////////////////////////////////////////////////////////////////////////////////////////
final String iid = com.google.android.gms.iid.InstanceID.getInstance(MyApplication.instance()).getId();
if (!Utils.isNullOrEmpty(iid)) {
return UniqueId.newInstance(iid, UniqueId.Type.iid);
}
return null;
}
public final class UniqueId implements Parcelable {
public enum Type implements Parcelable {
aid,
sid,
iid,
eid;
////////////////////////////////////////////////////////////////////////////
// Handling Parcelable nicely.
public static final Parcelable.Creator<Type> CREATOR = new Parcelable.Creator<Type>() {
public Type createFromParcel(Parcel in) {
return Type.valueOf(in.readString());
}
public Type[] newArray(int size) {
return new Type[size];
}
};
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeString(this.name());
}
// Handling Parcelable nicely.
////////////////////////////////////////////////////////////////////////////
}
public static boolean isValid(UniqueId uniqueId) {
if (uniqueId == null) {
return false;
}
return uniqueId.isValid();
}
private boolean isValid() {
return !org.yccheok.jstock.gui.Utils.isNullOrEmpty(id) && type != null;
}
private UniqueId(String id, Type type) {
if (org.yccheok.jstock.gui.Utils.isNullOrEmpty(id) || type == null) {
throw new java.lang.IllegalArgumentException();
}
this.id = id;
this.type = type;
}
public static UniqueId newInstance(String id, Type type) {
return new UniqueId(id, type);
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + id.hashCode();
result = 31 * result + type.hashCode();
return result;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof UniqueId)) {
return false;
}
UniqueId uniqueId = (UniqueId)o;
return this.id.equals(uniqueId.id) && this.type == uniqueId.type;
}
@Override
public String toString() {
return type + ":" + id;
}
////////////////////////////////////////////////////////////////////////////
// Handling Parcelable nicely.
public static final Parcelable.Creator<UniqueId> CREATOR = new Parcelable.Creator<UniqueId>() {
public UniqueId createFromParcel(Parcel in) {
return new UniqueId(in);
}
public UniqueId[] newArray(int size) {
return new UniqueId[size];
}
};
private UniqueId(Parcel in) {
this.id = in.readString();
this.type = in.readParcelable(Type.class.getClassLoader());
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeString(this.id);
parcel.writeParcelable(this.type, 0);
}
// Handling Parcelable nicely.
////////////////////////////////////////////////////////////////////////////
public final String id;
public final Type type;
}
public static String getEmail() {
Pattern emailPattern = Patterns.EMAIL_ADDRESS; // API level 8+
AccountManager accountManager = AccountManager.get(MyApplication.instance());
Account[] accounts = accountManager.getAccountsByType("com.google");
for (Account account : accounts) {
if (emailPattern.matcher(account.name).matches()) {
String possibleEmail = account.name;
return possibleEmail;
}
}
accounts = accountManager.getAccounts();
for (Account account : accounts) {
if (emailPattern.matcher(account.name).matches()) {
String possibleEmail = account.name;
return possibleEmail;
}
}
return null;
}
序列号是通过android.os.Build.Serial提供的唯一设备ID。
public static String getSerial() {
String serial = "";
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
serial = Build.getSerial();
}else{
serial = Build.SERIAL;
}
return serial;
}
在调用getSerial（）之前，请确保您具有READ_PHONE_STATE权限。
注意：-它不适用于没有电话的设备（如仅支持wifi的平板电脑）。
不建议使用，因为deviceId可以在第三方手中用作跟踪，但这是另一种方式。
@SuppressLint("HardwareIds")
private String getDeviceID() {
deviceId = Settings.Secure.getString(getApplicationContext().getContentResolver(),
Settings.Secure.ANDROID_ID);
return deviceId;
}
1.使用提供唯一id（即IMEI）的电话管理器。参见示例，
import android.telephony.TelephonyManager;
import android.content.Context;
// ...
TelephonyManager telephonyManager;
telephonyManager = (TelephonyManager) getSystemService(Context.
TELEPHONY_SERVICE);
/*
* getDeviceId() returns the unique device ID.
* For example,the IMEI for GSM and the MEID or ESN for CDMA phones.
*/
String deviceId = telephonyManager.getDeviceId();
/*
* getSubscriberId() returns the unique subscriber ID,
*/
String subscriberId = telephonyManager.getSubscriberId();
这需要为您的用户提供android.permission.READ_PHONE_STATE，这很难证明遵循您所做的应用程序类型。
没有电话服务的设备（如平板电脑）必须报告一个唯一的设备ID，该ID可以通过android.os.Build.SERIAL从android 2.3 Gingerbread获得。一些具有电话服务的电话还可以定义序列号。就像不是所有的Android设备都有序列号一样，这种解决方案并不可靠。在设备首次启动时，会生成并存储一个随机值。此值可通过Settings.Secure.ANDROID_ID获得。它是一个64位数字，在设备的生命周期内应保持不变。ANDROID_ID似乎是唯一设备标识符的好选择，因为它适用于智能手机和平板电脑。要检索值，可以使用以下代码：，StringandroidId=Settings.Secure.getString（getContentResolver（），Settings.Secure.ANDROID_ID）；
但是，如果在设备上执行出厂重置，则该值可能会更改。制造商的流行手机也存在一个已知的缺陷，每个实例都有相同的ANDROID_ID。显然，该解决方案并非100%可靠。
使用UUID。由于大多数应用程序的要求是识别特定的安装，而不是物理设备，因此，如果使用UUID类，获取用户的唯一id是一个很好的解决方案。以下解决方案由来自Google的Reto Meier在Google I/O演示中提出，
SharedPreferences sharedPrefs = context.getSharedPreferences(
PREF_UNIQUE_ID, Context.MODE_PRIVATE);
uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
更新：选项#1和#2在android 10之后不再可用，因为谷歌进行了隐私更新。因为选项2和3需要关键许可。
为了完整起见，以下是如何在Xamarin.Android和C#中获取Id：
var id = Settings.Secure.GetString(ContentResolver, Settings.Secure.AndroidId);
或者如果您不在“活动”中：
var id = Settings.Secure.GetString(context.ContentResolver, Settings.Secure.AndroidId);
其中上下文是传入的上下文。
为了包括Android 9，我只有一个想法可以继续工作，那就是（可能）不违反任何条款，需要权限，并且可以跨安装和应用程序工作。
涉及服务器的指纹应该能够唯一地识别设备。硬件信息+已安装的应用程序和安装时间的组合应该会起到作用。除非卸载并再次安装应用程序，否则首次安装时间不会更改。但这必须对设备上的所有应用程序进行，以便无法识别设备（即，在工厂重置后）。
我会这样做：
提取硬件信息、应用程序包名称和首次安装时间。
这是从Android中提取所有应用程序的方法（无需权限）：
final PackageManager pm = application.getPackageManager();
List<ApplicationInfo> packages =
pm.getInstalledApplications(PackageManager.GET_META_DATA);
for (ApplicationInfo packageInfo : packages) {
try {
Log.d(TAG, "Installed package :" + packageInfo.packageName);
Log.d(TAG, "Installed :" + pm.getPackageInfo(packageInfo.packageName, 0).firstInstallTime);
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}
}
在将每个包名称和安装时间戳组合发送到服务器之前，您可能需要对其进行哈希，因为用户在设备上安装的内容可能与您的业务无关，也可能与您无关。有些应用程序（实际上很多）是系统应用程序。这些可能具有相同的安装时间戳，与出厂重置后的最新系统更新相匹配。因为它们具有相同的安装时间戳，所以用户无法安装它们，并且可以过滤掉它们。将信息发送到服务器，并让它在先前存储的信息中查找最近的匹配。在安装和卸载应用程序时，您需要在与以前存储的设备信息进行比较时设置阈值。但我的猜测是，这一门槛可能很低，因为任何软件包名称和首次安装时间戳组合对于一个设备来说都是非常独特的，而且应用程序的安装和卸载并不频繁。拥有多个应用程序只会增加独一无二的可能性。返回为匹配项生成的唯一id，或生成唯一id，存储设备信息并返回此新id。
注：这是一种未经测试和验证的方法！我相信它会奏效，但我也非常确信，如果这一点流行起来，他们会以某种方式关闭它。
了解Android设备中可用的唯一ID。使用本官方指南。
唯一标识符的最佳做法：
IMEI、Mac地址、实例Id、GUID、SSAID、广告Id、用于验证设备的安全网API。
https://developer.android.com/training/articles/user-data-ids
以下是获得AAID的简单答案，测试工作正常2019年6月
AsyncTask<Void, Void, String> task = new AsyncTask<Void, Void, String>() {
@Override
protected String doInBackground(Void... params) {
String token = null;
Info adInfo = null;
try {
adInfo = AdvertisingIdClient.getAdvertisingIdInfo(getApplicationContext());
} catch (IOException e) {
// ...
} catch ( GooglePlayServicesRepairableException e) {
// ...
} catch (GooglePlayServicesNotAvailableException e) {
// ...
}
String android_id = adInfo.getId();
Log.d("DEVICE_ID",android_id);
return android_id;
}
@Override
protected void onPostExecute(String token) {
Log.i(TAG, "DEVICE_ID Access token retrieved:" + token);
}
};
task.execute();
请在此处详细阅读完整答案：
如果添加：
Settings.Secure.getString(context.contentResolver,
Settings.Secure.ANDROID_ID)
Android Lint将向您发出以下警告：
不建议使用getString获取设备标识符。检查信息：不建议使用这些设备标识符除了用于高价值欺诈预防和高级电话之外使用案例。对于广告用例，请使用AdvertisingIdClient$Info#getId，用于分析，请使用InstanceId#getId。
所以，你应该避免使用这个。
如Android开发者文档中所述：
1：避免使用硬件标识符。在大多数使用情况下，您可以避免使用硬件标识符，例如SSAID（Android ID）和IMEI，而不限制所需的功能。2：仅在用户分析或广告用例中使用广告ID。使用广告ID时，始终尊重用户的选择关于广告跟踪。此外，请确保标识符不能连接到个人身份信息（PII），并避免桥接广告ID重置。3：在所有其他用例中，尽可能使用实例ID或私有存储的GUID，但支付欺诈预防和电话除外。对于绝大多数非广告用例，实例ID或GUID应足够。4:使用适合您的用例的API，以最大限度地降低隐私风险。使用DRM API保护高价值内容用于滥用保护的SafetyNet API。SafetyNet API是确定设备是否为正品的最简单方法隐私风险。
要获取用户id，您可以使用Google Play授权库。
要下载此库，请打开SDK管理器=>SDK工具。下载的库文件的路径为：
path_to_android_sdk_on_your_pc/extras/google/market_licensing/library
将库包含在项目中（只需复制其文件）。
接下来，您需要一些策略接口的实现（只需使用库中的两个文件之一：ServerManagedPolicy或StrictPolicy）。
将在processServerResponse（）函数中为您提供用户id：
public void processServerResponse(int response, ResponseData rawData) {
if(rawData != null) {
String userId = rawData.userId
// use/save the value
}
// ...
}
接下来，需要使用策略构造LicenseChecker，并调用checkAccess（）函数。使用MainActivity.java作为示例说明如何执行此操作。MainActivity.ava位于以下文件夹中：
path_to_android_sdk_on_your_pc/extras/google/market_licensing/sample/src.com/sample/android/market/licensing
不要忘记将CHECK_LICENSE权限添加到AndroidManifest.xml。
有关授权库的详细信息：https://developer.android.com/google/play/licensing
是的，每个Android设备都有一个唯一的序列号，你可以从这个代码中得到它。Build.SERIAL。请注意，它只是在API级别9中添加的，可能不会出现在所有设备上。要在早期平台上获得唯一ID，您需要读取MAC地址或IMEI等信息。
android.telephony.TelephonyManager.getDeviceId()
这将返回唯一标识设备的任何字符串（GSM上的IMEI，CDMA上的MEID）。
在AndroidManifest.xml中需要以下权限：
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
这是一个简单的问题，没有简单的答案。
此外，这里所有现有的答案要么过时，要么不可靠。
因此，如果您正在寻找2020年后的解决方案。
以下是需要记住的几点：
所有基于硬件的标识符（IMEI、MAC、序列号等）对于非谷歌设备（Pixels和Nexuses除外）都是不可靠的，从统计上看，这些设备是世界上大多数android活动设备。因此，官方Android标识符最佳实践明确指出：
避免使用硬件标识符，如IMEI、MAC地址等。。。
这使得这里的大多数答案无效。同样由于不同的android安全更新，其中一些需要更新和更严格的运行时权限，用户可以简单地拒绝。
例如，CVE-2018-9489影响上述所有基于WIFI的技术。
这使得这些标识符不仅不可靠，而且在许多情况下无法访问。
所以简单地说：不要使用这些技术。
这里的许多其他答案都建议使用AdvertisingIdClient，这也是不兼容的，因为它是专为广告分析而设计的。官方参考文件中也有说明
仅将广告ID用于用户分析或广告用例
它不仅对设备识别不可靠，而且您还必须遵守有关广告跟踪的用户隐私政策，该政策明确规定用户可以随时重置或阻止它。
所以也不要使用它。
因为您无法获得所需的静态全局唯一和可靠的设备标识符。Android的官方参考建议：
在所有其他使用情况下，尽可能使用Firebase安装ID（FID）或私人存储的GUID，支付欺诈预防和电话除外。
它对于设备上的应用程序安装来说是独一无二的，因此当用户卸载应用程序时，它会被删除，因此它不是100%可靠，但它是次佳选择。
注意：截至目前，FirebaseInstanceId已弃用，您应改用FirebaseInstallations。
要使用FirebaseInstallations，请将最新的firebase消息传递依赖项添加到您的等级中
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标识符和类似法规依法进行。
Android在Android O之后限制硬件相关Id，Android_Id是唯一Id的解决方案，但当反射设备，它将生成新的android_id以克服此问题问题是我们可以使用DRUMID。
val WIDEVINE_UUID = UUID(-0x121074568629b532L, -0x5c37d8232ae2de13L)
val drumIDByteArray = MediaDrm(WIDEVINE_UUID).getPropertyByteArray(MediaDrm.PROPERTY_DEVICE_UNIQUE_ID)
val drumID = android.util.Base64.encodeToString(drumIDByteArray,android.util.Base64.DEFAULT)
借助以下功能获取设备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);
}
调用Above函数并检查上述代码的输出。请在android工作室中查看您的日志猫。如下所示：
您将通过使用以下代码获得wifi mac地址，无论您在尝试连接到wifi时是否使用了随机地址，也无论wifi是否打开或关闭。
我使用了下面链接中的一个方法，并添加了一个小修改，以获得准确的地址，而不是随机化的地址：
在Android 6.0中获取MAC地址
public static String getMacAddr() {
StringBuilder res1 = new StringBuilder();
try {
List<NetworkInterface> all =
Collections.list(NetworkInterface.getNetworkInterfaces());
for (NetworkInterface nif : all) {
if (!nif.getName().equalsIgnoreCase("p2p0")) continue;
byte[] macBytes = nif.getHardwareAddress();
if (macBytes == null) {
continue;
}
res1 = new StringBuilder();
for (byte b : macBytes) {
res1.append(String.format("%02X:",b));
}
if (res1.length() > 0) {
res1.deleteCharAt(res1.length() - 1);
}
}
} catch (Exception ex) {
}
return res1.toString();
}
包com.aapbd.appbajarlib.common；import android.os.Build；导入java.util.Locale；导入java.util.UUID；公共类DeviceID{公共静态字符串getDeviceLanguage（）{Locale Locale=Locale.getDefault（）；return locale.getDisplayLanguage（）；}公共静态字符串getDeviceCountry（）{Locale Locale=Locale.getDefault（）；return locale.getDisplayCountry（）；}公共静态字符串getDeviceName（）{字符串制造商=Build.manufacturer；字符串模型=Build.model；if（model.startsWith（制造商））{回报资本化（模型）；}其他{回报资本化（制造商）+“”+模型；}}公共静态字符串getAndroidVersion（）{字符串释放=Build.VERSION.release；int sdkVersion=内部版本.VERSION.SDK_int；return sdkVersion+“（”+release+“）”；}公共静态int getAndroidAPILevel（）{int sdkVersion=内部版本.VERSION.SDK_int；return sdkVersion；}私有静态字符串大写（字符串s）{如果（s==null||s.length（）==0）{return“”；}char first=s.charAt（0）；if（字符.isUpperCase（第一个））{返回s；}其他{return Character.toUpperCase（first）+s.substring（1）；}}/***返回伪唯一ID*@返回ID*/公共静态字符串getUniquePsuedoID（）{//如果所有其他操作都失败，如果用户的API低于API 9（低于//而不是姜饼），已重置其设备或“安全.ANDROID_ID”//返回“null”，则返回的ID将仅基于//关闭他们的Android设备信息。这就是碰撞的地方//可能发生。//谢谢http://www.pocketmagic.net/?p=1662!//尽量不要使用DISPLAY、HOST或ID-这些项目可能会更改。//如果发生冲突，则会出现重叠数据字符串m_szDevIDShort=“35”+（Build.BOARD.length（）%10）+（Build.BRAND.length）%10（）+（Build.CPU_ABI.length；//感谢@Roman SL！// http://stackoverflow.com/a/4789483/950427//只有API>=9的设备具有android.os.Build.SERIAL// http://developer.android.com/reference/android/os/Build.html#SERIAL//如果用户升级软件或根目录他们的设备，将有一个重复条目字符串序列=空；尝试{serial=android.os.Build.class.getField（“serial”）.get（null）.toString（）；//继续并返回api=>9的序列号返回新UUID（m_szDevIDShort.hashCode（），serial.hashCode））.toString（）；}catch（异常异常）{//字符串需要初始化serial=“serial”；//一些价值}//谢谢@乔！// http://stackoverflow.com/a/2853253/950427//最后，通过使用UUID类组合我们找到的值来创建唯一标识符返回新UUID（m_szDevIDShort.hashCode（），serial.hashCode））.toString（）；}}
我正在使用这个，它在过去的6年中一直有效。
这是图书馆：https://github.com/nillbiplob/AppBajarLIB
经过多次搜索。我意识到没有确定的方法可以拥有唯一的ID。
假设我们希望每个用户只能在一部手机上使用该应用程序。
我所做的是：
当用户在我的应用程序中注册时，我将当前时间保存为服务器和应用程序数据库中的唯一ID。
当用户尝试登录另一个电话时，我从服务器获取用户信息，并意识到该用户已经登录，因为唯一ID字段已满，所以向他/她显示一个对话框，表明他/她已经登录到另一个设备，无论他/她是否想离开上一个会话，如果他说是，我将为他创建一个新的唯一ID，并更新服务器上的唯一ID详细信息。
在我自己的应用程序中，每次运行时，我都会从服务器获取用户配置文件。如果存储在服务器上的唯一ID与存储在应用程序数据库中的唯一ID不同，我将自动注销用户。
这个示例演示了如何在Android中获取和存储设备ID，但我使用的是Kotlin。
val textView: TextView = findViewById(R.id.textView)
val uniqueId: String = Settings.Secure.getString(contentResolver, Settings.Secure.ANDROID_ID)
textView.text = "Device ID: $uniqueId"
生成设备标识符
private String generateDeviceIdentifier() {
String uniqueDevicePseudoID = "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(uniqueDevicePseudoID.hashCode(), serial.hashCode()).toString();
Log.e("DeviceIdentifier ", "\nDeviceIdentifier uuid is : " + uuid);
return uuid;
}
输出
DeviceIdentifier uuid is : 00000000-36ab-9c3c-0000-0000714a4f37
推荐文章
- 如何隐藏动作栏之前的活动被创建，然后再显示它?
- 是否有一种方法以编程方式滚动滚动视图到特定的编辑文本?
- 在Android中将字符串转换为Uri
- 如何在NestedScrollView内使用RecyclerView ?
- 移动到另一个EditText时，软键盘下一步点击Android
- Android应用中的GridView VS GridLayout
- Activity和FragmentActivity的区别
- 右对齐文本在android TextView
- 权限拒绝:start前台需要android.permission.FOREGROUND_SERVICE
- 如何更改android操作栏的标题和图标
- Android Split字符串
- 让一个链接在安卓浏览器启动我的应用程序?
- 如何在Android工作室的外部库中添加一个jar ?
- GridLayout(不是GridView)如何均匀地拉伸所有子元素
- 如何让一个片段删除自己，即它的等效完成()?
