내가 가지고 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) 서버 핑 (쉬운)

// 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 년 현재 하루 1,300 억 건의 요청을 처리했습니다. 당신의 앱이 아마도 오늘의 이야기가 아닐 수도 있습니다.

• 어떤 권한이 필요합니까?

  <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예 (코 틀린)

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 's solution ) :

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 / mobile)을 염두에두고 사용할 수도 있습니다.

또한 다음이 필요합니다.

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

당신의 안드로이드 매니페스트에서.

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) 

반환 된 NetworkInfo 객체의 DetailedState 열거를 구문 분석합니다.

편집 편집 : 호스트에 액세스 할 수 있는지 확인하려면 다음을 사용할 수 있습니다.

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

에서 확인할 수 있고이에서 수정 (!) 링크 :

매니페스트 파일에서 최소한 다음을 추가하십시오.

<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인터넷 액세스가 아닌 네트워크 액세스가있는 경우 모든 사용 이 true를 반환 하는 간단한 방법입니다 .Wi-Fi가 라우터에 연결되어 있지만 라우터에 인터넷이없는 경우 true를 반환하고 연결 가용성을 확인합니다.

둘째, 효율적인 방법

필요한 네트워크 상태 및 인터넷 권한

<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 true가 요청을 보내는 경우 네트워크 액세스를 확인하는 데 사용됩니다 (Ping)

• 에 요청 전송 http://clients3.google.com/generate_204이 잘 알려진 URL을 알고이보다 빠르고 효율적으로보다 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();
}

추신 : 이것은 호스트를 핑하지 않고 연결 상태 만 검사하므로 라우터에 인터넷이 연결되어 있지 않고 장치가 연결되어 있으면 인터넷이 없지만이 방법은 true를 반환 합니다 .
실제 테스트를 위해서는 HttpHead 요청 (예 : www.google.com)을 실행 하고 200 이상 이면 문제가없고 기기가 인터넷에 연결 되어 있는지 상태를 확인하는 것이 좋습니다 .

내가 사용하는 방법은 다음과 같습니다.

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

실제 연결이 존재하는지 확인하기위한 모바일 장치의 중요한 사용 사례입니다. 이것은 모바일 사용자가 로그인해야하는 "포털 포털"을 사용하여 Wi-Fi 네트워크에 접속할 때 일반적으로 발생하는 문제입니다. 백그라운드에서이 차단 기능을 사용하여 연결이 존재하는지 확인합니다.

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

나를 위해 Activity 클래스에서 연결 상태를 확인하는 것은 좋지 않았습니다.

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

사용 가능한 연결 (wifi, 네트워크)이없는 경우 UnknownHostException 예외를 포착합니다 .

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

이 방법을 사용하면 매우 빠른 방법 (실시간 피드백) 또는 느린 방법 (신뢰할 수있는 1 회 점검)을 선택할 수 있습니다.

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

안드로이드 네트워크 / 인터넷 연결 상태를 확인하는 것은 복잡하지 않습니다. 아래 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
}

이것은 안드로이드 문서 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;
}

또는 모바일 모빌 :

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

코 틀린과 코 루틴

나는에 함수를 배치 ViewModel했다 viewModelScope. 관찰 가능을 사용 LiveData하여 연결에 대한 활동을 알려줍니다.

뷰 모델

 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 핫스팟에 연결하라는 메시지가 표시됩니다.

2015 년 6 월 29 일 업데이트 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
    }