Android getAllNetworkInfo () est déprécié. Quelle est l'alternative?

quand je mets à jour mon code obsolète et que je veux encore prendre en charge L'Api backward. j'utilise ceci :

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.WANTED API VERSION){
//code
}else{
//code
}

de cette façon, chaque appareil utilise le code approprié. Exemple:

public class ConnectionDetector {

    private Context mContext;

    public ConnectionDetector(Context context) {
        this.mContext = context;
    }
    /**
     * Checking for all possible internet providers
     * **/
    public boolean isConnectingToInternet() {
        ConnectivityManager connectivityManager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            Network[] networks = connectivityManager.getAllNetworks();
            NetworkInfo networkInfo;
            for (Network mNetwork : networks) {
                networkInfo = connectivityManager.getNetworkInfo(mNetwork);
                if (networkInfo.getState().equals(NetworkInfo.State.CONNECTED)) {
                    return true;
                }
            }
        }else {
            if (connectivityManager != null) {
                //noinspection deprecation
                NetworkInfo[] info = connectivityManager.getAllNetworkInfo();
                if (info != null) {
                    for (NetworkInfo anInfo : info) {
                        if (anInfo.getState() == NetworkInfo.State.CONNECTED) {
                            LogUtils.d("Network",
                                    "NETWORKNAME: " + anInfo.getTypeName());
                            return true;
                        }
                    }
                }
            }
        }
        Toast.makeText(mContext,mContext.getString(R.string.please_connect_to_internet),Toast.LENGTH_SHORT).show();
        return false;
    }
}

j'ai fait des utils qui peuvent vous aider à vérifier:

• si le réseau est connecté.
• si WiFi est connecté.
• si les données mobiles sont connectées.

il utilise une API ancienne ou nouvelle en fonction de la plate-forme d'exécution:

import android.annotation.TargetApi;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkInfo;
import android.os.Build;
import android.support.annotation.NonNull;

public class NetworkUtils {

public static boolean isConnected(@NonNull Context context) {
    ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
    return (networkInfo != null && networkInfo.isConnected());
}

public static boolean isWifiConnected(@NonNull Context context) {
    return isConnected(context, ConnectivityManager.TYPE_WIFI);
}

public static boolean isMobileConnected(@NonNull Context context) {
    return isConnected(context, ConnectivityManager.TYPE_MOBILE);
}

private static boolean isConnected(@NonNull Context context, int type) {
    ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
        NetworkInfo networkInfo = connMgr.getNetworkInfo(type);
        return networkInfo != null && networkInfo.isConnected();
    } else {
        return isConnected(connMgr, type);
    }
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private static boolean isConnected(@NonNull ConnectivityManager connMgr, int type) {
    Network[] networks = connMgr.getAllNetworks();
    NetworkInfo networkInfo;
    for (Network mNetwork : networks) {
        networkInfo = connMgr.getNetworkInfo(mNetwork);
        if (networkInfo != null && networkInfo.getType() == type && networkInfo.isConnected()) {
            return true;
        }
    }
    return false;
}
}

mise à jour:

Plus d'informations sur @TargetApi et @RequiresApi : https://stackoverflow.com/a/40008157/421467 https://developer.android.com/reference/kotlin/androidx/annotation/RequiresApi

Pour quelqu'un a besoin de Kotlin version (ci-Dessous est le même code avec Maor Hadad)

fun Context.isNetworkConnected(): Boolean {
  val manager = getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    val allNetworks = manager?.allNetworks?.let { it } ?: return false
    allNetworks.forEach { network ->
      val info = manager.getNetworkInfo(network)
      if (info.state == NetworkInfo.State.CONNECTED) return true
    }
  } else {
    val allNetworkInfo = manager?.allNetworkInfo?.let { it } ?: return false
    allNetworkInfo.forEach { info ->
      if (info.state == NetworkInfo.State.CONNECTED) return true
    }
  }
  return false
}

ce code est une méthode d'extension de contexte.

notez ce code dans n'importe quel fichier kotlin(.kt), alors vous pouvez utiliser cette méthode dans toute classe qui implémente Contexte(comme l'Activité).

essayez le code suivant:

ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);    
    Network[] networks = connectivityManager.getAllNetworks();
    NetworkInfo networkInfo;
    Network network;
        for (int i = 0; i < networks.length; i++){               
            network = networks[i];
            networkInfo = connectivityManager.getNetworkInfo(network);
            if ((networkInfo.getType() ==     ConnectivityManager.TYPE_WIFI) && (networkInfo.getState().equals(NetworkInfo.State.CONNECTED))) {
               ConnectivityManager.setProcessDefaultNetwork(network);
                break;
            }
        }

Essayez cette

    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        Network[] networks=cm.getAllNetworks();
        if (cm != null) {
        for (Network netinfo : networks) {
            NetworkInfo ni = cm.getNetworkInfo(netinfo);
            if (ni.isConnected() && ni.isAvailable()) {
                    connected = true;
                }
            }
        }

essayez celui-ci .C'est la manière la plus simple.

public static boolean isNetworkAvailable(Activity activity) {  
        ConnectivityManager connectivity = (ConnectivityManager) activity.getSystemService(Context.CONNECTIVITY_SERVICE);  
        if (connectivity == null) {  
            return false;  
        } else {  
            NetworkInfo[] info = connectivity.getAllNetworkInfo();  
            if (info != null) {  
                for (int i = 0; i < info.length; i++) {  
                    if (info[i].getState() == NetworkInfo.State.CONNECTED) {  
                        return true;  
                    }  
                }  
            }  
        }  
        return false;  
    }  
}