Comment afficher un message si l'internet n'est pas disponible dans mon android webview

Appeler cette méthode avant l'ouverture de la webView si cette méthode returns true cela signifie que le connexion internet est disponible et vous pouvez traiter à la webview sinon de montrer quelques Toast ou vous pouvez montrer Dialog si cette méthode returns false.

Modifier

Utiliser ce type de code dans votre Main Activity comme ce

if(isNetworkStatusAvialable (getApplicationContext())) {
    Toast.makeText(getApplicationContext(), "internet avialable", Toast.LENGTH_SHORT).show();
} else {
    Toast.makeText(getApplicationContext(), "internet is not avialable", Toast.LENGTH_SHORT).show();

}

Méthode

public static boolean isNetworkStatusAvialable (Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (connectivityManager != null) 
    {
        NetworkInfo netInfos = connectivityManager.getActiveNetworkInfo();
        if(netInfos != null)
        if(netInfos.isConnected()) 
            return true;
    }
    return false;
}

OriginalL'auteur

que le Cerveau dit sur ce post

Afin de déterminer si l'appareil a une connexion réseau, demande la permission <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> et puis vous pouvez vérifier avec le code suivant. D'abord définir ces variables comme des variables de classe.

private Context c;
private boolean isConnected = true;

Dans votre onCreate() méthode initialize c = this;

Puis vérifier la connectivité.

ConnectivityManager connectivityManager = (ConnectivityManager)
    c.getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectivityManager != null) {
    NetworkInfo ni = connectivityManager.getActiveNetworkInfo();
    if (ni.getState() != NetworkInfo.State.CONNECTED) {
        //record the fact that there is not connection
        isConnected = false;
    }
}

Alors d'intercepter le WebView requets, vous pourriez faire quelque chose comme ce qui suit. Si vous utilisez cette option, vous aurez probablement envie de personnaliser les messages d'erreur afin d'inclure certains de l'information qui est disponible dans le onReceivedError méthode.

final String offlineMessageHtml = "DEFINE THIS";
final String timeoutMessageHtml = "DEFINE THIS";

WebView browser = (WebView) findViewById(R.id.webview);
browser.setNetworkAvailable(isConnected);
browser.setWebViewClient(new WebViewClient() {
    @Override
    public boolean shouldOverrideUrlLoading(WebView view, String url) {
        if (isConnected) {
            //return false to let the WebView handle the URL
            return false;
        } else {
            //show the proper "not connected" message
            view.loadData(offlineMessageHtml, "text/html", "utf-8");
            //return true if the host application wants to leave the current 
            //WebView and handle the url itself
            return true;
        }
    }
    @Override
    public void onReceivedError (WebView view, int errorCode, 
        String description, String failingUrl) {
        if (errorCode == ERROR_TIMEOUT) {
            view.stopLoading();  //may not be needed
            view.loadData(timeoutMessageHtml, "text/html", "utf-8");
        }
    }
});

OriginalL'auteur FxRi4

J'ai fait de cette façon:

Créer deux fichiers java comme ci-dessous:

NetworkConnectivity.java

package com.connectivity;
import java.util.ArrayList;
import java.util.List;
import android.app.Activity;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Handler;
public class NetworkConnectivity {
private static NetworkConnectivity sharedNetworkConnectivity = null;
private Activity activity = null;
private final Handler handler = new Handler();
private Runnable runnable = null;
private boolean stopRequested = false;
private boolean monitorStarted = false;
private static final int NETWORK_CONNECTION_YES = 1;
private static final int NETWORK_CONNECTION_NO = -1;
private static final int NETWORK_CONNECTION_UKNOWN = 0;
private int connected = NETWORK_CONNECTION_UKNOWN;
public static final int MONITOR_RATE_WHEN_CONNECTED_MS = 5000;
public static final int MONITOR_RATE_WHEN_DISCONNECTED_MS = 1000;
private final List<NetworkMonitorListener> networkMonitorListeners = new ArrayList<NetworkMonitorListener>();
private NetworkConnectivity() {
}
public synchronized static NetworkConnectivity sharedNetworkConnectivity() {
if (sharedNetworkConnectivity == null) {
sharedNetworkConnectivity = new NetworkConnectivity();
}
return sharedNetworkConnectivity;
}
public void configure(Activity activity) {
this.activity = activity;
}
public synchronized boolean startNetworkMonitor() {
if (this.activity == null) {
return false;
}
if (monitorStarted) {
return true;
}
stopRequested = false;
monitorStarted = true;
(new Thread(new Runnable() {
@Override
public void run() {
doCheckConnection();
}
})).start();
return true;
}
public synchronized void stopNetworkMonitor() {
stopRequested = true;
monitorStarted = false;
}
public void addNetworkMonitorListener(NetworkMonitorListener l) {
this.networkMonitorListeners.add(l);
this.notifyNetworkMonitorListener(l);
}
public boolean removeNetworkMonitorListener(NetworkMonitorListener l) {
return this.networkMonitorListeners.remove(l);
}
private void doCheckConnection() {
if (stopRequested) {
runnable = null;
return;
}
final boolean connectedBool = this.isConnected();
final int _connected = (connectedBool ? NETWORK_CONNECTION_YES
: NETWORK_CONNECTION_NO);
if (this.connected != _connected) {
this.connected = _connected;
activity.runOnUiThread(new Runnable() {
@Override
public void run() {
notifyNetworkMonitorListeners();
}
});
}
runnable = new Runnable() {
@Override
public void run() {
doCheckConnection();
}
};
handler.postDelayed(runnable,
(connectedBool ? MONITOR_RATE_WHEN_CONNECTED_MS
: MONITOR_RATE_WHEN_DISCONNECTED_MS));
}
public boolean isConnected() {
try {
ConnectivityManager cm = (ConnectivityManager) activity
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo netInfo = cm.getActiveNetworkInfo();
if (netInfo != null && netInfo.isConnected()) {
return true;
} else {
return false;
}
} catch (Exception e) {
return false;
}
}
private void notifyNetworkMonitorListener(NetworkMonitorListener l) {
try {
if (this.connected == NETWORK_CONNECTION_YES) {
l.connectionEstablished();
} else if (this.connected == NETWORK_CONNECTION_NO) {
l.connectionLost();
} else {
l.connectionCheckInProgress();
}
} catch (Exception e) {
}
}
private void notifyNetworkMonitorListeners() {
for (NetworkMonitorListener l : this.networkMonitorListeners) {
this.notifyNetworkMonitorListener(l);
}
}
}

NetworkMonitorListener.java

package com.connectivity;
public interface NetworkMonitorListener {
public void connectionEstablished();
public void connectionLost();
public void connectionCheckInProgress();
}

Et enfin, l'utilisation:

NetworkConnectivity.sharedNetworkConnectivity().configure(this);
NetworkConnectivity.sharedNetworkConnectivity().startNetworkMonitor();
NetworkConnectivity.sharedNetworkConnectivity()
.addNetworkMonitorListener(new NetworkMonitorListener() {
@Override
public void connectionCheckInProgress() {
//Okay to make UI updates (check-in-progress is rare)
}
@Override
public void connectionEstablished() {
//Okay to make UI updates -- do something now that
//connection is avaialble
Toast.makeText(getBaseContext(), "Connection established", Toast.LENGTH_SHORT).show();
}
@Override
public void connectionLost() {
//Okay to make UI updates -- bummer, no connection
Toast.makeText(getBaseContext(), "Connection lost.", Toast.LENGTH_LONG).show();
}
});

Ci-dessus, vous serez en mesure de vérifier pour la connexion à l'internet dans l'exécution. Dès que la connexion internet est perdue, Toast s'affiche (par le code ci-dessus).

OriginalL'auteur Chintan Soni