Récepteur de diffusion pour vérifier la connexion Internet dans l'application Android
Je développe un récepteur de diffusion Android pour vérifier la connexion Internet.
Le problème est que mon récepteur de radiodiffusion est appelé deux fois. Je veux qu'il soit appelé uniquement lorsque le réseau est disponible. Si ce n'est pas disponible, je ne veux pas être averti.
Ceci est le récepteur de diffusion
public class NetworkChangeReceiver extends BroadcastReceiver {
@Override
public void onReceive(final Context context, final Intent intent) {
final ConnectivityManager connMgr = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
final Android.net.NetworkInfo wifi = connMgr
.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
final Android.net.NetworkInfo mobile = connMgr
.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
if (wifi.isAvailable() || mobile.isAvailable()) {
// Do something
Log.d("Network Available ", "Flag No 1");
}
}
}
C'est le fichier manifest.xml
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
package="com.example.broadcastreceiverforinternetconnection"
Android:versionCode="1"
Android:versionName="1.0" >
<uses-sdk
Android:minSdkVersion="8"
Android:targetSdkVersion="17" />
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE"/>
<application
Android:allowBackup="true"
Android:icon="@drawable/ic_launcher"
Android:label="@string/app_name"
Android:theme="@style/AppTheme" >
<receiver Android:name=".NetworkChangeReceiver" >
<intent-filter>
<action Android:name="Android.net.conn.CONNECTIVITY_CHANGE" />
<action Android:name="Android.net.wifi.WIFI_STATE_CHANGED" />
</intent-filter>
</receiver>
</application>
</manifest>
Réponse à votre première question : Votre récepteur de radiodiffusion est appelé deux fois parce que
Vous avez ajouté deux <intent-filter>
Changement de connexion réseau:
<action Android:name="Android.net.conn.CONNECTIVITY_CHANGE" />Changement d'état WiFi:
<action Android:name="Android.net.wifi.WIFI_STATE_CHANGED" />
Il suffit d'en utiliser un:<action Android:name="Android.net.conn.CONNECTIVITY_CHANGE" />.
Il répondra à une seule action au lieu de deux. Voir ici pour plus d'informations.
Répondez à votre deuxième question (vous souhaitez que le destinataire n'appelle qu'une seule fois si la connexion Internet est disponible):
Votre code est parfait. vous notifiez uniquement lorsque Internet est disponible.
UPDATE
Vous pouvez utiliser cette méthode pour vérifier votre connectivité si vous souhaitez simplement vérifier si le mobile est connecté à Internet ou non.
public boolean isOnline(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo netInfo = cm.getActiveNetworkInfo();
//should check null because in airplane mode it will be null
return (netInfo != null && netInfo.isConnected());
}
public class NetworkChangeReceiver extends BroadcastReceiver {
@Override
public void onReceive(final Context context, final Intent intent) {
if(checkInternet(context))
{
Toast.makeText(context, "Network Available Do operations",Toast.LENGTH_LONG).show();
}
}
boolean checkInternet(Context context) {
ServiceManager serviceManager = new ServiceManager(context);
if (serviceManager.isNetworkAvailable()) {
return true;
} else {
return false;
}
}
}
ServiceManager.Java
public class ServiceManager {
Context context;
public ServiceManager(Context base) {
context = base;
}
public boolean isNetworkAvailable() {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = cm.getActiveNetworkInfo();
return networkInfo != null && networkInfo.isConnected();
}
}
autorisations:
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
<uses-permission Android:name="Android.permission.INTERNET" />
Vérification du statut Internet à chaque fois en utilisant Broadcast Receiver:
Code source complet disponible sur Google Drive .
AndroidManifest.xml
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission Android:name="Android.permission.INTERNET"/>
<receiver Android:name=".receivers.NetworkChangeReceiver">
<intent-filter>
<action Android:name="Android.net.conn.CONNECTIVITY_CHANGE" />
</intent-filter>
</receiver>
BroadcastReciever
package com.keshav.networkchangereceiverexample.receivers;
import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;
import Android.net.ConnectivityManager;
import Android.net.NetworkInfo;
import Android.util.Log;
import static com.keshav.networkchangereceiverexample.MainActivity.dialog;
public class NetworkChangeReceiver extends BroadcastReceiver
{
@Override
public void onReceive(Context context, Intent intent)
{
try
{
if (isOnline(context)) {
dialog(true);
Log.e("keshav", "Online Connect Intenet ");
} else {
dialog(false);
Log.e("keshav", "Conectivity Failure !!! ");
}
} catch (NullPointerException e) {
e.printStackTrace();
}
}
private boolean isOnline(Context context) {
try {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo netInfo = cm.getActiveNetworkInfo();
//should check null because in airplane mode it will be null
return (netInfo != null && netInfo.isConnected());
} catch (NullPointerException e) {
e.printStackTrace();
return false;
}
}
}
MainActivity.Java
package com.keshav.networkchangereceiverexample;
import Android.content.BroadcastReceiver;
import Android.content.Intent;
import Android.content.IntentFilter;
import Android.graphics.Color;
import Android.net.ConnectivityManager;
import Android.os.Build;
import Android.os.Handler;
import Android.os.Looper;
import Android.support.v7.app.AppCompatActivity;
import Android.os.Bundle;
import Android.util.Log;
import Android.view.View;
import Android.view.animation.Animation;
import Android.view.animation.AnimationUtils;
import Android.widget.TextView;
import com.keshav.networkchangereceiverexample.receivers.NetworkChangeReceiver;
public class MainActivity extends AppCompatActivity {
private BroadcastReceiver mNetworkReceiver;
static TextView tv_check_connection;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv_check_connection=(TextView) findViewById(R.id.tv_check_connection);
mNetworkReceiver = new NetworkChangeReceiver();
registerNetworkBroadcastForNougat();
}
public static void dialog(boolean value){
if(value){
tv_check_connection.setText("We are back !!!");
tv_check_connection.setBackgroundColor(Color.GREEN);
tv_check_connection.setTextColor(Color.WHITE);
Handler handler = new Handler();
Runnable delayrunnable = new Runnable() {
@Override
public void run() {
tv_check_connection.setVisibility(View.GONE);
}
};
handler.postDelayed(delayrunnable, 3000);
}else {
tv_check_connection.setVisibility(View.VISIBLE);
tv_check_connection.setText("Could not Connect to internet");
tv_check_connection.setBackgroundColor(Color.RED);
tv_check_connection.setTextColor(Color.WHITE);
}
}
private void registerNetworkBroadcastForNougat() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
registerReceiver(mNetworkReceiver, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
registerReceiver(mNetworkReceiver, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
}
}
protected void unregisterNetworkChanges() {
try {
unregisterReceiver(mNetworkReceiver);
} catch (IllegalArgumentException e) {
e.printStackTrace();
}
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterNetworkChanges();
}
}
activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:app="http://schemas.Android.com/apk/res-auto"
xmlns:tools="http://schemas.Android.com/tools"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
tools:context="com.keshav.networkchangereceiverexample.MainActivity">
<TextView
Android:id="@+id/tv_check_connection"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:text="Connection establised !"
Android:padding="25dp"
app:layout_constraintBottom_toBottomOf="parent"
Android:gravity="center"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</LinearLayout>
Utilisez cette méthode pour vérifier l'état du réseau:
private void checkInternetConnection() {
if (br == null) {
br = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Bundle extras = intent.getExtras();
NetworkInfo info = (NetworkInfo) extras
.getParcelable("networkInfo");
State state = info.getState();
Log.d("TEST Internet", info.toString() + " "
+ state.toString());
if (state == State.CONNECTED) {
Toast.makeText(getApplicationContext(), "Internet connection is on", Toast.LENGTH_LONG).show();
} else {
Toast.makeText(getApplicationContext(), "Internet connection is Off", Toast.LENGTH_LONG).show();
}
}
};
final IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
registerReceiver((BroadcastReceiver) br, intentFilter);
}
}
n'oubliez pas de désenregistrer le service dans onDestroy.
À votre santé!!
public static boolean isNetworkAvailable(Context context) {
boolean isMobile = false, isWifi = false;
NetworkInfo[] infoAvailableNetworks = getConnectivityManagerInstance(
context).getAllNetworkInfo();
if (infoAvailableNetworks != null) {
for (NetworkInfo network : infoAvailableNetworks) {
if (network.getType() == ConnectivityManager.TYPE_WIFI) {
if (network.isConnected() && network.isAvailable())
isWifi = true;
}
if (network.getType() == ConnectivityManager.TYPE_MOBILE) {
if (network.isConnected() && network.isAvailable())
isMobile = true;
}
}
}
return isMobile || isWifi;
}
/* You can write such method somewhere in utility class and call it NetworkChangeReceiver like below */
public class NetworkChangedReceiver extends BroadcastReceiver
{
@Override
public void onReceive(Context context, Intent intent) {
if (isNetworkAvailable(context))
{
Toast.makeText(context, "Network Available Do operations",Toast.LENGTH_LONG).show();
}
}
}
Ce récepteur de diffusion ci-dessus ne sera appelé que lorsque l'état du réseau passera à connecté et non déconnecté.
Essayez avec ça
public class ConnectionBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if (<Check internet connection available >) {
Toast.makeText(context, "connect to the internet", Toast.LENGTH_LONG).show();
/*upload background upload service*/
Intent serviceIntent = new Intent(context,<your service class>);
context.startService(serviceIntent);
}else{
Toast.makeText(context, "Connection faild", Toast.LENGTH_LONG).show();
}
}
}
Ceci est le récepteur de diffusion. dès que la connexion Internet déclenchera cette charge
Je sais que ce fil est ancien et que sa réponse est complète, mais j’estime que ce qui suit pourrait aider certaines personnes.
Le code dans le corps de la question contient un bogue que personne n’a abordé ici. @Nikhil vérifie si le wifi/mobile est disponible et non s'il est connecté.
Le correctif est ici:
@Override
public void onReceive(final Context context, final Intent intent) {
final ConnectivityManager connMgr = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
final Android.net.NetworkInfo wifi = connMgr
.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
final Android.net.NetworkInfo mobile = connMgr
.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
if (wifi.isConnected() || mobile.isConnected()) {
// do stuff
}
}
manifeste:
<receiver Android:name=".your.namepackage.here.ConnectivityReceiver">
<intent-filter>
<action Android:name="Android.net.conn.CONNECTIVITY_CHANGE"/>
</intent-filter>
</receiver>
classe pour le récepteur:
public class ConnectivityReceiver extends BroadcastReceiver{
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
switch (action) {
case ConnectivityManager.CONNECTIVITY_ACTION:
DebugUtils.logDebug("BROADCAST", "network change");
if(NetworkUtils.isConnect()){
//do action here
}
break;
}
}
}
et les classes utils comme exemple:
public class NetworkUtils {
public static boolean isConnect() {
ConnectivityManager connectivityManager = (ConnectivityManager) Application.getInstance().getSystemService(Context.CONNECTIVITY_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Lollipop) {
Network[] netArray = connectivityManager.getAllNetworks();
NetworkInfo netInfo;
for (Network net : netArray) {
netInfo = connectivityManager.getNetworkInfo(net);
if ((netInfo.getTypeName().equalsIgnoreCase("WIFI") || netInfo.getTypeName().equalsIgnoreCase("MOBILE")) && netInfo.isConnected() && netInfo.isAvailable()) {
//if (netInfo.getState().equals(NetworkInfo.State.CONNECTED)) {
Log.d("Network", "NETWORKNAME: " + netInfo.getTypeName());
return true;
}
}
} else {
if (connectivityManager != null) {
@SuppressWarnings("deprecation")
NetworkInfo[] netInfoArray = connectivityManager.getAllNetworkInfo();
if (netInfoArray != null) {
for (NetworkInfo netInfo : netInfoArray) {
if ((netInfo.getTypeName().equalsIgnoreCase("WIFI") || netInfo.getTypeName().equalsIgnoreCase("MOBILE")) && netInfo.isConnected() && netInfo.isAvailable()) {
//if (netInfo.getState() == NetworkInfo.State.CONNECTED) {
Log.d("Network", "NETWORKNAME: " + netInfo.getTypeName());
return true;
}
}
}
}
}
return false;
}
}
documentation CONNECTIVITY_ACTION :
Les applications ciblant Android 7.0 (API de niveau 24) et supérieur ne reçoivent pas cette diffusion si elles déclarent le récepteur de diffusion dans leur manifeste. Les applications recevront toujours des émissions si elles enregistrent leur BroadcastReceiver auprès de Context.registerReceiver () et que ce contexte est toujours valide.
juste pour quelqu'un d'autre qui veut enregistrer une émission de manière dynamique:
BroadcastReceiver mWifiReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (checkWifiConnect()) {
Log.d(TAG, "wifi has connected");
// TODO
}
}
};
private void registerWifiReceiver() {
IntentFilter filter = new IntentFilter();
filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
mContext.registerReceiver(mWifiReceiver, filter);
}
private void unregisterWifiReceiver() {
mContext.unregisterReceiver(mWifiReceiver);
}
private boolean checkWifiConnect() {
ConnectivityManager manager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = manager.getActiveNetworkInfo();
if (networkInfo != null
&& networkInfo.getType() == ConnectivityManager.TYPE_WIFI
&& networkInfo.isConnected()) {
return true;
}
return false;
}
public class AsyncCheckInternet extends AsyncTask<String, Void, Boolean> {
public static final int TIME_OUT = 10 * 1000;
private OnCallBack listener;
public interface OnCallBack {
public void onBack(Boolean value);
}
public AsyncCheckInternet(OnCallBack listener) {
this.listener = listener;
}
@Override
protected void onPreExecute() {
}
@Override
protected Boolean doInBackground(String... params) {
ConnectivityManager connectivityManager = (ConnectivityManager) General.context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
if ((networkInfo != null && networkInfo.isConnected())
&& ((networkInfo.getType() == ConnectivityManager.TYPE_WIFI) || (networkInfo
.getType() == ConnectivityManager.TYPE_MOBILE))) {
HttpURLConnection urlc;
try {
urlc = (HttpURLConnection) (new URL("http://www.google.com")
.openConnection());
urlc.setConnectTimeout(TIME_OUT);
urlc.connect();
if (urlc.getResponseCode() == HttpURLConnection.HTTP_OK) {
return true;
} else {
return false;
}
} catch (MalformedURLException e) {
e.printStackTrace();
return false;
} catch (IOException e) {
e.printStackTrace();
return false;
}
} else {
return false;
}
}
@Override
protected void onPostExecute(Boolean result) {
if (listener != null) {
listener.onBack(result);
}
}
}
Voici un moyen pratique de le faire pour une activité, un fragment ou un contexte. Elle sera également annulée automatiquement si vous le faites pour une activité/un fragment (dans onDestroy), si vous le souhaitez:
abstract class ConnectionBroadcastReceiver : BroadcastReceiver() {
companion object {
@JvmStatic
fun registerWithoutAutoUnregister(context: Context, connectionBroadcastReceiver: ConnectionBroadcastReceiver) {
context.registerReceiver(connectionBroadcastReceiver, IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION))
}
@JvmStatic
fun registerToFragmentAndAutoUnregister(context: Context, fragment: Fragment, connectionBroadcastReceiver: ConnectionBroadcastReceiver) {
val applicationContext = context.applicationContext
registerWithoutAutoUnregister(applicationContext, connectionBroadcastReceiver)
fragment.lifecycle.addObserver(object : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
applicationContext.unregisterReceiver(connectionBroadcastReceiver)
}
})
}
@JvmStatic
fun registerToActivityAndAutoUnregister(activity: AppCompatActivity, connectionBroadcastReceiver: ConnectionBroadcastReceiver) {
registerWithoutAutoUnregister(activity, connectionBroadcastReceiver)
activity.lifecycle.addObserver(object : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
activity.unregisterReceiver(connectionBroadcastReceiver)
}
})
}
@JvmStatic
fun hasInternetConnection(context: Context): Boolean {
val info = (context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager).activeNetworkInfo
return !(info == null || !info.isConnectedOrConnecting)
}
}
override fun onReceive(context: Context, intent: Intent) {
val hasConnection = !intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false)
// Log.d("AppLog", "conenctivity changed. hasConnection? $hasConnection")
onConnectionChanged(hasConnection)
}
abstract fun onConnectionChanged(hasConnection: Boolean)
}
Utilisation en fragment:
ConnectionBroadcastReceiver.registerToFragmentAndAutoUnregister(activity!!, this, object : ConnectionBroadcastReceiver() {
override fun onConnectionChanged(hasConnection: Boolean) {
// Log.d("AppLog", "onConnectionChanged:" + hasConnection)
}
})
Ajoutez un récepteur de diffusion pouvant écouter le changement de connectivité du réseau. Ensuite, vérifiez si le périphérique est connecté à Internet ou n'utilise pas ConnectivityManager. Reportez-vous à ceci post ou vidéo pour une compréhension détaillée. Ci-dessous le code:
public class NetworkStateChangeReceiver extends BroadcastReceiver {
public static final String NETWORK_AVAILABLE_ACTION = "com.ajit.singh.NetworkAvailable";
public static final String IS_NETWORK_AVAILABLE = "isNetworkAvailable";
@Override
public void onReceive(Context context, Intent intent) {
Intent networkStateIntent = new Intent(NETWORK_AVAILABLE_ACTION);
networkStateIntent.putExtra(IS_NETWORK_AVAILABLE, isConnectedToInternet(context));
LocalBroadcastManager.getInstance(context).sendBroadcast(networkStateIntent);
}
private boolean isConnectedToInternet(Context context) {
try {
if (context != null) {
ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
return networkInfo != null && networkInfo.isConnected();
}
return false;
} catch (Exception e) {
Log.e(NetworkStateChangeReceiver.class.getName(), e.getMessage());
return false;
}
}
}
J'ai écrit à ce récepteur pour afficher une notification à l'écran, c'est pourquoi vous voyez une émission locale avec l'état du réseau. Voici le code pour afficher la notification.
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
IntentFilter intentFilter = new IntentFilter(NetworkStateChangeReceiver.NETWORK_AVAILABLE_ACTION);
LocalBroadcastManager.getInstance(this).registerReceiver(new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
boolean isNetworkAvailable = intent.getBooleanExtra(IS_NETWORK_AVAILABLE, false);
String networkStatus = isNetworkAvailable ? "connected" : "disconnected";
Snackbar.make(findViewById(R.id.activity_main), "Network Status: " + networkStatus, Snackbar.LENGTH_LONG).show();
}
}, intentFilter);
}
}
Activity écoute l’intention diffusée par le récepteur réseau et affiche la notification à l’écran.
Code du récepteur de diffusion pour vérifier le changement de connectivité Internet:
public class BroadCastDetecter extends BroadcastReceiver {
public static boolean internet_status = false;
public static void checkInternetConenction(Context context) {
internet_status = false;
ConnectivityManager check = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (check != null) {
NetworkInfo[] info = check.getAllNetworkInfo();
if (info != null)
for (int i = 0; i < info.length; i++)
{
if (info[i].getState() == NetworkInfo.State.CONNECTED) {
internet_status = true;
}
}
if(internet_status)
{
//do what you want to if internet connection is available
}
}
}
@Override
public void onReceive(Context context, Intent intent)
{
try {
checkInternetConenction(context);
}catch(Exception e){
}
}
}
ajoutez ceci dans le fichier manifeste:
<receiver Android:name=".BroadCastDetecter">
<intent-filter>
<action Android:name="Android.net.conn.CONNECTIVITY_CHANGE" />
</intent-filter>
</receiver>
Cela vérifie uniquement si l'interface réseau est disponible, ne garantit pas la disponibilité d'un service réseau particulier, par exemple, il pourrait y avoir un faible temps d'immobilisation du serveur ou du serveur.
private boolean isNetworkInterfaceAvailable(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
return activeNetwork != null && activeNetwork.isConnectedOrConnecting();
}
si vous souhaitez établir une connexion réelle pour vous assurer que votre connexion peut collecter des données à partir d'un serveur ou de n'importe quelle URL:
private boolean isAbleToConnect(String url, int timeout) {
try {
URL myUrl = new URL(url);
URLConnection connection = myUrl.openConnection();
connection.setConnectTimeout(timeout);
connection.connect();
return true;
} catch (Exception e) {
Log.i("exception", "" + e.getMessage());
return false;
}
}
Cette fonction doit être encapsulée dans un fil d’arrière-plan:
final String action = intent.getAction();
if (intent.getAction().equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
checkConnectivity(context);
}
}
private void checkConnectivity(final Context context) {
if (!isNetworkInterfaceAvailable(context)) {
Toast.makeText(context, "You are OFFLINE!", Toast.LENGTH_SHORT).show();
return;
}
final Handler handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
final boolean isConnected = isAbleToConnect("http://www.google.com", 1000);
handler.post(new Runnable() {
@Override
public void run() {
if (isConnected)
Toast.makeText(context, "You are ONLINE!", Toast.LENGTH_SHORT).show();
else
Toast.makeText(context, "You are OFFLINE!", Toast.LENGTH_SHORT).show();
}
});
}
}).start();
}
Ajouter les autorisations requises:
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
<uses-permission Android:name="Android.permission.INTERNET"/>
Ajoutez cette ligne sous application dans le fichier manifeste:
Android:usesCleartextTraffic="true"
Ajouter le destinataire au fichier manifeste:
<receiver Android:name=".ConnectivityChangeReceiver" >
<intent-filter>
<action Android:name="Android.net.conn.CONNECTIVITY_CHANGE" />
</intent-filter>
</receiver>
Enregistrez/annulez l'enregistrement du BR dans votre activité:
@Override
protected void onStart() {
super.onStart();
IntentFilter filter = new IntentFilter("Android.net.conn.CONNECTIVITY_CHANGE");
registerReceiver(connectivityChangeReceiver, filter);
}
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(connectivityChangeReceiver);
}
c'est toute la classe Broadcast:
import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;
import Android.net.ConnectivityManager;
import Android.net.NetworkInfo;
import Android.os.Handler;
import Android.util.Log;
import Android.widget.Toast;
import Java.net.URL;
import Java.net.URLConnection;
public class ConnectivityChangeReceiver extends BroadcastReceiver {
@Override
public void onReceive(final Context context, final Intent intent) {
final String action = intent.getAction();
if (intent.getAction().equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
checkConnectivity(context);
}
}
private void checkConnectivity(final Context context) {
if (!isNetworkInterfaceAvailable(context)) {
Toast.makeText(context, "You are OFFLINE!", Toast.LENGTH_SHORT).show();
return;
}
final Handler handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
final boolean isConnected = isAbleToConnect("http://www.google.com", 1000);
handler.post(new Runnable() {
@Override
public void run() {
if (isConnected)
Toast.makeText(context, "You are ONLINE!", Toast.LENGTH_SHORT).show();
else
Toast.makeText(context, "You are OFFLINE!", Toast.LENGTH_SHORT).show();
}
});
}
}).start();
}
//This only checks if the network interface is available, doesn't guarantee a particular network service is available, for example, there could be low signal or server downtime
private boolean isNetworkInterfaceAvailable(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
return activeNetwork != null && activeNetwork.isConnectedOrConnecting();
}
//This makes a real connection to an url and checks if you can connect to this url, this needs to be wrapped in a background thread
private boolean isAbleToConnect(String url, int timeout) {
try {
URL myUrl = new URL(url);
URLConnection connection = myUrl.openConnection();
connection.setConnectTimeout(timeout);
connection.connect();
return true;
} catch (Exception e) {
Log.i("exception", "" + e.getMessage());
return false;
}
}
}
C'est plus facile à utiliser https://github.com/JobGetabu/DroidNet
@Override
public void onInternetConnectivityChanged(boolean isConnected) {
if (isConnected) {
//do Stuff with internet
netIsOn();
} else {
//no internet
netIsOff();
}
}
private void netIsOn(){...}
private void netIsOff(){...}