एंड्रॉइड डिवाइस का सीरियल नंबर कैसे खोजें?


115

मुझे एंड्रॉइड ऐप के लिए एक अद्वितीय आईडी का उपयोग करने की आवश्यकता है और मुझे लगा कि डिवाइस के लिए सीरियल नंबर एक अच्छा उम्मीदवार होगा। मैं अपने ऐप में एंड्रॉइड डिवाइस का सीरियल नंबर कैसे प्राप्त करूं?


2
Android को जोड़ना न भूलें: अपने प्रकट होने के लिए नाम = "android.permission.READ_PHONE_STATE"
16 SI पर माइकल SIlveus


आप किसी भी अनुमतियों के बिना एक अद्वितीय ID प्राप्त करना चाहते हैं, तो आप उपयोग कर सकते हैं इस पुस्तकालय या तो एक अद्वितीय डिवाइस प्रति आईडी उत्पन्न करने के लिए Identity.getDeviceId (संदर्भ) या माध्यम से आपके एप्लिकेशन स्थापना के लिए एक पहचानकर्ता Identity.getInstallationId (संदर्भ)
caw

जवाबों:


105
TelephonyManager tManager = (TelephonyManager)myActivity.getSystemService(Context.TELEPHONY_SERVICE);
String uid = tManager.getDeviceId();

getSystemService गतिविधि वर्ग से एक विधि है। getDeviceID () उस डिवाइस के MDN या MEID को लौटाएगा, जिसके आधार पर रेडियो फोन (GSM या CDMA) का उपयोग करता है।

प्रत्येक डिवाइस को यहां एक विशिष्ट मूल्य वापस करना होगा (यह एक फोन है)। यह किसी भी एंड्रॉइड डिवाइस के लिए सिम स्लॉट या सीडीएमए रेडियो के साथ काम करना चाहिए। आप उस Android संचालित माइक्रोवेव के साथ अपने दम पर हैं ;-)


@ हासम यह मेरे लिए काम नहीं कर रहा है, "फोर्स क्लोज़" एरर दे रहा है
परेश मेयानी

23
@Hasemam <चलन-अनुमति android: name = "android.permission.READ_PHONE_STATE"> </ उपयोग-अनुमति> androidManifest.xml फ़ाइल में अनुमति के बाद इसका ठीक चल रहा है।
परेश मेयानी

23
इस पहचानकर्ता का उपयोग करने के बारे में आधिकारिक एंड्रॉइड डेवलपर के ब्लॉग पर कुछ सलाह दी गई है: android-developers.blogspot.com/2011/03/…
डेविड स्नेबेल-कॉंट

8
एंड्रॉइड संचालित माइक्रोवेव से अलग, एंड्रॉइड संचालित टैबलेट के बारे में क्या? :)
अंजीर8181 31'11

21
इस विधि से बचा जाना चाहिए, यह फोन पर काम करेगा लेकिन फोन चिप के बिना उपकरणों पर काम नहीं करेगा (टैबलेट एक उदाहरण है)। 2.3 से आप android.os.Build.SERIAL का उपयोग कर सकते हैं, लेकिन डेवलपर ब्लॉग को देखें जो @DavidCaunt ने सुझाया था।
जॉन मिशेल

71

जैसा कि डेव वेब का उल्लेख है, एंड्रॉइड डेवलपर ब्लॉग में एक लेख है जो इसे कवर करता है।

मैंने कुछ वस्तुओं पर कुछ अतिरिक्त स्पष्टीकरण प्राप्त करने के लिए Google पर किसी के साथ बात की। यहाँ मैंने पाया है कि उपरोक्त ब्लॉग पोस्ट में इसका उल्लेख नहीं किया गया है:

  • ANDROID_ID पसंदीदा समाधान है। ANDROID_ID Android के संस्करणों पर पूरी तरह से विश्वसनीय है <= 2.1 या> = 2.3। केवल 2.2 में पोस्ट में उल्लिखित समस्याएं हैं।
  • 2.2 में ANDROID_ID बग से कई निर्माताओं के कई उपकरण प्रभावित होते हैं।
  • जहां तक ​​मैं निर्धारित करने में सक्षम रहा हूं, सभी प्रभावित उपकरणों में एक ही ANDROID_ID है , जो 9774d56d682e549c है । एमुलेटर, btw द्वारा रिपोर्ट की गई वही डिवाइस आईडी भी है।
  • Google का मानना ​​है कि ओईएम ने कई या अधिकांश डिवाइसों के लिए समस्या को पैच किया है, लेकिन मैं यह सत्यापित करने में सक्षम था कि अप्रैल 2011 की शुरुआत में, कम से कम, अभी भी उन डिवाइसों को ढूंढना काफी आसान है जिनके पास ANDROID_ID टूटे हुए हैं।

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

1
किसी ऐप को इसका उपयोग करने के लिए किन अनुमतियों की आवश्यकता होती है?
डेव एल

1
<उपयोग-अनुमति Android: नाम = "android.permission.READ_PHONE_STATE"> </ उपयोग-अनुमति>
गैब्रिएल

1
@ ef2011 यह डबल-चेक किया गया लॉकिंग पैटर्न है: en.wikipedia.org/wiki/Double-checked_locking
emmby

3
पोस्ट करने का शुक्रिया। लेकिन अपनी पसंद के एक नए UUID में डालने के लिए बस rooted phone_id.xml से रूट किए गए फोन के साथ किसी को रोकने के लिए क्या है? (यानी 'नि: शुल्क परीक्षण' को रोकने के लिए) यह बेहतर नहीं होगा यदि वर्ग केवल वरीयता फ़ाइल में मान संग्रहीत करता है अगर उसे यादृच्छिक आईडी विधि का सहारा लेना पड़ता है? अन्यथा, एप्लिकेशन रन के बीच इसे जारी रखने की आवश्यकता नहीं है; इसे फिर से तैयार करना अधिक सुरक्षित है।
कार्लोस पी

1
"ANDROID_ID" पसंदीदा समाधान है "। ध्यान दें कि ANDROID_ID अब किसी उपकरण की विशिष्ट पहचान नहीं करता है: stackoverflow.com/a/13465373/150016
टॉम

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

यह कोड एक छिपे हुए एंड्रॉइड एपीआई का उपयोग करके डिवाइस सीरियल नंबर देता है।


7
यह सिर्फ मुझे android.os.Bild के साथ मिलता है के रूप में एक ही मूल्य देता है।
बहू।सामाजिक

क्या मैं गलत हूं, या यह सीरियल नंबर एक विशिष्ट कस्टम रोम वाले सभी उपकरणों में समान है? मेरा डिवाइस सीरियल नंबर (ग्रहण डिवाइस लांचर में) एक कस्टम रोम वाले फोन के लिए 01234567890ABC दिखाता है।
पीटरडक

मेरे डिवाइस पर @Peterdk cyanogen-9 दोनों तरीकों के साथ (पूर्व -9 उत्तर के रूप में और andy-9 पर उपलब्ध आसान) रिपोर्ट सही s / n (निर्माता स्टिकर पर समान)। यह विशिष्ट कस्टम रोम संस्करण पर निर्भर हो सकता है, हालांकि। आप किस रोम / संस्करण का उपयोग कर रहे हैं?
morgwai

16
String deviceId = Settings.System.getString(getContentResolver(),
                                Settings.System.ANDROID_ID);

हालाँकि, यह गारंटी नहीं है कि Android ID एक विशिष्ट पहचानकर्ता होगा।


@Paresh Mayani, यह बताना मुश्किल है कि कोड को देखे बिना क्या समस्या हो सकती है। मेरी एकमात्र धारणा यह है कि getContentResolverलौट रहा है null। हालांकि, यह एक सवाल खोलने और अपने कोड को पोस्ट करते समय लायक हो सकता है।
एंथनी फोर्लोनी

4
यह आईडी फोन से जुड़े Google खाते से आती है। सिम्युलेटर में आमतौर पर एक नहीं होता है। एक असली फोन में एक भी नहीं हो सकता है। इसके अलावा, यह "फ़ैक्टरी रीसेट पर बदल सकता है" के रूप में प्रलेखित है, और इसे रूट किए गए फोन पर कभी भी मनमाने ढंग से बदला जा सकता है। अपने जोखिम पार इस्तेमाल करें। कोई अच्छा विकल्प नहीं है - अन्य अस्थायी डिवाइस आईडी या तो सार्वभौमिक रूप से उपलब्ध नहीं हैं, या अद्वितीय या दोनों नहीं हैं। इस दुख की कहानी के बाकी हिस्सों के लिए अन्य उत्तर देखें।
सेवा अलेक्सेयेव

14

इस पर चर्चा करने वाले Android डेवलपर के ब्लॉग पर एक उत्कृष्ट पोस्ट है

यह TelephonyManager.getDeviceId()एंड्रॉइड डिवाइस पर काम नहीं करने के खिलाफ सिफारिश करता है जो कि टैबलेट जैसे फोन नहीं हैं, इसके लिए READ_PHONE_STATEअनुमति की आवश्यकता होती है और यह सभी फोनों के लिए मज़बूती से काम नहीं करता है।

इसके बजाय आप निम्न में से एक का उपयोग कर सकते हैं:

  • मैक पते
  • क्रमांक
  • ANDROID_ID

पोस्ट प्रत्येक के पेशेवरों और विपक्षों के बारे में चर्चा करता है और यह पढ़ने के लायक है इसलिए आप यह काम कर सकते हैं जो आपके उपयोग के लिए सबसे अच्छा होगा।


+1, हाय डेव, स्पष्टीकरण के लिए धन्यवाद क्योंकि अभी मैं टैबलेट के लिए एक एप्लिकेशन विकसित कर रहा हूं, जहां मुझे एंड्रॉइड डिवाइस की यूनिक आईडी की आवश्यकता है, इसलिए मुझे यूनीक एंड्रॉइड टैबलेट डिवाइस प्राप्त करने के लिए क्या उपयोग करना चाहिए?
परेश मेयानी

12

एक सरल संख्या के लिए जो डिवाइस के लिए अद्वितीय है और अपने जीवनकाल के लिए स्थिर है (फ़ैक्टरी रीसेट या हैकिंग को छोड़कर), 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);

सीधा सा जवाब !!
फारिस फारिस

Build.SER --AL को जावा में चित्रित किया गया
Eyyüp Alkış

7

IMEI अच्छा है लेकिन केवल फोन के साथ Android उपकरणों पर काम करता है। आपको टैबलेट या अन्य Android उपकरणों के लिए समर्थन पर विचार करना चाहिए, जिनके पास फोन नहीं है।

आपके पास कुछ विकल्प हैं जैसे: कक्षा सदस्य, बीटी मैक, डब्ल्यूएलएएन मैक, या इससे भी बेहतर - इन सभी का एक संयोजन बनाएँ।

मैंने अपने ब्लॉग पर एक लेख में इन विवरणों को समझाया है, देखें: http://www.pocketmagic.net/?p=1662


6

चूँकि यहाँ कोई उत्तर सही, असफल-प्रूफ आईडी का उल्लेख नहीं करता है, जो सिस्टम अपडेट के माध्यम से दोनों के समान है और सभी उपकरणों में मौजूद है (मुख्यतः इस तथ्य के कारण कि Google से अलग-अलग समाधान नहीं है), मैंने एक विधि पोस्ट करने का फैसला किया है जो है उपलब्ध पहचानकर्ताओं में से दो को जोड़कर अगली सबसे अच्छी बात, और रन-टाइम में उनके बीच चयन करने के लिए एक चेक।

कोड से पहले, 3 तथ्य:

  1. TelephonyManager.getDeviceId()(akaIMEI) अच्छी तरह से या गैर-जीएसएम, 3 जी, एलटीई, आदि उपकरणों के लिए बिल्कुल भी काम नहीं करेगा, लेकिन संबंधित हार्डवेयर मौजूद होने पर भी हमेशा एक अद्वितीय आईडी लौटाएगा , जब कोई सिम नहीं डाला जाता है या तब भी जब कोई सिम स्लॉट मौजूद नहीं है ( कुछ ओईएम ने ऐसा किया है)।

  2. चूंकि जिंजरब्रेड (एंड्रॉइड 2.3) android.os.Build.SERIAL को किसी भी उपकरण पर मौजूद होना चाहिए जो आईएमईआई प्रदान नहीं करता है , अर्थात, एंड्रॉइड पॉलिसी के अनुसार, उपरोक्त हार्डवेयर मौजूद नहीं है।

  3. तथ्य (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 छेड़छाड़ हैक / हार्डवेयर मॉड के माध्यम से होती है।


5

उपरोक्त सभी दृष्टिकोणों के साथ समस्याएं हैं। 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 मैं विशेष रूप से बैकअप के रूप में परीक्षण पर नीचे दिए गए अनुभाग की सिफारिश करता हूं तुरंत नहीं होता है और इसलिए परीक्षण करने के लिए आपको बैकअप को मजबूर करना होगा।


2

दूसरा तरीका यह है कि ऐप में / 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 का उपयोग करना होगा। बस सुनिश्चित करें कि आप इसे अपवाद हैंडलर में लपेटते हैं क्योंकि सभी उपकरणों में यह फ़ाइल नहीं है।

कम से कम निम्नलिखित उपकरणों को इस फ़ाइल को विश्व-पठनीय माना जाता है:

  • गैलेक्सी नेक्सस
  • नेक्सस एस
  • मोटोरोला Xoom 3 जी
  • तोशिबा AT300
  • एचटीसी वन वी
  • मिनी MK802
  • सैमसंग गैलेक्सी एस II

आप यहाँ मेरे ब्लॉग पोस्ट को भी देख सकते हैं: http://insitusec.blogspot.com/2013/01/leaking-android-hardware-serial-number.html जहाँ मैं चर्चा करता हूँ कि अन्य फाइलें जानकारी के लिए उपलब्ध हैं।


अपना उत्तर पोस्ट करने के लिए धन्यवाद! कृपया सेल्फ-प्रमोशन पर अक्सर पूछे जाने वाले प्रश्नों को ध्यान से पढ़ें । यह भी ध्यान दें कि यह आवश्यक है कि आप अपनी साइट / उत्पाद से लिंक करने पर हर बार एक अस्वीकरण पोस्ट करें।
एंड्रयू बार्बर

1

जैसा कि @haserman कहते हैं:

TelephonyManager tManager = (TelephonyManager)myActivity.getSystemService(Context.TELEPHONY_SERVICE);
String uid = tManager.getDeviceId();

लेकिन यह प्रकट फ़ाइल में अनुमति सहित आवश्यक है:

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

1

स्ट्रिंग के रूप में एंड्रॉइड ओएस डिवाइस की अनूठी डिवाइस आईडी।

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 द्वारा सुझाई गई इस विधि की कड़ाई से सिफारिश करता हूं

ऐप प्रतिष्ठान की पहचान करना


1

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

0

मुझे पता है कि यह प्रश्न पुराना है, लेकिन यह कोड की एक पंक्ति में किया जा सकता है

String deviceID = Build.SERIAL;


AFAIK, यह डिवाइस के OS अपडेट के बाद बदल जाएगा, उदाहरण के लिए 4.4.2 से 4.4.4 या जो भी हो।
डेन ड्रोबियाज़ो

-1

मैंने @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;
    }

आईडी को साझा किए गए प्रीफ़ में रखना वास्तव में अद्वितीय आईडी पाने के लिए मूल उद्देश्य से समझौता करता है। जैसे अगर आप कुछ प्रतिबंधों के लिए कुंजी के रूप में उस आईडी का उपयोग करना चाहते हैं, तो आप खराब हो जाएंगे जब कुशल उपयोगकर्ता एक डिवाइस को रूट करते हैं और आपकी साझा प्राथमिकता फ़ाइल तक पहुंच प्राप्त करते हैं। इसकी सामग्री को कॉपी किया जा सकता है जिसका अर्थ है ...
यूजीन वीक्स्लर

MB के उत्तर और तुम्हारा भी एक अन्य त्रुटि है..यदि आप एक डिवाइसआईडी के रूप में randomUUID का उपयोग करते हैं और यह उन सभी उपकरणों के लिए काम करता है, जो किसी भी तरह से चाहे वे फोन हों या नहीं या यदि वे google exp डिवाइस हैं या नहीं, तो भी।
फ्रेड ग्रोट

-2

हाँ। यह एक डिवाइस हार्डवेयर सीरियल नंबर है और यह अद्वितीय है। तो Api स्तर 2.3 और इसके बाद के संस्करण को प्राप्त करने के लिए आप android.os.Build.ANDROID_ID का उपयोग कर सकते हैं । नीचे 2.3 एपीआई स्तर के लिए TelephonyManager.getDeviceID () का उपयोग करें ।

आप इसे http://android-developers.blogspot.in/2011/03/identifying-app-installations.html पर पढ़ सकते हैं

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.