先來看看幾種比較單一的方式：

 IMEI

方式：TelephonyManager.getDeviceId():

問題

範圍：只能支援擁有通話功能的裝置，對於平板不可以。

永續性：返廠，資料擦除的時候不徹底，保留了原來的標識。

許可權：需要許可權：android.permission.READ_PHONE_STATE

bug: 有些廠家的實現有bug，返回一些不可用的資料

 Mac地址

ACCESS_WIFI_STATE許可權

有些裝置沒有WiFi，或者藍芽，就不可以，如果WiFi沒有開啟，硬體也不會返回Mac地址，不建議使用

ANDROID_ID

2.2（Froyo，8）版本系統會不可信，來自主要生產廠商的主流手機，至少有一個普遍發現的bug，這些有問題的手機相同的ANDROID_ID: 9774d56d682e549c

但是如果返廠的手機，或者被root的手機，可能會變

 
 Serial Number

從Android 2.3 (“Gingerbread”)開始可用，可以通過android.os.Build.SERIAL獲取，對於沒有通話功能的裝置，它會

返回一個唯一的device ID，

以下幾個是stackoverflow上評論較多的幾個，沒貼完，還有其他，綜合的，用到以上的部分方式：

有興趣的朋友可以再仔細看看

支援率比較高的（支援票數157）：androidID --> 剔除2.2版本（API 8）中有問題的手機，使用UUID替代 

1. import android.content.Context;  
2. import android.content.SharedPreferences;  
3. import android.provider.Settings.Secure;  
4. import android.telephony.TelephonyManager;  
5. import java.io.UnsupportedEncodingException;  
6. import java.util.UUID;  
7. publicclass DeviceUuidFactory {  
8.     protectedstaticfinal String PREFS_FILE = "device_id.xml";  
9.     protectedstaticfinal String PREFS_DEVICE_ID = "device_id";  
10.     protectedstaticvolatile UUID uuid;  
11.     public DeviceUuidFactory(Context context) {  
12.         if (uuid == null) {  
13.             synchronized (DeviceUuidFactory.class) {  
14.                 if (uuid == null) {  
15.                     final SharedPreferences prefs = context  
16.                             .getSharedPreferences(PREFS_FILE, 0);  
17.                     final String id = prefs.getString(PREFS_DEVICE_ID, null);  
18.                     if (id != null) {  
19.                         // Use the ids previously computed and stored in the
20.                         // prefs file
21.                         uuid = UUID.fromString(id);  
22.                     } else {  
23.                         final String androidId = Secure.getString(  
24.                             context.getContentResolver(), Secure.ANDROID_ID);  
25.                         // Use the Android ID unless it's broken, in which case
26.                         // fallback on deviceId,
27.                         // unless it's not available, then fallback on a random
28.                         // number which we store to a prefs file
29.                         try {  
30.                             if (!"9774d56d682e549c".equals(androidId)) {  
31.                                 uuid = UUID.nameUUIDFromBytes(androidId  
32.                                         .getBytes("utf8"));  
33.                             } else {  
34.                                 final String deviceId = ((TelephonyManager)   
35.                                         context.getSystemService(  
36.                                             Context.TELEPHONY_SERVICE)  
37.                                             .getDeviceId();  
38.                                 uuid = deviceId != null ? UUID  
39.                                         .nameUUIDFromBytes(deviceId  
40.                                                 .getBytes("utf8")) : UUID  
41.                                         .randomUUID();  
42.                             }  
43.                         } catch (UnsupportedEncodingException e) {  
44.                             thrownew RuntimeException(e);  
45.                         }  
46.                         // Write the value out to the prefs file
47.                         prefs.edit()  
48.                                 .putString(PREFS_DEVICE_ID, uuid.toString())  
49.                                 .commit();  
50.                     }  
51.                 }  
52.             }  
53.         }  
54.     }  
55.     /** 
56.      * Returns a unique UUID for the current android device. As with all UUIDs, 
57.      * this unique ID is "very highly likely" to be unique across all Android 
58.      * devices. Much more so than ANDROID_ID is. 
59.      *  
60.      * The UUID is generated by using ANDROID_ID as the base key if appropriate, 
61.      * falling back on TelephonyManager.getDeviceID() if ANDROID_ID is known to 
62.      * be incorrect, and finally falling back on a random UUID that's persisted 
63.      * to SharedPreferences if getDeviceID() does not return a usable value. 
64.      *  
65.      * In some rare circumstances, this ID may change. In particular, if the 
66.      * device is factory reset a new device ID may be generated. In addition, if 
67.      * a user upgrades their phone from certain buggy implementations of Android 
68.      * 2.2 to a newer, non-buggy version of Android, the device ID may change. 
69.      * Or, if a user uninstalls your app on a device that has neither a proper 
70.      * Android ID nor a Device ID, this ID may change on reinstallation. 
71.      *  
72.      * Note that if the code falls back on using TelephonyManager.getDeviceId(), 
73.      * the resulting ID will NOT change after a factory reset. Something to be 
74.      * aware of. 
75.      *  
76.      * Works around a bug in Android 2.2 for many devices when using ANDROID_ID 
77.      * directly. 
78.      *  
79.      * @see http://code.google.com/p/android/issues/detail?id=10603 
80.      *  
81.      * @return a UUID that may be used to uniquely identify your device for most 
82.      *         purposes. 
83.      */
84.     public UUID getDeviceUuid() {  
85.         return uuid;  
86.     }  
87. }  

根據版本進行判斷的方式：Serial序列號-->UUID （支援數31）

通過Serial 即可，在覆蓋率上，你已經成功的獲得了98.4%的使用者，剩下的1.6%的使用者系統是在9 以下的。

通過AndroidID獲取，前面已經說過，在8上，有些商家的手機會有一些bug，返回相同的AndroidID，如果Serial和AndroidID都不行

1. /** 
2.  * Return pseudo unique ID 
3.  * @return ID 
4.  */
5. publicstatic String getUniquePsuedoID()  
6. {  
7.     // If all else fails, if the user does have lower than API 9 (lower
8.     // than Gingerbread), has reset their phone or 'Secure.ANDROID_ID'
9.     // returns 'null', then simply the ID returned will be solely based
10.     // off their Android device information. This is where the collisions
11.     // can happen.
12.     // Thanks http://www.pocketmagic.net/?p=1662!
13.     // Try not to use DISPLAY, HOST or ID - these items could change.
14.     // If there are collisions, there will be overlapping data