ฉันได้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();
    }   
}

การเชื่อมต่อเครือข่าย / การเข้าถึงอินเทอร์เน็ต

• isConnectedOrConnecting()(ใช้ในคำตอบส่วนใหญ่) ตรวจสอบการเชื่อมต่อเครือข่ายใด ๆ
• หากต้องการทราบว่าเครือข่ายใดมีการเชื่อมต่ออินเทอร์เน็ตหรือไม่ให้ใช้อย่างใดอย่างหนึ่งต่อไปนี้

A) Ping a Server (ง่าย)

// 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 และอื่น ๆ ) มันจะบล็อกในขณะที่หากไม่มีอินเทอร์เน็ตให้ใช้

B) เชื่อมต่อกับซ็อกเก็ตบนอินเทอร์เน็ต (ขั้นสูง)

// 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,000 คำขอต่อวัน สมมุติว่าแอปของคุณอาจไม่ใช่คำพูดประจำวัน

• ต้องการสิทธิ์ใดบ้าง

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

  เพียงแค่เข้าถึงอินเทอร์เน็ต - แปลกใจ ^^ (Btw คุณเคยคิดวิธีการบางอย่างของวิธีการที่แนะนำที่นี่อาจมีกาวระยะไกลเกี่ยวกับการเข้าถึงอินเทอร์เน็ตโดยไม่ได้รับอนุญาตนี้?)

พิเศษ: 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ตัวอย่างOne-shot (Kotlin)

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 */}

หากอุปกรณ์อยู่ในโหมดเครื่องบิน (หรือในสถานการณ์อื่น ๆ ที่ไม่มีเครือข่ายที่ใช้งานได้) cm.getActiveNetworkInfo()จะเป็นnullเช่นนั้นดังนั้นคุณต้องเพิ่มการnullตรวจสอบ

แก้ไข ( โซลูชันของ Eddie ) ด้านล่าง:

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ฉันเดาว่านี่ขึ้นอยู่กับแต่ละกรณีการใช้งาน

ไม่จำเป็นต้องซับซ้อน วิธีที่ง่ายที่สุดและกรอบคือการใช้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 ของคุณ

ในการgetActiveNetworkInfo()ไปทำงานคุณต้องเพิ่มสิ่งต่อไปนี้ในรายการ

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

ตรวจสอบคลาส 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) 

และแยกวิเคราะห์ DetailedState enum ของวัตถุ NetworkInfo ที่ส่งคืน

แก้ไขแก้ไข: หากต้องการทราบว่าคุณสามารถเข้าถึงโฮสต์ได้หรือไม่คุณสามารถใช้

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

เห็นได้ชัดว่าฉันใช้ Context.getSystemService (Context.CONNECTIVITY_SERVICE) เป็นพร็อกซีเพื่อพูด

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

ตรวจสอบรหัสนี้ ... มันใช้งานได้สำหรับฉัน :)

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

พบที่และแก้ไข (!) จากลิงค์นี้:

ในไฟล์ Manifest ของคุณให้เพิ่มอย่างน้อย:

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

ฉันทำรหัสนี้มันง่ายที่สุดและมันก็เป็นบูลีน โดยถาม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;
}

มันใช้งานได้สำหรับฉัน:

วิธีตรวจสอบความพร้อมเครือข่าย:

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

มีมากกว่าหนึ่งวิธี

ครั้งแรกวิธีที่สั้นที่สุด แต่ไม่มีประสิทธิภาพ

การอนุญาตสถานะเครือข่ายจำเป็นเท่านั้น

<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ส่งคืนจริงถ้ามีการเข้าถึงเครือข่ายไม่ใช่อินเทอร์เน็ตหมายความว่าถ้า WiFi ของคุณเชื่อมต่อกับเราเตอร์ แต่เราเตอร์ไม่มีอินเทอร์เน็ต ผลตอบแทนจริงมันตรวจสอบความพร้อมในการเชื่อมต่อ

ประการที่สองวิธีที่มีประสิทธิภาพ

จำเป็นต้องระบุสถานะเครือข่ายและอินเทอร์เน็ต

<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_204URL ที่นี้ที่รู้จักกันดีเป็นที่รู้จักกันเพื่อกลับหน้าว่างที่มีสถานะ HTTP 204 นี้ได้เร็วขึ้นและมีประสิทธิภาพมากขึ้นกว่าhttp://www.google.comอ่านนี้ หากคุณมีเว็บไซต์แนะนำให้ใส่เว็บไซต์ของคุณแทนที่จะเป็น google เฉพาะเมื่อคุณใช้เว็บไซต์ภายในแอป

• หมดเวลาสามารถเปลี่ยนช่วง (20ms -> 2000ms), 1500ms ใช้กันทั่วไป

จากทุกสิ่งที่ฉันได้เห็นจนถึงวิธีที่สั้นและสะอาดที่สุด:

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: นี่ไม่ได้ ping โฮสต์ใด ๆ เพียงตรวจสอบการเชื่อมต่อสถานะดังนั้นถ้าเราเตอร์ของคุณไม่มีการเชื่อมต่ออินเทอร์เน็ตและอุปกรณ์ของคุณเชื่อมต่อกับมันวิธีนี้จะกลับมาจริงแม้ว่าคุณจะไม่มีอินเทอร์เน็ต
สำหรับการทดสอบจริงฉันขอแนะนำให้ดำเนินการตามคำขอ HttpHead (เช่น www.google.com)และตรวจสอบสถานะหาก200 OKทุกอย่างเรียบร้อยและอุปกรณ์ของคุณมีการเชื่อมต่ออินเทอร์เน็ต

นี่คือวิธีที่ฉันใช้:

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

กรณีการใช้งานที่สำคัญอย่างหนึ่งบนอุปกรณ์พกพาเพื่อให้แน่ใจว่ามีการเชื่อมต่อจริง นี่เป็นปัญหาที่พบบ่อยเมื่อผู้ใช้มือถือเข้าสู่เครือข่าย Wifi ด้วย "Captive Portal" ซึ่งพวกเขาจำเป็นต้องลงชื่อเข้าใช้ฉันใช้ฟังก์ชั่นการบล็อกนี้ในพื้นหลังเพื่อให้แน่ใจว่ามีการเชื่อมต่ออยู่

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

คุณสามารถวนซ้ำผ่านการเชื่อมต่อเครือข่ายทั้งหมดและตรวจสอบว่ามีการเชื่อมต่อที่ใช้ได้อย่างน้อยหนึ่งรายการ:

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

สำหรับฉันมันไม่ใช่วิธีที่ดีในการตรวจสอบสถานะการเชื่อมต่อในคลาสกิจกรรมเพราะ

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

ควรถูกเรียกใช้ที่นั่นหรือคุณต้องกดลงอินสแตนซ์กิจกรรม (บริบท) ของคุณไปยังคลาสตัวจัดการการเชื่อมต่อเพื่อตรวจสอบสถานะการเชื่อมต่อที่นั่นเมื่อไม่มีการเชื่อมต่อที่พร้อมใช้งาน (WiFi, เครือข่าย) ฉันตรวจพบข้อยกเว้น

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

ด้วยวิธีนี้ฉันสามารถจัดการกรณีนี้พร้อมกับกรณีอื่น ๆ ในระดับเดียวกัน (เซิร์ฟเวอร์ของฉันตอบกลับด้วยสตริง json เสมอ)

มันใช้งานได้สำหรับฉัน ลองดู

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

วิธีนี้ช่วยให้คุณมีตัวเลือกสำหรับวิธีที่รวดเร็วมาก (สำหรับข้อเสนอแนะแบบเรียลไทม์) หรือวิธีที่ช้ากว่า (สำหรับการตรวจสอบครั้งเดียวที่ต้องการความน่าเชื่อถือ)

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

ฉันใช้รหัสนี้แทน InetAddress:

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

ไม่ซับซ้อนในการตรวจสอบสถานะการเชื่อมต่อเครือข่าย 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 / การเชื่อมต่ออินเทอร์เน็ต

แนวทางที่ดีที่สุด:

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

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

ต่อไปนี้เป็นรหัสจากUtilsชั้นเรียนของฉัน:

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

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

}

คุณสามารถใช้วิธีนี้เพื่อตรวจสอบความพร้อมเครือข่าย -

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

ฉันใช้วิธีการแก้ปัญหาโดย @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
}

นี้จะครอบคลุมในเอกสาร Android http://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html

ฉันได้ทำตามคำตอบทั้งหมดแล้วและฉันได้คำตอบของตัวเองซึ่งตรวจสอบก่อนว่าอินเทอร์เน็ตนั้นมีอยู่หรือไม่และถ้าอินเทอร์เน็ตพร้อมใช้งานแล้วมันจะตรวจสอบว่ามันใช้งานได้หรือไม่

ฉันได้รวมวิธีการและคลาสที่จำเป็นทั้งหมดเพื่อตรวจสอบการเชื่อมต่ออินเทอร์เน็ตที่ใช้งานอยู่

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

สำคัญมากในการตรวจสอบว่าเรามีการเชื่อมต่อกับ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();
}

และคุณสามารถแยกประเภทของเครือข่ายWiFi ที่ใช้งานอยู่:

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

หรือมือถือMóvil :

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" />

Kotlin และ coroutines

ฉันได้วางฟังก์ชั่นในซึ่งมี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
         }
     }
  }

เพียงแค่สร้างคลาสต่อไปนี้ซึ่งตรวจสอบการเชื่อมต่ออินเทอร์เน็ต:

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.");
        }
    }

ในโค้ดด้านบนหากผลลัพธ์เป็นเท็จ (ดังนั้นจึงไม่มีการเชื่อมต่ออินเทอร์เน็ตผู้ใช้จะถูกนำไปที่แผง Android Wi-Fi ซึ่งเขาได้รับแจ้งให้เชื่อมต่อกับฮอตสปอต Wi-Fi

อัปเดต 29/06/2015 หากคุณใช้ Xamarin.Android และต้องการตรวจสอบการเชื่อมต่อคุณสามารถใช้แพ็คเกจ Nuget ที่จะให้ฟังก์ชั่นนี้ในหลายแพลตฟอร์ม ผู้สมัครที่ดีอยู่ที่นี่และที่นี่ [สิ้นสุดการอัพเดท]

คำตอบข้างต้นค่อนข้างดี แต่ทั้งหมดอยู่ใน Java และเกือบทั้งหมดตรวจสอบการเชื่อมต่อ ในกรณีของฉันฉันต้องมีการเชื่อมต่อกับการเชื่อมต่อบางประเภทและฉันกำลังพัฒนาบน Xamarin.Android นอกจากนี้ฉันไม่ผ่านการอ้างอิงไปยังบริบทกิจกรรมของฉันในเลเยอร์ฮาร์ดแวร์ฉันใช้บริบทแอปพลิเคชัน ดังนั้นนี่คือทางออกของฉันในกรณีที่บางคนมาที่นี่ด้วยข้อกำหนดที่คล้ายกัน ฉันยังไม่ได้ทำการทดสอบเต็มรูปแบบ แต่จะอัปเดตคำตอบเมื่อฉันทำการทดสอบเสร็จแล้ว

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
    }