Android में डिवाइस का IMEI / ESN प्रोग्राम कैसे प्राप्त करें?


343

प्रत्येक डिवाइस को विशिष्ट रूप से पहचानने के लिए मैं IMEI (या CDMA उपकरणों के लिए ESN नंबर) का उपयोग करना चाहूंगा। इस प्रोग्राम को कैसे एक्सेस करें?


दोहरी सिम में दोनों सिम के लिए IMEI प्राप्त करने के लिए फ़ोन में जावा प्रतिबिंब का उपयोग किया जाता है। यहाँ देखें डेमो है
वैभव जानी

5
@PiedPiper: IMEI सिम-विशिष्ट नहीं है। आप IMSI सोच रहे हैं।
फिलिप

@Phillip धन्यवाद दोस्त। मैंने अपना उत्तर अपडेट कर दिया है :)
वैभव जानी

1
हर कोई .. एंड्रॉइड 6 में कुछ बदलाव हैं? क्या हम अभी भी IMEI को कुछ तरीकों से एक्सेस कर सकते हैं?
उपचारक

1
आपको क्रम में READ_PHONE_STATE की अनुमति का अनुरोध करने की आवश्यकता है, फिर भी आप IMEI प्राप्त कर सकते हैं
फ़्लो वी

जवाबों:


387

आप बुलाना चाहते हैं android.telephony.TelephonyManager.getDeviceId()

यह जो भी स्ट्रिंग विशिष्ट डिवाइस (IMEI पर GSM, MEID for CDMA) की पहचान करेगा।

आपको अपने में निम्नलिखित अनुमति की आवश्यकता होगी AndroidManifest.xml:

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

ऐसा करने के लिए।

कहा जा रहा है, ऐसा करने के बारे में सावधान रहें। न केवल उपयोगकर्ताओं को आश्चर्य होगा कि आपका एप्लिकेशन उनके टेलीफोनी स्टैक तक क्यों पहुंच रहा है, यदि उपयोगकर्ता को एक नया डिवाइस मिलता है, तो डेटा को स्थानांतरित करना मुश्किल हो सकता है।

अद्यतन: जैसा कि नीचे टिप्पणी में कहा गया है, यह उपयोगकर्ताओं को प्रमाणित करने का एक सुरक्षित तरीका नहीं है, और गोपनीयता की चिंताओं को बढ़ाता है। यह अनुशंसित नहीं है। इसके बजाय, यदि आप एक घर्षण रहित लॉगिन प्रणाली को लागू करना चाहते हैं, तो Google+ लॉगिन एपीआई देखें

Android बैकअप एपीआई अगर आप सिर्फ एक हल्के तरह से एक उपयोगकर्ता को अपना फ़ोन रीसेट करता है (या एक नया उपकरण खरीदता है) जब के लिए तार का एक बंडल बनाए रखना चाहते भी उपलब्ध है।


1
फिर एक बेहतर समाधान क्या होगा जो उन्हें भविष्य में डेटा स्थानांतरित करने में सक्षम करेगा? Google ईमेल पता? यदि हां, तो मैं इसे सिस्टम से कैसे निकाल सकता हूं?
टॉम

3
ऐसा करने का सबसे विश्वसनीय तरीका यह है कि जब वे पहली बार आपका ऐप लॉन्च करें, तो उन्हें केवल एक खाता बनाना होगा। उपयोगकर्ता के ईमेल पते को प्राप्त करने के तरीके हैं (खाता प्रबंधक पर डॉक्स देखें), लेकिन यह सत्यापित करते हुए कि दुर्भावनापूर्ण उपयोगकर्ता ने यह जानकारी जाली नहीं की है कि Google डेटा API कैसे काम करता है, इसके बारे में थोड़ी जानकारी चाहिए - इससे अधिक मैं इसमें डाल सकता हूं छोटी टिप्पणी बॉक्स। ;)
ट्रेवर जॉन्स

1
वास्तव में, इस बात के लिए, आपके पास कोई गारंटी नहीं है कि उपयोगकर्ता ने अपने IMEI / MEID को जाली नहीं बनाया है। यदि सुरक्षा किसी भी चिंता का विषय है, तो आपको वास्तव में एक उपयोगकर्ता नाम / पासवर्ड या खाता प्रबंधक में getAuthToken () विधि का उपयोग करने की आवश्यकता है (और फिर, आपको मूल रूप से इसे जारी करने वाले सर्वर के साथ इस टोकन को सत्यापित करने की आवश्यकता होगी)।
ट्रेवर जॉन्स

2
आदि: डिवाइस आईडी प्राप्त करने के लिए कोड? ऊपर वर्णित एक विधि + अनुमति से अधिक कुछ नहीं है। उस ने कहा, आपको Google+ लॉगिन एपीआई में देखना चाहिए, जो इन दिनों उपयोगकर्ताओं को प्रमाणित करने के लिए अनुशंसित दृष्टिकोण है: डेवलपर.
android.com/google/play-services/auth.html

2
क्या यह एंड्रॉइड 6 चला रहा है? और क्या आप एसडीके 23 को लक्षित कर रहे हैं? फिर आपको IMEI
Flo We

284

ट्रेवर जॉन्स के उत्तर के अलावा, आप इसका उपयोग इस प्रकार कर सकते हैं:

TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
telephonyManager.getDeviceId();

और आपको अपनी Manifest.xml फ़ाइल में निम्नलिखित अनुमति देनी चाहिए:

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

एमुलेटर में, आपको संभवतः "00000 ..." मान मिलेगा। यदि डिवाइस आईडी उपलब्ध नहीं है तो getDeviceId () NULL लौटाता है।


1
क्या IMEI नंबर वापस करने के लिए एमुलेटर प्राप्त करने का कोई तरीका है?
माइकस्चैम

@MikeSchem, एमुलेटर में सार्थक IMEI स्ट्रिंग नहीं है।
1

कोशिश न करें: <उपयोग-अनुमति एंड्रॉइड: नाम = "android.permission.READ_PHONE_STATE" /> यह अनुमति बहुत संवेदनशील है, आप Google Play टीम से ऐप रिजेक्ट कर सकते हैं (नए सुरक्षा नियम 2018 के अंत में जोड़े गए)। सलाह के रूप में बेहतर विज्ञापन आईडी का उपयोग करें।
दून

@Taner क्या यह डुअल सिम डिवाइस पर काम करेगा? (केवल पहले IMEI प्राप्त करने की आवश्यकता है)
अर्नोल्ड ब्राउन

क्या READ_PHONE_STATEअनुमति का उपयोग करने के लिए कोई सुरक्षा चिंता है ?
सांप

62

मैं IMEI प्राप्त करने के लिए निम्न कोड का उपयोग करता हूं या एक विकल्प के रूप में Secure.ANDROID_ID का उपयोग करता हूं, जब डिवाइस में फोन की क्षमता नहीं होती है:

/**
 * Returns the unique identifier for the device
 *
 * @return unique identifier for the device
 */
public String getDeviceIMEI() {
    String deviceUniqueIdentifier = null;
    TelephonyManager tm = (TelephonyManager) this.getSystemService(Context.TELEPHONY_SERVICE);
    if (null != tm) {
        deviceUniqueIdentifier = tm.getDeviceId();
    }
    if (null == deviceUniqueIdentifier || 0 == deviceUniqueIdentifier.length()) {
        deviceUniqueIdentifier = Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID);
    }
    return deviceUniqueIdentifier;
}

17
TextUtils.isEmpty () -> अगर (पहचानकर्ता == अशक्त || पहचानकर्ता .length () == 0)
मिखाइली

2
हाय पिनहासी, क्या आपके पास कोई मामला है जब टेलीफोनी प्रबंधक द्वारा लौटाए गए डिवाइस आईडी शून्य या खाली थे, लेकिन Secure.ANDROID_ID से पढ़ा गया मान गैर-रिक्त था? धन्यवाद
बुद्ध

4
जहाँ तक मुझे याद है कि यह बिना सिम कार्ड वाली गोलियों के लिए था (लेकिन मुझे 100% यकीन नहीं है)।
आसफ पिंहासी

डिवाइस को स्वरूपित या रोम फ़ैक्टरी रीसेट होने पर सुरक्षित .ANDROID_ID बदल जाता है
श्रीदत्त कोठारी

मेरा Nexus7 (1stGen) nullटेलीफोनी डिवाइस के लिए रिटर्न देता है ... कोई भी जानता है कि टैबलेट से IMEI कैसे प्राप्त करें?
साकिबॉय

38

या आप Android.Provider.Settings.System (जैसा कि यहां strazerre.com वर्णित है ) से ANDROID_ID सेटिंग का उपयोग कर सकते हैं ।

इसका यह लाभ है कि इसके लिए विशेष अनुमति की आवश्यकता नहीं होती है, लेकिन यदि कोई अन्य एप्लिकेशन लिखता है और इसे बदलता है (जो कि स्पष्ट रूप से असामान्य है लेकिन असंभव नहीं है) बदल सकता है।

बस संदर्भ के लिए यहाँ ब्लॉग से कोड है:

import android.provider.Settings;
import android.provider.Settings.System;   

String androidID = System.getString(this.getContentResolver(),Secure.ANDROID_ID);

कार्यान्वयन नोट : यदि आईडी सिस्टम आर्किटेक्चर के लिए महत्वपूर्ण है, तो आपको यह पता होना चाहिए कि व्यवहार में कुछ बहुत ही कम एंड्रॉइड फोन और टैबलेट एक ही ANDROID_ID (9774d56d682e549c) का पुन: उपयोग करते हुए पाए गए हैं जो हमारे लॉग में दिखा रहा था)


15
इस स्थिरांक को हटा दिया जाता है। इसके बजाय आपको android.provider.Settings.Secure.ANDROID_ID का उपयोग करने की आवश्यकता है;
मॉर्कले

@mcorley जब मैं android.provider.Settings.Secure.ANDROID_ID का उपयोग कर रहा हूँ तो नेक्सस 7 टैबलेट और नेक्सस 4 के लिए यह समान मूल्य 'android_id'
लौटाता है

3
@meowmeo ने मेरे लिए ऐसा ही किया, जब तक कि मैंने कोड का उपयोग नहीं किया जो अब उत्तर (ish) का एक हिस्सा है। String androidID = android.provider.Settings.System.getString(this.getContentResolver(), Secure.ANDROID_ID);
मथियास

लेकिन क्या यह फ़ैक्टरी रीसेट पर नए ANDROID_ID पर रीसेट नहीं होगा? क्या होगा अगर मुझे एक निरंतर ANDROID_ID की आवश्यकता है जो कि रीसेट को बचा सकता है।
इगोरगानपोलस्की

35

प्रेषक: http://mytechead.wordpress.com/2011/08/28/how-to-get-ime-number-of-android-device/ :

निम्नलिखित कोड Android उपकरणों की IMEI संख्या प्राप्त करने में मदद करता है:

TelephonyManager tm = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String device_id = tm.getDeviceId();

Android मैनिफेस्ट में आवश्यक अनुमतियां:

android.permission.READ_PHONE_STATE

नोट: टेबलेट या डिवाइस के मामले में जो मोबाइल फोन IMEI के रूप में कार्य नहीं कर सकता है, अशक्त होगा।


1
यह वास्तविक कोड है जो मुझे IMEI के लिए मिल रहा है
आनंद सवजानी

2
दुर्भाग्य से, मार्शमैलो आगे के साथ अब आपको रनटाइम में इस अनुमति के लिए पूछना होगा। यह अनुमति आदर्श नहीं है, क्योंकि यह उपयोगकर्ता अनुभव को परेशान करता है, और कुछ उपयोगकर्ताओं को संदिग्ध बना सकता है।
इगोरगानापोलस्की

कोशिश न करें: <उपयोग-अनुमति एंड्रॉइड: नाम = "android.permission.READ_PHONE_STATE" /> यह अनुमति बहुत संवेदनशील है, आप Google Play टीम (2018 के अंत में जोड़े गए नए सुरक्षा नियम) से ऐप रिजेक्ट कर सकते हैं। सलाह बेहतर विज्ञापन आईडी बजाय आईएमईआई का उपयोग करते हैं
Duna

Android 10 के लिए क्या उपाय है?
अमीन पिंजारी

23

IMEI पाने के लिए (अंतर्राष्ट्रीय मोबाइल उपकरण पहचानकर्ता)

public String getIMEI(Activity activity) {
    TelephonyManager telephonyManager = (TelephonyManager) activity
            .getSystemService(Context.TELEPHONY_SERVICE);
    return telephonyManager.getDeviceId();
}

डिवाइस को पाने के लिए यूनिक आई.डी.

public String getDeviceUniqueID(Activity activity){
    String device_unique_id = Secure.getString(activity.getContentResolver(),
            Secure.ANDROID_ID);
    return device_unique_id;
}

2
Device_unique_id विकल्प दिखाना वास्तव में मददगार है
जोगलिंड

20

एंड्रॉइड 6.0+ के लिए गेम बदल गया है, इसलिए मेरा सुझाव है कि आप इसका उपयोग करें;

जाने का सबसे अच्छा तरीका रनटाइम के दौरान है और आपको अनुमति त्रुटियां मिलती हैं।

   /**
 * A loading screen after AppIntroActivity.
 */
public class LoadingActivity extends BaseActivity {
private static final int MY_PERMISSIONS_REQUEST_READ_PHONE_STATE = 0;
private TextView loading_tv2;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_loading);

    //trigger 'loadIMEI'
    loadIMEI();
    /** Fading Transition Effect */
    overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
}

/**
 * Called when the 'loadIMEI' function is triggered.
 */
public void loadIMEI() {
    // Check if the READ_PHONE_STATE permission is already available.
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE)
            != PackageManager.PERMISSION_GRANTED) {
        // READ_PHONE_STATE permission has not been granted.
        requestReadPhoneStatePermission();
    } else {
        // READ_PHONE_STATE permission is already been granted.
        doPermissionGrantedStuffs();
    }
}



/**
 * Requests the READ_PHONE_STATE permission.
 * If the permission has been denied previously, a dialog will prompt the user to grant the
 * permission, otherwise it is requested directly.
 */
private void requestReadPhoneStatePermission() {
    if (ActivityCompat.shouldShowRequestPermissionRationale(this,
            Manifest.permission.READ_PHONE_STATE)) {
        // Provide an additional rationale to the user if the permission was not granted
        // and the user would benefit from additional context for the use of the permission.
        // For example if the user has previously denied the permission.
        new AlertDialog.Builder(LoadingActivity.this)
                .setTitle("Permission Request")
                .setMessage(getString(R.string.permission_read_phone_state_rationale))
                .setCancelable(false)
                .setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        //re-request
                        ActivityCompat.requestPermissions(LoadingActivity.this,
                                new String[]{Manifest.permission.READ_PHONE_STATE},
                                MY_PERMISSIONS_REQUEST_READ_PHONE_STATE);
                    }
                })
                .setIcon(R.drawable.onlinlinew_warning_sign)
                .show();
    } else {
        // READ_PHONE_STATE permission has not been granted yet. Request it directly.
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_PHONE_STATE},
                MY_PERMISSIONS_REQUEST_READ_PHONE_STATE);
    }
}

/**
 * Callback received when a permissions request has been completed.
 */
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                       @NonNull int[] grantResults) {

    if (requestCode == MY_PERMISSIONS_REQUEST_READ_PHONE_STATE) {
        // Received permission result for READ_PHONE_STATE permission.est.");
        // Check if the only required permission has been granted
        if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // READ_PHONE_STATE permission has been granted, proceed with displaying IMEI Number
            //alertAlert(getString(R.string.permision_available_read_phone_state));
            doPermissionGrantedStuffs();
        } else {
            alertAlert(getString(R.string.permissions_not_granted_read_phone_state));
          }
    }
}

private void alertAlert(String msg) {
    new AlertDialog.Builder(LoadingActivity.this)
            .setTitle("Permission Request")
            .setMessage(msg)
            .setCancelable(false)
            .setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    // do somthing here
                }
            })
            .setIcon(R.drawable.onlinlinew_warning_sign)
            .show();
}


public void doPermissionGrantedStuffs() {
    //Have an  object of TelephonyManager
    TelephonyManager tm =(TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
    //Get IMEI Number of Phone  //////////////// for this example i only need the IMEI
    String IMEINumber=tm.getDeviceId();

    /************************************************
     * **********************************************
     * This is just an icing on the cake
     * the following are other children of TELEPHONY_SERVICE
     *
     //Get Subscriber ID
     String subscriberID=tm.getDeviceId();

     //Get SIM Serial Number
     String SIMSerialNumber=tm.getSimSerialNumber();

     //Get Network Country ISO Code
     String networkCountryISO=tm.getNetworkCountryIso();

     //Get SIM Country ISO Code
     String SIMCountryISO=tm.getSimCountryIso();

     //Get the device software version
     String softwareVersion=tm.getDeviceSoftwareVersion()

     //Get the Voice mail number
     String voiceMailNumber=tm.getVoiceMailNumber();


     //Get the Phone Type CDMA/GSM/NONE
     int phoneType=tm.getPhoneType();

     switch (phoneType)
     {
     case (TelephonyManager.PHONE_TYPE_CDMA):
     // your code
     break;
     case (TelephonyManager.PHONE_TYPE_GSM)
     // your code
     break;
     case (TelephonyManager.PHONE_TYPE_NONE):
     // your code
     break;
     }

     //Find whether the Phone is in Roaming, returns true if in roaming
     boolean isRoaming=tm.isNetworkRoaming();
     if(isRoaming)
     phoneDetails+="\nIs In Roaming : "+"YES";
     else
     phoneDetails+="\nIs In Roaming : "+"NO";


     //Get the SIM state
     int SIMState=tm.getSimState();
     switch(SIMState)
     {
     case TelephonyManager.SIM_STATE_ABSENT :
     // your code
     break;
     case TelephonyManager.SIM_STATE_NETWORK_LOCKED :
     // your code
     break;
     case TelephonyManager.SIM_STATE_PIN_REQUIRED :
     // your code
     break;
     case TelephonyManager.SIM_STATE_PUK_REQUIRED :
     // your code
     break;
     case TelephonyManager.SIM_STATE_READY :
     // your code
     break;
     case TelephonyManager.SIM_STATE_UNKNOWN :
     // your code
     break;

     }
     */
    // Now read the desired content to a textview.
    loading_tv2 = (TextView) findViewById(R.id.loading_tv2);
    loading_tv2.setText(IMEINumber);
}
}

आशा है कि यह आपकी या किसी की मदद करेगा।


16

नई अपडेट:

Android संस्करण 6 और इसके बाद के संस्करण के लिए, WLAN MAC पता हटा दिया गया है, ट्रेवर जॉन्स जवाब का पालन करें

अपडेट करें:

उपकरणों की विशिष्ट पहचान के लिए, आप Secure.ANDROID_ID का उपयोग कर सकते हैं ।

पुराना उत्तर:

अद्वितीय डिवाइस आईडी के रूप में IMEI का उपयोग करने के नुकसान:

  • IMEI डिवाइस के Simcard स्लॉट पर निर्भर है, इसलिए उन डिवाइस के लिए IMEI प्राप्त करना संभव नहीं है जो Simcard का उपयोग नहीं करते हैं। डुअल सिम डिवाइस में, हमें एक ही डिवाइस के लिए 2 अलग-अलग IMEI मिलते हैं क्योंकि इसमें simcard के लिए 2 स्लॉट हैं।

आप WLAN MAC एड्रेस स्ट्रिंग का उपयोग कर सकते हैं (Marshmallow और Marshmallow के लिए अनुशंसित नहीं है) क्योंकि WLAN MAC एड्रेस को Marshmallow को आगे बढ़ाया गया है। इसलिए आपको एक बोगस मान मिलेगा।

हम WLAN मैक पते का उपयोग करके एंड्रॉइड फोन के लिए यूनिक आईडी प्राप्त कर सकते हैं। मैक पता सभी उपकरणों के लिए अद्वितीय है और यह सभी प्रकार के उपकरणों के लिए काम करता है।

डिवाइस आईडी के रूप में WLAN मैक पते का उपयोग करने के लाभ:

  • यह सभी प्रकार के उपकरणों (स्मार्ट फोन और टैबलेट) के लिए अद्वितीय पहचानकर्ता है।

  • यदि एप्लिकेशन को फिर से इंस्टॉल किया जाता है तो यह अद्वितीय रहता है

डिवाइस आईडी के रूप में WLAN मैक पते का उपयोग करने के नुकसान:

  • आप मार्शमैलो और ऊपर से एक बोगस मान दें।

  • अगर डिवाइस में wifi हार्डवेयर नहीं है तो आपको null MAC एड्रेस मिलता है, लेकिन आमतौर पर यह देखा जाता है कि ज्यादातर Android डिवाइसों में wifi हार्डवेयर होता है और मार्केट में शायद ही कोई ऐसा डिवाइस हो जिसमें कोई wifi हार्डवेयर न हो।

स्रोत: technetexperts.com


7
"आईएमईआई सिमकार्ड पर निर्भर है" ... यह गलत है। आप IMSI नंबर के साथ IMEI को भ्रमित कर रहे हैं
Merlevede

2
एक अंतर्राष्ट्रीय मोबाइल स्टेशन उपकरण पहचान या लघु के लिए IMEI एक संख्या है जो जीएसएम नेटवर्क पर चलने वाले मोबाइल फोन की पहचान करती है। मैंने व्यक्तिगत रूप से इसकी कोशिश की है और यह जीएसएम फोन पर कोई वायरलेस वाहक नहीं होने पर मुझे प्रोग्राम के तौर पर अशक्त कर देता है। smartmobilephonesolutions.com/content/…
जमील

3
आप सही हैं, मैंने ध्यान से नहीं पढ़ा। IMEI सिम कार्ड ट्रांसीवर से जुड़ा होता है, सिम कार्ड से नहीं। मेरी गलती!
मेराल्वेडे

2
WLAN MAC एड्रेस को मार्शमैलो फॉरवर्ड पर अपग्रेड किया गया है। तो आपको एक फर्जी मूल्य मिलेगा!
इगोरगानपोलस्की

1
Android 6 न ही अपने कोड के साथ सही WIFI मैक एड्रेस लौटाएं। ध्यान दो।
zszen

15

जैसा कि एपीआई 26 में है getDeviceId() में मूल्यह्रास है, इसलिए आप निम्नलिखित कोड का उपयोग API 26 और पुराने संस्करणों को पूरा करने के लिए कर सकते हैं

TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String imei="";
if (android.os.Build.VERSION.SDK_INT >= 26) {
  imei=telephonyManager.getImei();
}
else
{
  imei=telephonyManager.getDeviceId();
}

READ_PHONE_STATEउपरोक्त कोड का उपयोग करने के लिए अनुमति अनुरोध जोड़ना न भूलें ।

अद्यतन: एंड्रॉइड 10 से उपयोगकर्ता ऐप के लिए IMEI जैसे गैर-पुन: प्रयोज्य हार्डवेयर पहचानकर्ता प्राप्त करने के लिए प्रतिबंधित है।


मन साझा करना जहां मुझे 'getImei () "विधि के लिए संदर्भ मिल सकता है?
सैम बाइट

2
GetImei () संदर्भ के लिए कृपया डेवलपर. android.com/reference/android/telephony/… का उपयोग करें
मुहम्मद हमजा शहीद

Android 10 के लिए क्या उपाय है?
अमीन पिंजारी

1
दुर्भाग्यवश एंड्रॉइड 10 में अमीन सुरक्षा कारणों से अब तीसरे पक्ष के ऐप के लिए हार्डवेयर पहचानकर्ता प्राप्त करने के लिए प्रतिबंधित है, जो एंड्रॉइड 10 में डेवलपर
।android.com/about/versions/

Android Oreo पर काम करता है।
सतीश शेट्टी

10

TeleDonyManager की विधि getDeviceId () अद्वितीय डिवाइस ID लौटाती है, उदाहरण के लिए, GSM के लिए IMEI और CDMA फोन के लिए MEID या ESN। यदि डिवाइस ID उपलब्ध नहीं है, तो अशक्त लौटें।

जावा कोड

package com.AndroidTelephonyManager;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.telephony.TelephonyManager;
import android.widget.TextView;

public class AndroidTelephonyManager extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    TextView textDeviceID = (TextView)findViewById(R.id.deviceid);

    //retrieve a reference to an instance of TelephonyManager
    TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);

    textDeviceID.setText(getDeviceID(telephonyManager));

}

String getDeviceID(TelephonyManager phonyManager){

 String id = phonyManager.getDeviceId();
 if (id == null){
  id = "not available";
 }

 int phoneType = phonyManager.getPhoneType();
 switch(phoneType){
 case TelephonyManager.PHONE_TYPE_NONE:
  return "NONE: " + id;

 case TelephonyManager.PHONE_TYPE_GSM:
  return "GSM: IMEI=" + id;

 case TelephonyManager.PHONE_TYPE_CDMA:
  return "CDMA: MEID/ESN=" + id;

 /*
  *  for API Level 11 or above
  *  case TelephonyManager.PHONE_TYPE_SIP:
  *   return "SIP";
  */

 default:
  return "UNKNOWN: ID=" + id;
 }

}
}

एक्सएमएल

<linearlayout android:layout_height="fill_parent" android:layout_width="fill_parent" android:orientation="vertical" xmlns:android="http://schemas.android.com/apk/res/android">
<textview android:layout_height="wrap_content" android:layout_width="fill_parent" android:text="@string/hello">
<textview android:id="@+id/deviceid" android:layout_height="wrap_content" android:layout_width="fill_parent">
</textview></textview></linearlayout> 

प्रकट फ़ाइल में अनुमति आवश्यक READ_PHONE_STATE।


4

अद्वितीय डिवाइस ID प्राप्त करने के लिए आप इस टेलीफोनी मैनजर TELEPHONY_SERVICE फ़ंक्शन का उपयोग कर सकते हैं , इसके लिए अनुमति आवश्यक है: READ_PHONE_STATE

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

उदाहरण के लिए, जीएसएम के लिए IMEI और CDMA फोन के लिए MEID या ESN

/**
 * Gets the device unique id called IMEI. Sometimes, this returns 00000000000000000 for the
 * rooted devices.
 **/
public static String getDeviceImei(Context ctx) {
    TelephonyManager telephonyManager = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
    return telephonyManager.getDeviceId();
}

यदि डिवाइस ID उपलब्ध नहीं है, तो अशक्त लौटें


और डिवाइस आईडी शून्य क्यों है? जड़ वाले उपकरण के कारण।
विशाल सोजित्रा

Android 10 के लिए क्या उपाय है?
अमीन पिंजारी


3

इसे आज़माएं (हमेशा पहले IMEI प्राप्त करने की आवश्यकता है)

TelephonyManager mTelephony = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        if (ActivityCompat.checkSelfPermission(LoginActivity.this,Manifest.permission.READ_PHONE_STATE)!= PackageManager.PERMISSION_GRANTED) {

         return;
}

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                if (mTelephony.getPhoneCount() == 2) {
                    IME = mTelephony.getImei(0);
                }else{
                    IME = mTelephony.getImei();
                }
            }else{
                if (mTelephony.getPhoneCount() == 2) {
                    IME = mTelephony.getDeviceId(0);
                } else {
                    IME = mTelephony.getDeviceId();
                }
            }
        } else {
            IME = mTelephony.getDeviceId();
        }

Android 10 के लिए क्या उपाय है? डेवलपर
.android.com/about/versions/

2

नीचे दिए गए कोड का उपयोग आपको IMEI नंबर देता है:

TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
System.out.println("IMEI::" + telephonyManager.getDeviceId());

1

एपीआई स्तर 11 या इसके बाद के संस्करण के लिए:

case TelephonyManager.PHONE_TYPE_SIP: 
return "SIP";

TelephonyManager tm= (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
textDeviceID.setText(getDeviceID(tm));

1

DeviceId (IMEI) प्राप्त करने के लिए कोटलिन कोड सभी Android संस्करणों के लिए अनुमति और तुलनात्मक जांच से निपटने के लिए:

 val  telephonyManager = getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE)
        == PackageManager.PERMISSION_GRANTED) {
        // Permission is  granted
        val imei : String? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)  telephonyManager.imei
        // older OS  versions
        else  telephonyManager.deviceId

        imei?.let {
            Log.i("Log", "DeviceId=$it" )
        }

    } else {  // Permission is not granted

    }

इस अनुमति को AndroidManifest.xml में भी जोड़ें:

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

1

आपको अपने AndroidManifest.xml में निम्नलिखित अनुमति की आवश्यकता होगी:

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

IMEI (अंतरराष्ट्रीय मोबाइल उपकरण पहचानकर्ता) प्राप्त करने के लिए और यदि यह एपीआई स्तर 26 से ऊपर है, तो हम telephonyManager.getImei()इसके लिए इतना अशक्त हो जाते हैं, हम एक विशिष्ट पहचानकर्ता के रूप में ANDROID_ID का उपयोग करते हैं ।

 public static String getIMEINumber(@NonNull final Context context)
            throws SecurityException, NullPointerException {
        TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        String imei;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            assert tm != null;
            imei = tm.getImei();
            //this change is for Android 10 as per security concern it will not provide the imei number.
            if (imei == null) {
                imei = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
            }
        } else {
            assert tm != null;
            if (tm.getDeviceId() != null && !tm.getDeviceId().equals("000000000000000")) {
                imei = tm.getDeviceId();
            } else {
                imei = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
            }
        }

        return imei;
    }

0

कोटलिन संस्करण की तलाश करने वालों के लिए, आप कुछ इस तरह का उपयोग कर सकते हैं;

private fun telephonyService() {
    val telephonyManager = getSystemService(TELEPHONY_SERVICE) as TelephonyManager
    val imei = if (android.os.Build.VERSION.SDK_INT >= 26) {
        Timber.i("Phone >= 26 IMEI")
        telephonyManager.imei
    } else {
        Timber.i("Phone IMEI < 26")
        telephonyManager.deviceId
    }

    Timber.i("Phone IMEI $imei")
}

नोट: आपको CheckSelfPermissiontelephonyService() का उपयोग करके एक अनुमति जांच के साथ ऊपर लपेटना होगा या आपके द्वारा उपयोग की जाने वाली किसी भी विधि के ।

इस अनुमति को प्रकट फ़ाइल में भी जोड़ें;

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

0

नीचे दिए गए कोड का उपयोग करें:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        String[] permissions = {Manifest.permission.READ_PHONE_STATE};
        if (ActivityCompat.checkSelfPermission(this,
                Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(permissions, READ_PHONE_STATE);
        }
    } else {
        try {
            TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            String imei = telephonyManager.getDeviceId();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

और कोड के बाद onRequestPiersResult विधि पर कॉल करें:

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    switch (requestCode) {
        case READ_PHONE_STATE:
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED)
                try {
                    TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
                    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
                        return;
                    }
                    String imei = telephonyManager.getDeviceId();

                } catch (Exception e) {
                    e.printStackTrace();
                }
    }
}

अपने AndroidManifest.xml में निम्नलिखित अनुमति जोड़ें:

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

0

Android 10 के लिए निम्नलिखित कोड मेरे लिए काम कर रहा है।

val uid: String = Settings.Secure.getString(ctx.applicationContext.contentResolver, Settings.Secure.ANDROID_ID)
if (ContextCompat.checkSelfPermission(ctx, Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED) {
            imei = when {
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q -> {
                    uid
                }
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.O -> {
                    telephonyManager.imei
                }
                else -> {
                    telephonyManager.deviceId
                }
            }
        }
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.