web-dev-qa-db-fra.com

Comment savoir si les données du réseau mobile sont activées ou désactivées (même si elles sont connectées par WiFi)

Je souhaite utiliser une application pour obtenir un rapport sur l'état de la connexion à partir d'une requête à distance.

Je veux savoir si le WiFi est connecté et si l'accès aux données est activé sur le réseau mobile.

Si le WiFi est hors de portée, je veux savoir si je peux compter sur le réseau mobile.

Le problème est que les données activées sont toujours renvoyées comme étant vraies lorsque je suis connecté par WiFi, et que je ne peux interroger correctement le réseau mobile que s'il n'est pas connecté par WiFi.

toutes les réponses que j'ai vues suggèrent une interrogation pour savoir quelle est la connexion actuelle, mais je veux savoir si un réseau mobile est disponible si j'en ai besoin, même si je suis actuellement connecté au WiFi.

Est-il possible de savoir si les données du réseau mobile sont activées sans interrogation pour savoir si elles sont connectées?

MODIFIER

Donc, lorsque je suis connecté par WiFi Si je vais dans les paramètres et que je désélectionne "Données activées", je le fais dans mon application:

 boolean mob_avail = 
 conMan.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).isAvailable();

mob_avail est retourné comme 'vrai', mais j'ai désactivé les données du réseau mobile, alors je m'attendrais à ce que ce soit 'faux'

Si j'éteins le WiFi, il n'y a (à juste titre) pas de connexion car j'ai désactivé les données du réseau mobile. 

alors, comment vérifier si les données du réseau mobile sont activées lorsque je suis connecté par WiFi?

METTRE À JOUR

J'ai jeté un oeil à getAllNetworkInfo () comme suggéré dans les commentaires de ss1271

J'ai fourni les informations renvoyées sur le réseau mobile dans les 3 conditions suivantes

WiFi Off - Données mobiles sur

WiFi On - Données mobiles désactivées

WiFi On - Données mobiles sur 

et a obtenu les résultats suivants:

Avec WiFi désactivé:

mobile [HSUPA], état: CONNECTED/CONNECTED, motif: inconnu, extra: internet, itinérance: false, basculement: false, isAvailable: true, featureId: -1, userDefault: false

Avec WiFi activé/mobile désactivé

NetworkInfo: type: mobile [HSUPA], état: DISCONNECTED/DISCONNECTED, raison: connectionDisabled, extra: (aucun), itinérance: false, failover: false, isAvailable: true, featureId: -1, userDefault: faux

Avec WiFi activé/mobile activé

NetworkInfo: type: mobile [HSPA], état: DISCONNECTED/DISCONNECTED, raison: connectionDisabled, extra: (aucun), itinérance: false, failover: false, isAvailable: true, featureId: -1, userDefault: faux

Comme vous pouvez le constater, isAvailable est retourné à chaque fois et l’état n’a été indiqué que Déconnecté lorsque le WiFi était actif.

CLARIFICATION

Je suis PAS cherche à savoir si mon téléphone est actuellement connecté au réseau mobile. Je SUIS essaie d'établir si l'utilisateur a activé/désactivé l'accès aux données sur le réseau mobile. Ils peuvent l'activer et le désactiver en accédant à Paramètres -> Paramètres réseau et sans fil -> Paramètres du réseau mobile -> Données activées.

androidnetworkingnetwork-connection
60
Kevin Bradshaw

Le code suivant vous indiquera si "données mobiles" est activé ou non, qu'il y ait ou non une connexion de données mobile en ce moment ou si le wifi est activé ou non. Ce code ne fonctionne que sur Android 2.3 (Gingerbread) et plus tard. En fait, ce code fonctionne également sur les versions antérieures d'Android ;-)

    boolean mobileDataEnabled = false; // Assume disabled
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    try {
        Class cmClass = Class.forName(cm.getClass().getName());
        Method method = cmClass.getDeclaredMethod("getMobileDataEnabled");
        method.setAccessible(true); // Make the method callable
        // get the setting for "mobile data"
        mobileDataEnabled = (Boolean)method.invoke(cm);
    } catch (Exception e) {
        // Some problem accessible private API
        // TODO do whatever error handling you want here
    }

Remarque: vous devez avoir la permission Android.permission.ACCESS_NETWORK_STATE pour pouvoir utiliser ce code.

108
David Wasser

J'ai amélioré la réponse d'Allesio. Mobile_data int de Settings.Secure est passé à Settings.Global depuis 4.2.2.

Essayez ce code lorsque vous voulez savoir si le réseau mobile est activé même lorsque le wifi est activé et connecté.

Mise à jour pour vérifier si la carte SIM est disponible. Merci d'avoir signalé murat.

boolean mobileYN = false;

TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
if (tm.getSimState() == TelephonyManager.SIM_STATE_READY) {
    if(Android.os.Build.VERSION.SDK_INT >= Android.os.Build.VERSION_CODES.JELLY_BEAN_MR1)
    {
        mobileYN = Settings.Global.getInt(context.getContentResolver(), "mobile_data", 1) == 1;
    }
    else{
        mobileYN = Settings.Secure.getInt(context.getContentResolver(), "mobile_data", 1) == 1;
    }
}
29
sNash

Une solution consiste à vérifier si l'utilisateur a activé les données mobiles dans les paramètres, ce qui sera le plus souvent utilisé si le wifi est désactivé . dans l'API:

boolean mobileDataAllowed = Settings.Secure.getInt(getContentResolver(), "mobile_data", 1) == 1;

En fonction de l'API, vous devez vérifier Settings.Global au lieu de Settings.Secure, comme indiqué par @ user1444325.

Source: Appel de l'API Android pour déterminer le paramètre utilisateur "Données activées"

21
Alessio

La fonction de @ sNash fonctionne très bien. Mais dans quelques appareils, j'ai trouvé que cela retournait vrai même si les données étaient désactivées ... J'ai donc trouvé une solution alternative dans l'API Android.

getDataState () méthode de TelephonyManager sera très utile.

J'ai mis à jour la fonction de @ snash avec la fonction ci-dessus utilisée. La fonction ci-dessous renvoie false lorsque les données cellulaires sont désactivées, sinon true.

private boolean checkMobileDataIsEnabled(Context context){
        boolean mobileYN = false;

        TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        if (tm.getSimState() == TelephonyManager.SIM_STATE_READY) {
            TelephonyManager tel = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
//          if(Android.os.Build.VERSION.SDK_INT >= Android.os.Build.VERSION_CODES.JELLY_BEAN_MR1)
//          {
//              mobileYN = Settings.Global.getInt(context.getContentResolver(), "mobile_data", 0) == 1;
//          }
//          else{
//              mobileYN = Settings.Secure.getInt(context.getContentResolver(), "mobile_data", 0) == 1;
//          }
            int dataState = tel.getDataState();
            Log.v(TAG,"tel.getDataState() : "+ dataState);
            if(dataState != TelephonyManager.DATA_DISCONNECTED){
                mobileYN = true;
            }

        }

        return mobileYN;
    }
3
MohK

Vous pouvez essayer quelque chose comme ça:

ConnectivityManager conMan = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

//mobile
State mobile = conMan.getNetworkInfo(0).getState();

//wifi
State wifi = conMan.getNetworkInfo(1).getState();


if (mobile == NetworkInfo.State.CONNECTED || mobile == NetworkInfo.State.CONNECTING) 
{
    //mobile
}
else if (wifi == NetworkInfo.State.CONNECTED || wifi == NetworkInfo.State.CONNECTING) 
{
    //wifi
}

Si vous êtes intéressé si vous êtes vraiment connecté, utilisez

NetworkInfo.State.CONNECTED

seulement, au lieu de 

NetworkInfo.State.CONNECTED || NetworkInfo.State.CONNECTING
2
Miloš

Je pense que l'utilisation de la classe NetworkInfo et isConnected devrait fonctionner:

ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);

return info != NULL || info.isConnected();

Et pour vérifier les données mobiles est peut-être connecté. Je ne peux pas être sûr jusqu'à ce que je le teste. Ce que je ne peux pas faire avant demain.

TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

if(tm .getDataState() == tm .DATA_CONNECTED)
   return true;
0
tozka
To identify which SIM or slot is making data connection active in mobile, we need to register action Android:name="Android.net.conn.CONNECTIVITY_CHANGE"  with permission   
uses-permission Android:name="Android.permission.CONNECTIVITY_INTERNAL" &    uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE"

    public void onReceive(Context context, Intent intent) 
 if (Android.net.conn.CONNECTIVITY_CHANGE.equalsIgnoreCase(intent
                .getAction())) {

IBinder b = ServiceManager.getService(Context.CONNECTIVITY_SERVICE);
 IConnectivityManager service =  IConnectivityManager.Stub.asInterface(b);
NetworkState[] states = service.getAllNetworkState();

 for (NetworkState state : states) {

                if (state.networkInfo.getType() == ConnectivityManager.TYPE_MOBILE
                        && state.networkInfo.isConnected()) {

 TelephonyManager mTelephonyManager = (TelephonyManager) context
                        .getSystemService(Context.TELEPHONY_SERVICE);
         int slotList =  { 0, 1 };
          int[] subId = SubscriptionManager.getSubId(slotList[0]);
          if(mTelephonyManager.getDataEnabled(subId[0])) {
             // this means data connection is active for SIM1 similary you 
             //can chekc for SIM2 by slotList[1]
               .................
          }
}

}
0
amit

Vous devez utiliser ConnectivityManager et les détails de NetworkInfo sont disponibles ici

0
CAM-Dev

Voici une solution simple issue de deux autres réponses:

        TelephonyManager tm = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            return tm.isDataEnabled();

        } else {
            return tm.getSimState() == TelephonyManager.SIM_STATE_READY && tm.getDataState() != TelephonyManager.DATA_DISCONNECTED;
        }
0
Brian Hong
private boolean haveMobileNetworkConnection() {
        boolean haveConnectedMobile = false;

        ConnectivityManager cm = (ConnectivityManager) getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo[] netInfo = cm.getAllNetworkInfo();

        for (NetworkInfo ni : netInfo) {

            if (ni.getTypeName().equalsIgnoreCase("MOBILE"))
                if (ni.isConnected())
                    haveConnectedMobile = true;
        }
        return haveConnectedMobile;
    }

Remarque: vous devez avoir la permission Android.permission.ACCESS_NETWORK_STATE pour pouvoir utiliser ce code.

0
Annas Bin Waheed

utiliser TelephonyManager

TelephonyManager tm = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);

tm.isDataEnabled()

Selon la documentation Android

https://developer.Android.com/reference/Android/telephony/TelephonyManager.html#isDataEnabled ()

0
Ralph Chen
    ConnectivityManager cm = (ConnectivityManager) activity
                        .getSystemService(Context.CONNECTIVITY_SERVICE);
                NetworkInfo info = cm.getActiveNetworkInfo();
                String networkType = "";
    if (info.getType() == ConnectivityManager.TYPE_WIFI) {
                    networkType = "WIFI";
                } 
else if (info.getType() == ConnectivityManager.TYPE_MOBILE) {

                    networkType = "mobile";
    }
0
Srishti Roy

Selon la documentation Android https://developer.Android.com/training/monitoring-device-state/connectivity-monitoring#Java

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

NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean isConnected = activeNetwork != null &&
                      activeNetwork.isConnectedOrConnecting();
0
Rémy

Voici une solution xamarin à ce problème:

    public static bool IsMobileDataEnabled()
    {
        bool result = false;

        try
        {
            Context context = //get your context here or pass it as a param

            if (Build.VERSION.SdkInt >= BuildVersionCodes.JellyBeanMr1)
            {
                //Settings comes from the namespace Android.Provider
                result = Settings.Global.GetInt(context.ContentResolver, "mobile_data", 1) == 1;
            }
            else
            {
                result = Settings.Secure.GetInt(context.ContentResolver, "mobile_data", 1) == 1;
            }
        }
        catch (Exception ex)
        {
            //handle exception
        }

        return result;
    }

PS: Assurez-vous que vous avez toutes les autorisations pour ce code.

0
SubqueryCrunch

Eh bien, il existe une solution de contournement pour vérifier si la connexion de données est activée. Mais je ne suis pas sûr que cela fonctionne sur tous les appareils. Vous devez vérifier cela. (Cela fonctionnait sur Android un appareil)

long data = TrafficStats.getMobileRxBytes();
if(data > 0){
    //Data is On
}
else{
    //Data is Off
}

Si vous ne connaissez pas cette méthode, elle renvoie le nombre total d'octets reçus sur le réseau mobile depuis le démarrage du périphérique. Lorsque vous désactivez la connexion de données mobiles, elle renvoie zéro (0). Lorsque vous allumez, le nombre total d'octets sera renvoyé. Mais vous devez savoir qu’un problème peut survenir lors de l’utilisation de cette solution de contournement.

  • Cette méthode renvoie également 0 lorsque vous redémarrez le téléphone, car le calcul commence à 0 octet.
0
Thamidu de Harshitha