एंड्रॉइड पर इंटरनेट एक्सेस कैसे जांचें? InetAddress कभी बाहर नहीं

657

मुझे वह मिल गया है AsyncTaskजो होस्ट नाम पर नेटवर्क एक्सेस की जांच करने वाला है। लेकिन doInBackground()कभी भी समय समाप्त नहीं होता है। किसी के पास कोई सुराग है?

public class HostAvailabilityTask extends AsyncTask<String, Void, Boolean> {

    private Main main;

    public HostAvailabilityTask(Main main) {
        this.main = main;
    }

    protected Boolean doInBackground(String... params) {
        Main.Log("doInBackground() isHostAvailable():"+params[0]);

        try {
            return InetAddress.getByName(params[0]).isReachable(30); 
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;       
    }

    protected void onPostExecute(Boolean... result) {
        Main.Log("onPostExecute()");

        if(result[0] == false) {
            main.setContentView(R.layout.splash);
            return;
        }

        main.continueAfterHostCheck();
    }   
}
android  networking  asynchronous 
— विदुर बनियान
स्रोत
5
इंटरनेट कनेक्शन की जांच करने के लिए, शायद सबसे विश्वसनीय तरीका एक प्रमुख नाम सर्वर को पिंग करना होगा, यह उदाहरण के लिए किया जा सकता है if(Runtime.getRuntime().exec("/system/bin/ping -c 1 8.8.8.8").waitFor()==0) ...। इस के एक अच्छे कार्यान्वयन के लिए मेरा जवाब देखें । Btw स्वीकृत उत्तर (और यहां कई अन्य) सिर्फ एक नेटवर्क कनेक्शन की जांच करें , इंटरनेट नहीं।
— लेविट
— देखें-
4
पिंग विधि का उपयोग न करें, इसके बजाय एक HTTP चेक का उपयोग करें। आईसीएमपी कुछ नेटवर्क पर अवरुद्ध है, इसलिए पिंग काम नहीं करेगा। उदा: यह मेरे होम वाईफाई पर पूरी तरह से काम करता है, लेकिन ऐसा नहीं है जब मैं वोडाफोन के नेटवर्क (हंगरी में) पर मोबाइल डेटा का उपयोग कर रहा हूं। या 2 विधियों को एक कमबैक के रूप में संयोजित करें, लेकिन सावधान रहें क्योंकि WaitFor () के बारे में 20 सेकंड प्रतीक्षा करेगा, भले ही -w या -W का उपयोग किया जाए।
— तमसे बोलवरी
इसे देखें: stackoverflow.com/a/39766506/3806413
— 0xAliHn
@ TamásBolvári: इससे भी बेहतर होगा कि इसे tcp लेयर पर टैकल किया जाए। जो आपको एक HTTP अनुरोध के साथ, ICMP की गति के करीब होना चाहिए। मैंने तदनुसार "पिंग उत्तर" संपादित किया।
— लेवी

जवाबों:

552

नेटवर्क कनेक्शन / इंटरनेट का उपयोग

  • isConnectedOrConnecting()(अधिकांश उत्तरों में प्रयुक्त) किसी भी नेटवर्क कनेक्शन के लिए जाँच
  • यह जानने के लिए कि उनमें से किसी भी नेटवर्क में इंटरनेट एक्सेस है या नहीं, निम्न में से किसी एक का उपयोग करें

ए) एक सर्वर पिंग (आसान)

// ICMP 
public boolean isOnline() {
    Runtime runtime = Runtime.getRuntime();
    try {
        Process ipProcess = runtime.exec("/system/bin/ping -c 1 8.8.8.8");
        int     exitValue = ipProcess.waitFor();
        return (exitValue == 0);
    }
    catch (IOException e)          { e.printStackTrace(); }
    catch (InterruptedException e) { e.printStackTrace(); }

    return false;
}

+ मुख्य धागे पर चल सकता है

- कुछ पुराने उपकरणों (Galays S3, आदि) पर काम नहीं करता है, अगर कोई इंटरनेट उपलब्ध नहीं है तो यह कुछ समय के लिए अवरुद्ध हो जाता है।

बी) इंटरनेट पर एक सॉकेट से कनेक्ट (उन्नत)

// TCP/HTTP/DNS (depending on the port, 53=DNS, 80=HTTP, etc.)
public boolean isOnline() {
    try {
        int timeoutMs = 1500;
        Socket sock = new Socket();
        SocketAddress sockaddr = new InetSocketAddress("8.8.8.8", 53);

        sock.connect(sockaddr, timeoutMs);
        sock.close();

        return true;
    } catch (IOException e) { return false; }
}

+बहुत तेज (या तो), सभी उपकरणों पर काम करता है, बहुत विश्वसनीय है

- UI थ्रेड पर नहीं चल सकता

यह बहुत मज़बूती से, हर डिवाइस पर काम करता है, और बहुत तेज़ है। हालांकि इसे एक अलग कार्य में चलाने की आवश्यकता है (जैसे ScheduledExecutorServiceया AsyncTask)।

संभव प्रश्न

  • क्या यह वास्तव में काफी तेज है?

    हाँ, बहुत तेज़ ;-)

  • क्या इंटरनेट की जांच करने का कोई विश्वसनीय तरीका नहीं है, इंटरनेट पर कुछ परीक्षण करने के अलावा?

    जहाँ तक मुझे पता है, नहीं, लेकिन मुझे बताइए, और मैं अपना उत्तर संपादित करूँगा।

  • क्या होगा अगर DNS डाउन है?

    Google DNS (उदा 8.8.8.8) दुनिया का सबसे बड़ा सार्वजनिक DNS है। 2013 तक इसने एक दिन में 130 बिलियन अनुरोधों की सेवा दी। चलो बस कहना है, अपने app शायद दिन की बात नहीं होगी।

  • किन अनुमतियों की आवश्यकता है?

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

    बस इंटरनेट का उपयोग - आश्चर्य ^ ^ (बीडब्ल्यूटी क्या आपने कभी इस बारे में सोचा है कि यहां बताए गए कुछ तरीके इंटरनेट की पहुंच के बारे में रिमोट की अनुमति कैसे दे सकते हैं, इस अनुमति के बिना?)

 

अतिरिक्त: एक-शॉट AsyncTaskउदाहरण

class InternetCheck extends AsyncTask<Void,Void,Boolean> {

    private Consumer mConsumer;
    public  interface Consumer { void accept(Boolean internet); }

    public  InternetCheck(Consumer consumer) { mConsumer = consumer; execute(); }

    @Override protected Boolean doInBackground(Void... voids) { try {
        Socket sock = new Socket();
        sock.connect(new InetSocketAddress("8.8.8.8", 53), 1500);
        sock.close();
        return true;
    } catch (IOException e) { return false; } }

    @Override protected void onPostExecute(Boolean internet) { mConsumer.accept(internet); }
}

///////////////////////////////////////////////////////////////////////////////////
// Usage

    new InternetCheck(internet -> { /* do something with boolean response */ });

अतिरिक्त: एक-शॉट RxJava/RxAndroidउदाहरण (कोटलिन)

fun hasInternetConnection(): Single<Boolean> {
  return Single.fromCallable {
    try {
      // Connect to Google DNS to check for connection
      val timeoutMs = 1500
      val socket = Socket()
      val socketAddress = InetSocketAddress("8.8.8.8", 53)

      socket.connect(socketAddress, timeoutMs)
      socket.close()

      true
    } catch (e: IOException) {
      false
    }
  }
  .subscribeOn(Schedulers.io())
  .observeOn(AndroidSchedulers.mainThread())
}

///////////////////////////////////////////////////////////////////////////////////
    // Usage

    hasInternetConnection().subscribe { hasInternet -> /* do something */}
— लेवीय
स्रोत
22
यह कोड की बहुत शांति है! मुझे यह उन उपकरणों पर बहुत उपयोगी लगा जो प्रीपेड कार्ड का उपयोग करते हैं! जब वे पैसे से बाहर भागते हैं, तो उनके पास इंटरनेट का उपयोग उपलब्ध होता है, लेकिन इंटरनेट नहीं। तो सिर्फ कनेक्टिविटी के लिए जाँच नहीं करेगा। धन्यवाद!
— ब्लेजर
10
ध्यान रखें कि यह दृष्टिकोण एक अवरोधक है, इसलिए आपको इसे UI थेरेपी में निष्पादित नहीं करना चाहिए
— Sergii
36
@Levit यह स्वीकृत उत्तर होना चाहिए। इसके बाद के संस्करण का जवाब सिर्फ नेटवर्क एन नहीं इंटरनेट कनेक्शन की जाँच करता है । और हाँ यह बहुत तेज है। धन्यवाद। इसलिए उत्थान।
— Roon13
9
यह समाधान सभी उपकरणों के लिए काम नहीं कर रहा है। कुछ उपकरण हमेशा 2 लौट रहे हैं जैसा कि @Salmaan ने कहा है। जिन उपकरणों का मैंने परीक्षण किया था उनमें इंटरनेट कनेक्शन था और पिंग लक्ष्य Google DNS सर्वर है - जो पिंग अनुरोधों का जवाब दे रहा है। मुझे लगता है कि कुछ विक्रेता पिंग अनुरोधों की अनुमति नहीं दे रहे हैं। उदाहरण के लिए, मैंने सैमसंग 10.1 टैबलेट (4.3) के साथ परीक्षण किया, और समाधान काम नहीं कर रहा है। जब मैं कमांड लाइन उपयोगिता के माध्यम से पिंग कमांड चलाता हूं, तो मुझे एक अनुमति त्रुटि मिलती है। कमांड भी एमुलेटर पर काम नहीं कर रहा है। इस समाधान का उपयोग कर सावधान रहें।
— एरेन यिलमाज़
9
यह दृष्टिकोण सभी फोन पर काम नहीं करता है। यह सैमसंग गैलेक्सी एस 3 पर उदाहरण के लिए विफल रहता है। यहां देखें: पिंग कुछ उपकरणों पर काम क्यों करता है और दूसरों पर नहीं?
— आदिल हुसैन
1032

यदि डिवाइस हवाई जहाज मोड में है (या संभवतः अन्य स्थितियों में जहां कोई उपलब्ध नेटवर्क नहीं है), cm.getActiveNetworkInfo()होगा null, इसलिए आपको एक nullचेक जोड़ने की आवश्यकता है ।

नीचे संशोधित ( एडी का समाधान ):

public boolean isOnline() {
    ConnectivityManager cm =
        (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo netInfo = cm.getActiveNetworkInfo();
    return netInfo != null && netInfo.isConnectedOrConnecting();
}

इसके अलावा निम्नलिखित अनुमति जोड़ें AndroidManifest.xml:

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

एक अन्य छोटा बिंदु, यदि आपको दिए गए बिंदु पर समय में नेटवर्क कनेक्शन की आवश्यकता है, तो इसके netInfo.isConnected()बजाय इसका उपयोग करना बेहतर हो सकता है netInfo.isConnectedOrConnecting। मुझे लगता है कि यह व्यक्तिगत उपयोग के मामले पर निर्भर है।

— gar
स्रोत
109
imo आपको अभी भी चाहिए और http टाइमआउट अपवादों के लिए जाँच करने की आवश्यकता है क्योंकि ऐसी स्थितियाँ हो सकती हैं जब कोई नेटवर्क जुड़ा हो लेकिन कोई वास्तविक इंटरनेट कनेक्शन न हो क्योंकि इसे एक्सेस करने का एकमात्र तरीका उदाहरण के लिए वीपीएन है - इस तरह से आपके पास यू है, के लिए उदाहरण, WI-FI कनेक्शन लेकिन कोई वास्तविक इंटरनेट ट्रैफ़िक नहीं। एक और स्थिति एक सर्वर हैंग-ऑन है। ये 2 मुद्दे हैं जो मैंने हाल ही में चलाए हैं और कनेक्शन प्रबंधक वहां मदद करने वाला नहीं है।
— मध्यरात्रि
21
मैं आधी रात और पिंटू से सहमत हूं, इस जवाब को स्वीकार किए जाने वाला जवाब नहीं होना चाहिए, इसका कोई मतलब नहीं है कि आप इंटरनेट पर वेदर की जाँच करें। उदाहरण के लिए, यदि फोन किसी कैप्टिव पोर्टल के साथ वाईफाई नेटवर्क से जुड़ा है, जैसे किसी होटल में, यह फ़ंक्शन गलत तरीके से सही होगा। सही उत्तर सार्वजनिक इंटरनेट पर एक सर्वर को पिंग करना है।
— मिगेल
9
जब मेरे राउटर के लिए कोई इंटरनेट काम नहीं कर रहा है, अगर मैं वाईफाई के माध्यम से राउटर से कनेक्ट करता हूं, तो उपरोक्त कोड सही है। लेकिन, यह माना नहीं जाता है, है ना? क्या आप मेरी मदद कर सकते हैं
— MoHaN K RaJ
5
मुझे प्रसंग जोड़ना था, context.getSystemServiceया यह काम नहीं करता है। मुझे अपना सुराग यहां androidhive.info/2012/07/…
— फ्रांसिस्को
1
नेटवर्क उपलब्धता की जांच करने का अच्छा तरीका। लेकिन इंटरनेट एक्सेस की जांच कैसे करें?
— तमसे बोलवरी
296

जटिल होने की आवश्यकता नहीं है। ACCESS_NETWORK_STATEअनुमति का उपयोग करने और बस एक जुड़ा तरीका बनाने के लिए सबसे सरल और रूपरेखा तरीका है

public boolean isOnline() {
    ConnectivityManager cm =
        (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

    return cm.getActiveNetworkInfo() != null && 
       cm.getActiveNetworkInfo().isConnectedOrConnecting();
}

requestRouteToHostअगर आपके पास पार्टिकल होस्ट और कनेक्शन प्रकार (wifi / मोबाइल) है तो आप इसका उपयोग कर सकते हैं।

आपको इसकी आवश्यकता भी होगी:

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

अपने Android प्रकट में।

— एडी
स्रोत
82
cm.getActiveNetworkInfo () स्तर पर एक अशक्त जांच करना बेहतर है यदि कोई सक्रिय नेटवर्क उपलब्ध नहीं था, तो यह अशक्त हो जाता है।
— शमूएल
देख stackoverflow.com/a/11691676/1979773 requestRouteToHost () के बारे में एक गहरी exaplanation के लिए
— Spartako
मुझे प्रसंग जोड़ना था, context.getSystemServiceया यह काम नहीं करता है। मुझे अपना सुराग यहाँ androidhive.info/2012/07/…
— फ्रांसिस्को
9
यदि आप वाईफाई हॉटस्पॉट से जुड़े हैं तो भी यह समाधान सही साबित होगा, भले ही इस हॉटस्पॉट में इंटरनेट कनेक्टिविटी न हो।
— जोश
— नीलेश राठौड़
63

प्राप्त करने के लिए getActiveNetworkInfo()काम करने के लिए आप प्रकट करने के लिए निम्नलिखित जोड़ने की जरूरत है।

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
— azelez
स्रोत
यह निश्चित रूप से सही उत्तर के तहत होना चाहिए (बहुत समय बर्बाद किया गया है जो यह पता लगाना है कि क्या गलत है)।
— Indrek K .ue
2
इसके लिए INTERNET अनुमति की आवश्यकता नहीं है, केवल ACCESS_NETWORK_STATE। इंटरनेट केवल तभी आवश्यक है जब आप वास्तव में दूरस्थ स्थानों पर कनेक्शन बना रहे हों, डिवाइस के रेडियो की स्थिति के बारे में नहीं पूछ रहे हों।
— टॉम
3
आपका जवाब वर्तमान में वास्तव में एक जवाब नहीं है, यह अन्य उत्तरों के लिए सिर्फ एक अपेक्षाकृत मामूली है। यदि अन्य सभी उत्तर यहां नहीं थे, तो क्या आपका उत्तर समझ में आएगा? ज़रुरी नहीं। क्योंकि अगर इसका उपयोग करने के तरीके पर कोड के साथ अपने उत्तर का विस्तार करना बेहतर है, या अपना उत्तर हटा दें और किसी अन्य उत्तर में जानकारी जोड़ें (आप किसी भी प्रतिष्ठा को नहीं खोएंगे)
— टिम
सावधान रहें getActiveNetworkInfo()एपीआई स्तर 29 में अपदस्थ है।
— स्टैक ओवरफ्लो
46

ConnectivityManager वर्ग पर एक नज़र डालें। आप होस्ट पर सक्रिय कनेक्शन के बारे में जानकारी प्राप्त करने के लिए इस वर्ग का उपयोग कर सकते हैं। http://developer.android.com/reference/android/net/ConnectivityManager.html

संपादित करें: आप उपयोग कर सकते हैं 

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .getNetworkInfo(ConnectivityManager.TYPE_MOBILE)

या

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .getNetworkInfo(ConnectivityManager.TYPE_WIFI)

और लौटे NetworkInfo ऑब्जेक्ट के विस्तृत स्टेप एनुम को पार्स करें

EDIT EDIT: यह पता लगाने के लिए कि क्या आप एक होस्ट तक पहुंच सकते हैं, आप उपयोग कर सकते हैं 

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .requestRouteToHost(TYPE_WIFI, int hostAddress)

जाहिर है, मैं कहने के लिए प्रॉक्सी के रूप में Context.getSystemService (Context.CONNECTIVITY_SERVICE) का उपयोग कर रहा हूं

ConnectivityManager cm = Context.getSystemService(Context.CONNECTIVITY_SERVICE);
cm.yourMethodCallHere();
— चिन्मय कांची
स्रोत
यकीन नहीं हो रहा है, लेकिन यह कोड की तरह लगता है कि वर्तमान में किस तरह के नेटवर्क कनेक्शन की जाँच करें। उदाहरण के लिए, वाईफाई पर कोई गारंटी नहीं है कि आप घर वाईफाई राउटर इंटरनेट से जुड़े हुए हैं ... यह जांचने के लिए कि आपको वास्तव में एक इंटरनेटसेवर के लिए एक अनुरोध करने की आवश्यकता है ...
— विडार वेस्टनेस
1
EDIT EDIT सेक्शन में एक गलती थी, मैंने requestRouteToHost () कॉल छोड़ दिया। अब जवाब फिर से पढ़ें :)
— चिन्मय कांची
requestRouteToHost को हटा दिया गया है।
— जहज़िल
46

इस कोड की जाँच करें ... यह मेरे लिए काम :)

public static void isNetworkAvailable(final Handler handler, final int timeout) {
    // ask fo message '0' (not connected) or '1' (connected) on 'handler'
    // the answer must be send before before within the 'timeout' (in milliseconds)

    new Thread() {
        private boolean responded = false;   
        @Override
        public void run() { 
            // set 'responded' to TRUE if is able to connect with google mobile (responds fast) 
            new Thread() {      
                @Override
                public void run() {
                    HttpGet requestForTest = new HttpGet("http://m.google.com");
                    try {
                        new DefaultHttpClient().execute(requestForTest); // can last...
                        responded = true;
                    } 
                    catch (Exception e) {
                    }
                } 
            }.start();

            try {
                int waited = 0;
                while(!responded && (waited < timeout)) {
                    sleep(100);
                    if(!responded ) { 
                        waited += 100;
                    }
                }
            } 
            catch(InterruptedException e) {} // do nothing 
            finally { 
                if (!responded) { handler.sendEmptyMessage(0); } 
                else { handler.sendEmptyMessage(1); }
            }
        }
    }.start();
}

फिर, मैं हैंडलर को परिभाषित करता हूं:

Handler h = new Handler() {
    @Override
    public void handleMessage(Message msg) {

        if (msg.what != 1) { // code if not connected

        } else { // code if connected

        }   
    }
};

... और परीक्षण का शुभारंभ:

isNetworkAvailable(h,2000); // get the answser within 2000 ms
— Gilbou
स्रोत
3
Google क्या है? इसके लिए इंटरनेट की अनुमति भी आवश्यक है, जो दिए गए कार्य के लिए अनावश्यक है। अंत में, जो डेटा का उपभोग करता है (भले ही महत्वहीन)। यह सिर्फ इस तरह के एक कीचड़ लगता है।
— टॉम
28
@ उचित होने के लिए, यह शायद एकमात्र सही उत्तर है। अन्य उदाहरण केवल यह दर्शाते हैं कि क्या कोई नेटवर्क कनेक्शन उपलब्ध है और / या यदि उस नेटवर्क से कोई संबंध है, लेकिन इस सवाल का जवाब न दें कि क्या वह नेटवर्क वास्तव में रिमोट कनेक्शन भी बना सकता है (उदाहरण के लिए वेबसाइट पर)। तो यह पोस्टर क्यू का उत्तर देता है, और अन्य उत्तर नहीं हैं
— 11
2
@dmmh हाँ, यह दुर्भाग्य से सच है जो मैंने एंड्रॉइड एपीआई के साथ देखा है। शायद एक साधारण पिंग बेहतर हो सकता है, stackoverflow.com/questions/3905358/… । यदि आप वास्तव में चिंतित थे, तो आप आईपी की एक सूची भी पिंग में शामिल कर सकते हैं, क्योंकि एक बहुत ही कम मौका है कि Google कभी भी नीचे जाएगा, एक और भी छोटा मौका है कि उसी दिन Google, Bing, और Yahoo डाउन हो जाएगा । बस मेरे विचार।
— टॉम
10
इस जाँच को करने का कोई मतलब नहीं है। यदि आप Google से कनेक्ट होने के लिए सिस्टम समय और नेटवर्क संसाधनों को खर्च करने जा रहे हैं, तो आप उन्हें उस संसाधन से कनेक्ट करने के बजाय खर्च कर सकते हैं, जिसकी आप वास्तव में परवाह करते हैं।
— बेंजामिन
16
चीन में Google अवरुद्ध था !!
— एंथोन
26

इस लिंक से मिला और संशोधित () :

अपनी मैनिफ़ेस्ट फ़ाइल में कम से कम जोड़ें:

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

यदि आप इसे एक्सेस कर रहे हैं तो आपके पास संभवत: पहले से ही इंटरनेट की अनुमति है। फिर एक बूलियन फ़ंक्शन जो कनेक्टिविटी के लिए परीक्षण करने की अनुमति देता है:

private boolean checkInternetConnection() {
    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    // test for connection
    if (cm.getActiveNetworkInfo() != null
            && cm.getActiveNetworkInfo().isAvailable()
            && cm.getActiveNetworkInfo().isConnected()) {
        return true;
    } else {
        Log.v(TAG, "Internet Connection Not Present");
        return false;
    }
}
— Ajhar
स्रोत
18

मैंने यह कोड बनाया है, यह सबसे सरल है और यह सिर्फ एक बूलियन है। पूछकरif(isOnline()){

यदि कोई कनेक्शन है और आप इसे किसी पेज से कनेक्ट कर सकते हैं तो स्टेटस कोड 200(स्थिर कनेक्शन)।

सही INTERNETऔर ACCESS_NETWORK_STATEअनुमतियाँ जोड़ना सुनिश्चित करें ।

public boolean isOnline() {
    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo netInfo = cm.getActiveNetworkInfo();
    if (netInfo != null && netInfo.isConnected()) {
        try {
            URL url = new URL("http://www.google.com");
            HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
            urlc.setConnectTimeout(3000);
            urlc.connect();
            if (urlc.getResponseCode() == 200) {
                return new Boolean(true);
            }
        } catch (MalformedURLException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    return false;
}
— Android.Thirio.nl
स्रोत
6
हो सकता है कि आपको HttpURLConnection.HTTP_OK
— Yash
5
क्या होगा अगर Google नीचे है?
— यरव गदव
12

यह मेरे लिए काम करता है:

नेटवर्क उपलब्धता की पुष्टि करने के लिए:

private Boolean isNetworkAvailable() {
ConnectivityManager connectivityManager 
      = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
return activeNetworkInfo != null && activeNetworkInfo.isConnectedOrConnecting();}

इंटरनेट का उपयोग सत्यापित करने के लिए:

public Boolean isOnline() {
    try {
        Process p1 = java.lang.Runtime.getRuntime().exec("ping -c 1 www.google.com");
        int returnVal = p1.waitFor();
        boolean reachable = (returnVal==0);
        return reachable;
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return false;
}
— Musculaa
स्रोत
यह जांचने के लिए एक शानदार समाधान है कि क्या सर्वर सी ऊपर, वास्तव में ठीक काम करता है। धन्यवाद!
— विल्व
1
isOnline () मुख्य थ्रेड पर बिल्कुल भी नहीं चलना चाहिए, जैसे कि वाई-फाई सिग्नल है, लेकिन कोई इंटरनेट नहीं है यह बहुत लंबा लगेगा और मुख्य थ्रेड को ब्लॉक करेगा।
— humazed
9

एक से अधिक तरीके हैं

सबसे पहले, कम से कम लेकिन अक्षम तरीका

नेटवर्क राज्य की अनुमति केवल आवश्यक है

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

फिर यह विधि,

 public boolean activeNetwork () {
        ConnectivityManager cm =
                (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);

        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
        boolean isConnected = activeNetwork != null &&
                activeNetwork.isConnected();

        return isConnected;

    }

जैसा कि उत्तर में देखा गया ConnectivityManagerएक समाधान है, मैंने इसे एक विधि के भीतर जोड़ा है यह एक सरलीकृत विधि है जिसका सभी उपयोग करते हैं
ConnectivityManager करता है, यदि कोई नेटवर्क एक्सेस नहीं है, तो रिटर्न सही है, मतलब अगर आपका वाईफाई राउटर से जुड़ा है, लेकिन राउटर में कोई इंटरनेट नहीं है यह सही है, यह कनेक्शन उपलब्धता की जांच करता है

दूसरा, कुशल तरीका

नेटवर्क स्टेट और इंटरनेट अनुमतियां

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

तब यह वर्ग,

 public class CheckInternetAsyncTask extends AsyncTask<Void, Integer, Boolean> {

        private Context context;

        public CheckInternetAsyncTask(Context context) {
            this.context = context;
        }

        @Override
        protected Boolean doInBackground(Void... params) {

            ConnectivityManager cm =
                    (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

            assert cm != null;
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            boolean isConnected = activeNetwork != null &&
                    activeNetwork.isConnected();


            if (isConnected) {
                try {
                    HttpURLConnection urlc = (HttpURLConnection)
                            (new URL("http://clients3.google.com/generate_204")
                                    .openConnection());
                    urlc.setRequestProperty("User-Agent", "Android");
                    urlc.setRequestProperty("Connection", "close");
                    urlc.setConnectTimeout(1500);
                    urlc.connect();
                    if (urlc.getResponseCode() == 204 &&
                            urlc.getContentLength() == 0)
                        return true;

                } catch (IOException e) {
                    Log.e("TAG", "Error checking internet connection", e);
                    return false;
                }
            } else {
                Log.d("TAG", "No network available!");
                return false;
            }


            return null;
        }

        @Override
        protected void onPostExecute(Boolean result) {
            super.onPostExecute(result);
            Log.d("TAG", "result" + result);

            if(result){
                // do ur code
            }

        }


    }

कॉल CheckInternetAsyncTask

new CheckInternetAsyncTask(getApplicationContext()).execute();

कुछ स्पष्टीकरण: -

  • आपको इंटरनेट पर जांच करनी होगी AsyncTask, अन्यथा यह android.os.NetworkOnMainThreadExceptionकुछ मामलों में फेंक सकता है

  • ConnectivityManager नेटवर्क का उपयोग जाँचने के लिए किया जाता है अगर सही अनुरोध भेजता है (पिंग)

  • करने के लिए अनुरोध भेजने http://clients3.google.com/generate_204, यह अच्छी तरह से ज्ञात यूआरएल में जाना जाता है एक HTTP स्थिति 204 के साथ एक खाली पृष्ठ पर लौटने के लिए इस तेजी से और अधिक कुशल से है http://www.google.com, पढ़ने के लिए इस । यदि आपके पास वेबसाइट है, तो आप Google के बजाय वेबसाइट डालना पसंद करते हैं, केवल अगर आप इसे ऐप के भीतर उपयोग करते हैं

  • टाइमआउट को रेंज (20ms -> 2000ms) में बदला जा सकता है, आमतौर पर 1500ms का उपयोग किया जाता है

— मोहम्मद एम्बे
स्रोत
2
महान सवाल, इसके दुख की बात है कि आप अधिक अंक नहीं है। यह सही उत्तर होना चाहिए।
— झोन फ्रेई ट्रुजिलो ओर्टेगा
मैं Android के लिए नया हूँ। हालाँकि, यह अच्छी तरह से कवर किया गया उत्तर है और इसे अधिक ध्यान मिलता है @ 7569106
— Mazen Embaby
1
सबसे अच्छा और पूरा जवाब, धन्यवाद। अगर किसी के पास एक वेबसाइट नोटिस है कि इस स्थिति को इस urlc.getResponseCode () == 200 की तरह होना चाहिए और urlc.getContentLength () == 0 की
— 9
आपका दूसरा विकल्प दुर्घटनाग्रस्त हो जाता है मुझे पता नहीं क्यों
— नफीस ने
यह आवेदन जमा देता है
— nafees
8

अब तक मैंने जो कुछ भी देखा है, उसमें से सबसे छोटा और साफ तरीका होना चाहिए:

public final static boolean isConnected( Context context )
{   
   final ConnectivityManager connectivityManager = 
         (ConnectivityManager) context.getSystemService( Context.CONNECTIVITY_SERVICE );  
   final NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();    
   return networkInfo != null && networkInfo.isConnected();
}

PS: यह किसी भी होस्ट को पिंग नहीं करता है, यह सिर्फ कनेक्शनस्टैटस की जांच करता है, इसलिए यदि आपके राउटर का कोई इंटरनेट कनेक्शन नहीं है और आपका डिवाइस इससे जुड़ा हुआ है, तो यह तरीका सही होगा, हालांकि आपके पास कोई इंटरनेट नहीं है।
एक वास्तविक परीक्षण के लिए, मैं एक HttpHead अनुरोध (जैसे www.google.com) को निष्पादित करने की सलाह दूंगा और स्थिति की जांच करूंगा , अगर इसकी 200 ठीक सब कुछ ठीक है और आपके डिवाइस में इंटरनेट कनेक्शन है।

— Nickolaus
स्रोत
मैं इस विधि को एक वैश्विक कक्षा में रखना चाहता था, इसलिए मुझे इस संस्करण का उपयोग करना था ताकि मैं जिस गतिविधि से बुला रहा था, उससे संदर्भ को पास कर सकूं। धन्यवाद!
— रयानग्रेन
8

यहाँ मैं प्रयोग विधि है:

public boolean isNetworkAvailable(final Context context) {
    return ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo() != null;
}

और भी बेहतर, यह सुनिश्चित करने के लिए जांचें कि यह "कनेक्ट" है:

public boolean isNetworkAvailable(final Context context) {
    final ConnectivityManager connectivityManager = ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE));
    return connectivityManager.getActiveNetworkInfo() != null && connectivityManager.getActiveNetworkInfo().isConnected();
}

यहाँ विधि का उपयोग करने का तरीका बताया गया है:

if (isNetworkAvailable(context)) {
    // code here
} else {
    // code
}

अनुमति आवश्यक:

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

https://stackoverflow.com/a/16124915/950427

— जारेड बरोज
स्रोत
7

मोबाइल उपकरणों पर एक महत्वपूर्ण उपयोग मामला यह सुनिश्चित करता है कि वास्तविक कनेक्शन मौजूद है। यह एक सामान्य समस्या है जब एक मोबाइल उपयोगकर्ता एक "कैप्टिव पोर्टल" के साथ एक वाईफ़ाई नेटवर्क में प्रवेश करता है, जिसमें उन्हें साइन इन करने की आवश्यकता होती है। मैं कनेक्शन को सुनिश्चित करने के लिए पृष्ठभूमि में इस अवरुद्ध फ़ंक्शन का उपयोग करता हूं।

/*
 * Not Thread safe. Blocking thread. Returns true if it
 * can connect to URL, false and exception is logged.
 */
public boolean checkConnectionHttps(String url){
    boolean responded = false;
    HttpGet requestTest = new HttpGet(url);
    HttpParams params = new BasicHttpParams();
    HttpConnectionParams.setConnectionTimeout(params, 3000);
    HttpConnectionParams.setSoTimeout(params, 5000);
    DefaultHttpClient client = new DefaultHttpClient(params);
    try {
        client.execute(requestTest);
        responded = true;
    } catch (ClientProtocolException e) {
        Log.w(MainActivity.TAG,"Unable to connect to " + url + " " + e.toString());
    } catch (IOException e) {
        Log.w(MainActivity.TAG,"Unable to connect to " + url + " " + e.toString());
        e.printStackTrace();
    }
    return responded;
}
— user1528493
स्रोत
3
+1 वास्तव में एंड-टू-एंड कनेक्टिविटी की जाँच के लिए। "कैप्टिव पोर्टल" स्थिति के लिए, हालांकि, मैंने पाया है कि कई लोग उपरोक्त परीक्षा पास करेंगे भले ही आपने साइन इन न किया हो - आपको लॉगिन पेज और 200 प्रतिसाद मिले, इससे कोई फर्क नहीं पड़ता कि आप क्या मांगते हैं। इसलिए मैं अपने स्वयं के डोमेन पर एक पृष्ठ हिट करने का प्रयास करता हूं जो मुझे पता है कि मौजूद नहीं है, और सुनिश्चित करें कि मुझे 404 मिलता है। वैकल्पिक रूप से, आप एक ज्ञात मौजूदा पृष्ठ को हिट कर सकते हैं, सुनिश्चित करें कि आपको 200 मिलता है, और उस सामग्री की जांच करें यह सुनिश्चित करने के लिए लौटा है कि यह वही है जो आप उम्मीद करते हैं।
— ग्रेबियरगेड गीक जूल 1'13
6

आप सभी नेटवर्क कनेक्शनों पर पुनरावृति कर सकते हैं और पूछ सकते हैं कि क्या कम से कम एक उपलब्ध कनेक्शन है:

public boolean isConnected() {
    boolean connected = false;

    ConnectivityManager cm = 
        (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

    if (cm != null) {
        NetworkInfo[] netInfo = cm.getAllNetworkInfo();

        for (NetworkInfo ni : netInfo) {
            if ((ni.getTypeName().equalsIgnoreCase("WIFI")
                    || ni.getTypeName().equalsIgnoreCase("MOBILE"))
                    && ni.isConnected() && ni.isAvailable()) {
                connected = true;
            }

        }
    }

    return connected;
}
— इमरे यज़ीसी
स्रोत
6

मेरे लिए गतिविधि वर्ग में कनेक्शन की स्थिति की जांच करना अच्छा नहीं था, क्योंकि 

ConnectivityManager cm =
    (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

वहाँ बुलाया जाना चाहिए, या आपको कनेक्शन हैंडलर वर्ग के लिए अपनी गतिविधि उदाहरण (संदर्भ) को नीचे धकेलने की आवश्यकता है ताकि कनेक्शन की स्थिति की जांच करने में सक्षम हो जब कोई उपलब्ध कनेक्शन (वाईफाई, नेटवर्क) मैं अज्ञातहस्ट अपवाद अपवाद को पकड़ता है:

JSONObject jObj = null;
Boolean responded = false;
HttpGet requestForTest = new HttpGet("http://myserver.com");
try {
    new DefaultHttpClient().execute(requestForTest);
    responded = true;
} catch (UnknownHostException e) {
    jObj = new JSONObject();
    try {
        jObj.put("answer_code", 1);
        jObj.put("answer_text", "No available connection");
    } catch (Exception e1) {}
    return jObj;
} catch (IOException e) {
    e.printStackTrace();
}

इस तरह से मैं इस मामले को अन्य मामलों के साथ एक ही कक्षा में संभाल सकता हूं (मेरा सर्वर हमेशा एक जवां स्ट्रिंग के साथ प्रतिक्रिया करता है)

— हिब
स्रोत
6

यह मेरे लिए काम करता है। कोशिश करके देखो।

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    try {
        URL url = new URL("http://stackoverflow.com/posts/11642475/edit" );
        //URL url = new URL("http://www.nofoundwebsite.com/" );
        executeReq(url);
        Toast.makeText(getApplicationContext(), "Webpage is available!", Toast.LENGTH_SHORT).show();
    }
    catch(Exception e) {
        Toast.makeText(getApplicationContext(), "oops! webpage is not available!", Toast.LENGTH_SHORT).show();
    }
}

private void executeReq(URL urlObject) throws IOException
{
    HttpURLConnection conn = null;
    conn = (HttpURLConnection) urlObject.openConnection();
    conn.setReadTimeout(30000);//milliseconds
    conn.setConnectTimeout(3500);//milliseconds
    conn.setRequestMethod("GET");
    conn.setDoInput(true);

    // Start connect
    conn.connect();
    InputStream response =conn.getInputStream();
    Log.d("Response:", response.toString());
}}
— selva_pollachi
स्रोत
यह उत्तर अब काम नहीं कर सकता है, क्योंकि हम अब मुख्य धागे पर नेटवर्क का उपयोग नहीं कर सकते हैं।
— 14: 正宗 '
1
मेरा मतलब एपीआई स्तर 11 से है, यह काम नहीं करता है। कारण: developer.android.com/reference/android/os/… । यदि यह आपके लिए काम करता है, तो इसका मतलब है कि आप पुराने एंड्रॉइड डिवाइस पर इस कोड को चला रहे हैं। (GB से पहले)।
— 14 正宗 '
StrictMode.ThreadPolicy नीति = नई StrictMode.ThreadPolicy.Builder () .permitAll () build (); StrictMode.setThreadPolicy (नीति); नेटवर्क मुख्य थ्रेड अपवाद से बचने के लिए इन दो पंक्तियों को अपने प्रोग्राम से जोड़ें
— selva_pollachi
ठीक है, मुझे यह नहीं कहना चाहिए कि यह काम नहीं कर सकता है, मुझे कहना चाहिए कि यह काम कर सकता है (पुराने संस्करण या स्ट्रिक्टमोड सेटअप को लक्षित करके) लेकिन हतोत्साहित किया गया है। इससे ANR आसानी से हो सकता है। (Canpurlconnection में इतने अधिक टाइमआउट कॉन्फ़िगरेशन के साथ)
— 布鞋 '
हां..आप सही हैं..बस मैंने इसे डाल दिया क्योंकि यह भी एक तरीका है।
— selva_pollachi
6

यह विधि आपको वास्तव में तेज़ विधि (वास्तविक समय प्रतिक्रिया के लिए) या धीमी विधि (एक बंद चेक के लिए जो विश्वसनीयता की आवश्यकता होती है) के लिए विकल्प देती है

public boolean isNetworkAvailable(bool SlowButMoreReliable) {
    bool Result = false; 
    try {
        if(SlowButMoreReliable){
            ConnectivityManager MyConnectivityManager = null;
            MyConnectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

            NetworkInfo MyNetworkInfo = null;
            MyNetworkInfo = MyConnectivityManager.getActiveNetworkInfo();

            Result = MyNetworkInfo != null && MyNetworkInfo.isConnected();

        } else
        {
            Runtime runtime = Runtime.getRuntime();
            Process ipProcess = runtime.exec("/system/bin/ping -c 1 8.8.8.8");

            int i = ipProcess.waitFor();

            Result = i== 0;

        }

    } catch(Exception ex)
    {
        //Common.Exception(ex); //This method is one you should have that displays exceptions in your log
    }
    return Result;
}
— WonderWorker
स्रोत
5

InetAddress के बजाय इस कोड का उपयोग कर Im:

    try {

        URL url = new URL("http://"+params[0]);

        HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
        urlc.setRequestProperty("User-Agent", "Android Application:"+Z.APP_VERSION);
        urlc.setRequestProperty("Connection", "close");
        urlc.setConnectTimeout(1000 * 30); // mTimeout is in seconds
        urlc.connect();
        if (urlc.getResponseCode() == 200) {
            Main.Log("getResponseCode == 200");
            return new Boolean(true);
        }
    } catch (MalformedURLException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
— विदुर बनियान
स्रोत
यह बहुत अच्छा होगा यदि आपने स्पष्ट किया था यदि IOException का मतलब कोई इंटरनेट कनेक्शन नहीं है और यह कितना विश्वसनीय हो सकता है।
— मिलाद.नोजारी
5

Android नेटवर्क / इंटरनेट कनेक्टिविटी स्थिति की जांच करना जटिल नहीं है। निम्न DetectConnectionश्रेणी आपको इस स्थिति की जाँच करने में मदद करेगी:

import android.content.Context;
import android.net.ConnectivityManager;

public class DetectConnection {
    public static boolean checkInternetConnection(Context context) {
        ConnectivityManager con_manager = (ConnectivityManager) context
                                .getSystemService(Context.CONNECTIVITY_SERVICE);

        if (con_manager.getActiveNetworkInfo() != null
            && con_manager.getActiveNetworkInfo().isAvailable()
            && con_manager.getActiveNetworkInfo().isConnected()) {
                return true;
        } else {
            return false;
        }
    }
}

अधिक जानकारी के लिए Android नेटवर्क / इंटरनेट कनेक्टिविटी स्थिति की जांच कैसे करें

— JSupport
स्रोत
5

सबसे अच्छा तरीका:

public static boolean isOnline() {
    try {
    InetAddress.getByName("google.com").isReachable(3);

    return true;
    } catch (UnknownHostException e){
    return false;
    } catch (IOException e){
    return false;
    }
    }
— लो जुएगो
स्रोत
1
मुझे यह दृष्टिकोण पसंद है लेकिन मुझे कुछ चीजों को इंगित करना है। isReachable () एक बूलियन लौटाता है, इसलिए ट्राइ सेक्शन में सही रिटर्न करने के बजाय, आप इसे बूलियन कनेक्टेड = InetAddress.getByName ("google.com") की तरह कर सकते हैं। isReachable (3); फिर जुड़ा हुआ। इसके अलावा, isReacheable IOException और IllegalArgumentException अपवादों को फेंकता है, इसलिए यह IllegalArgumentException के साथ अज्ञातHostException को प्रतिस्थापित करने का एक अच्छा विचार होगा और एक तीसरा कैच पकड़ने के साथ, (अपवाद E)।
— यश
2
लेकिन फिर, isReachable आईसीएमपी का उपयोग करता है जिसे रूट विशेषाधिकारों की आवश्यकता होती है और पोर्ट 7 का उपयोग करता है जिसमें आमतौर पर नवीनतम प्रणालियों पर कोई चलने वाली सेवाएं नहीं होती हैं। इसलिए एक ऑनलाइन सेवा के लिए मार्ग की जांच करने का सबसे अच्छा तरीका नियमित टीसीपी है; इसलिए एक डाउन वोट।
— यश
5

निम्नलिखित मेरी Utilsकक्षा से कोड है :

public static boolean isNetworkAvailable(Context context) {
        ConnectivityManager connectivityManager 
              = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
        return activeNetworkInfo != null && activeNetworkInfo.isConnected();
}
— महेंद्र लिया
स्रोत
5 
public class Network {

Context context;

public Network(Context context){
    this.context = context;
}

public boolean isOnline() {
    ConnectivityManager cm =
            (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    return activeNetwork != null &&
                          activeNetwork.isConnectedOrConnecting();
}

}
— user2912903
स्रोत
के रूप में अन्य सभी जो समस्या के माध्यम से पढ़ा नहीं था, यह समस्या को हल नहीं करता है, क्योंकि यह वास्तव में इंटरनेट के लिए एक कनेक्शन के लिए जाँच नहीं करता है। एक स्थानीय वाईफाई हॉटस्पॉट का कनेक्शन सही लौटेगा, भले ही हॉटस्पॉट आपको इंटरनेट के माध्यम से जाने की अनुमति न दे।
— पेड्रो पोमबेरो
5

नेटवर्क उपलब्धता का पता लगाने के लिए आप इस विधि का उपयोग कर सकते हैं-

public static boolean isDeviceOnline(Context context) {
        boolean isConnectionAvail = false;
        try {
            ConnectivityManager cm = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo netInfo = cm.getActiveNetworkInfo();
            return netInfo.isConnected();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return isConnectionAvail;
    }
— अक्षय पालीवाल
स्रोत
5

मैंने @Levit द्वारा प्रदान किए गए समाधान को लागू किया है और फ़ंक्शन बनाया है जो अतिरिक्त Http अनुरोध को कॉल नहीं करेगा।

यह त्रुटि को हल करेगा Unable to Resolve Host

public static boolean isInternetAvailable(Context context) {
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    if (activeNetwork == null) return false;

    switch (activeNetwork.getType()) {
        case ConnectivityManager.TYPE_WIFI:
            if ((activeNetwork.getState() == NetworkInfo.State.CONNECTED ||
                    activeNetwork.getState() == NetworkInfo.State.CONNECTING) &&
                    isInternet())
                return true;
            break;
        case ConnectivityManager.TYPE_MOBILE:
            if ((activeNetwork.getState() == NetworkInfo.State.CONNECTED ||
                    activeNetwork.getState() == NetworkInfo.State.CONNECTING) &&
                    isInternet())
                return true;
            break;
        default:
            return false;
    }
    return false;
}

private static boolean isInternet() {

    Runtime runtime = Runtime.getRuntime();
    try {
        Process ipProcess = runtime.exec("/system/bin/ping -c 1 8.8.8.8");
        int exitValue = ipProcess.waitFor();
        Debug.i(exitValue + "");
        return (exitValue == 0);
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }

    return false;
}

अब इसे कॉल करें,

if (!isInternetAvailable(getActivity())) {
     //Show message
} else {
     //Perfoem the api request
}
— जयमिन पांचाल
स्रोत
4

यह Android डॉक्स http://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html में शामिल है

— Kreker
स्रोत
1
लेकिन वहां वर्णित विधि वास्तव में इंटरनेट कनेक्शन के लिए जांच नहीं करती है, यह सिर्फ यह जांचती है कि क्या कनेक्शन स्थापित है (क्या इंटरनेट तक पहुंच है या नहीं)। उस आधिकारिक डॉक्टर का शीर्षक वास्तव में भ्रामक है।
— टियागो
2
प्रश्न का उत्तर देने से बेहतर है कि आप सूचना के लिए लिंक पोस्ट करें। यदि लिंक मृत हो जाए तो क्या होगा? हमारे पास कोई जवाब नहीं होगा।
— जोस लेलॉसस
4

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

मैंने सक्रिय इंटरनेट कनेक्शन की जांच के लिए सभी आवश्यक विधि और कक्षाएं शामिल की हैं।

NetworkUtils.class

public class NetworkUtils {

    public static final int STATUS_CONNECTED = 0 ;

    public static boolean isInternetAvailable(Context ctx){
        ConnectivityManager cm = (ConnectivityManager)ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
        return activeNetwork != null && activeNetwork.isConnectedOrConnecting();
    }

    public static int isInternetActiveWithPing() {
        try {
            Runtime runtime = Runtime.getRuntime();
            Process process = runtime.exec("/system/bin/ping -c 1 8.8.8.8");
            int exitValue = process.waitFor();
            return exitValue;
        } catch (Exception ex) {
            return -1;
        }
    }

    public static boolean isInternetActiveWithInetAddress() {
        try {
            InetAddress inetAddress = InetAddress.getByName("www.google.com");
            return inetAddress != null && !inetAddress.toString().equals("");
        } catch (Exception ex) {
            return false;
        }
    }

    public static void displayInternetConnectionMessage(Context ctx){
        Toast.makeText(ctx, "Check Internet Connection", Toast.LENGTH_SHORT).show();
    }
}

आप नीचे दिए गए कोड का उपयोग करके देख सकते हैं कि इंटरनेट सक्रिय है या नहीं:

 private void checkInternetConnection() {
        if (NetworkUtils.isInternetAvailable(this)) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    if (NetworkUtils.isInternetActiveWithPing() == NetworkUtils.STATUS_CONNECTED) {
                        performNetworkingOperations();
                    } else {
                        if (NetworkUtils.isInternetActiveWithInetAddress()) {
                            performNetworkingOperations();
                        } else {
                            displayConnectionMessage();
                        }
                    }
                }
            }).start();

        } else {
            displayConnectionMessage();
        }
    }

    private void performNetworkingOperations() {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(MainActivity.this, "Internet is Available", Toast.LENGTH_SHORT).show();
            }
        });
    }

    private void displayConnectionMessage() {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                NetworkUtils.displayInternetConnectionMessage(MainActivity.this);
            }
        });
    }
— राजेश
स्रोत
आपके NetworkUtils में बेहतर पैक थ्रेडिंग और इसलिए "फोर्स" डेवलपर आपके तरीके का गलत इस्तेमाल न करने के लिए
— Ewoks
एक अतिरिक्त हटाने के लिए अगर हालत। if ((NetworkUtils.isInternetActiveWithPing () == NetworkUtils.STATUS_CONNECTED) || NetworkUtils.isInternetActiveWithInetAressress ()) {// Do Network Operation} बाकी {// Error Message}
— Jawad Zeb
4

यह जांचने के लिए बहुत महत्वपूर्ण है कि क्या हमारे पास isAvailable () के साथ कनेक्टिविटी है और यदि isConnected () के साथ संबंध स्थापित करना संभव है

private static ConnectivityManager manager;

public static boolean isOnline(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected();
}

और आप नेटवर्क सक्रिय वाईफाई के प्रकार को समाप्त कर सकते हैं :

public static boolean isConnectedWifi(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
}

या मोबाइल Mvvil :

public static boolean isConnectedMobile(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE;
}

अनुमतियाँ मत भूलना:

    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
   <uses-permission android:name="android.permission.INTERNET" />
— Jorgesys
स्रोत
डिवाइस कनेक्टिविटी घटकों का अच्छा सारांश, बस क्रैश से बचने के लिए उन्हें कोशिश / बयान में लपेटने की आवश्यकता है। इसी तरह, बस अपना रूटीन HttpURLConnection कॉल्स करें, जब तक वे एरर हैंडलिंग में लपेटे जाते हैं, आपको जल्द ही पता चल जाएगा कि आपका इंटरनेट कनेक्शन है या नहीं
— rangi
4

कोटलिन और कोरटाइन

मैंने फ़ंक्शन को एक में रखा है ViewModel, जिसमें है viewModelScope। अवलोकन के उपयोग से LiveDataमैं कनेक्शन के बारे में एक गतिविधि को सूचित करता हूं।

ViewModel

 fun checkInternetConnection() {
        viewModelScope.launch {
            withContext(Dispatchers.IO) {
                try {
                    val timeoutMs = 3000
                    val socket = Socket()
                    val socketAddress = InetSocketAddress("8.8.8.8", 53)

                    socket.connect(socketAddress, timeoutMs)
                    socket.close()

                    withContext(Dispatchers.Main) {
                        _connection.value = true
                    }
                }
                catch(ex: IOException) {
                    withContext(Main) {
                        _connection.value = false
                    }
                }
            }
        }
    }

 private val _connection = MutableLiveData<Boolean>()
 val connection: LiveData<Boolean> = _connection

गतिविधि

 private fun checkInternetConnection() {
     viewModel.connection.observe(this) { hasInternet ->
         if(!hasInternet) {
             //hasn't connection
         }
         else {
            //has connection
         }
     }
  }
— Hawklike
स्रोत
3

बस निम्न वर्ग बनाएं जो इंटरनेट कनेक्शन के लिए जाँच करता है:

public class ConnectionStatus {

    private Context _context;

    public ConnectionStatus(Context context) {
        this._context = context;
    }

    public boolean isConnectionAvailable() {
        ConnectivityManager connectivity = (ConnectivityManager) _context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connectivity != null) {
            NetworkInfo[] info = connectivity.getAllNetworkInfo();
            if (info != null)
                for (int i = 0; i < info.length; i++)
                    if (info[i].getState() == NetworkInfo.State.CONNECTED) {
                        return true;
                    }
        }
        return false;
    }
}

इस वर्ग में बस एक विधि शामिल है जो कनेक्शन स्थिति की बूलियन मान लौटाता है। इसलिए सरल शब्दों में, यदि विधि इंटरनेट से एक वैध कनेक्शन ढूंढती है, तो रिटर्न मान है true, अन्यथा falseयदि कोई वैध कनेक्शन नहीं मिला है।

MainActivity में निम्न विधि फिर पहले बताई गई विधि से परिणाम को कॉल करती है, और उपयोगकर्ता को तदनुसार कार्य करने के लिए प्रेरित करती है:

public void addListenerOnWifiButton() {
        Button btnWifi = (Button)findViewById(R.id.btnWifi);

        iia = new ConnectionStatus(getApplicationContext());

        isConnected = iia.isConnectionAvailable();
        if (!isConnected) {
            btnWifi.setOnClickListener(new View.OnClickListener() {

                @Override
                public void onClick(View v) {
                    startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
                    Toast.makeText(getBaseContext(), "Please connect to a hotspot",
                            Toast.LENGTH_SHORT).show();
                }
            });
        }
        else {
            btnWifi.setVisibility(4);
            warning.setText("This app may use your mobile data to update events and get their details.");
        }
    }

उपरोक्त कोड में, यदि परिणाम गलत है, (इसलिए कोई इंटरनेट कनेक्शन नहीं है, तो उपयोगकर्ता को एंड्रॉइड वाई-फाई पैनल पर ले जाया जाता है, जहां उसे वाई-फाई हॉटस्पॉट से कनेक्ट करने के लिए संकेत दिया जाता है।

— मिशेल ला फेरला
स्रोत
3

अद्यतन 29/06/2015 यदि आप Xamarin.Android का उपयोग कर रहे हैं और कनेक्टिविटी की जांच करना चाहते हैं, तो आप एक Nuget पैकेज का उपयोग कर सकते हैं जो आपको कई प्लेटफार्मों पर यह कार्यक्षमता प्रदान करेगा। अच्छे उम्मीदवार यहां और यहां हैं । [अपडेट का अंत]

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

using Android.App;
using Android.Content;
using Android.Net;

namespace Leopard.Mobile.Hal.Android
{
    public class AndroidNetworkHelper
    {
        public static AndroidNetworkStatus GetWifiConnectivityStatus()
        {
            return GetConnectivityStatus(ConnectivityType.Wifi);
        }

        public static AndroidNetworkStatus GetMobileConnectivityStatus()
        {
            return GetConnectivityStatus(ConnectivityType.Mobile);
        }

        #region Implementation

        private static AndroidNetworkStatus GetConnectivityStatus(ConnectivityType connectivityType)
        {
            var connectivityManager = (ConnectivityManager)Application.Context.GetSystemService(Context.ConnectivityService);
            var wifiNetworkInfo = connectivityManager.GetNetworkInfo(connectivityType);
            var result = GetNetworkStatus(wifiNetworkInfo);
            return result;
        }

        private static AndroidNetworkStatus GetNetworkStatus(NetworkInfo wifiNetworkInfo)
        {
            var result = AndroidNetworkStatus.Unknown;
            if (wifiNetworkInfo != null)
            {
                if (wifiNetworkInfo.IsAvailable && wifiNetworkInfo.IsConnected)
                {
                    result = AndroidNetworkStatus.Connected;
                }
                else
                {
                    result = AndroidNetworkStatus.Disconnected;
                }
            }
            return result;
        } 

        #endregion
    }

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