Récepteur de diffusion pour vérifier la connexion Internet dans l'application Android

Question

Je développe un récepteur de diffusion Android pour vérifier la connexion Internet.

Le problème est que mon récepteur de diffusion est appelé deux fois. Je veux qu'il soit appelé uniquement lorsque le réseau est disponible. S'il est indisponible, je ne veux pas être notifié.

Voici 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()) {
            // Faire quelque chose

            Log.d("Réseau disponible", "Drapeau n°1");
        }
    }
}

Voici le manifest.xml

Answer 1

Manifest:

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", "changement de réseau");
                if(NetworkUtils.isConnect()){
                    //faire l'action ici
                }
            break;
        }
    }
}

et une classe 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", "NOMDURESEAU: " + 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", "NOMDURESEAU: " + netInfo.getTypeName());
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
}

Answer 2

Essayez ceci

public class ConnectionBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {

    if () { 
        Toast.makeText(context, "se connecter à Internet", Toast.LENGTH_LONG).show();

        /*service de téléchargement en arrière-plan*/
        Intent serviceIntent = new Intent(context,);
        context.startService(serviceIntent);

    }else{
        Toast.makeText(context, "Échec de la connexion", Toast.LENGTH_LONG).show();

    }
    }
}

Dès que la connexion Internet est déclenchée, ce (BroadcastReciever) sera chargé

Answer 3

public class AsyncCheckInternet extends AsyncTask {

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

}

Answer 4

Ajoutez un récepteur de diffusion qui peut écouter les changements de connectivité réseau. Ensuite, vérifiez si l'appareil est connecté à Internet ou non en utilisant ConnectivityManager. Référez-vous à ce post ou à cette vidéo pour une compréhension détaillée. Voici 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 diffusion locale avec le statut 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 ? "connecté" : "déconnecté";

        Snackbar.make(findViewById(R.id.activity_main), "Etat du réseau : " + networkStatus, Snackbar.LENGTH_LONG).show();
      }
    }, intentFilter);
  }
}

L'activité écoute l'intent diffusé par le récepteur réseau et affiche la notification à l'écran.

Answer 5

Dès 2022, aucune des approches de BroadcastReceiver ci-dessus ne fonctionnera. La méthode BroadcastReceiver ne fonctionnera plus en raison des restrictions imposées sur Android 7.0. La manière la plus récente et la plus simple de vérifier si Internet est disponible ou non consiste à utiliser le code suivant. (Fonctionne sur Android 12 testé)

val networkRequest = NetworkRequest.Builder()
        .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
        .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
        .build()

private val networkCallback = object : ConnectivityManager.NetworkCallback() {
    // le réseau est disponible pour une utilisation
    override fun onAvailable(network: Network) {
        super.onAvailable(network)
    }

    // Les capacités réseau ont changé pour le réseau
    override fun onCapabilitiesChanged(
            network: Network,
            networkCapabilities: NetworkCapabilities
    ) {
        super.onCapabilitiesChanged(network, networkCapabilities)
        val unmetered = networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
    }

    // perte de connexion réseau
    override fun onLost(network: Network) {
        super.onLost(network)
    }
}

val connectivityManager = getSystemService(ConnectivityManager::class.java) as ConnectivityManager
connectivityManager.requestNetwork(networkRequest, networkCallback

Placez ce morceau de code dans une fonction et appelez-le dans onCreate() de votre activité/fragment. Vous serez notifié à chaque fois que Internet est connecté ou déconnecté dans les fonctions onAvailable() et onLost(). En plus de cela, vous pouvez utiliser liveData ou ce que vous voulez pour diffuser ces mises à jour dans d'autres activités/fragments. Le lien de la documentation officielle : https://developer.android.com/training/monitoring-device-state/connectivity-status-type