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

Réponse complète ici

Fichier de manifestation

Classe BroadecardReceiver

public class NetworkStateReceiver extends BroadcastReceiver {
    public void onReceive(Context context, Intent intent) {
     Log.d("app","Changement de connectivité réseau");
     if(intent.getExtras()!=null) {
        NetworkInfo ni=(NetworkInfo) intent.getExtras().get(ConnectivityManager.EXTRA_NETWORK_INFO);
        if(ni!=null && ni.getState()==NetworkInfo.State.CONNECTED) {
            Log.i("app","Réseau "+ni.getTypeName()+" connecté");
        } else if(intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY,Boolean.FALSE)) {
            Log.d("app","Pas de connectivité réseau");
        }
   }
}

Inscription du récepteur dans MainActivity

@Override
protected void onResume() {
    super.onResume();
    IntentFilter intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
    registerReceiver(networkReceiver, intentFilter);
}

@Override
protected void onPause() {
    super.onPause();
    if (networkReceiver != null)
        unregisterReceiver(networkReceiver);
}

Profitez-en !

Answer 2

Code du récepteur de diffusion pour vérifier les changements 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)
            {
               //faire ce que vous voulez si la connexion Internet est disponible
            }
        }
    }

    @Override
    public void onReceive(Context context, Intent intent)
    {
        try {
            checkInternetConenction(context);
        }catch(Exception e){

        }
    }
}

ajouter ceci dans le fichier manifeste :

Answer 3

Cela ne vérifie que si l'interface réseau est disponible, ne garantit pas qu'un service réseau particulier est disponible, par exemple, il pourrait y avoir un faible signal ou une panne de 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 voulez établir une véritable connexion pour vous assurer que votre connexion peut récupérer 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 enveloppée dans un thread en 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, "Vous êtes HORS LIGNE!", 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, "Vous êtes EN LIGNE!", Toast.LENGTH_SHORT).show();
                        else
                            Toast.makeText(context, "Vous êtes HORS LIGNE!", Toast.LENGTH_SHORT).show();
                    }
                });

            }
        }).start();

    }

Ajoutez les autorisations requises:

Ajoutez cette ligne sous l'application dans le fichier manifeste :

android:usesCleartextTraffic="true"

Ajoutez le récepteur au fichier manifeste :

Inscrivez/Désinscrivez le 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);
    }

Voici l'intégralité de la classe de diffusion :

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, "Vous êtes HORS LIGNE!", 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, "Vous êtes EN LIGNE!", Toast.LENGTH_SHORT).show();
                        else
                            Toast.makeText(context, "Vous êtes HORS LIGNE!", Toast.LENGTH_SHORT).show();
                    }
                });

            }
        }).start();

    }

    //Cela ne vérifie que si l'interface réseau est disponible, ne garantit pas qu'un service réseau particulier est disponible, par exemple, il pourrait y avoir un faible signal ou une panne de serveur
    private boolean isNetworkInterfaceAvailable(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
        return activeNetwork != null && activeNetwork.isConnectedOrConnecting();
    }

    //Cela établit une véritable connexion à une URL et vérifie si vous pouvez vous connecter à cette URL, cela doit être enveloppé dans un thread en arrière-plan
    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;
        }
    }
}

Answer 4

1) Dans le manifeste : - appelez le récepteur comme ci-dessous

2) Créez une classe Broad Cast Receiver : - Dans cette classe, ajoutez le code de vérification du réseau

package com.safal.checkinternet;

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 android.widget.Toast;

public class NetworkChangeReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(final Context context, final Intent intent) {
        if (isOnline(context)){
            Toast.makeText(context, "Disponible", Toast.LENGTH_SHORT).show();
        }else {
            Toast.makeText(context, "Non disponible", Toast.LENGTH_SHORT).show();
        }
    }
    public boolean isOnline(Context context) {

        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        assert cm != null;
        NetworkInfo netInfo = cm.getActiveNetworkInfo();
        return (netInfo != null && netInfo.isConnected());
    }    
} 

3) Dans votre activité, appelez le Broad Cast Receiver : -

package com.safal.checkinternet;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
//Appelez le Broad Cast Receiver 
        IntentFilter filter = new IntentFilter();
        filter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
        registerReceiver(new NetworkChangeReceiver(), filter);
    }
}

Answer 5

• Maintenant, vous n'avez pas besoin d'un récepteur de diffusion pour observer les changements réseau
• Nous pouvons y parvenir en utilisant le flux

Voici une meilleure solution fonctionnelle avec le code source et la démo implémentée dans mon github