変更 一意のAndroidデバイスIDはありますか?




15 Answers

更新 :Androidの最近のバージョンでは、 ANDROID_IDに関する問題の多くが解決されており、このアプローチはもはや必要ではないと私は考えています。 アンソニーの答えを見てください。

完全開示:私のアプリは元々は以下のアプローチを使用していましたが、このアプローチを使用しませんでした。そしてemmbyの回答リンク(つまり、 UUID#randomUUID()生成と保存UUID#randomUUID()android-developers.blogspot.com/2011/03/…エントリで概説されているアプローチを使用します。

この質問には多くの回答がありますが、そのほとんどは時間の「ある程度」しか働かず、残念ながら十分ではありません。

デバイスのテスト(少なくとも1つはアクティブ化されていないすべての電話機)に基づいています。

  1. テストされたすべてのデバイスは、 TelephonyManager.getDeviceId()値を返しました。
  2. すべてのGSMデバイス(すべてSIMでテスト済み)は、 TelephonyManager.getSimSerialNumber()値を返しました。
  3. すべてのCDMAデバイスがgetSimSerialNumber()に対してnullをgetSimSerialNumber()期待どおり)
  4. 追加されたGoogleアカウントを持つすべての端末で、 ANDROID_ID値が返されANDROID_ID
  5. ANDROID_IDTelephonyManager.getDeviceId()両方ANDROID_ID 、すべてのCDMAデバイスが同じ値(または同じ値の派生)をANDROID_ID - セットアップ中にGoogleアカウントが追加されている限り
  6. SIMがないGSMデバイス、Googleアカウントが追加されていないGSMデバイス、飛行機モードのデバイスをテストする機会はまだありませんでした。

したがって、デバイス自体に固有のものが必要な場合は、 TM.getDeviceId()で十分です。 明らかに、一部のユーザーは他のユーザーよりも編集的ですので、文字列はデバイスには依然として固有ですが、ユーザーの実際のデバイスを明示的に識別することはありません。 たとえば、 String.hashCode()を使用し、UUIDと組み合わせると、次のようになります。

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

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

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

次のような結果になることがあります: 00000000-54b3-e7c7-0000-000046bffd97

それは私のために十分に機能します。

Richardが以下に述べるように、 TelephonyManagerプロパティを読み取る権限が必要であることを忘れないでください。これをマニフェストに追加してください:

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

インポートライブラリ

import android.content.Context;
import android.telephony.TelephonyManager;
import android.view.View;
android_id 確認方法

Androidデバイスには固有のIDがありますか?その場合は、Javaを使用して簡単にアクセスできますか?




Dave Webbが言及しているように、 Android Developer Blogにはこれをカバーする記事があります。 彼らの好ましい解決策は、デバイスではなくアプリのインストールを追跡することであり、ほとんどのユースケースでうまくいくでしょう。 ブログ投稿には、その作業を行うために必要なコードが表示されます。チェックアウトすることをお勧めします。

しかし、ブログの投稿では、アプリのインストール識別子ではなくデバイス識別子が必要な場合の解決策について説明しています。 私はあなたがそうする必要がある場合、いくつかの項目についていくつかの追加の説明を得るために、Googleの誰かと話しました。 前述のブログの投稿に記載されていないデバイスIDについて、私が発見したのは次のとおりです。

  • ANDROID_IDが優先デバイス識別子です。 ANDROID_IDは、Android <2.1または> = 2.3のバージョンでは完全に信頼できます。 このポストで言及されている問題は2.2しかありません。
  • いくつかのメーカーのいくつかのデバイスは、2.2のANDROID_IDバグの影響を受けます。
  • 私が知る限り 、影響を受けるすべてのデバイスのANDROID_IDは同じです( 9774d56d682e549c 。 これは、エミュレータbtwによって報告された同じデバイスIDでもあります。
  • Googleでは、多くのデバイスまたは大部分のデバイスでOEMが問題を修正していると考えていますが、少なくとも2011年4月の時点では、ANDROID_IDが壊れているデバイスを見つけるのはまだ簡単です。

Googleの推奨事項に基づいて、必要に応じてANDROID_IDをシードとして使用し、必要に応じてTelephonyManager.getDeviceId()を使用して、各デバイスの固有のUUIDを生成するクラスを実装し、それが失敗した場合、ランダムに生成された一意のUUIDアプリの再起動後も保持されます(アプリの再インストールは不可)。

デバイスIDにフォールバックする必要のあるデバイスの場合、一意のIDは工場出荷時のリセットを通じて保持されます。 これは認識すべきことです。 工場出荷時のリセットで一意のIDがリセットされるようにする必要がある場合は、デバイスIDの代わりにランダムなUUIDに直接戻すことを検討してください。

ここでも、このコードはデバイスID用であり、アプリインストールID用ではありません。 ほとんどの場合、アプリインストールIDはおそらくあなたが探しているものです。 しかし、デバイスIDが必要な場合は、おそらく次のコードが役に立ちます。

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

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

public class DeviceUuidFactory {

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

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

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



また、Wi-FiアダプタのMACアドレスも考慮する必要があります。 リトリーブされた:

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

マニフェストにandroid.permission.ACCESS_WIFI_STATE権限が必要です。

Wi-Fiが接続されていない場合でも利用できると報告されています。 上記の答えのJoeが、これを多くのデバイスで試してみると、それはうれしいでしょう。

一部の端末では、Wi-Fiがオフの場合は利用できません。

注: Android 6.xから、一貫した偽のMACアドレスを返します: 02:00:00:00:00:00







次のコードは、隠しAndroid APIを使用してデバイスのシリアル番号を返します。しかし、このコードは、このデバイスで "ro.serialno"が設定されていないため、Samsung Galaxy Tabでは機能しません。

String serial = null;

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

}



以下のコードを使用すると、Android OSデバイスの一意のデバイスIDを文字列として取得できます。

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



私が追加することの1つは - 私はそれらの独特の状況の1つを持っています。

使用方法:

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

私のViewsonic G TabletがNullではないDeviceIDを報告しても、すべての単一G Tabletが同じ番号を報告することが分かります。

「ユニークな」DeviceIDに基づいて、誰かのアカウントに即座にアクセスできる「Pocket Empires」をプレイするのは面白いことです。

私のデバイスにはセルラ無線がありません。




下のクラスファイルにコードを追加:

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

AndroidManifest.xmlに追加:

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



長所と短所を持つこれらのANDROID_ID問題を回避するには、さまざまなアプローチがあります(null時には、特定のモデルのデバイスが常に同じIDを返すことがあります)

  • カスタムID生成アルゴリズムの実装(静的で、変更されないデバイスプロパティに基づいて - >誰が知っているか)
  • IMEI、シリアル番号、Wi-Fi / Bluetooth-MACアドレスなどの他のIDを悪用する(すべてのデバイスには存在しないか、追加の権限が必要になる)

私は自分自身がAndroid用の既存のOpenUDID実装(https://github.com/ylechelle/OpenUDID参照)を使用する方が好きです(https://github.com/vieux/OpenUDID参照)。ANDROID_ID上記の問題に対して、フォールバックを統合して使用するのは簡単です。




私の2セント - これはデバイス(エラー)固有のIDのためのものであり、Android開発者のブログで説明したようなインストールIDではありません。

ことに注意してsolution SharedPreferencesが(参照プロセス間で同期されていないよう@emmbyが提供するアプリケーションごとのIDにフォールバックしhereとhere)。だから、私はこれをすべて避けた。

代わりに、列挙型の(デバイス)IDを取得するためのさまざまな戦略をカプセル化しました。列挙型定数の順序を変更すると、IDを取得するさまざまな方法の優先順位に影響します。最初のnull以外のIDが返されるか、または例外がスローされます(Javaには意味がないことに注意してください)。つまり、私はTELEPHONYを最初に持っていますが、良いデフォルトの選択はANDROID_ID ベータです:

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

// TODO : hash
public final class DeviceIdentifier {

    private DeviceIdentifier() {}

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

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

    private static enum IDs {
        TELEPHONY_ID {

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

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

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

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

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

        abstract String getId(Context ctx) throws DeviceIDException;

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

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

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

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

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

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

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

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

    public static final class DeviceIDNotUniqueException extends
            DeviceIDException {

        private static final long serialVersionUID = -8940090896069484955L;

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



もう1つの方法は/sys/class/android_usb/android0/iSerial、許可なしにアプリで使用することです。

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

Javaでこれを行うには、FileInputStreamを使ってiSerialファイルを開き、文字を読み出すだけです。すべてのデバイスがこのファイルを持っているわけではないので、例外ハンドラにラップするようにしてください。

少なくとも次のデバイスは、このファイルを世界で読み取り可能とすることが知られています。

  • ギャラクシーネクサス
  • Nexus S
  • Motorola Xoom 3G
  • 東芝AT300
  • HTCワンV
  • ミニMK802
  • サムスンギャラクシーS II

私のブログの投稿を見ることもできます。Androidのハードウェアのシリアル番号が特権のないアプリ漏れています。




私は次のコードをIMEI使用してSecureを使用します。ANDROID_IDデバイスが電話機能を持たない場合の代替手段として、

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



GoogleインスタンスID

I / O 2015でリリース。AndroidではPlayサービスが必要です7.5。

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

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

Googleでは、このIDを使用してAndroid、Chrome、およびiOSのインストールを識別する予定です。

これはデバイスではなくインストールを識別しますが、ANDROID_ID(これは受け入れられた回答)はデバイスを識別しません。ARCランタイムでは、この新しいインスタンスIDと同様に、インストールごとに新しいANDROID_IDが生成されます(詳細はこちら)。また、私は、機器(機器ではない)を特定することは、私たちのほとんどが実際に探しているものだと私は考えます。

インスタンスIDの利点

Googleは、この目的で(インストールを特定する)、クロスプラットフォームで使用することを意図しており、他の多くの目的に使用できるように思われます(上記のリンクを参照)。

GCMを使用している場合は、最終的にこのインスタンスIDを使用する必要があります。これは、GCMトークン(古いGCM登録IDを置き換える)を取得するために必要なためです。

欠点/問題

現在の実装(GPS 7.5)では、アプリケーションが要求するとインスタンスIDがサーバーから取得されます。これは、上記の呼び出しがブロッキングコールであることを意味します。私の非科学的テストでは、デバイスがオンラインの場合は1〜3秒かかり、オフラインの場合は0.5〜1.0秒かかります(おそらくこれをあきらめてランダムID)。これは北米でAndroid 5.1.1とGPS 7.5を搭載したNexus 5でテストされました。

あなたが意図する目的のためにIDを使用する場合 - 例えば。アプリ認証、アプリID、GCM - この1〜3秒は迷惑であると思います(アプリにもよるが)。




ここには30以上の回答があり、いくつかは同じで、いくつかはユニークです。この回答は、それらの答えのいくつかに基づいています。それらの1つは@ Lenn Dollingの答えです。

3つのIDを結合し、32桁の16進数文字列を作成します。それは私のために非常にうまくいった。

3 IDは次のとおりです。
擬似ID - 物理デバイスの仕様に基づいて生成されます
。ANDROID_ID - Settings.Secure.ANDROID_ID
Bluetoothアドレス - Bluetoothアダプタアドレス

これは次のようなものを返します:551F27C060712A72730B0A0F734064B1

注:longId文字列には常にIDを追加できます。たとえば、シリアル番号。wifiアダプタアドレス。IMEI。この方法で、デバイスごとに固有のものにしています。

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

        String pseudoId = "35" +
                Build.BOARD.length() % 10 +
                Build.BRAND.length() % 10 +
                Build.CPU_ABI.length() % 10 +
                Build.DEVICE.length() % 10 +
                Build.DISPLAY.length() % 10 +
                Build.HOST.length() % 10 +
                Build.ID.length() % 10 +
                Build.MANUFACTURER.length() % 10 +
                Build.MODEL.length() % 10 +
                Build.PRODUCT.length() % 10 +
                Build.TAGS.length() % 10 +
                Build.TYPE.length() % 10 +
                Build.USER.length() % 10;

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

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

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

        String longId = pseudoId + androidId + btId;

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

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

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

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

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

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

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



TelephonyManger.getDeviceId()固有のデバイスIDを返します。たとえば、GSMのIMEI、CDMA電話のMEIDまたはESNなどを返します。

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

しかし、私は使用することをお勧めします:

Android IDを一意の64ビット16進数文字列として返すSettings.Secure.ANDROID_ID

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

場合によってはTelephonyManger.getDeviceId()はnullを返します。したがって、一意のIDを保証するには、このメソッドを使用します。

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



Related