Как насчет 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, не придающими значения null). Так, например, у меня сначала есть ТЕЛЕФОНИЯ, но хорошим выбором по умолчанию будет 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);
        }
    }
}

Другой способ - использовать /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
• Мини MK802
• 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;
}

Идентификатор экземпляра Google

Выпущено на 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 (подробности здесь), как и этот новый идентификатор экземпляра. Кроме того, я думаю, что идентификация установок (а не устройств) - это то, что на самом деле ищет большинство из нас.

Преимущества идентификатора экземпляра

Мне кажется, что 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 секунды могут доставить неудобства (конечно, в зависимости от вашего приложения).

Для аппаратного распознавания конкретного устройства 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 не включен.

P.S. Это множество других интерфейсов, которые вы получите из списка, содержащего 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);

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

Рекомендации по использованию уникальных идентификаторов.

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

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

Теперь у Google есть рекламный идентификатор.
Он также может использоваться, но учтите, что:

Рекламный идентификатор - это уникальный сбрасываемый идентификатор, зависящий от пользователя.

а также

позволяет пользователям сбросить свой идентификатор или отказаться от рекламы на основе интересов в приложениях Google Play.

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

Дополнительная информация @ develper.android

Скопируйте и вставьте сюда код

HTH

1. Используйте диспетчер телефонии, который предоставляет уникальный идентификатор (например, IMEI). См. Пример,

import android.telephony.TelephonyManager;
import android.content.Context;
// ...
TelephonyManager telephonyManager;
telephonyManager = (TelephonyManager) getSystemService(Context.
                TELEPHONY_SERVICE);
/*
* getDeviceId() returns the unique device ID.
* For example,the IMEI for GSM and the MEID or ESN for CDMA phones.
*/
String deviceId = telephonyManager.getDeviceId();
/*
* getSubscriberId() returns the unique subscriber ID,
*/
String subscriberId = telephonyManager.getSubscriberId();

Это требует android.permission.READ_PHONE_STATE от вашего пользователя, что может быть трудно оправдать, следуя типу приложения, которое вы сделали.

2. Устройства без услуг телефонии, такие как планшеты, должны сообщать уникальный идентификатор устройства, доступный через android.os.Build.SERIAL, начиная с Android 2.3 Gingerbread. Некоторые телефоны с услугами телефонии также могут определять серийный номер. Поскольку не все устройства Android имеют серийный номер, это решение ненадежно.

3. При первой загрузке устройства генерируется и сохраняется случайное значение. Это значение доступно через Settings.Secure.ANDROID_ID. Это 64-битное число, которое должно оставаться постоянным на протяжении всего срока службы устройства. ANDROID_ID кажется хорошим выбором для уникального идентификатора устройства, поскольку он доступен для смартфонов и планшетов. Чтобы получить значение, вы можете использовать следующий код,

   Строка androidId = Settings.Secure.getString (getContentResolver (), Settings.Secure.ANDROID_ID);

Однако значение может измениться, если на устройстве будет выполнен сброс настроек до заводских. Также есть известная ошибка в популярном телефоне от производителя, где на каждом экземпляре есть одинаковый ANDROID_ID. Ясно, что решение не на 100% надежно.

4. Используйте UUID. Поскольку требование для большинства приложений - идентифицировать конкретную установку, а не физическое устройство, хорошее решение для получения уникального идентификатора для пользователя, если использовать класс UUID. Следующее решение было представлено Рето Мейером из Google в презентации Google I / O:

SharedPreferences sharedPrefs = context.getSharedPreferences(
         PREF_UNIQUE_ID, Context.MODE_PRIVATE);
uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);

Обновление: варианты №1 и №2 больше не доступны после Android 10 в связи с обновлениями конфиденциальности от Google. поскольку вариант 2 и 3 требует критического разрешения.

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

Используйте следующий код, чтобы получить идентификатор Mac:

WifiManager manager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
WifiInfo info = manager.getConnectionInfo();
String address = info.getMacAddress();

Кроме того, не забудьте добавить соответствующие разрешения в свой AndroidManifest.xml:

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

Напоминаем всем, кто читает и ищет более свежую информацию. В Android O внесены некоторые изменения в то, как система управляет этими идентификаторами.

https://android-developers.googleblog.com/2017/04/changes-to-device-identifiers-in.html

tl; dr Serial потребует разрешения ТЕЛЕФОНА, а идентификатор Android будет изменяться для разных приложений в зависимости от имени пакета и подписи.

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

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

Обычно я использую уникальный идентификатор устройства для своих приложений. Но иногда пользуюсь IMEI. Оба номера уникальны.

чтобы получить IMEI (международный идентификатор мобильного оборудования)

public String getIMEI(Activity activity) {
    TelephonyManager telephonyManager = (TelephonyManager) activity
            .getSystemService(Context.TELEPHONY_SERVICE);
    return telephonyManager.getDeviceId();
}

чтобы получить уникальный идентификатор устройства

public String getDeviceUniqueID(Activity activity){
    String device_unique_id = Secure.getString(activity.getContentResolver(),
            Secure.ANDROID_ID);
    return device_unique_id;
}

Я столкнулся с этим вопросом несколько лет назад и научился реализовывать обобщенное решение, основанное на различных ответах.

Я использовал обобщенное решение в течение нескольких лет в реальном продукте. Пока он мне служит очень хорошо. Вот фрагмент кода, основанный на различных ответах.

Обратите внимание, что getEmail большую часть времени будет возвращать null, поскольку мы не запрашивали разрешение явно.

private static UniqueId getUniqueId() {
    MyApplication app = MyApplication.instance();

    // Our prefered method of obtaining unique id in the following order.
    // (1) Advertising id
    // (2) Email
    // (2) ANDROID_ID
    // (3) Instance ID - new id value, when reinstall the app.

    ////////////////////////////////////////////////////////////////////////////////////////////
    // ADVERTISING ID
    ////////////////////////////////////////////////////////////////////////////////////////////
    AdvertisingIdClient.Info adInfo = null;
    try {
        adInfo = AdvertisingIdClient.getAdvertisingIdInfo(app);
    } catch (IOException e) {
        Log.e(TAG, "", e);
    } catch (GooglePlayServicesNotAvailableException e) {
        Log.e(TAG, "", e);
    } catch (GooglePlayServicesRepairableException e) {
        Log.e(TAG, "", e);
    }

    if (adInfo != null) {
        String aid = adInfo.getId();
        if (!Utils.isNullOrEmpty(aid)) {
            return UniqueId.newInstance(aid, UniqueId.Type.aid);
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    // EMAIL
    ////////////////////////////////////////////////////////////////////////////////////////////
    final String email = Utils.getEmail();
    if (!Utils.isNullOrEmpty(email)) {
        return UniqueId.newInstance(email, UniqueId.Type.eid);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    // ANDROID ID
    ////////////////////////////////////////////////////////////////////////////////////////////
    final String sid = Settings.Secure.getString(app.getContentResolver(), Settings.Secure.ANDROID_ID);
    if (!Utils.isNullOrEmpty(sid)) {
        return UniqueId.newInstance(sid, UniqueId.Type.sid);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    // INSTANCE ID
    ////////////////////////////////////////////////////////////////////////////////////////////
    final String iid = com.google.android.gms.iid.InstanceID.getInstance(MyApplication.instance()).getId();
    if (!Utils.isNullOrEmpty(iid)) {
        return UniqueId.newInstance(iid, UniqueId.Type.iid);
    }

    return null;
}

public final class UniqueId implements Parcelable {
    public enum Type implements Parcelable {
        aid,
        sid,
        iid,
        eid;

        ////////////////////////////////////////////////////////////////////////////
        // Handling Parcelable nicely.

        public static final Parcelable.Creator<Type> CREATOR = new Parcelable.Creator<Type>() {
            public Type createFromParcel(Parcel in) {
                return Type.valueOf(in.readString());
            }

            public Type[] newArray(int size) {
                return new Type[size];
            }
        };

        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(Parcel parcel, int flags) {
            parcel.writeString(this.name());
        }

        // Handling Parcelable nicely.
        ////////////////////////////////////////////////////////////////////////////
    }

    public static boolean isValid(UniqueId uniqueId) {
        if (uniqueId == null) {
            return false;
        }
        return uniqueId.isValid();
    }

    private boolean isValid() {
        return !org.yccheok.jstock.gui.Utils.isNullOrEmpty(id) && type != null;
    }

    private UniqueId(String id, Type type) {
        if (org.yccheok.jstock.gui.Utils.isNullOrEmpty(id) || type == null) {
            throw new java.lang.IllegalArgumentException();
        }
        this.id = id;
        this.type = type;
    }

    public static UniqueId newInstance(String id, Type type) {
        return new UniqueId(id, type);
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + id.hashCode();
        result = 31 * result + type.hashCode();
        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        }

        if (!(o instanceof UniqueId)) {
            return false;
        }

        UniqueId uniqueId = (UniqueId)o;
        return this.id.equals(uniqueId.id) && this.type == uniqueId.type;
    }

    @Override
    public String toString() {
        return type + ":" + id;
    }

    ////////////////////////////////////////////////////////////////////////////
    // Handling Parcelable nicely.

    public static final Parcelable.Creator<UniqueId> CREATOR = new Parcelable.Creator<UniqueId>() {
        public UniqueId createFromParcel(Parcel in) {
            return new UniqueId(in);
        }

        public UniqueId[] newArray(int size) {
            return new UniqueId[size];
        }
    };

    private UniqueId(Parcel in) {
        this.id = in.readString();
        this.type = in.readParcelable(Type.class.getClassLoader());
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel parcel, int flags) {
        parcel.writeString(this.id);
        parcel.writeParcelable(this.type, 0);
    }

    // Handling Parcelable nicely.
    ////////////////////////////////////////////////////////////////////////////

    public final String id;
    public final Type type;
}

public static String getEmail() {
    Pattern emailPattern = Patterns.EMAIL_ADDRESS; // API level 8+
    AccountManager accountManager = AccountManager.get(MyApplication.instance());
    Account[] accounts = accountManager.getAccountsByType("com.google");
    for (Account account : accounts) {
        if (emailPattern.matcher(account.name).matches()) {
            String possibleEmail = account.name;
            return possibleEmail;
        }
    }

    accounts = accountManager.getAccounts();
    for (Account account : accounts) {
        if (emailPattern.matcher(account.name).matches()) {
            String possibleEmail = account.name;
            return possibleEmail;
        }
    }

    return null;
} 

Не рекомендуется, так как deviceId можно использовать для отслеживания в сторонних руках, но это другой способ.

@SuppressLint("HardwareIds")
private String getDeviceID() {
    deviceId = Settings.Secure.getString(getApplicationContext().getContentResolver(),
                    Settings.Secure.ANDROID_ID);
    return deviceId;
}

Вот простой ответ, чтобы получить AAID, протестировано, работает правильно, июнь 2019 г.

 AsyncTask<Void, Void, String> task = new AsyncTask<Void, Void, String>() {
        @Override
        protected String doInBackground(Void... params) {
            String token = null;
            Info adInfo = null;
            try {
                adInfo = AdvertisingIdClient.getAdvertisingIdInfo(getApplicationContext());
            } catch (IOException e) {
                // ...
            } catch ( GooglePlayServicesRepairableException e) {
                // ...
            } catch (GooglePlayServicesNotAvailableException e) {
                // ...
            }
            String android_id = adInfo.getId();
            Log.d("DEVICE_ID",android_id);

            return android_id;
        }

        @Override
        protected void onPostExecute(String token) {
            Log.i(TAG, "DEVICE_ID Access token retrieved:" + token);
        }

    };
    task.execute();

прочтите полный ответ подробно здесь:

Получите D UUID устройства, номер модели с названием бренда и его номер версии с помощью функции ниже.

Работает в Android 10 безупречно, и вам не нужно разрешать чтение состояния телефона.

Фрагменты кода:

private void fetchDeviceInfo() {
    String uniquePseudoID = "35" +
            Build.BOARD.length() % 10 +
            Build.BRAND.length() % 10 +
            Build.DEVICE.length() % 10 +
            Build.DISPLAY.length() % 10 +
            Build.HOST.length() % 10 +
            Build.ID.length() % 10 +
            Build.MANUFACTURER.length() % 10 +
            Build.MODEL.length() % 10 +
            Build.PRODUCT.length() % 10 +
            Build.TAGS.length() % 10 +
            Build.TYPE.length() % 10 +
            Build.USER.length() % 10;

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

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

Чтобы включить Android 9, у меня есть только одна идея, которая (вероятно) не нарушает никаких условий, не требует разрешений и работает с разными установками и приложениями.

Отпечатки пальцев на сервере должны позволять однозначно идентифицировать устройство. Сочетание информации об оборудовании + установленных приложений и времени установки должно помочь. Время первой установки не изменится, если приложение не будет удалено и снова установлено. Но это необходимо сделать для всех приложений на устройстве, чтобы они не могли идентифицировать устройство (например, после сброса настроек).

Вот как я бы это сделал:

1. Извлеките информацию об оборудовании, названиях пакетов приложений и времени первой установки.

Вот как вы извлекаете все приложения из Android (разрешения не требуются):

final PackageManager pm = application.getPackageManager();
List<ApplicationInfo> packages = 
pm.getInstalledApplications(PackageManager.GET_META_DATA);

for (ApplicationInfo packageInfo : packages) {
    try {
        Log.d(TAG, "Installed package :" + packageInfo.packageName);
        Log.d(TAG, "Installed :" + pm.getPackageInfo(packageInfo.packageName, 0).firstInstallTime);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
}

2. Вы можете захотеть создать хэш для каждой комбинации имени пакета и метки времени установки, прежде чем отправлять ее на сервер, поскольку это может или не может быть связано с вашим бизнесом, что пользователь установил на устройстве.
3. Некоторые приложения (на самом деле их много) являются системными. Скорее всего, они будут иметь одинаковую метку времени установки, соответствующую последнему обновлению системы после сброса к заводским настройкам. Поскольку они имеют одинаковую метку времени установки, они не могут быть установлены пользователем и могут быть отфильтрованы.
4. Отправьте информацию на сервер и позвольте ему найти ближайшее совпадение среди ранее сохраненной информации. Вам необходимо установить порог при сравнении с ранее сохраненной информацией об устройстве по мере установки и удаления приложений. Но я предполагаю, что этот порог может быть очень низким, поскольку любое сочетание имени пакета и отметки времени первой установки само по себе будет довольно уникальным для устройства, а приложения не так часто устанавливаются и удаляются. Наличие нескольких приложений только увеличивает вероятность быть уникальным.
5. Верните сгенерированный уникальный идентификатор для соответствия или сгенерируйте уникальный идентификатор, сохраните с информацией об устройстве и верните этот новый идентификатор.

NB: это непроверенный и непроверенный метод! Я уверен, что это сработает, но я также почти уверен, что, если это приживется, они так или иначе закроют его.

Если вы добавите:

Settings.Secure.getString(context.contentResolver,
    Settings.Secure.ANDROID_ID)

Android Lint выдаст следующее предупреждение:

Не рекомендуется использовать getString для получения идентификаторов устройств. Информация для проверки: использование этих идентификаторов устройств не рекомендуется, кроме как для предотвращения крупного мошенничества и сложных случаев использования телефонии. Для рекламных случаев используйте AdvertisingIdClient $ Info # getId, а для аналитики - InstanceId # getId.

Поэтому вам следует избегать этого.

Как указано в документации для разработчиков Android :

1: Избегайте использования идентификаторов оборудования.

В большинстве случаев вы можете избежать использования аппаратных идентификаторов, таких как SSAID (Android ID) и IMEI, без ограничения необходимой функциональности.

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

При использовании рекламного идентификатора всегда уважайте выбор пользователей в отношении отслеживания рекламы. Кроме того, убедитесь, что идентификатор не может быть связан с информацией, позволяющей установить личность (PII), и избегайте параллельного сброса идентификатора рекламы.

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

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

4. Используйте API-интерфейсы, подходящие для вашего варианта использования, чтобы минимизировать риск конфиденциальности.

Используйте DRM API для защиты ценных материалов и API SafetyNet для защиты от злоупотреблений. API-интерфейсы SafetyNet - это самый простой способ определить, является ли устройство подлинным, без риска для конфиденциальности.

String SERIAL_NUMER = Build.SERIAL;

Возвращает СЕРИЙНЫЙ НОМЕР в виде строки, уникальной для каждого устройства.

Серийный номер - это уникальный идентификатор устройства, доступный через android.os.Build.SERIAL.

public static String getSerial() {
    String serial = "";
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
        serial = Build.getSerial();
    }else{ 
        serial = Build.SERIAL;    
    }
    return serial;
}

Перед вызовом getSerial () убедитесь, что у вас есть разрешение READ_PHONE_STATE.

ПРИМЕЧАНИЕ. - Недоступно для устройств без телефонии (например, планшетов только с Wi-Fi).

Для полноты, вот как вы можете получить Id в Xamarin.Android и C #:

var id = Settings.Secure.GetString(ContentResolver, Settings.Secure.AndroidId);

Или, если вы не в Activity:

var id = Settings.Secure.GetString(context.ContentResolver, Settings.Secure.AndroidId);

Где context - это переданный контекст.

android.telephony.TelephonyManager.getDeviceId()

Это вернет любую строку, однозначно идентифицирующую устройство (IMEI в GSM, MEID для CDMA).

Вам понадобится следующее разрешение в вашем AndroidManifest.xml:

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

Да, у каждого устройства Android есть уникальный серийный номер, который можно узнать из этого кода. Build.SERIAL. Обратите внимание, что он был добавлен только в API уровня 9 и может присутствовать не на всех устройствах. Чтобы получить уникальный идентификатор на более ранних платформах, вам нужно будет прочитать что-то вроде MAC-адреса или IMEI.

Проверьте SystemInfo.deviceUniqueIdentifier

Документация: http://docs.unity3d.com/Documentation/ScriptReference/SystemInfo-deviceUniqueIdentifier.html

Уникальный идентификатор устройства. Гарантия уникальности для каждого устройства (только чтение).

iOS: на устройствах до iOS7 возвращается хэш MAC-адреса. На устройствах iOS7 это будет UIDevice identifierForVendor или, если это не удается по какой-либо причине, ASIdentifierManager AdvertisingIdentifier.

Получите идентификатор устройства только один раз, а затем сохраните его в базе данных или файле. В этом случае, если это первая загрузка приложения, оно генерирует идентификатор и сохраняет его. В следующий раз потребуется только идентификатор, хранящийся в файле.

Чтобы получить идентификатор пользователя, вы можете использовать библиотеку лицензирования Google Play.

Чтобы загрузить эту библиотеку, откройте SDK Manager => SDK Tools. Путь к загруженным файлам библиотеки:

path_to_android_sdk_on_your_pc / extras / google / market_licensing / library

Включите библиотеку в свой проект (вы можете просто скопировать ее файлы).

Далее вам понадобится реализация интерфейса Policy (вы можете просто использовать один из двух файлов из библиотеки: ServerManagedPolicy или StrictPolicy).

Идентификатор пользователя будет предоставлен вам внутри processServerResponse() функции:

public void processServerResponse(int response, ResponseData rawData) {
    if(rawData != null) {
        String userId = rawData.userId
        // use/save the value
    }
    // ...
}

Затем вам нужно создать LicenseChecker с политикой и вызвать функцию checkAccess(). Используйте MainActivity.java в качестве примера того, как это сделать. MainActivity.java находится внутри этой папки:

path_to_android_sdk_on_your_pc / extras / google / market_licensing / sample / src / com / example / android / market / licensing

Не забудьте добавить разрешение CHECK_LICENSE к вашему AndroidManifest.xml.

Подробнее о библиотеке лицензирования: https://developer.android.com/google/play/licensing

Android ограничивает идентификатор, связанный с оборудованием, после Android O, поэтому Android_Id является решением для уникального идентификатора, но у него есть проблема, когда отражатель устройства генерирует новый android_id, чтобы преодолеть эту проблему, мы можем использовать DRUMID.

val WIDEVINE_UUID = UUID(-0x121074568629b532L, -0x5c37d8232ae2de13L)
val drumIDByteArray = MediaDrm(WIDEVINE_UUID).getPropertyByteArray(MediaDrm.PROPERTY_DEVICE_UNIQUE_ID)

val drumID = android.util.Base64.encodeToString(drumIDByteArray,android.util.Base64.DEFAULT)

Вы получите MAC-адрес Wi-Fi, используя следующий код, независимо от того, использовали ли вы случайный адрес при попытке подключиться к Wi-Fi или нет, и независимо от того, был ли Wi-Fi включен или выключен.

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

Получение MAC-адреса в Android 6.0

public static String getMacAddr() {
StringBuilder res1 = new StringBuilder();
try {
List<NetworkInterface> all =     
Collections.list(NetworkInterface.getNetworkInterfaces());
for (NetworkInterface nif : all) {    
if (!nif.getName().equalsIgnoreCase("p2p0")) continue;

        byte[] macBytes = nif.getHardwareAddress();
        if (macBytes == null) {
            continue;
        }

        res1 = new StringBuilder();
        for (byte b : macBytes) {
            res1.append(String.format("%02X:",b));
        }

        if (res1.length() > 0) {
            res1.deleteCharAt(res1.length() - 1);
        }
    }
} catch (Exception ex) {
}
return res1.toString();

}