मुझे एंड्रॉइड ऐप के लिए एक अद्वितीय आईडी का उपयोग करने की आवश्यकता है और मुझे लगा कि डिवाइस के लिए सीरियल नंबर एक अच्छा उम्मीदवार होगा। मैं अपने ऐप में एंड्रॉइड डिवाइस का सीरियल नंबर कैसे प्राप्त करूं?
मुझे एंड्रॉइड ऐप के लिए एक अद्वितीय आईडी का उपयोग करने की आवश्यकता है और मुझे लगा कि डिवाइस के लिए सीरियल नंबर एक अच्छा उम्मीदवार होगा। मैं अपने ऐप में एंड्रॉइड डिवाइस का सीरियल नंबर कैसे प्राप्त करूं?
जवाबों:
TelephonyManager tManager = (TelephonyManager)myActivity.getSystemService(Context.TELEPHONY_SERVICE);
String uid = tManager.getDeviceId();
getSystemService गतिविधि वर्ग से एक विधि है। getDeviceID () उस डिवाइस के MDN या MEID को लौटाएगा, जिसके आधार पर रेडियो फोन (GSM या CDMA) का उपयोग करता है।
प्रत्येक डिवाइस को यहां एक विशिष्ट मूल्य वापस करना होगा (यह एक फोन है)। यह किसी भी एंड्रॉइड डिवाइस के लिए सिम स्लॉट या सीडीएमए रेडियो के साथ काम करना चाहिए। आप उस Android संचालित माइक्रोवेव के साथ अपने दम पर हैं ;-)
जैसा कि डेव वेब का उल्लेख है, एंड्रॉइड डेवलपर ब्लॉग में एक लेख है जो इसे कवर करता है।
मैंने कुछ वस्तुओं पर कुछ अतिरिक्त स्पष्टीकरण प्राप्त करने के लिए Google पर किसी के साथ बात की। यहाँ मैंने पाया है कि उपरोक्त ब्लॉग पोस्ट में इसका उल्लेख नहीं किया गया है:
Google की सिफारिशों के आधार पर, मैंने एक वर्ग लागू किया है जो ANDROID_ID को बीज के रूप में उपयोग करते हुए प्रत्येक डिवाइस के लिए एक अद्वितीय UUID उत्पन्न करेगा, जहाँ उपयुक्त हो, आवश्यक रूप से TelephonyManager.getDeviceId () पर वापस गिर रहा है, और यदि वह विफल रहता है, तो एक यादृच्छिक रूप से उत्पन्न अद्वितीय UUID का सहारा लेना यह एप रीस्टार्ट (लेकिन एप री-इंस्टॉलेशन नहीं) है।
import android.content.Context;
import android.content.SharedPreferences;
import android.provider.Settings.Secure;
import android.telephony.TelephonyManager;
import java.io.UnsupportedEncodingException;
import java.util.UUID;
public class DeviceUuidFactory {
protected static final String PREFS_FILE = "device_id.xml";
protected static final String PREFS_DEVICE_ID = "device_id";
protected static volatile 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;
}
}
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 deviceId = Settings.System.getString(getContentResolver(),
Settings.System.ANDROID_ID);
हालाँकि, यह गारंटी नहीं है कि Android ID एक विशिष्ट पहचानकर्ता होगा।
getContentResolver
लौट रहा है null
। हालांकि, यह एक सवाल खोलने और अपने कोड को पोस्ट करते समय लायक हो सकता है।
इस पर चर्चा करने वाले Android डेवलपर के ब्लॉग पर एक उत्कृष्ट पोस्ट है ।
यह TelephonyManager.getDeviceId()
एंड्रॉइड डिवाइस पर काम नहीं करने के खिलाफ सिफारिश करता है जो कि टैबलेट जैसे फोन नहीं हैं, इसके लिए READ_PHONE_STATE
अनुमति की आवश्यकता होती है और यह सभी फोनों के लिए मज़बूती से काम नहीं करता है।
इसके बजाय आप निम्न में से एक का उपयोग कर सकते हैं:
पोस्ट प्रत्येक के पेशेवरों और विपक्षों के बारे में चर्चा करता है और यह पढ़ने के लायक है इसलिए आप यह काम कर सकते हैं जो आपके उपयोग के लिए सबसे अच्छा होगा।
एक सरल संख्या के लिए जो डिवाइस के लिए अद्वितीय है और अपने जीवनकाल के लिए स्थिर है (फ़ैक्टरी रीसेट या हैकिंग को छोड़कर), Settings.Secure.ANDROID_ID का उपयोग करें ।
String id = Secure.getString(getContentResolver(), Secure.ANDROID_ID);
यदि उपलब्ध हो और Android ID पर वापस आ जाए, तो डिवाइस सीरियल नंबर ("सिस्टम सेटिंग / अबाउट / स्टेटस" में दिखाया गया है) का उपयोग करने के लिए:
String serialNumber = Build.SERIAL != Build.UNKNOWN ? Build.SERIAL : Secure.getString(getContentResolver(), Secure.ANDROID_ID);
IMEI अच्छा है लेकिन केवल फोन के साथ Android उपकरणों पर काम करता है। आपको टैबलेट या अन्य Android उपकरणों के लिए समर्थन पर विचार करना चाहिए, जिनके पास फोन नहीं है।
आपके पास कुछ विकल्प हैं जैसे: कक्षा सदस्य, बीटी मैक, डब्ल्यूएलएएन मैक, या इससे भी बेहतर - इन सभी का एक संयोजन बनाएँ।
मैंने अपने ब्लॉग पर एक लेख में इन विवरणों को समझाया है, देखें: http://www.pocketmagic.net/?p=1662
चूँकि यहाँ कोई उत्तर सही, असफल-प्रूफ आईडी का उल्लेख नहीं करता है, जो सिस्टम अपडेट के माध्यम से दोनों के समान है और सभी उपकरणों में मौजूद है (मुख्यतः इस तथ्य के कारण कि Google से अलग-अलग समाधान नहीं है), मैंने एक विधि पोस्ट करने का फैसला किया है जो है उपलब्ध पहचानकर्ताओं में से दो को जोड़कर अगली सबसे अच्छी बात, और रन-टाइम में उनके बीच चयन करने के लिए एक चेक।
कोड से पहले, 3 तथ्य:
TelephonyManager.getDeviceId()
(akaIMEI) अच्छी तरह से या गैर-जीएसएम, 3 जी, एलटीई, आदि उपकरणों के लिए बिल्कुल भी काम नहीं करेगा, लेकिन संबंधित हार्डवेयर मौजूद होने पर भी हमेशा एक अद्वितीय आईडी लौटाएगा , जब कोई सिम नहीं डाला जाता है या तब भी जब कोई सिम स्लॉट मौजूद नहीं है ( कुछ ओईएम ने ऐसा किया है)।
चूंकि जिंजरब्रेड (एंड्रॉइड 2.3) android.os.Build.SERIAL
को किसी भी उपकरण पर मौजूद होना चाहिए जो आईएमईआई प्रदान नहीं करता है , अर्थात, एंड्रॉइड पॉलिसी के अनुसार, उपरोक्त हार्डवेयर मौजूद नहीं है।
तथ्य (2.) के कारण, इन दो विशिष्ट पहचानकर्ताओं में से कम से कम एक हमेशा मौजूद रहेगा , और SERIAL उसी समय मौजूद हो सकता है जब IMEI है।
नोट: तथ्य (1.) और (2.) Google के कथनों पर आधारित हैं
उपाय
उपरोक्त तथ्यों के साथ, किसी के पास IMEI- बाउंड हार्डवेयर होने की जाँच करके हमेशा एक विशिष्ट पहचानकर्ता हो सकता है, और जब यह नहीं होता है, तो यह जाँच कर सकता है कि कोई ऐसा नहीं है जो मौजूदा SERIAL मान्य है। निम्न स्थिर वर्ग ऐसी उपस्थिति की जाँच करने और IMEI या SERIAL का उपयोग करने के लिए 2 तरीके प्रस्तुत करता है:
import java.lang.reflect.Method;
import android.content.Context;
import android.content.pm.PackageManager;
import android.os.Build;
import android.provider.Settings;
import android.telephony.TelephonyManager;
import android.util.Log;
public class IDManagement {
public static String getCleartextID_SIMCHECK (Context mContext){
String ret = "";
TelephonyManager telMgr = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
if(isSIMAvailable(mContext,telMgr)){
Log.i("DEVICE UNIQUE IDENTIFIER",telMgr.getDeviceId());
return telMgr.getDeviceId();
}
else{
Log.i("DEVICE UNIQUE IDENTIFIER", Settings.Secure.ANDROID_ID);
// return Settings.Secure.ANDROID_ID;
return android.os.Build.SERIAL;
}
}
public static String getCleartextID_HARDCHECK (Context mContext){
String ret = "";
TelephonyManager telMgr = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
if(telMgr != null && hasTelephony(mContext)){
Log.i("DEVICE UNIQUE IDENTIFIER",telMgr.getDeviceId() + "");
return telMgr.getDeviceId();
}
else{
Log.i("DEVICE UNIQUE IDENTIFIER", Settings.Secure.ANDROID_ID);
// return Settings.Secure.ANDROID_ID;
return android.os.Build.SERIAL;
}
}
public static boolean isSIMAvailable(Context mContext,
TelephonyManager telMgr){
int simState = telMgr.getSimState();
switch (simState) {
case TelephonyManager.SIM_STATE_ABSENT:
return false;
case TelephonyManager.SIM_STATE_NETWORK_LOCKED:
return false;
case TelephonyManager.SIM_STATE_PIN_REQUIRED:
return false;
case TelephonyManager.SIM_STATE_PUK_REQUIRED:
return false;
case TelephonyManager.SIM_STATE_READY:
return true;
case TelephonyManager.SIM_STATE_UNKNOWN:
return false;
default:
return false;
}
}
static public boolean hasTelephony(Context mContext)
{
TelephonyManager tm = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
if (tm == null)
return false;
//devices below are phones only
if (Build.VERSION.SDK_INT < 5)
return true;
PackageManager pm = mContext.getPackageManager();
if (pm == null)
return false;
boolean retval = false;
try
{
Class<?> [] parameters = new Class[1];
parameters[0] = String.class;
Method method = pm.getClass().getMethod("hasSystemFeature", parameters);
Object [] parm = new Object[1];
parm[0] = "android.hardware.telephony";
Object retValue = method.invoke(pm, parm);
if (retValue instanceof Boolean)
retval = ((Boolean) retValue).booleanValue();
else
retval = false;
}
catch (Exception e)
{
retval = false;
}
return retval;
}
}
मैं उपयोग करने पर सलाह दूंगा getCleartextID_HARDCHECK
। यदि प्रतिबिंब आपके वातावरण में नहीं चिपकता है, तो getCleartextID_SIMCHECK
इसके बजाय विधि का उपयोग करें , लेकिन ध्यान रखें कि इसे आपकी विशिष्ट सिम-उपस्थिति आवश्यकताओं के अनुकूल होना चाहिए।
पुनश्च : कृपया ध्यान दें कि OEM ने Google नीति के विरुद्ध SERIAL को हटाने में कामयाब रहे हैं (समान सीरियल वाले कई उपकरण), और Google ने कहा कि एक बड़े OEM में कम से कम एक ज्ञात मामला है (खुलासा नहीं किया गया है और मुझे नहीं पता कि कौन सा ब्रांड है यह या तो, मैं सैमसंग का अनुमान लगा रहा हूं)।
डिस्क्लेमर : यह एक अद्वितीय डिवाइस आईडी प्राप्त करने के मूल प्रश्न का उत्तर देता है, लेकिन ओपी ने यह कहते हुए अस्पष्टता का परिचय दिया कि उसे एक एपीपी के लिए एक विशिष्ट आईडी की आवश्यकता है। यहां तक कि अगर ऐसे परिदृश्यों के लिए Android_ID बेहतर होगा, तो यह काम नहीं करेगा, कहते हैं, एक ऐप का टाइटेनियम बैकअप 2 अलग-अलग रॉम इंस्टॉल के माध्यम से हो सकता है (यहां तक कि एक ही रॉम हो सकता है)। मेरा समाधान दृढ़ता को बनाए रखता है जो एक फ्लैश या फैक्ट्री रीसेट से स्वतंत्र है, और केवल तभी विफल होगा जब IMEI या SERIAL छेड़छाड़ हैक / हार्डवेयर मॉड के माध्यम से होती है।
उपरोक्त सभी दृष्टिकोणों के साथ समस्याएं हैं। Google i / o रेटो मीयर ने इस बारे में एक मजबूत जवाब जारी किया कि इसे कैसे प्राप्त किया जाए, जो कि अधिकांश डेवलपर्स को मिलना चाहिए, उपयोगकर्ताओं को प्रतिष्ठानों पर नज़र रखने की आवश्यकता है।
यह दृष्टिकोण आपको एक अनाम, सुरक्षित उपयोगकर्ता आईडी देगा जो विभिन्न उपकरणों (टैबलेट सहित, प्राथमिक Google खाते पर आधारित) और एक ही डिवाइस पर इंस्टॉल के दौरान उपयोगकर्ता के लिए लगातार रहेगा। बेसिक एप्रोच एक रैंडम यूजर आईडी जनरेट करना है और इसे एप्स में शेयर करना है। फिर आप क्लाउड में Google खाते से जुड़ी साझा प्राथमिकताओं को संग्रहीत करने के लिए Google के बैकअप एजेंट का उपयोग करते हैं।
पूर्ण दृष्टिकोण से गुजरें। सबसे पहले हमें Android Backup सेवा का उपयोग करके अपने SharedPreferences के लिए एक बैकअप बनाने की आवश्यकता है। इस लिंक के माध्यम से अपना ऐप पंजीकृत करके शुरू करें: http://developer.android.com/google/backup/signup.html
Google आपको एक बैकअप सेवा कुंजी देगा जिसे आपको मैनिफ़ेस्ट में जोड़ना होगा। आपको निम्नानुसार BackupAgent का उपयोग करने के लिए एप्लिकेशन को भी बताने की आवश्यकता है:
<application android:label="MyApplication"
android:backupAgent="MyBackupAgent">
...
<meta-data android:name="com.google.android.backup.api_key"
android:value="your_backup_service_key" />
</application>
फिर आपको बैकअप एजेंट बनाने और इसे साझा करने वाले के लिए सहायक एजेंट का उपयोग करने की आवश्यकता है:
public class MyBackupAgent extends BackupAgentHelper {
// The name of the SharedPreferences file
static final String PREFS = "user_preferences";
// A key to uniquely identify the set of backup data
static final String PREFS_BACKUP_KEY = "prefs";
// Allocate a helper and add it to the backup agent
@Override
public void onCreate() {
SharedPreferencesBackupHelper helper = new SharedPreferencesBackupHelper(this, PREFS);
addHelper(PREFS_BACKUP_KEY, helper);
}
}
बैकअप को पूरा करने के लिए आपको अपनी मुख्य गतिविधि में BackupManager का एक उदाहरण बनाना होगा:
BackupManager backupManager = new BackupManager(context);
अंत में एक उपयोगकर्ता आईडी बनाएं, यदि यह पहले से मौजूद नहीं है, और इसे साझा किए गए संदर्भों में संग्रहीत करें:
public static String getUserID(Context context) {
private static String uniqueID = null;
private static final String PREF_UNIQUE_ID = "PREF_UNIQUE_ID";
if (uniqueID == null) {
SharedPreferences sharedPrefs = context.getSharedPreferences(
MyBackupAgent.PREFS, Context.MODE_PRIVATE);
uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
if (uniqueID == null) {
uniqueID = UUID.randomUUID().toString();
Editor editor = sharedPrefs.edit();
editor.putString(PREF_UNIQUE_ID, uniqueID);
editor.commit();
//backup the changes
BackupManager mBackupManager = new BackupManager(context);
mBackupManager.dataChanged();
}
}
return uniqueID;
}
यह User_ID अब पूरे इंस्टॉलेशन में लगातार रहेगा, भले ही उपयोगकर्ता डिवाइस को स्विच कर दे।
इस दृष्टिकोण के बारे में अधिक जानकारी के लिए यहाँ देखें रेटो की बात http://www.google.com/events/io/2011/session/android-protips-advanced-topics-for-expert-android-app-developers.html
और बैकअप एजेंट को कैसे लागू किया जाए, इसकी पूरी जानकारी के लिए डेवलपर साइट यहां देखें: http://developer.android.com/guide/topics/data/backup.html मैं विशेष रूप से बैकअप के रूप में परीक्षण पर नीचे दिए गए अनुभाग की सिफारिश करता हूं तुरंत नहीं होता है और इसलिए परीक्षण करने के लिए आपको बैकअप को मजबूर करना होगा।
दूसरा तरीका यह है कि ऐप में / 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
जावा में ऐसा करने के लिए एक iInerial फ़ाइल खोलने और वर्णों को पढ़ने के लिए बस एक FileInputStream का उपयोग करना होगा। बस सुनिश्चित करें कि आप इसे अपवाद हैंडलर में लपेटते हैं क्योंकि सभी उपकरणों में यह फ़ाइल नहीं है।
कम से कम निम्नलिखित उपकरणों को इस फ़ाइल को विश्व-पठनीय माना जाता है:
आप यहाँ मेरे ब्लॉग पोस्ट को भी देख सकते हैं: http://insitusec.blogspot.com/2013/01/leaking-android-hardware-serial-number.html जहाँ मैं चर्चा करता हूँ कि अन्य फाइलें जानकारी के लिए उपलब्ध हैं।
जैसा कि @haserman कहते हैं:
TelephonyManager tManager = (TelephonyManager)myActivity.getSystemService(Context.TELEPHONY_SERVICE);
String uid = tManager.getDeviceId();
लेकिन यह प्रकट फ़ाइल में अनुमति सहित आवश्यक है:
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
स्ट्रिंग के रूप में एंड्रॉइड ओएस डिवाइस की अनूठी डिवाइस आईडी।
String deviceId;
final TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
if (mTelephony.getDeviceId() != null){
deviceId = mTelephony.getDeviceId();
}
else{
deviceId = Secure.getString(getApplicationContext().getContentResolver(), Secure.ANDROID_ID);
}
लेकिन मैं Google द्वारा सुझाई गई इस विधि की कड़ाई से सिफारिश करता हूं
Build.SERIAL
जाने का सबसे सरल तरीका है, हालांकि पूरी तरह से विश्वसनीय नहीं है क्योंकि यह खाली हो सकता है या कभी-कभी आपके डिवाइस की सेटिंग में जो आप देख सकते हैं उससे अलग मूल्य ( प्रूफ 1 , प्रूफ 2 ) लौटाते हैं।
डिवाइस के निर्माता और एंड्रॉइड वर्जन के आधार पर उस नंबर को प्राप्त करने के कई तरीके हैं, इसलिए मैंने हर संभव समाधान संकलित करने का फैसला किया, जो मुझे एक सिंगल जिस्ट में मिल सकता है । यहाँ इसका एक सरलीकृत संस्करण है:
public static String getSerialNumber() {
String serialNumber;
try {
Class<?> c = Class.forName("android.os.SystemProperties");
Method get = c.getMethod("get", String.class);
serialNumber = (String) get.invoke(c, "gsm.sn1");
if (serialNumber.equals(""))
serialNumber = (String) get.invoke(c, "ril.serialnumber");
if (serialNumber.equals(""))
serialNumber = (String) get.invoke(c, "ro.serialno");
if (serialNumber.equals(""))
serialNumber = (String) get.invoke(c, "sys.serialnumber");
if (serialNumber.equals(""))
serialNumber = Build.SERIAL;
// If none of the methods above worked
if (serialNumber.equals(""))
serialNumber = null;
} catch (Exception e) {
e.printStackTrace();
serialNumber = null;
}
return serialNumber;
}
मुझे पता है कि यह प्रश्न पुराना है, लेकिन यह कोड की एक पंक्ति में किया जा सकता है
String deviceID = Build.SERIAL;
मैंने @emmby द्वारा पोस्ट की गई उदाहरण वर्ग को एक महान शुरुआती बिंदु पाया। लेकिन इसमें कुछ खामियां हैं, जैसा कि अन्य पोस्टरों द्वारा बताया गया है। प्रमुख यह है कि यह एक XML फ़ाइल के लिए UUID को अनावश्यक रूप से जारी रखता है और उसके बाद हमेशा इस फ़ाइल से इसे पुनर्प्राप्त करता है। यह कक्षा को एक आसान हैक करने के लिए खुला देता है: कोई भी रूट किए गए फोन के साथ खुद को एक नया UUID देने के लिए XML फ़ाइल को संपादित कर सकता है।
मैंने कोड को अपडेट कर दिया है ताकि यह केवल XML तक बना रहे यदि आवश्यक हो (यानी एक बेतरतीब ढंग से उत्पन्न यूयूआईडी का उपयोग करते समय) और @Brill Pappin के उत्तर के अनुसार तर्क को फिर से सच कर दिया जाए:
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 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) || (androidId == null) ) {
final String deviceId = ((TelephonyManager) context.getSystemService( Context.TELEPHONY_SERVICE )).getDeviceId();
if (deviceId != null)
{
uuid = UUID.nameUUIDFromBytes(deviceId.getBytes("utf8"));
}
else
{
uuid = UUID.randomUUID();
// Write the value out to the prefs file so it persists
prefs.edit().putString(PREFS_DEVICE_ID, uuid.toString() ).commit();
}
}
else
{
uuid = UUID.nameUUIDFromBytes(androidId.getBytes("utf8"));
}
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
}
}
}
}
}
/**
* 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;
}
हाँ। यह एक डिवाइस हार्डवेयर सीरियल नंबर है और यह अद्वितीय है। तो Api स्तर 2.3 और इसके बाद के संस्करण को प्राप्त करने के लिए आप android.os.Build.ANDROID_ID का उपयोग कर सकते हैं । नीचे 2.3 एपीआई स्तर के लिए TelephonyManager.getDeviceID () का उपयोग करें ।
आप इसे http://android-developers.blogspot.in/2011/03/identifying-app-installations.html पर पढ़ सकते हैं