android - كيفية التحقق من الوصول إلى الإنترنت على الروبوت؟ InetAddress لم أوقات الخروج





networking asynchronous (25)


لقد صنعت هذا الكود ، إنه أبسط وهو مجرد منطقي. من خلال السؤال عما 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;
}

حصلت على 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();
    }   
}



There's more than one way

First, shortest but Inefficient way

Network State Permission only needed

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

Then this method,

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

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

        return isConnected;

    }

As seen in answers ConnectivityManager is a solution, I just added it within a method this is a simplified method all use
ConnectivityManager returns true if there is a network access not Internet access, means if your WiFi is connected to a router but the router has no internet it returns true, it check connection availability

Second, Efficient way

Network State and Internet Permissions needed

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

Then this class,

 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
            }

        }


    }

Call CheckInternetAsyncTask

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

Some Explanations :-

  • you have to check Internet on AsyncTask , otherwise it can throw android.os.NetworkOnMainThreadException in some cases

  • ConnectivityManager used to check the network access if true sends request (Ping)

  • Request send to http://clients3.google.com/generate_204 , This well-known URL is known to return an empty page with an HTTP status 204 this is faster and more efficient than http://www.google.com , read this . if you have website it's preferred to put you website instead of google, only if you use it within the app

  • Timeout can be changed range (20ms -> 2000ms), 1500ms is commonly used




الإجابات الأخرى التي تستخدم ConnectivityManager خاطئة لأن وجود اتصال بالشبكة لا يعني أن لديك اتصالاً بالإنترنت. على سبيل المثال ، قد يكون المستخدم متصلاً بمنفذ WiFi في المقهى ولكن لا يمكنه الوصول إلى الإنترنت. للتحقق من إمكانية الوصول إلى الإنترنت ، عليك محاولة الاتصال بخادم فعلي. عندما تريد أن تفعل ذلك عادةً ما تضع في اعتبارك خادمًا معينًا ترغب في الاتصال به ، فانتقل أولاً وتحقق مما إذا كان يمكنك الاتصال بهذا الخادم. إليك طريقة بسيطة للتحقق من الاتصال بالخادم.

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

السبب في تعيين ConnectTimeout هو أنه بخلاف ذلك الافتراضي إلى TCP مهلة التي يمكن أن تكون طويلة عدة ثوان.

لاحظ أيضًا أن Android لن يسمح لك بتشغيل هذا على مؤشر الترابط الرئيسي الخاص بك.




فيما يلي الكود من صف Utils بي:

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



إحدى حالات الاستخدام المهمة على أجهزة الجوّال لها تضمن وجود اتصال فعلي. تعد هذه مشكلة شائعة عندما يدخل مستخدم الجوّال شبكة 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;
}



لا حاجة لتكون معقدة. الطريقة الأبسط ACCESS_NETWORK_STATE استخدامًا هي استخدام إذن 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" />

في بيان Android الخاص بك.




I have applied the solution provided by @Levit and created function that will not call the extra Http Request.

It will solve the error 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;
}

Now call it like,

if (!isInternetAvailable(getActivity())) {
     //Show message
} else {
     //Perfoem the api request
}






أفضل نهج:

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

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



يمكنك استخدام هذه الطريقة للكشف عن توفر الشبكة

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



كل شيء رأيته حتى الآن أقصر وأقصر طريقة يجب أن يكون:

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

ملاحظة: هذا لا يتدخل بين أي مضيف ، إنه يقوم فقط بفحص connectstatus ، لذلك إذا كان جهاز التوجيه الخاص بك لا يوجد به اتصال بالإنترنت وكان جهازك متصلاً به ، فإن هذه الطريقة ستعود على الرغم من عدم وجود الإنترنت.
للحصول على اختبار فعلي ، أوصي بتنفيذ طلب HttpHead (على سبيل المثال إلى www.google.com) وتحقق من الحالة ، إذا كان كل شيء على ما يرام 200 على ما يرام وكان جهازك يحتوي على اتصال بالإنترنت.




اتصال الشبكة / الوصول إلى الإنترنت

  • isConnectedOrConnecting() (يستخدم في معظم الإجابات) يتحقق لأي اتصال بالشبكة
  • لمعرفة ما إذا كان أي من هذه الشبكات لديه اتصال بالإنترنت ، استخدم أحد ما يلي

أ) اختبار خادم (سهل)

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

    return false;
}

+ يمكن تشغيلها على الموضوع الرئيسي

- لا يعمل على بعض الأجهزة القديمة (Galays S3 ، وما إلى ذلك) ، فإنه يمنع بعض الوقت إذا لم يتوفر الإنترنت

ب) الاتصال بمقبس على الإنترنت (متقدم)

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

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

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

+ سريع جدا (في كلتا الحالتين) ، يعمل على جميع الأجهزة ، موثوقة للغاية

~ لا يمكن تشغيلها على مهمة واجهة المستخدم

- لا شيء

هذا يعمل بشكل موثوق به للغاية ، على كل جهاز ، وهو سريع جدا. تحتاج إلى تشغيل في مهمة منفصلة على الرغم من (مثل ScheduledExecutorService أو AsyncTask ).

أسئلة محتملة

  • هل هو سريع حقا بما فيه الكفاية؟

    نعم ، سريع جدا ؛-)

  • ألا توجد طريقة موثوقة للتحقق من الإنترنت ، بخلاف اختبار شيء ما على الإنترنت؟

    ليس بقدر ما أعرف ، ولكن اسمحوا لي أن أعرف ، وسأقوم بتحرير جوابي.

  • ماذا لو كان DNS معطلاً؟

    Google DNS (على سبيل المثال 8.8.8.8 ) هو أكبر DNS عام في العالم. اعتبارا من عام 2013 كان يخدم 130 مليار طلب في اليوم. دعنا نقول فقط ، من المحتمل ألا يكون تطبيقك هو حديث اليوم.

  • ما الأذونات المطلوبة؟

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

    مجرد الوصول إلى الإنترنت - مفاجأة ^^ (هل فكرت يومًا ، كيف يمكن لبعض الطرق المقترحة هنا أن تحتوي على غراء بعيد عن الوصول إلى الإنترنت ، بدون هذا الإذن؟)

إضافي: One-shot 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 */ });



تحقق من هذا الرمز ... عملت بالنسبة لي :)

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



هذه هي الطريقة التي استخدمها:

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://.com/a/16124915/950427




يعمل لي:

للتحقق من توفر الشبكة:

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



إنه يعمل بالنسبة لي. حاول.

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    try {
        URL url = new URL("http://.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());
}}



Just create the following class which checks for an internet 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;
    }
}

This class simply contains a method which returns the boolean value of the connection status. Therefore in simple terms, if the method finds a valid connection to the Internet, the return value is true , otherwise false if no valid connection is found.

The following method in the MainActivity then calls the result from the method previously described, and prompts the user to act accordingly:

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

In the above code, if the result is false, (therefore there is no internet connection, the user is taken to the Android wi-fi panel, where he is prompted to connect to a wi-fi hotspot.




إلقاء نظرة على فئة 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 للكائن NetworkInfo الذي تم إرجاعه

تحرير EDIT: لمعرفة ما إذا كان يمكنك الوصول إلى مضيف ، يمكنك استخدام

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

من الواضح أنني أستخدم Context.getSystemService (Context.CONNECTIVITY_SERVICE) كوكيل ليقول

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



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

}



بالنسبة لي لم تكن ممارسة جيدة للتحقق من حالة الاتصال في فصل النشاط ، لأن

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)




I have gone through all the answers and i come up with my own answer which first check whether Internet is available and if Internet is available then it check whether it is active or not.

I have included all necessary method and classes to check for active Internet connection.

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

You can check whether Internet is active using below code:

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



ليس من الصعب التحقق من حالة اتصال شبكة الإنترنت / شبكة 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 / شبكة الاتصال بالإنترنت




Eddie. مجرد تعديل طفيف على الحل الخاص بك - إذا كان الجهاز في وضع الطائرة (أو يفترض أنه في حالات أخرى حيث لا يوجد شبكة متوفرة) ، فإن cm.getActiveNetworkInfo() ستكون null ، لذا تحتاج إلى إضافة فحص null .

الحل المعدل أدناه:

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

أضف الإذن التالي أيضًا إلى AndroidManifest.xml :

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

نقطة صغيرة أخرى ، إذا احتجت تماماً إلى اتصال شبكة اتصال في الوقت المحدد ، فقد يكون من الأفضل استخدام netInfo.isConnected() بدلاً من netInfo.isConnectedOrConnecting . أعتقد أن هذا الأمر متروك لحالة الاستخدام الفردية.




لتقليل وقت بدء المحاكي ، تحتاج إلى التحقق من "تعطيل الرسوم المتحركة التمهيد" قبل بدء محاكي. ارجع إلى وثائق Android .

إذا كنت لا تعرف ، فأنت لست بحاجة إلى إغلاق المحاكي في كل مرة تقوم بتشغيل / تصحيح تطبيقك. إذا قمت بالنقر فوق تشغيل / تصحيح عندما يكون مفتوحًا بالفعل ، فسيتم تحميل ملف APK الخاص بك إلى المحاكي ويبدأ على الفور إلى حد كبير. يأخذ المحاكي وقتًا طويلاً بشكل مزعج فقط عندما يبدأ في المرة الأولى.

إليك بعض النصائح لتسريع محاكي Android: كيفية تسريع محاكي Android بنسبة تصل إلى 400٪ .





android networking asynchronous