UPDATE : a partir de versões recentes do Android, muitos dos problemas com ANDROID_ID foram resolvidos, e eu acredito que esta abordagem já não é necessária. Por favor, veja a resposta do Anthony.

Divulgação completa: o meu aplicativo usou a abordagem abaixo originalmente, mas já não usa mais esta abordagem, e agora usamos a abordagem delineada no Blog de desenvolvimento do Android entrada que a resposta de emmby ligações para (nomeadamente, gerar e salvar um UUID#randomUUID()).

Com base nos meus testes de dispositivos (todos os telefones, pelo menos um dos quais não está activado):

1. todos os dispositivos testados devolveram um valor para TelephonyManager.getDeviceId()
2. todos os dispositivos GSM (todos ensaiados com um SIM) devolveram um valor para TelephonyManager.getSimSerialNumber()
3. todos os dispositivos CDMA devolvidos nulos para getSimSerialNumber() (como esperado)
4. todos os dispositivos com uma conta do Google adicionada devolveram um valor para ANDROID_ID
5. todos os dispositivos CDMA devolveram o mesmo valor (ou derivação do mesmo valor) para {[[3]} e TelephonyManager.getDeviceId() -- desde que uma conta do Google tenha sido adicionada durante a configuração.
6. Eu ainda não tive a oportunidade de testar dispositivos GSM sem SIM, um dispositivo GSM sem Conta Google adicionada, ou qualquer um dos dispositivos no modo avião.

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();

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

Importação de libs

import android.content.Context;
import android.telephony.TelephonyManager;
import android.view.View;

Última Actualização: 6/2/15

Depois de ler todas as postagens de estouro de Stack sobre a criação de um ID único, O Blog do Google developer e a documentação do Android, sinto como se o 'Pseudo ID' fosse a melhor opção possível.

Questão principal: Hardware vs Software

Hardware

• Os utilizadores podem mudar o seu hardware, tablet Android ou telefone, por isso, identificações únicas baseadas no hardware não são boas ideias para rastrear os utilizadores
• para localização HARDWARE , esta é uma grande ideia

Software

• Os utilizadores podem limpar/alterar a sua ROM se estiverem enraizados
• pode seguir os utilizadores através das plataformas (iOS, Android, Windows e Web)
• O melhor que pode querer rastrear um utilizador individual com o seu consentimento é simplesmente fazer com que se autentiquem (fazer isto sem descontinuidades usando OAuth)

- garantir a unicidade (incluindo dispositivos enraizados) para API > = 9/10 (99,5% dos dispositivos Android)

- Sem permissões extra

Código Psuedo:

if API >= 9/10: (99.5% of devices)

return unique ID containing serial id (rooted devices may be different)

else

return unique ID of build information (may overlap data - API < 9)

Lista de opções-razões pelas quais/ por que não as utilizar:

• Software De E - Mail Do Utilizador

  • O Utilizador pode alterar o e - mail-muito improvável
  • API 5+ <uses-permission android:name="android.permission.GET_ACCOUNTS" /> ou
  • API 14+ <uses-permission android:name="android.permission.READ_PROFILE" /> <uses-permission android:name="android.permission.READ_CONTACTS" /> (como chegar o endereço de E-mail principal do dispositivo Android)

• Número De Telefone Do Utilizador-Software

  • Os utilizadores podem alterar os números de telefone-muito improvável
  • <uses-permission android:name="android.permission.READ_PHONE_STATE" />

• IMEI - Hardware (apenas telefones, necessidades android.permission.READ_PHONE_STATE)

  A maioria dos utilizadores odeia o facto de dizer "telefonemas" na autorização. Alguns usuários dão má audiência, porque eles acreditam que você está simplesmente roubando seus pessoais informação, quando tudo o que você realmente quer fazer é instalar dispositivos de localização. É óbvio que você está coletando dados.
• <uses-permission android:name="android.permission.READ_PHONE_STATE" />

Eu sei que não há nenhuma maneira 'perfeita' de obter um ID único sem usar permissões; no entanto, às vezes nós só precisamos realmente de rastrear a instalação do dispositivo. Quando se trata de criar um ID único, nós podemos criar um 'ID pseudo único' baseado apenas na informação que a API Android nos dá sem usar extra permissao. Desta forma, podemos mostrar o respeito do Usuário e tentar oferecer uma boa experiência do usuário também.

Com um ID pseudo-único, você realmente só se depara com o fato de que pode haver duplicados com base no fato de que existem dispositivos similares. Você pode ajustar o método combinado para torná-lo mais único; no entanto, alguns desenvolvedores precisam rastrear instalações de dispositivos e isso vai fazer o truque ou desempenho com base em dispositivos semelhantes.

API > = 9:

Lembre-se, tecnicamente só está a perder cerca de 0, 5% dos utilizadores que têm API . Então você pode se concentrar no resto: este é 99,5% dos usuários!

API

Se o dispositivo Android do Utilizador for inferior ao API 9; Esperemos que não tenham feito um reset de fábrica e o seu 'seguro'.ANDROID_ID "será preservado ou não "nulo". (ver http://developer.android.com/about/dashboards/index.html)

Se tudo o resto falhar:

Se tudo o resto falhar, se o utilizador tiver menos do que o API 9 (inferior ao Pão de gengibre), reiniciou o seu dispositivo ou 'seguro'.ANDROID_ID 'retorna ' null' , então simplesmente o ID retornado será baseado apenas em sua informação do dispositivo Android. É aqui que as colisões podem acontecer.

Alterações:

Andróide Removido.A SECURE_ID ' por causa de resets de fábrica poderia causar o valor a alterar
• editou o código para mudar na API
• alterei o Pseudo

Por favor, dê uma olhada no método abaixo:

/**
 * 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();
}

Novo (para aplicações com anúncios e serviços do Google Play):

A partir da consola de desenvolvimento do Google Play:

A partir de 1 de agosto de 2014, a Política do Programa de desenvolvimento do Google Play necessita de todas as novas uploads de aplicações e actualizações para usar o ID de publicidade em substituição de qualquer outro persistente identificadores para fins publicitários. Saiba mais

Execução:

Permissão:

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

Código:

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

Fonte / Documentos:

Http://developer.android.com/google/play-services/id.html http://developer.android.com/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.html

Importante:

([18]] pretende-se que o ID publicitário seja completamente substituir o existente utilização de outros identificadores para efeitos ads (como a utilização de ANDROID_ID em Configurações.Seguro) quando os Serviços do Google Play estão disponíveis. Vez quando os Serviços do Google Play não estão disponíveis, são indicados por um GooglePlayServicesNotAvailableException de ser jogado por getAdvertisingIdInfo ().

Atenção, os utilizadores podem reiniciar:

Http://en.kioskea.net/faq/34732-android-reset-your-advertising-id

Os Serviços Do Google Player InstanceID

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

Como Dave Webb menciona, o Blog de desenvolvimento do Android tem um artigo que cobre isto. Sua solução preferida é rastrear instalações de aplicativos em vez de dispositivos, e isso vai funcionar bem para a maioria dos casos de uso. O post do blog irá mostrar-lhe o código necessário para fazer com que isso funcione, e eu recomendo que você verifique isso para fora.

No entanto, o post do blog continua a discutir soluções se você precisa de um identificador de dispositivo em vez de um identificador de instalação app. Falei com alguém no Google para obter alguns esclarecimentos adicionais sobre alguns itens no caso de que você precisa fazer isso. Eis o que descobri sobre identificadores de dispositivos que não são mencionados no post mencionado:

• O ANDROID_ID é o identificador preferido do dispositivo. ANDROID_ID é perfeitamente confiável em versões do Android = 2.3. Apenas 2.2 tem os problemas mencionados no post.
• vários dispositivos de vários fabricantes são afectados pelo erro ANDROID_ID no ponto 2.2.
Até onde eu cheguei foi capaz de determinar, todos os dispositivos afetados têm o mesmo ANDROID_ID, que é 9774d56d682e549c. Que também é o mesmo ID do dispositivo relatado pelo emulador, btw.
• o Google acredita que os OEMs ter corrigido o problema, para muitos ou a maioria dos seus dispositivos, mas não foi capaz de verificar que a partir do início de abril de 2011, pelo menos, ainda é muito fácil encontrar dispositivos que tenham quebrado ANDROID_ID.

Note - se que para os dispositivos que têm de recuar no ID do dispositivo, o ID único irá persistir através dos reiniciamentos da fábrica. Isto é algo a ter em conta. Se tiver de garantir que uma reinicialização de fábrica irá reiniciar o seu ID único, você pode querer considerar voltar diretamente para o UUID Aleatório em vez do ID do dispositivo.

Novamente, este código é para um ID de dispositivo, não um ID de instalação de app. Para a maioria das situações, um ID de instalação app é provavelmente o que você está procurando. Mas se você precisa de um ID de dispositivo, então o seguinte código provavelmente funcionará para você.

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

Aqui está o código que o Reto Meier usou na apresentação do Google I/o este ano para obter um id único para o utilizador:

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

Se juntar isto com uma estratégia de salvaguarda para enviar as preferências para a nuvem (também descrito no reto talk, deverá ter um id que se ligue a um utilizador e fique por perto depois de o dispositivo ter sido apagado, ou mesmo substituído. Eu planejo usar isso em análise indo para a frente (em outras palavras, eu ainda não fiz essa parte :).

Também podes considerar o endereço MAC do adaptador Wi-Fi. Retrieved thusly:

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

Requer autorização android.permission.ACCESS_WIFI_STATE no manifesto.

Comunicado disponível mesmo quando o Wi-Fi não está ligado. Se o Joe da resposta acima der a este um teste aos seus muitos dispositivos, isso seria bom.

Nota: {[14] } do Android 6.x, devolve um endereço mac falso consistente: 02:00:00:00:00:00

Abrange cinco tipos de identificação diferentes:

1. IMEI (apenas para dispositivos Android com uso de telefone; necessidades android.permission.READ_PHONE_STATE)
2. Id Pseudo-único (para todos os dispositivos Android) {[[16]}
3. Id Android (pode ser nulo, pode mudar após a reinicialização da fábrica, pode ser alterado no telefone enraizado) {[[16]}
4. WLAN Mac Address string (necessita android.permission.ACCESS_WIFI_STATE)
5. BT endereço MAC texto (dispositivos com Bluetooth, necessita android.permission.BLUETOOTH)

At O Google I/O Reto Meier lançou uma resposta robusta para como abordar esta questão, que deverá satisfazer a maioria dos programadores precisa de seguir os utilizadores através das instalações. Anthony Nolan mostra a direção em sua resposta, mas eu pensei em escrever a abordagem completa para que os outros possam facilmente ver como fazê-lo (levei um tempo para descobrir os detalhes).

Esta abordagem dar-lhe-á um ID de utilizador anónimo e seguro que será persistente para o utilizador através de diferentes dispositivos (com base na conta primária do Google) e em todas as instalações. A abordagem básica é gerar um ID de usuário Aleatório e armazenar isso nas preferências compartilhadas dos aplicativos. Você então usa o agente de backup do Google para armazenar as preferências compartilhadas ligadas à Conta Google na nuvem.

O Google dá-lhe uma chave de serviço de backup que precisas de adicionar ao manifesto. Você também precisa dizer à aplicação para usar o BackupAgent do seguinte modo:

<application android:label="MyApplication"
         android:backupAgent="MyBackupAgent">
    ...
    <meta-data android:name="com.google.android.backup.api_key"
        android:value="your_backup_service_key" />
</application>

Então você precisa criar o agente de backup e dizer-lhe para usar o agente auxiliar para as opreferências de partilha:

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

Para completar a cópia de segurança, é necessário criar uma instância de BackupManager na sua actividade principal:

BackupManager backupManager = new BackupManager(context);

Finalmente crie um ID de utilizador, se ele já não existir, e guarde-o nas predefinições de acções:

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

Este utilizador será agora persistente em todas as instalações, mesmo que o utilizador mova o dispositivo.

Para mais informações sobre esta abordagem, ver Reto talk.

E para mais detalhes sobre como implementar o agente de reserva Veja cópia de segurança dos dados. Eu particularmente recomendo a seção na parte inferior no teste como o backup não acontece instantaneamente e assim para testar você tem que forçar o backup.

O seguinte código devolve o número de série do dispositivo usando uma API Android escondida. Mas este código não funciona na página da Samsung Galaxy porque " ro.serialno " não está definido neste dispositivo.

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) {

}

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

(Informação Extra: a técnica dada acima foi copiada de um artigo sobre magia de Bolso .)

Usando o código abaixo, você pode obter o ID de dispositivo único de um dispositivo Android como uma string.

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

O campo Série foi adicionado à classeBuild no nível 9 da API (Android 2.3 - Gengerbread). A documentação diz que representa o número de série do hardware. Assim, deve ser único, se existir no dispositivo.

Eu não sei se ele é realmente suportado (=não nulo) por todos os dispositivos com nível de API >= 9.

Usando:

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

Acontece que mesmo que o meu Tablet Viewsonic G relate um DeviceID que não é nulo, todos os Tablet G relatam o mesmo número.

Para instruções detalhadas sobre como obter um identificador único para cada dispositivo Android a partir do qual o seu aplicativo está instalado, veja o Blog Oficial do Android Developers postando identificação das instalações da aplicação.

Parece que a melhor maneira é você mesmo gerar um após a instalação e posteriormente lê-lo quando a aplicação é relançada.

O seguinte é um exemplo de escrita de dados para um arquivo de instalação que seria armazenado juntamente com quaisquer outros dados que a aplicação grava localmente.

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

Adicionar abaixo o código no ficheiro da classe:

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

Adicione AndroidManifest.xml:

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

O ID do dispositivo único de um dispositivo Android como String, usando TelephonyManager e ANDROID_ID, é obtido por:

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

Mas recomendo vivamente um método sugerido pelo Google, veja identificação das instalações da aplicação.

Há muitas abordagens diferentes para trabalhar em torno desses ANDROID_ID problemas (pode ser null por vezes ou dispositivos de um modelo específico sempre retornar o mesmo ID) com prós e contras:

• a implementar um algoritmo de geração de ID personalizado (baseado nas propriedades do dispositivo que supostamente são estáticas e não mudam -> quem sabe)
• abusar de outros IDs como IMEI , número de série, Endereço Wi-Fi/Bluetooth-MAC (não existirão em todos os dispositivos ou permissões adicionais torna-se necessário)

Eu próprio Prefiro utilizar uma implementação aberta existente (ver https://github.com/ylechelle/OpenUDID para Android (Ver[17]}https://github.com/vieux/OpenUDID é fácil integrar e utilizar o {[[0]} com recuos para as questões acima mencionadas.

Que tal o IMEI. Isso é único para Android ou outros dispositivos móveis.

Os meus dois cêntimos-NB Este é para um dispositivo (err) ID único {[[4]} - não a instalação tal como discutido no blog dos programadores do Android .

De notar que a solução fornecida por @emmby recua num ID por aplicação, dado que as preferências de acções não são sincronizadas através de processos (ver aqui e aqui ). Por isso evitei isto completamente.

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

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

Outra maneira é usar /sys/class/android_usb/android0/iSerial num aplicativo sem quaisquer permissões.

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

Para fazer isso em Java, basta usar um FileInputStream para abrir o arquivo iSerial e ler os caracteres. Apenas certifique-se de embrulhá-lo num controlador de excepções, porque nem todos os dispositivos têm este ficheiro.

Pelo menos os seguintes dispositivos são conhecidos por terem este ficheiro legível a nível mundial:

• Galaxy Nexus
• Nexus S
• Motorola Xoom 3G
Toshiba AT300
• HTC One V
• Mini MK802
Samsung Galaxy S II

Você também pode ver o meu post no bloga passar o número de série do hardware Android para aplicações não protegidas onde eu discuto que outros arquivos estão disponíveis para informações.

Podes fazê-lo dessa maneira:

Em AndroidManifest.xml

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

Agora no seu código:

List<NetworkInterface> interfacesList = Collections.list(NetworkInterface.getNetworkInterfaces());

for (NetworkInterface interface : interfacesList) {
   // This will give you the interface MAC ADDRESS
   interface.getHardwareAddress();
}

Uso o seguinte código para obter o IMEI ou usar o Secure.ANDROID_ID Como alternativa, quando o dispositivo não tem capacidades telefónicas:

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

Mais especificamente, Settings.Secure.ANDROID_ID. Esta é uma quantidade de 64 bits que é gerada e armazenada quando o dispositivo primeiro Botas. É reiniciado quando o dispositivo é limpo.

ANDROID_ID parece uma boa escolha para um identificador único de dispositivo. Existem desvantagens: em primeiro lugar, não é 100% confiável em lançamentos do Android antes de 2.2 (“Froyo”). Também, houve pelo menos um bug amplamente observado em um aparelho popular de um grande fabricante, onde cada instância tem o mesmo ANDROID_ID.

ID da instância do Google

Lançado em I/O 2015; no Android requer serviços de jogo 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

Identifica uma instalação em vez de um dispositivo, mas depois novamente, ANDROID_ID (que é a resposta Aceita) agora já não identifica dispositivos também. Com o tempo de execução do arco, é gerado um novo ANDROID_ID para cada instalação (detalhes aqui), assim como este novo ID de instância. Além disso, acho que identificar instalações (Não dispositivos) é o que a maioria de nós está realmente procurando.

As vantagens do ID da instância

Se você usar o GCM, então você eventualmente precisará usar este ID de instância porque você precisa dele para obter o token GCM (que substitui o ID de registro antigo GCM).

As desvantagens/problemas

Na implementação actual (GPS 7.5) o ID da instância é obtido a partir de um servidor quando o seu aplicativo o solicita. Isso significa que a chamada acima é uma chamada de bloqueio-em meu teste não científico que leva 1-3 segundos se o dispositivo está on-line, e 0.5 - 1.0 segundos Se off-line (presumivelmente este é o tempo que ele espera antes de desistir e gerar um ID aleatório). Isto foi testado na América do Norte na Nexus 5 com Android 5.1.1 e GPS 7.5.

Se usar o ID para os fins que pretendem-por exemplo. app authentication, app identification, GCM - I think this 1-3 seconds could be a distortage (depending on your app, of course).

Android device mac id também é um id único, não vai mudar suponha que se formatarmos o próprio dispositivo então usando o seguinte código para obter o ID mac

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

Também não se esqueça de adicionar as permissões apropriadas ao seu AndroidManifest.xml

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

Há mais de 30 respostas aqui e algumas são iguais e algumas são únicas. Esta resposta baseia-se em poucas dessas respostas. Uma delas é a resposta de @Lenn Dolling.

3 IDs são:
Pseudo-ID - Ele é gerado com base no dispositivo físico especificações
ANDROID_ID - Settings.Secure.ANDROID_ID
Endereço Bluetooth - adaptador Bluetooth endereço

Nota: pode sempre adicionar mais IDs ao texto longId. Por exemplo, Serial #. endereço do adaptador wifi. IMEI. Desta forma, você está tornando-o mais único por dispositivo.

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

O Google tem agora um ID de Publicidade .
Isto também pode ser usado, mas note que:

O ID publicitário é um ID específico do utilizador, único e susceptível de ser reinscrito

E

Permite aos utilizadores redefinir o seu identificador ou optar por não incluir anúncios com base em interesses no Google Play apps.

Então, embora este id possa mudar, parece que em breve podemos não ter escolha, depende do propósito deste id.

Mais informações @ develper.Andróide

Código de copiar-colar aqui

HTH

Telefononymanger.o getDeviceId () Devolve o ID único do dispositivo, por exemplo, o IMEI para o GSM e o MEID ou o ESN para os telefones CDMA.

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

Mas eu recomendo usar:

Configuração.Seguro.ANDROID_ID que devolve o ID do Android como uma única cadeia hexadecimal de 64 bits.

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

Às Vezes Telefonista.o getDeviceId () irá retornar nulo, por isso, para assegurar um id único, irá usar este método:

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