Есть ли у Android-устройств уникальный идентификатор, и если да, то какой простой способ получить к нему доступ с помощью Java?

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 Blog, на которую ссылается ответ emmby (а именно, создание и сохранение a UUID#randomUUID()).

Есть много ответов на этот вопрос, большинство из которых будет работать только «некоторое время», и, к сожалению, этого недостаточно.

На основании моих тестов устройств (все телефоны, хотя бы один из которых не активирован):

1. Все протестированные устройства вернули значение для TelephonyManager.getDeviceId()
2. Все устройства GSM (все протестированные с SIM-картой) вернули значение для TelephonyManager.getSimSerialNumber()
3. Все устройства CDMA вернули ноль для getSimSerialNumber()(как и ожидалось)
4. Все устройства с добавленной учетной записью Google вернули значение для ANDROID_ID
5. Все устройства CDMA возвращали одно и то же значение (или производное одно и то же значение) для обоих ANDROID_IDи TelephonyManager.getDeviceId()- до тех пор, пока учетная запись Google была добавлена ​​во время установки.
6. У меня еще не было возможности протестировать устройства 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://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:

Начиная с 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

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

Как упоминает Дейв Уэбб, в блоге разработчиков 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;
}

Если вы соедините это со стратегией резервного копирования для отправки предпочтений в облако (также описано в выступлении Рето , у вас должен быть идентификатор, который привязывается к пользователю и остается после того, как устройство было стерто или даже заменено. Я планирую использовать это в аналитике, идущей вперед (другими словами, я еще этого не сделал :).

Также вы можете рассмотреть 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

Там довольно полезная информация здесь .

Он охватывает пять различных типов удостоверений личности:

1. IMEI (только для устройств Android с использованием телефона; необходимо android.permission.READ_PHONE_STATE)
2. Псевдо-уникальный идентификатор (для всех устройств Android)
3. Идентификатор Android (может быть нулевым, может быть изменен при сбросе настроек, может быть изменен на рутированном телефоне)
4. Строка MAC-адреса WLAN (необходимо android.permission.ACCESS_WIFI_STATE)
5. Строка 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 .)

Следующий код возвращает серийный номер устройства с помощью скрытого API Android. Но этот код не работает на 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) {

}

Это простой вопрос, без простого ответа.

Более того, все существующие здесь ответы являются либо устаревшими, либо ненадежными.

Так что, если вы ищете решение в 2020 году .

Вот несколько вещей, которые следует иметь в виду:

Все аппаратные идентификаторы (SSAID, IMEI, MAC и т. Д.) Ненадежны для устройств, не принадлежащих Google (все, кроме пикселей и связующих), которые составляют более 50% активных устройств во всем мире. Поэтому в официальных рекомендациях по идентификаторам Android четко говорится:

Избегайте использования аппаратных идентификаторов , таких как SSAID (идентификатор Android), IMEI, MAC-адрес и т. Д.

Это делает большинство ответов выше недействительными. Кроме того, из-за различных обновлений безопасности для Android некоторые из них требуют более новых и более строгих разрешений во время выполнения, которые могут быть просто отклонены пользователем.

В качестве примера, CVE-2018-9489который влияет на все технологии, основанные на WIFI, упомянутые выше.

Это делает эти идентификаторы не только ненадежными, но и недоступными во многих случаях.

Итак, проще говоря: не используйте эти методы .

Многие другие ответы здесь предлагают использовать AdvertisingIdClient, что также несовместимо, так как его дизайн должен использоваться только для профилирования рекламы. Это также указано в официальной ссылке

Используйте рекламный идентификатор только для профилирования пользователей или для случаев использования рекламы.

Это не только ненадежно для идентификации устройства, но вы также должны соблюдать конфиденциальность пользователя в отношении политики отслеживания рекламы , в которой четко указано, что пользователь может сбросить или заблокировать ее в любой момент.

Так что не используйте его тоже .

Поскольку вы не можете иметь желаемый статический глобально уникальный и надежный идентификатор устройства. Официальный справочник Android предлагает:

Используйте FirebaseInstanceId или конфиденциальный GUID, когда это возможно, для всех других случаев использования, кроме предотвращения мошенничества с платежами и телефонии.

Он уникален для установки приложения на устройстве, поэтому, когда пользователь удаляет приложение - оно стирается, поэтому оно не на 100% надежно, но это следующая лучшая вещь.

Чтобы использовать, FirebaseInstanceIdдобавьте последнюю версию Firebase -сообщений в ваш Gradle

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

И используйте код ниже в фоновом потоке:

String reliableIdentifier = FirebaseInstanceId.getInstance().getId();

Если вам нужно сохранить идентификацию устройства на вашем удаленном сервере, не храните его как есть (простой текст), но хеш с солью .

Сегодня это не только лучшая практика, вы должны делать это по закону в соответствии с GDPR - идентификаторами и аналогичными правилами.

Используя приведенный ниже код, вы можете получить уникальный идентификатор устройства Android OS в виде строки.

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

Серийное поле было добавлено к Buildклассу уровня API 9 (Android 2.3 - Пряник). Документация говорит, что это представляет серийный номер оборудования. При этом он должен быть уникальным, если он существует на устройстве.

Я не знаю, поддерживается ли он (= не ноль) всеми устройствами с уровнем API> = 9.

Я добавлю одну вещь - у меня одна из тех уникальных ситуаций.

С помощью:

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

Оказывается, что хотя мой Viewsonic G Tablet сообщает об DeviceID, который не является нулевым, каждый G Tablet сообщает одно и то же число.

Это делает интересной игру в «Pocket Empires», которая дает вам мгновенный доступ к чьей-либо учетной записи на основе «уникального» DeviceID.

У моего устройства нет сотового радио.

Подробные инструкции о том, как получить уникальный идентификатор для каждого устройства 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 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, см. Определение установок приложений .

Существует много разных подходов к ANDROID_IDрешению этих проблем ( nullиногда это происходит, когда устройства определенной модели всегда возвращают один и тот же идентификатор) с плюсами и минусами:

• Реализация собственного алгоритма генерации идентификатора (на основе свойств устройства, которые должны быть статическими и не изменятся -> кто знает)
• Злоупотребление другими идентификаторами, такими как IMEI , серийный номер, Wi-Fi / Bluetooth-MAC-адрес (они не будут существовать на всех устройствах, или потребуются дополнительные разрешения)

Я сам предпочитаю использовать существующую реализацию OpenUDID (см. Https://github.com/ylechelle/OpenUDID ) для Android (см. Https://github.com/vieux/OpenUDID ). Он легко интегрируется и использует ANDROID_IDзапасные варианты с этими проблемами, упомянутыми выше.

Как насчет IMEI . Это уникально для Android или других мобильных устройств.

Вот как я генерирую уникальный идентификатор:

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;
}

Мои два цента - 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 "";
}

Другой способ - использовать /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
• Мини МК802
• Samsung Galaxy S II

Вы также можете увидеть мой пост в блоге « Утечка серийного номера оборудования Android» в непривилегированных приложениях, где я обсуждаю, какие другие файлы доступны для информации.

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 вы можете проверить 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, но это может измениться между телефонами.

Я использую следующий код, чтобы получить 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);

Более конкретно Settings.Secure.ANDROID_ID. Это 64-разрядная величина, которая генерируется и сохраняется при первой загрузке устройства. Сбрасывается при стирании устройства.

ANDROID_IDкажется хорошим выбором для уникального идентификатора устройства. Есть недостатки: во-первых, это не на 100% надежно в выпусках Android до 2.2. (“Froyo”).Кроме того, в популярном телефоне от одного крупного производителя была обнаружена, по крайней мере, одна широко распространенная ошибка, где каждый экземпляр имеет одинаковый ANDROID_ID.

Чтобы понять доступные уникальные идентификаторы в устройствах Android. Используйте это официальное руководство.

Лучшие практики для уникальных идентификаторов:

IMEI, адреса Mac, идентификатор экземпляра, GUID, SSAID, идентификатор рекламы, API сети безопасности для проверки устройств.

https://developer.android.com/training/articles/user-data-ids

Идентификатор 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.

Если вы используете идентификатор для целей, для которых они предназначены - например, аутентификация приложения, идентификация приложения, GCM - я думаю, что это 1-3 секунды, что может быть неприятно (в зависимости от вашего приложения, конечно).