programing

Android에서 인터넷 접속을 확인하는 방법은?InetAddress가 타임아웃되지 않음

itsource 2022. 8. 14. 10:06

Android에서 인터넷 접속을 확인하는 방법은?InetAddress가 타임아웃되지 않음

는 는는이졌다.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();
    }   
}

모드 사용 한 네트워크가 일 수 인 경우, " " " (" " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " ""cm.getActiveNetworkInfo() 되다null에 a, ㄴ데, ㄴ데, ㄴ데를 nulldisclossible을 클릭합니다.

아래 수정(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다만, 이것은 개인 유스케이스에 따라 다르다고 생각합니다.

네트워크 접속/인터넷 접속

isConnectedOrConnecting()(대부분의 응답에 사용) 네트워크 접속 체크
이러한 네트워크에서 인터넷에 액세스할 수 있는지 확인하려면 다음 중 하나를 사용하십시오.

A) 서버 ping (간단)

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

이것은 모든 디바이스에서 매우 안정적으로 동작하며 매우 빠릅니다.별도의 작업(예 만만, 른른른른((((((((((((((((((((()으로 실행해야 합니다.ScheduledExecutorService ★★★★★★★★★★★★★★★★★」AsyncTask를 참조해 주세요.

가능한 질문

정말 충분히 빠릅니까?

네, 매우 빠릅니다;-)
인터넷에서 무언가를 테스트하는 것 외에 인터넷을 확인하는 믿을 만한 방법은 없습니까?

제가 알기로는 아닙니다만, 알려주시면 답변을 수정해 드리겠습니다.
DNS가 다운되면 어떻게 됩니까?

DNS Google DNS(::8.8.8.8)는 세계에서 가장 큰 퍼블릭 DNS입니다.2018년 기준으로 하루에 1조 건 이상의 쿼리를 처리했습니다[1].예를 들어, 당신의 앱은 아마도 오늘의 화제가 되지 않을 것입니다.
어떤 권한이 필요합니까?
```
<uses-permission android:name="android.permission.INTERNET" />
```
인터넷 접속만 하면 됩니다.깜짝 ^^ (여기서 제안하는 방법 중 몇 가지가 어떻게 허가 없이 인터넷 접속에 대한 원격 접착제를 사용할 수 있는지 생각해 본 적이 있습니까?)

: ★★★★★★★★★★★★★★★*`RxJava/RxAndroid`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 */}

: ★★★★★★★★★★★★★★★*`RxJava/RxAndroid`Java)

public static Single<Boolean> hasInternetConnection() {
    return Single.fromCallable(() -> {
        try {
            // Connect to Google DNS to check for connection
            int timeoutMs = 1500;
            Socket socket = new Socket();
            InetSocketAddress socketAddress = new InetSocketAddress("8.8.8.8", 53);

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

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

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

    hasInternetConnection().subscribe((hasInternet) -> {
        if(hasInternet) {

        }else {

        }
    });

: ★★★★★★★★★★★★★★★*`AsyncTask` »

주의:이 예에서는 요청 수행 방법에 대한 다른 예를 보여 줍니다.하지만, 그 이후로는AsyncTask권장되지 않습니다. 코틀린 코루틴스, Rx 코루틴스.

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

복잡할 필요는 없습니다.에 박힌 로, 「이것들」을 합니다.ACCESS_NETWORK_STATE 방법을 요.

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

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

이 경우에도 하실 수 있습니다.requestRouteToHost특정 호스트 및 연결 유형(하드웨어/모바일)을 염두에 두고 있는 경우.

또, 다음과 같은 것도 필요합니다.

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

당신의 안드로이드 매니페스토에 있어요

getActiveNetworkInfo()작업하려면 매니페스트에 다음 항목을 추가해야 합니다.

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

Connectivity Manager 클래스를 확인합니다.이 클래스를 사용하여 호스트의 활성 연결에 대한 정보를 얻을 수 있습니다.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)

콘텍스트를 사용하고 있습니다.getSystemService(콘텍스트).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를 합니다.

둘째, 효율적인 방법

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

<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 request true 인 합니다.
http://clients3.google.com/generate_204의 빈 있습니다은 "well-known URL" HTTP 204보다 입니다.이것은 보다 빠르고 효율적입니다.http://www.google.com읽어주세요.웹 사이트가 있는 경우, 앱 내에서 사용하는 경우에만 구글 대신 웹 사이트를 추가하는 것이 좋습니다.
타임아웃의 범위는 변경할 수 있습니다(20밀리초 -> 2000밀리초).일반적으로 1500밀리초가 사용됩니다.

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

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

내가 지금까지 본 모든 것 중에서 가장 짧고 깨끗한 방법은 다음과 같다.

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을 수행하지 않고 연결 상태만 체크하기 때문에 라우터에 인터넷 연결이 없고 디바이스가 연결되어 있으면 인터넷이 없어도 이 방법은 true로 반환됩니다.
실제 테스트에서는 HttpHead 요구(www.google.com 등)를 실행하여 상태를 체크할 것을 권장합니다.이러한 요구는 200으로 정상이며, 디바이스는 인터넷에 연결되어 있습니다.

모바일 디바이스의 중요한 사용 사례 중 하나는 실제 접속을 확실하게 하기 위한 것입니다.이는 모바일 사용자가 로그인해야 하는 "Captive Portal"을 사용하여 WiFi 네트워크에 들어갈 때 흔히 발생하는 문제입니다.백그라운드에서 이 차단 기능을 사용하여 연결이 존재하는지 확인합니다.

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

코틀린 코루틴

은 이이 a a a a a에 했습니다.ViewModel에는)이 .viewModelScope할 수 있는 것을 해서.LiveData이치노

뷰 모델

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

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

                _connection.postValue(true)
            }
            catch(ex: IOException) {
                _connection.postValue(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
         }
     }
  }

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

모든 네트워크 접속을 반복하여 적어도1개의 사용 가능한 접속이 있는지 여부를 확인할 수 있습니다.

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

를 호출하거나 액티비티 인스턴스(콘텍스트)를 접속 핸들러 클래스로 푸시다운하여 접속 상태를 확인할 수 있어야 합니다.사용 가능한 접속(와이파이, 네트워크)이 없을 때 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());
}}

이 방법을 사용하여 네트워크의 가용성을 검출할 수 있습니다.

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

이 메서드는 매우 빠른 메서드(실시간 피드백용) 또는 느린 메서드(신뢰성이 필요한 일회성 체크용) 옵션을 제공합니다.

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

Android 네트워크/인터넷 연결 상태를 확인하는 것은 복잡하지 않습니다.는 ★★★DetectConnection 상태를 확인할 수 .class about about about about about about about about about about about about about about about.

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

}

이는 안드로이드 문서(http://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html에서 다룹니다.

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

또는 모바일 Movil:

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

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

Xamarin을 사용하는 경우 업데이트 29/06/2015.Android에서 연결을 확인하고 싶다면 Nuget 패키지를 사용하면 여러 플랫폼에서 이 기능을 사용할 수 있습니다.좋은 후보들이 여기나 여기나 있어요.[갱신 종료]

위의 답변은 매우 좋지만 모두 Java로 되어 있으며, 거의 모든 답변이 연결 여부를 확인합니다.제 경우 특정 유형의 연결과 연결이 필요했고 현재 Xamarin을 개발 중입니다.안드로이드.또한 하드웨어 계층에서 작업 컨텍스트에 대한 참조를 전달하지 않고 애플리케이션 컨텍스트를 사용합니다.여기 누군가 비슷한 조건을 가지고 올 경우를 대비해서 제 해결책이 있습니다.아직 완전한 테스트는 하지 않았습니다.테스트가 끝나면 답변을 갱신합니다.

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
    }

Connectivity Manager를 사용하는 다른 답변은 올바르지 않습니다.네트워크 접속이 있다고 해서 인터넷에 접속할 수 있는 것은 아니기 때문입니다.예를 들어 사용자가 커피숍의 WiFi 포털에 연결되어 있지만 인터넷에 접속할 수 없는 경우가 있습니다.인터넷에 접속할 수 있는지 확인하려면 실제 서버에 접속해야 합니다.통상, 이 조작을 실시할 때는, 접속하는 특정의 서버를 염두에 두고 있기 때문에, 그 서버에 접속할 수 있는지를 확인해 주세요.서버 접속을 확인하는 간단한 방법은 다음과 같습니다.

private boolean isOnTheInternet() {
    try {
        URLConnection urlConnection = new URL("http://yourserver").openConnection();
        urlConnection.setConnectTimeout(400);
        urlConnection.connect();
        return true;
    } catch (Exception e) {
        return false;
    }
}

Connect Timeout을 설정하는 이유는 이 설정이 디폴트일 경우 TCP 타임아웃이 되기 때문입니다.TCP 타임아웃은 몇 초가 될 수 있습니다.

Android에서는 메인 스레드에서 실행할 수 없습니다.

나는 모든 답을 검토했고 우선 인터넷이 가능한지 여부를 확인하고 인터넷이 가능한지 여부를 확인하는 나만의 답을 생각해냈다.

인터넷 접속 활성화 여부를 확인하기 위해 필요한 모든 방법과 클래스를 포함했습니다.

Network Utils. 클래스

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

언급URL : https://stackoverflow.com/questions/1560788/how-to-check-internet-access-on-android-inetaddress-never-times-out

저작자표시

'programing' 카테고리의 다른 글

[Vue warn] :중복된 키가 검출되었습니다.x 。이로 인해 업데이트 오류가 발생할 수 있습니다. (0)	2022.08.14
VueJ 팝업 "대화 상자"에 매개 변수 전달 (0)	2022.08.14
vuejs에 따옴표가 두 개 있는 img 태그 (0)	2022.08.14
JPA Join Column vs mappedBy (0)	2022.08.08
Rails Vuejs Webpacker: 인스턴스 변수 데이터 전달 (0)	2022.08.08

현재글Android에서 인터넷 접속을 확인하는 방법은?InetAddress가 타임아웃되지 않음

각종 프로그래밍 정보를 다루는 블로그입니다.

vuex, Spring, Spring3, Java, c#, JavaScript, C++, jQuery, C, vuejs2,

Today :
Yesterday :

itsource

Android에서 인터넷 접속을 확인하는 방법은?InetAddress가 타임아웃되지 않음

Android에서 인터넷 접속을 확인하는 방법은?InetAddress가 타임아웃되지 않음

네트워크 접속/인터넷 접속

A) 서버 ping (간단)

B) 인터넷상의 소켓에 접속(어드밴스드밴스드)

가능한 질문

: ★★★★★★★★★★★★★★★*`RxJava/RxAndroid`Kotlin)

: ★★★★★★★★★★★★★★★*`RxJava/RxAndroid`Java)

: ★★★★★★★★★★★★★★★*`AsyncTask` »

코틀린 코루틴

'programing' 카테고리의 다른 글

'programing'의 다른글

티스토리툴바

« 2025/02 »
일	월	화	수	목	금	토
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28

Android에서 인터넷 접속을 확인하는 방법은?InetAddress가 타임아웃되지 않음

Android에서 인터넷 접속을 확인하는 방법은?InetAddress가 타임아웃되지 않음

네트워크 접속/인터넷 접속

A) 서버 ping (간단)

B) 인터넷상의 소켓에 접속(어드밴스드밴스드)

가능한 질문

: ★★★★★★★★★★★★★★★*RxJava/RxAndroidKotlin)

: ★★★★★★★★★★★★★★★*RxJava/RxAndroidJava)

: ★★★★★★★★★★★★★★★*AsyncTask »

코틀린 코루틴

'programing' 카테고리의 다른 글

'programing'의 다른글

관련글

티스토리툴바

: ★★★★★★★★★★★★★★★*`RxJava/RxAndroid`Kotlin)

: ★★★★★★★★★★★★★★★*`RxJava/RxAndroid`Java)

: ★★★★★★★★★★★★★★★*`AsyncTask` »