Существует ли уникальный идентификатор устройства Android?
Есть ли у Android-устройств уникальный идентификатор, и если да, то какой простой способ получить к нему доступ с помощью Java?
56 ответов
Settings.Secure#ANDROID_ID возвращает идентификатор Android как уникальную для каждого пользователя 64-битную шестнадцатеричную строку.
import android.provider.Settings.Secure;
private String android_id = Secure.getString(getContext().getContentResolver(),
Secure.ANDROID_ID);
ОБНОВЛЕНИЕ: В последних версиях Android, многие проблемы с ANDROID_ID были решены, и я считаю, что такой подход больше не нужен. Пожалуйста, взгляните на ответ Энтони.
Полное раскрытие: мое приложение изначально использовало описанный ниже подход, но больше не использует этот подход, и теперь мы используем подход, изложенный в записи блога Android Developer, на которую ссылается ответ emmby (а именно, создание и сохранение UUID#randomUUID()).
Есть много ответов на этот вопрос, большинство из которых будет работать только "некоторое время", и, к сожалению, этого недостаточно.
На основании моих тестов устройств (все телефоны, хотя бы один из которых не активирован):
- Все протестированные устройства вернули значение для
TelephonyManager.getDeviceId() - Все устройства GSM (все протестированные с SIM-картой) вернули значение для
TelephonyManager.getSimSerialNumber() - Все устройства CDMA вернули ноль для
getSimSerialNumber()(как и ожидалось) - Все устройства с добавленной учетной записью Google вернули значение для
ANDROID_ID - Все устройства CDMA возвращали одно и то же значение (или вывод одного и того же значения) для обоих
ANDROID_IDа такжеTelephonyManager.getDeviceId()- пока учетная запись Google была добавлена во время установки. - У меня еще не было возможности протестировать устройства GSM без SIM-карты, устройство GSM без добавленной учетной записи Google или какое-либо из устройств в режиме полета.
Так что если вы хотите что-то уникальное для самого устройства, 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
Это работает достаточно хорошо для меня.
Как упоминает Ричард ниже, не забывайте, что вам нужно разрешение на чтение TelephonyManager Свойства, поэтому добавьте это в свой манифест:
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
импортные библиотеки
import android.content.Context;
import android.telephony.TelephonyManager;
import android.view.View;
Последнее обновление: 02.06.15
После прочтения каждого поста о переполнении стека о создании уникального идентификатора, блога разработчиков Google и документации по Android я чувствую, что "псевдоидентификация" - лучший из возможных вариантов.
Основная проблема: оборудование против программного обеспечения
аппаратные средства
- Пользователи могут менять свое оборудование, планшет Android или телефон, поэтому уникальные идентификаторы, основанные на оборудовании, не являются хорошими идеями для отслеживания пользователей
- Для ОТСЛЕЖИВАНИЯ ОБОРУДОВАНИЯ это отличная идея
Программного обеспечения
- Пользователи могут стереть / изменить свой ПЗУ, если они рутированы
- Вы можете отслеживать пользователей на разных платформах (iOS, Android, Windows и Web)
- Лучшее желание отследить индивидуального пользователя с его согласия - просто попросить его войти в систему (сделайте это без проблем, используя OAuth)
Общий срыв с Android
- Гарантия уникальности (включая рутированные устройства) для API >= 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 за публикацию всех наших опций (в этом вопросе о переполнении стека).
Список опций - причины, почему / почему не стоит их использовать:
Электронная почта пользователя - Программное обеспечение
- Пользователь может изменить адрес электронной почты - очень маловероятно
- API 5+
<uses-permission android:name="android.permission.GET_ACCOUNTS" />или же - API 14+
<uses-permission android:name="android.permission.READ_PROFILE" /><uses-permission android:name="android.permission.READ_CONTACTS" />( Как получить основной адрес электронной почты устройства Android)
Номер телефона пользователя - Программное обеспечение
- Пользователи могут менять номера телефонов - крайне маловероятно
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
IMEI - Hardware (только телефоны, нужны
android.permission.READ_PHONE_STATE)- Большинство пользователей ненавидят тот факт, что в разрешении написано "Телефонные звонки". Некоторые пользователи дают плохие оценки, потому что они считают, что вы просто крадете их личную информацию, когда все, что вы действительно хотите сделать, это отслеживать установку устройства. Очевидно, что вы собираете данные.
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
Идентификатор Android - Аппаратное обеспечение (может быть нулевым, может изменяться при сбросе настроек, может быть изменено на корневом устройстве)
- Так как это может быть 'null', мы можем проверить 'null' и изменить его значение, но это означает, что он больше не будет уникальным.
- Если у вас есть пользователь с устройством сброса к заводским настройкам, значение может быть изменено или изменено на корневом устройстве, поэтому могут быть дубликаты записей, если вы отслеживаете установки пользователей.
WLAN MAC-адрес - аппаратное обеспечение (необходимо
android.permission.ACCESS_WIFI_STATE)- Это может быть второй лучший вариант, но вы все еще собираете и храните уникальный идентификатор, который приходит непосредственно от пользователя. Это очевидно, что вы собираете данные.
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE "/>
Bluetooth MAC Address - Hardware (устройства с Bluetooth, нужны
android.permission.BLUETOOTH)- Большинство приложений на рынке не используют Bluetooth, и поэтому, если ваше приложение не использует Bluetooth, и вы включаете это, пользователь может заподозрить.
<uses-permission android:name="android.permission.BLUETOOTH "/>
Pseudo-Unique ID - Программное обеспечение (для всех устройств Android)
- Очень возможно, может содержать столкновения - см. Мой метод, опубликованный ниже!
- Это позволяет вам иметь "почти уникальный" идентификатор пользователя, не принимая ничего личного. Вы можете создать свой собственный анонимный идентификатор из информации об устройстве.
Я знаю, что не существует "идеального" способа получения уникального идентификатора без использования разрешений; однако иногда нам действительно нужно отслеживать установку устройства. Когда дело доходит до создания уникального идентификатора, мы можем создать "псевдо уникальный идентификатор", основываясь исключительно на информации, которую нам предоставляет API Android без использования дополнительных разрешений. Таким образом, мы можем проявить уважение к пользователю и попытаться предложить хороший пользовательский опыт.
С псевдо-уникальным идентификатором вы действительно столкнетесь только с тем фактом, что могут быть дубликаты, основанные на том факте, что существуют подобные устройства. Вы можете настроить комбинированный метод, чтобы сделать его более уникальным; однако, некоторые разработчики должны отслеживать установку устройств, и это будет работать на основе аналогичных устройств.
API> = 9:
Если их Android-устройство имеет API 9 или более поздней версии, оно гарантированно будет уникальным из-за поля Build.SERIAL.
ПОМНИТЕ, технически вы пропускаете только около 0,5% пользователей с API <9. Таким образом, вы можете сосредоточиться на остальном: это 99,5% пользователей!
API <9:
Если Android-устройство пользователя ниже API 9; надеюсь, что они не сделали сброс к заводским настройкам, и их "Secure.ANDROID_ID" будет сохранен или не будет "нулевым". (см. http://developer.android.com/about/dashboards/index.html)
Если все остальное терпит неудачу:
Если все остальное терпит неудачу, если пользователь имеет более низкий уровень, чем API 9 (ниже, чем Gingerbread), сбросил свое устройство или "Secure.ANDROID_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://stackru.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://stackru.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:
Начиная с 1 августа 2014 г. в соответствии с политикой программы разработчиков Google Play все новые загрузки и обновления приложений должны использовать рекламный идентификатор вместо любых других постоянных идентификаторов в любых рекламных целях. Учить больше
Реализация:
Разрешение:
<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();
}
Источник / Docs:
http://developer.android.com/google/play-services/id.html http://developer.android.com/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.html
Важный:
Предполагается, что рекламный идентификатор полностью заменит существующее использование других идентификаторов в рекламных целях (например, использование ANDROID_ID в Settings.Secure), когда службы Google Play доступны. Случаи, когда Сервисы Google Play недоступны, указываются в исключении GooglePlayServicesNotAvailableException, которое генерируется getAdvertisingIdInfo().
Внимание, пользователи могут сбросить:
http://en.kioskea.net/faq/34732-android-reset-your-advertising-id
Я пытался ссылаться на каждую ссылку, с которой я взял информацию. Если вы пропали без вести и должны быть включены, пожалуйста, прокомментируйте!
Идентификатор экземпляра служб Google Player
Как упоминает Дейв Уэбб, в блоге разработчиков Android есть статья, в которой об этом говорится. Их предпочтительным решением является отслеживание установок приложений, а не устройств, и это будет хорошо работать в большинстве случаев использования. В блоге будет показан необходимый код для этой работы, и я рекомендую вам проверить его.
Однако в блоге обсуждаются решения, если вам нужен идентификатор устройства, а не идентификатор установки приложения. Я поговорил с кем-то из Google, чтобы получить дополнительные разъяснения по нескольким пунктам на тот случай, если вам нужно это сделать. Вот что я обнаружил об идентификаторах устройств, которые НЕ упоминаются в вышеупомянутом сообщении в блоге:
- ANDROID_ID является предпочтительным идентификатором устройства. ANDROID_ID является абсолютно надежным в версиях Android <=2.1 или>=2.3. Только 2.2 имеет проблемы, упомянутые в посте.
- На несколько устройств нескольких производителей влияет ошибка ANDROID_ID в 2.2.
- Насколько я смог определить, все затронутые устройства имеют одинаковый ANDROID_ID, который равен 9774d56d682e549c. Который также является идентичным идентификатором устройства, сообщаемым эмулятором, кстати.
- Google считает, что производители исправили проблему для многих или большинства своих устройств, но я смог убедиться, что по крайней мере с начала апреля 2011 года найти устройства с поврежденным ANDROID_ID по-прежнему довольно легко.
Основываясь на рекомендациях Google, я реализовал класс, который будет генерировать уникальный UUID для каждого устройства, используя ANDROID_ID в качестве начального числа, где это необходимо, используя при необходимости TelephonyManager.getDeviceId(), а в случае неудачи прибегая к случайно генерируемому уникальному UUID. это сохраняется при перезапуске приложения (но не при переустановке приложения).
Обратите внимание, что для устройств, которые вынуждены использовать идентификатор устройства, уникальный идентификатор будет сохраняться при сбросе до заводских настроек. Это то, что нужно знать. Если вам необходимо убедиться, что сброс настроек к заводским установкам приведет к сбросу вашего уникального идентификатора, вы можете рассмотреть возможность возврата непосредственно к случайному UUID вместо идентификатора устройства.
Опять же, этот код предназначен для идентификатора устройства, а не идентификатора установки приложения. В большинстве случаев, идентификатор установки приложения, вероятно, то, что вы ищете. Но если вам нужен идентификатор устройства, то следующий код, вероятно, будет работать для вас.
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;
}
}
Вот код, который Reto Meier использовал в презентации Google I/O в этом году, чтобы получить уникальный идентификатор для пользователя:
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;
}
Если вы соедините это со стратегией резервного копирования для отправки настроек в облако (также описано в выступлении Рето, у вас должен быть идентификатор, который привязывается к пользователю и остается после того, как устройство было стерто или даже заменено. Я планирую использовать это в аналитике, идущей вперед (другими словами, я еще этого не сделал:).
Это простой вопрос, на который нет простого ответа.
Более того, все существующие ответы здесь устарели или ненадежны.
Итак, если вы ищете решение в 2020 году.
Вот несколько вещей, о которых следует помнить:
Все аппаратные идентификаторы (SSAID, IMEI, MAC и т. Д.) Ненадежны для устройств, не принадлежащих Google (все, кроме пикселей и нексусов), которые составляют более 50% активных устройств во всем мире. Поэтому в лучших практиках официальных идентификаторов Android четко указано:
Избегайте использования аппаратных идентификаторов, таких как SSAID (Android ID), IMEI, MAC-адрес и т. Д.
Это делает большинство приведенных выше ответов недействительными. Также из-за различных обновлений безопасности Android некоторые из них требуют более новых и более строгих разрешений времени выполнения, что может быть просто отклонено пользователем.
Как пример CVE-2018-9489 что влияет на все упомянутые выше методы на основе WIFI.
Это делает эти идентификаторы не только ненадежными, но и во многих случаях недоступными.
Итак, проще говоря: не используйте эти методы.
Многие другие ответы здесь предлагают использовать AdvertisingIdClient, который также несовместим, так как по замыслу должен использоваться только для профилирования рекламы. Об этом также говорится в официальной справке.
Используйте рекламный идентификатор только для профилирования пользователей или вариантов использования рекламы
Это не только ненадежно для идентификации устройства, но вы также должны соблюдать конфиденциальность пользователя в отношении политики отслеживания рекламы, в которой четко указано, что пользователь может сбросить или заблокировать ее в любой момент.
Так что и не используйте его.
Поскольку у вас не может быть желаемого статического глобально уникального и надежного идентификатора устройства. Официальный справочник Android предлагает:
По возможности используйте FirebaseInstanceId или GUID, хранящийся в частном порядке, для всех других случаев использования, кроме предотвращения мошенничества с платежами и телефонии.
Это уникально для установки приложения на устройство, поэтому, когда пользователь удаляет приложение - оно стирается, поэтому оно не на 100% надежно, но это еще одна лучшая вещь.
Использовать FirebaseInstanceIdдобавьте последнюю зависимость обмена сообщениями firebase в свой gradle
implementation 'com.google.firebase:firebase-messaging:20.2.4'
И используйте приведенный ниже код в фоновом потоке:
String reliableIdentifier = FirebaseInstanceId.getInstance().getId();
Если вам нужно сохранить идентификацию устройства на удаленном сервере, сохраняйте его не как есть (обычный текст), а в виде хеша с солью.
Сегодня это не только лучшая практика, вы фактически должны делать это по закону в соответствии с GDPR - идентификаторами и аналогичными правилами.
Также вы можете рассмотреть MAC-адрес адаптера Wi-Fi. Получено таким образом:
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
Здесь довольно полезная информация.
Он охватывает пять различных типов удостоверений личности:
- IMEI (только для устройств Android с телефоном; требуется
android.permission.READ_PHONE_STATE) - Псевдо-уникальный идентификатор (для всех устройств Android)
- Идентификатор Android (может быть нулевым, может быть изменен при сбросе настроек, может быть изменен на рутированном телефоне)
- Строка MAC-адреса WLAN (необходимо
android.permission.ACCESS_WIFI_STATE) - Строка MAC-адреса BT (устройства с Bluetooth, нужны
android.permission.BLUETOOTH)
В официальном блоге разработчиков Android теперь есть полная статья, посвященная этой теме, " Определение установок приложений".
В Google I/O Рето Мейер (Rto Meier) выпустил исчерпывающий ответ о том, как подойти к этому, что должно отвечать большинству разработчиков, чтобы отслеживать пользователей в различных установках Энтони Нолан показывает направление в своем ответе, но я подумал, что напишу полный подход, чтобы другие могли легко увидеть, как это сделать (мне потребовалось время, чтобы выяснить детали).
Этот подход даст вам анонимный, безопасный идентификатор пользователя, который будет постоянным для пользователя на разных устройствах (в зависимости от основной учетной записи Google) и во время установки. Основной подход заключается в создании произвольного идентификатора пользователя и сохранении его в общих настройках приложений. Затем вы используете агент резервного копирования Google для хранения общих настроек, связанных с учетной записью Google, в облаке.
Давайте пройдем через полный подход. Во-первых, нам нужно создать резервную копию наших SharedPreferences с помощью службы резервного копирования Android. Начните с регистрации вашего приложения через 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);
}
}
Для завершения резервного копирования вам нужно создать экземпляр BackupManager в вашей основной деятельности:
BackupManager backupManager = new BackupManager(context);
Наконец, создайте идентификатор пользователя, если он еще не существует, и сохраните его в 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 теперь будет постоянным во всех установках, даже если пользователь перемещает устройство.
Для получения дополнительной информации об этом подходе см. Доклад Рето.
А для получения полной информации о том, как реализовать агент резервного копирования, см. Резервное копирование данных. Я особенно рекомендую раздел внизу, посвященный тестированию, поскольку резервное копирование не происходит мгновенно, поэтому для тестирования необходимо принудительно создать резервную копию.
Я думаю, что это верный способ построить скелет для уникального идентификатора... проверить это.
Псевдо-уникальный идентификатор, который работает на всех устройствах Android. На некоторых устройствах нет телефона (например, планшета) или по какой-то причине вы не хотите включать разрешение READ_PHONE_STATE. Вы по-прежнему можете читать такие сведения, как версия ПЗУ, имя производителя, тип ЦП и другие сведения об оборудовании, которые хорошо подойдут, если вы хотите использовать идентификатор для проверки серийного ключа или других общих целей. Вычисленный таким образом идентификатор не будет уникальным: можно найти два устройства с одинаковым идентификатором (на основе одного и того же оборудования и образа ПЗУ), но изменения в реальных приложениях незначительны. Для этого вы можете использовать класс 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 (15 цифр). Есть и другие возможности, просто взгляните на эти строки. Возвращает что-то вроде 355715565309247, Специального разрешения не требуется, что делает этот подход очень удобным.
(Дополнительная информация: техника, приведенная выше, была скопирована из статьи о Pocket Magic.)
Следующий код возвращает серийный номер устройства с помощью скрытого 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) {
}
Используя приведенный ниже код, вы можете получить уникальный идентификатор устройства Android OS в виде строки.
deviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID);
Я добавлю одну вещь - у меня одна из тех уникальных ситуаций.
С помощью:
deviceId = Secure.getString(this.getContext().getContentResolver(), Secure.ANDROID_ID);
Оказывается, что хотя мой планшет Viewsonic G сообщает об идентификаторе устройства, который не является нулевым, каждый планшет G сообщает одно и то же число.
Это делает интересной игру в "Pocket Empires", которая дает вам мгновенный доступ к чьей-либо учетной записи на основе "уникального" DeviceID.
У моего устройства нет сотового радио.
Серийное поле было добавлено к Build класс в API уровня 9 (Android 2.3 - Gingerbread). Документация говорит, что это представляет серийный номер оборудования. При этом он должен быть уникальным, если он существует на устройстве.
Я не знаю, поддерживается ли он (= не ноль) всеми устройствами с уровнем API>= 9.
Подробные инструкции о том, как получить уникальный идентификатор для каждого устройства Android, с которого установлено приложение, см. В официальном блоге разработчиков Android, в котором описывается определение установок приложений.
Похоже, что лучший способ для вас - создать его самостоятельно после установки, а затем прочитать его при перезапуске приложения.
Я лично считаю это приемлемым, но не идеальным. Ни один идентификатор, предоставляемый Android, не работает во всех случаях, так как большинство из них зависит от состояния радиосвязи телефона (вкл / выкл Wi-Fi, вкл / выкл сотовой связи, вкл / выкл Bluetooth). Остальные, как 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();
}
}
Добавьте код ниже в файл класса:
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" />
Есть много разных подходов, чтобы обойти эти ANDROID_ID проблемы (может быть null иногда или устройства определенной модели всегда возвращают один и тот же идентификатор) с плюсами и минусами:
- Реализация собственного алгоритма генерации идентификатора (на основе свойств устройства, которые должны быть статическими и не изменятся -> кто знает)
- Злоупотребление другими идентификаторами, такими как IMEI, серийный номер, Wi-Fi/Bluetooth-MAC-адрес (они не будут существовать на всех устройствах, или потребуются дополнительные разрешения)
Я сам предпочитаю использовать существующую реализацию OpenUDID (см. https://github.com/ylechelle/OpenUDID) для Android (см. https://github.com/vieux/OpenUDID). Это легко интегрировать и использует ANDROID_ID с запасными вариантами для тех проблем, упомянутых выше.
Мои два цента - NB это для уникального идентификатора устройства (err) - не установочный, как обсуждалось в блоге разработчиков Android.
Следует отметить, что решение, предоставляемое @emmby, использует идентификатор каждого приложения, поскольку SharedPreferences не синхронизируются между процессами (см. Здесь и здесь). Так что я вообще этого избежал.
Вместо этого я инкапсулировал различные стратегии получения идентификатора (устройства) в перечислении - изменение порядка перечисления констант влияет на приоритет различных способов получения идентификатора. Возвращается первый ненулевой идентификатор или генерируется исключение (в соответствии с хорошими практиками 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);
}
}
}
Здесь более 30 ответов, и некоторые из них одинаковы, а некоторые уникальны. Этот ответ основан на нескольких из этих ответов. Одним из них является ответ @Lenn Dolling.
Он объединяет 3 идентификатора и создает 32-значную шестнадцатеричную строку. Это сработало очень хорошо для меня.
3 идентификатора:
Псевдо-ID - генерируется на основе спецификаций физического устройства.
ANDROID_ID - Settings.Secure.ANDROID_ID
Адрес Bluetooth - адрес адаптера Bluetooth
Он вернет что-то вроде этого: 551F27C060712A72730B0A0F734064B1
Примечание. Вы всегда можете добавить дополнительные идентификаторы к longId строка. Например, Серийный №. адрес адаптера Wi-Fi. 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 "";
}
Как насчет IMEI. Это уникально для Android или других мобильных устройств.
Уникальный идентификатор устройства Android OS как String, используя 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, см. Определение установок приложений.
Вот как я генерирую уникальный идентификатор:
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;
}
Другой способ заключается в использовании /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" в непривилегированных приложениях, где я обсуждаю, какие другие файлы доступны для информации.
Я использую следующий код, чтобы получить 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);
Для аппаратного распознавания определенного устройства Android вы можете проверить MAC-адреса.
Вы можете сделать это так:
в AndroidManifest.xml
<uses-permission android:name="android.permission.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 не включен.
PS Это множество других интерфейсов, которые вы получите из списка, содержащего MACS, но это может измениться между телефонами.
Идентификатор Google Instance
Выпущено в 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 намеревается использовать этот идентификатор для идентификации установок через Android, Chrome и iOS.
Он идентифицирует установку, а не устройство, но опять же, ANDROID_ID (который является принятым ответом) теперь больше не идентифицирует устройства. Во время выполнения ARC новый ANDROID_ID генерируется для каждой установки ( подробности здесь), как и этот новый идентификатор экземпляра. Кроме того, я думаю, что большинство из нас на самом деле ищут определение установок (не устройств).
Преимущества ID экземпляра
Мне кажется, что Google намеревается использовать его для этой цели (идентифицируя ваши установки), он кроссплатформенный и может использоваться для ряда других целей (см. Ссылки выше).
Если вы используете GCM, то в конечном итоге вам понадобится использовать этот идентификатор экземпляра, потому что он нужен вам для получения токена GCM (который заменяет старый регистрационный идентификатор GCM).
Недостатки / проблемы
В текущей реализации (GPS 7.5) идентификатор экземпляра извлекается с сервера, когда ваше приложение запрашивает его. Это означает, что вышеуказанный вызов является блокирующим вызовом - в моем ненаучном тестировании это занимает 1-3 секунды, если устройство подключено к сети, и 0,5 - 1,0 секунды, если устройство находится в автономном режиме (предположительно, это то, сколько времени он ожидает, прежде чем сдаться и сгенерировать случайный идентификатор). Это было протестировано в Северной Америке на Nexus 5 с Android 5.1.1 и GPS 7.5.
Если вы используете ID для целей, для которых они предназначены - например. аутентификация приложения, идентификация приложения, GCM - я думаю, что это 1-3 секунды, что может быть неприятно (в зависимости от вашего приложения, конечно).
TelephonyManger.getDeviceId() Возвращает уникальный идентификатор устройства, например, IMEI для GSM и MEID или ESN для телефонов CDMA.
final TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
String myAndroidDeviceId = mTelephony.getDeviceId();
Но я рекомендую использовать:
Settings.Secure.ANDROID_ID, который возвращает идентификатор Android в виде уникальной 64-битной шестнадцатеричной строки.
String myAndroidDeviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID);
Иногда TelephonyManger.getDeviceId() будет возвращать null, поэтому для обеспечения уникального идентификатора вы будете использовать этот метод:
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;
}
Чтобы понять доступные уникальные идентификаторы в устройствах Android. Используйте это официальное руководство.
Лучшие практики для уникальных идентификаторов:
IMEI, адреса Mac, идентификатор экземпляра, GUID, SSAID, идентификатор рекламы, API сети безопасности для проверки устройств.
https://developer.android.com/training/articles/user-data-ids
У Google теперь есть рекламный идентификатор.
Это также можно использовать, но учтите, что:
Рекламный идентификатор - это уникальный для пользователя, сбрасываемый идентификатор
а также
позволяет пользователям сбросить свой идентификатор или отказаться от рекламы на основе интересов в приложениях Google Play.
Таким образом, хотя этот идентификатор может измениться, кажется, что вскоре у нас может не быть выбора, зависит от цели этого идентификатора.
Больше информации @ develper.android
Скопируйте и вставьте код здесь
НТН