Risposte:
Se il problema è scoprire se la rete del telefono è connessa e abbastanza veloce da soddisfare le tue esigenze, devi gestire tutti i tipi di rete restituiti getSubType()
.
Mi ci sono voluti un'ora o due per cercare e scrivere questo corso per fare esattamente questo, e ho pensato di condividerlo con altri che lo avrebbero trovato utile.
Ecco una sintesi della classe , quindi puoi biforcarla e modificarla.
package com.emil.android.util;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.telephony.TelephonyManager;
/**
* Check device's network connectivity and speed
* @author emil http://stackoverflow.com/users/220710/emil
*
*/
public class Connectivity {
/**
* Get the network info
* @param context
* @return
*/
public static NetworkInfo getNetworkInfo(Context context){
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
return cm.getActiveNetworkInfo();
}
/**
* Check if there is any connectivity
* @param context
* @return
*/
public static boolean isConnected(Context context){
NetworkInfo info = Connectivity.getNetworkInfo(context);
return (info != null && info.isConnected());
}
/**
* Check if there is any connectivity to a Wifi network
* @param context
* @return
*/
public static boolean isConnectedWifi(Context context){
NetworkInfo info = Connectivity.getNetworkInfo(context);
return (info != null && info.isConnected() && info.getType() == ConnectivityManager.TYPE_WIFI);
}
/**
* Check if there is any connectivity to a mobile network
* @param context
* @return
*/
public static boolean isConnectedMobile(Context context){
NetworkInfo info = Connectivity.getNetworkInfo(context);
return (info != null && info.isConnected() && info.getType() == ConnectivityManager.TYPE_MOBILE);
}
/**
* Check if there is fast connectivity
* @param context
* @return
*/
public static boolean isConnectedFast(Context context){
NetworkInfo info = Connectivity.getNetworkInfo(context);
return (info != null && info.isConnected() && Connectivity.isConnectionFast(info.getType(),info.getSubtype()));
}
/**
* Check if the connection is fast
* @param type
* @param subType
* @return
*/
public static boolean isConnectionFast(int type, int subType){
if(type==ConnectivityManager.TYPE_WIFI){
return true;
}else if(type==ConnectivityManager.TYPE_MOBILE){
switch(subType){
case TelephonyManager.NETWORK_TYPE_1xRTT:
return false; // ~ 50-100 kbps
case TelephonyManager.NETWORK_TYPE_CDMA:
return false; // ~ 14-64 kbps
case TelephonyManager.NETWORK_TYPE_EDGE:
return false; // ~ 50-100 kbps
case TelephonyManager.NETWORK_TYPE_EVDO_0:
return true; // ~ 400-1000 kbps
case TelephonyManager.NETWORK_TYPE_EVDO_A:
return true; // ~ 600-1400 kbps
case TelephonyManager.NETWORK_TYPE_GPRS:
return false; // ~ 100 kbps
case TelephonyManager.NETWORK_TYPE_HSDPA:
return true; // ~ 2-14 Mbps
case TelephonyManager.NETWORK_TYPE_HSPA:
return true; // ~ 700-1700 kbps
case TelephonyManager.NETWORK_TYPE_HSUPA:
return true; // ~ 1-23 Mbps
case TelephonyManager.NETWORK_TYPE_UMTS:
return true; // ~ 400-7000 kbps
/*
* Above API level 7, make sure to set android:targetSdkVersion
* to appropriate level to use these
*/
case TelephonyManager.NETWORK_TYPE_EHRPD: // API level 11
return true; // ~ 1-2 Mbps
case TelephonyManager.NETWORK_TYPE_EVDO_B: // API level 9
return true; // ~ 5 Mbps
case TelephonyManager.NETWORK_TYPE_HSPAP: // API level 13
return true; // ~ 10-20 Mbps
case TelephonyManager.NETWORK_TYPE_IDEN: // API level 8
return false; // ~25 kbps
case TelephonyManager.NETWORK_TYPE_LTE: // API level 11
return true; // ~ 10+ Mbps
// Unknown
case TelephonyManager.NETWORK_TYPE_UNKNOWN:
default:
return false;
}
}else{
return false;
}
}
}
Assicurati inoltre di aggiungere questa autorizzazione al tuo AndroidManifest.xml
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
Le fonti per la velocità della rete includono wikipedia e http://3gstore.com/page/78_what_is_evdo_mobile_broadband.html
targetSdkVersion
impostazione. Ho modificato il post per rimuovere l'hack, grazie.
Per ottenere informazioni più precise (e intuitive) sul tipo di connessione. È possibile utilizzare questo codice (derivato da un metodo @hide in TelephonyManager.java ).
Questo metodo restituisce una stringa che descrive il tipo di connessione corrente.
vale a dire uno di: "WIFI", "2G", "3G", "4G", "5G", "-" (non collegato) o "?" (sconosciuto)
Nota: questo codice richiede API 25+, ma è possibile supportare facilmente le versioni precedenti utilizzando int anziché const. (Vedi commenti nel codice).
public static String getNetworkClass(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = cm.getActiveNetworkInfo();
if (info == null || !info.isConnected())
return "-"; // not connected
if (info.getType() == ConnectivityManager.TYPE_WIFI)
return "WIFI";
if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
int networkType = info.getSubtype();
switch (networkType) {
case TelephonyManager.NETWORK_TYPE_GPRS:
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_1xRTT:
case TelephonyManager.NETWORK_TYPE_IDEN: // api< 8: replace by 11
case TelephonyManager.NETWORK_TYPE_GSM: // api<25: replace by 16
return "2G";
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_EVDO_B: // api< 9: replace by 12
case TelephonyManager.NETWORK_TYPE_EHRPD: // api<11: replace by 14
case TelephonyManager.NETWORK_TYPE_HSPAP: // api<13: replace by 15
case TelephonyManager.NETWORK_TYPE_TD_SCDMA: // api<25: replace by 17
return "3G";
case TelephonyManager.NETWORK_TYPE_LTE: // api<11: replace by 13
case TelephonyManager.NETWORK_TYPE_IWLAN: // api<25: replace by 18
case 19: // LTE_CA
return "4G";
case TelephonyManager.NETWORK_TYPE_NR: // api<29: replace by 20
return "5G";
default:
return "?";
}
}
return "?";
}
Puoi usare getSubtype () per maggiori dettagli. Dai un'occhiata alla diapositiva 9 qui: http://dl.google.com/io/2009/pres/W_0300_CodingforLife-BatteryLifeThatIs.pdf
ConnectivityManager mConnectivity = null;
TelephonyManager mTelephony = null;
// Skip if no connection, or background data disabled
NetworkInfo info = mConnectivity.getActiveNetworkInfo();
if (info == null || !mConnectivity.getBackgroundDataSetting()) {
return false;
}
// Only update if WiFi or 3G is connected and not roaming
int netType = info.getType();
int netSubtype = info.getSubtype();
if (netType == ConnectivityManager.TYPE_WIFI) {
return info.isConnected();
} else if (netType == ConnectivityManager.TYPE_MOBILE
&& netSubtype == TelephonyManager.NETWORK_TYPE_UMTS
&& !mTelephony.isNetworkRoaming()) {
return info.isConnected();
} else {
return false;
}
Inoltre, controlla la risposta di Emil per un'immersione più dettagliata in questo.
@ La risposta di Emil sopra è brillante.
Piccola aggiunta: dovremmo idealmente usare TelephonyManager per rilevare i tipi di rete. Quindi quanto sopra dovrebbe invece leggere:
/**
* Check if there is fast connectivity
* @param context
* @return
*/
public static boolean isConnectedFast(Context context){
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = cm.getActiveNetworkInfo();
TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
return (info != null && info.isConnected() && Connectivity.isConnectionFast(info.getType(), tm.getNetworkType()));
}
La risposta di Emil Davtyan è buona, ma sono stati aggiunti tipi di rete che non sono stati considerati nella sua risposta. Quindi, isConnectionFast(int type, int subType)
può restituire falso quando dovrebbe essere vero.
Ecco una classe modificata che utilizza la reflection per tenere conto dei tipi di rete aggiunti nelle API successive:
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.telephony.TelephonyManager;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* <p>Utility methods to check the current network connection status.</p>
*
* <p>This requires the caller to hold the permission
* {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.</p>
*/
public class NetworkUtils {
/** The absence of a connection type. */
public static final int TYPE_NONE = -1;
/** Unknown network class. */
public static final int NETWORK_CLASS_UNKNOWN = 0;
/** Class of broadly defined "2G" networks. */
public static final int NETWORK_CLASS_2_G = 1;
/** Class of broadly defined "3G" networks. */
public static final int NETWORK_CLASS_3_G = 2;
/** Class of broadly defined "4G" networks. */
public static final int NETWORK_CLASS_4_G = 3;
/**
* Returns details about the currently active default data network. When connected, this network
* is the default route for outgoing connections. You should always check {@link
* NetworkInfo#isConnected()} before initiating network traffic. This may return {@code null}
* when there is no default network.
*
* @return a {@link NetworkInfo} object for the current default network or {@code null} if no
* network default network is currently active
*
* This method requires the call to hold the permission
* {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.
* @see ConnectivityManager#getActiveNetworkInfo()
*/
public static NetworkInfo getInfo(Context context) {
return ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE))
.getActiveNetworkInfo();
}
/**
* Reports the current network type.
*
* @return {@link ConnectivityManager#TYPE_MOBILE}, {@link ConnectivityManager#TYPE_WIFI} ,
* {@link ConnectivityManager#TYPE_WIMAX}, {@link ConnectivityManager#TYPE_ETHERNET}, {@link
* ConnectivityManager#TYPE_BLUETOOTH}, or other types defined by {@link ConnectivityManager}.
* If there is no network connection then -1 is returned.
* @see NetworkInfo#getType()
*/
public static int getType(Context context) {
NetworkInfo info = getInfo(context);
if (info == null || !info.isConnected()) {
return TYPE_NONE;
}
return info.getType();
}
/**
* Return a network-type-specific integer describing the subtype of the network.
*
* @return the network subtype
* @see NetworkInfo#getSubtype()
*/
public static int getSubType(Context context) {
NetworkInfo info = getInfo(context);
if (info == null || !info.isConnected()) {
return TYPE_NONE;
}
return info.getSubtype();
}
/** Returns the NETWORK_TYPE_xxxx for current data connection. */
public static int getNetworkType(Context context) {
return ((TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE))
.getNetworkType();
}
/** Check if there is any connectivity */
public static boolean isConnected(Context context) {
return getType(context) != TYPE_NONE;
}
/** Check if there is any connectivity to a Wifi network */
public static boolean isWifiConnection(Context context) {
NetworkInfo info = getInfo(context);
if (info == null || !info.isConnected()) {
return false;
}
switch (info.getType()) {
case ConnectivityManager.TYPE_WIFI:
return true;
default:
return false;
}
}
/** Check if there is any connectivity to a mobile network */
public static boolean isMobileConnection(Context context) {
NetworkInfo info = getInfo(context);
if (info == null || !info.isConnected()) {
return false;
}
switch (info.getType()) {
case ConnectivityManager.TYPE_MOBILE:
return true;
default:
return false;
}
}
/** Check if the current connection is fast. */
public static boolean isConnectionFast(Context context) {
NetworkInfo info = getInfo(context);
if (info == null || !info.isConnected()) {
return false;
}
switch (info.getType()) {
case ConnectivityManager.TYPE_WIFI:
case ConnectivityManager.TYPE_ETHERNET:
return true;
case ConnectivityManager.TYPE_MOBILE:
int networkClass = getNetworkClass(getNetworkType(context));
switch (networkClass) {
case NETWORK_CLASS_UNKNOWN:
case NETWORK_CLASS_2_G:
return false;
case NETWORK_CLASS_3_G:
case NETWORK_CLASS_4_G:
return true;
}
default:
return false;
}
}
private static int getNetworkClassReflect(int networkType)
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Method getNetworkClass = TelephonyManager.class.getDeclaredMethod("getNetworkClass", int.class);
if (!getNetworkClass.isAccessible()) {
getNetworkClass.setAccessible(true);
}
return (int) getNetworkClass.invoke(null, networkType);
}
/**
* Return general class of network type, such as "3G" or "4G". In cases where classification is
* contentious, this method is conservative.
*/
public static int getNetworkClass(int networkType) {
try {
return getNetworkClassReflect(networkType);
} catch (Exception ignored) {
}
switch (networkType) {
case TelephonyManager.NETWORK_TYPE_GPRS:
case 16: // TelephonyManager.NETWORK_TYPE_GSM:
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_1xRTT:
case TelephonyManager.NETWORK_TYPE_IDEN:
return NETWORK_CLASS_2_G;
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_EVDO_B:
case TelephonyManager.NETWORK_TYPE_EHRPD:
case TelephonyManager.NETWORK_TYPE_HSPAP:
case 17: // TelephonyManager.NETWORK_TYPE_TD_SCDMA:
return NETWORK_CLASS_3_G;
case TelephonyManager.NETWORK_TYPE_LTE:
case 18: // TelephonyManager.NETWORK_TYPE_IWLAN:
return NETWORK_CLASS_4_G;
default:
return NETWORK_CLASS_UNKNOWN;
}
}
private NetworkUtils() {
throw new AssertionError();
}
}
if (NetworkUtils.isWifiConnection(this) { /* do stuff */ }
È possibile creare un metodo personalizzato per eseguire questa attività.
public String getNetworkClass(Context context) {
TelephonyManager mTelephonyManager = (TelephonyManager)
context.getSystemService(Context.TELEPHONY_SERVICE);
int networkType = mTelephonyManager.getNetworkType();
switch (networkType) {
case TelephonyManager.NETWORK_TYPE_GPRS:
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_1xRTT:
case TelephonyManager.NETWORK_TYPE_IDEN:
return "2G";
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_EVDO_B:
case TelephonyManager.NETWORK_TYPE_EHRPD:
case TelephonyManager.NETWORK_TYPE_HSPAP:
return "3G";
case TelephonyManager.NETWORK_TYPE_LTE:
return "4G";
default:
return "Unknown";
}
}
Oltre alla terribile risposta di Emil, vorrei aggiungere un altro metodo, per verificare se si dispone effettivamente dell'accesso a Internet in quanto è possibile disattivare i dati sul telefono.
public static boolean hasInternetAccess(Context c){
TelephonyManager tm = (TelephonyManager) c.getSystemService(Context.TELEPHONY_SERVICE);
if(isConnected(c) && tm.getDataState() == TelephonyManager.DATA_CONNECTED)
return true;
else
return false;
}
Nota che questo serve solo per verificare se esiste una connessione dati cellulare e restituirà falso se hai WiFi connesso, poiché i dati cellulari sono spenti quando il WiFi è connesso.
Puoi controllare in questo modo
public void checktype() {
ConnectivityManager cm = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null) { // connected to the internet
if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
// connected to wifi
Toast.makeText(this, activeNetwork.getTypeName(), Toast.LENGTH_SHORT).show();
} else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
// connected to the mobile provider's data plan
Toast.makeText(this, activeNetwork.getTypeName(), Toast.LENGTH_SHORT).show();
}
}
}
Attualmente sono supportati solo MOBILE e WIFI. Dai un'occhiata e funzione di tipo leggibile dall'uomo .
Puoi provare questo:
public String ConnectionQuality() {
NetworkInfo info = getInfo(context);
if (info == null || !info.isConnected()) {
return "UNKNOWN";
}
if(info.getType() == ConnectivityManager.TYPE_WIFI) {
WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
int numberOfLevels = 5;
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
int level = WifiManager.calculateSignalLevel(wifiInfo.getRssi(), numberOfLevels);
if(level == 2 )
return "POOR";
else if(level == 3 )
return "MODERATE";
else if(level == 4 )
return "GOOD";
else if(level == 5 )
return "EXCELLENT";
else
return "UNKNOWN";
}else if(info.getType() == ConnectivityManager.TYPE_MOBILE) {
int networkClass = getNetworkClass(getNetworkType(context));
if(networkClass == 1)
return "POOR";
else if(networkClass == 2 )
return "GOOD";
else if(networkClass == 3 )
return "EXCELLENT";
else
return "UNKNOWN";
}else
return "UNKNOWN";
}
public NetworkInfo getInfo(Context context) {
return ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
}
public int getNetworkClass(int networkType) {
try {
return getNetworkClassReflect(networkType);
}catch (Exception ignored) {
}
switch (networkType) {
case TelephonyManager.NETWORK_TYPE_GPRS:
case 16: // TelephonyManager.NETWORK_TYPE_GSM:
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_1xRTT:
case TelephonyManager.NETWORK_TYPE_IDEN:
return 1;
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_EVDO_B:
case TelephonyManager.NETWORK_TYPE_EHRPD:
case TelephonyManager.NETWORK_TYPE_HSPAP:
case 17: // TelephonyManager.NETWORK_TYPE_TD_SCDMA:
return 2;
case TelephonyManager.NETWORK_TYPE_LTE:
case 18: // TelephonyManager.NETWORK_TYPE_IWLAN:
return 3;
default:
return 0;
}
}
private int getNetworkClassReflect(int networkType) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Method getNetworkClass = TelephonyManager.class.getDeclaredMethod("getNetworkClass", int.class);
if (!getNetworkClass.isAccessible()) {
getNetworkClass.setAccessible(true);
}
return (Integer) getNetworkClass.invoke(null, networkType);
}
public static int getNetworkType(Context context) {
return ((TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE)).getNetworkType();
}
Rileva il tipo di rete e ottieni il valore booleano di isconnected o non utilizzalo sotto lo snippet
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.telephony.TelephonyManager;
public class NetworkManagerUtils {
/**
* Get the network info
* @param context
* @return
*/
public static NetworkInfo getNetworkInfo(Context context){
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
return cm.getActiveNetworkInfo();
}
/**
* Check if there is any connectivity
* @param context
* @return
*/
public static boolean isConnected(Context context){
NetworkInfo info = NetworkManagerUtils.getNetworkInfo(context);
return (info != null && info.isConnected());
}
/**
* Check if there is any connectivity to a Wifi network
* @param context.
* @param type
* @return
*/
public static boolean isConnectedWifi(Context context){
NetworkInfo info = NetworkManagerUtils.getNetworkInfo(context);
return (info != null && info.isConnected() && info.getType() == ConnectivityManager.TYPE_WIFI);
}
/**
* Check if there is any connectivity to a mobile network
* @param context
* @param type
* @return
*/
public static boolean isConnectedMobile(Context context){
NetworkInfo info = NetworkManagerUtils.getNetworkInfo(context);
return (info != null && info.isConnected() && info.getType() == ConnectivityManager.TYPE_MOBILE);
}
/**
* Check if there is fast connectivity
* @param context
* @return
*/
public static boolean isConnectedFast(Context context){
NetworkInfo info = NetworkManagerUtils.getNetworkInfo(context);
return (info != null && info.isConnected() && NetworkManagerUtils.isConnectionFast(info.getType(),info.getSubtype()));
}
/**
* Check if the connection is fast
* @param type
* @param subType
* @return
*/
public static boolean isConnectionFast(int type, int subType){
if(type== ConnectivityManager.TYPE_WIFI){
return true;
}else if(type==ConnectivityManager.TYPE_MOBILE){
switch(subType){
case TelephonyManager.NETWORK_TYPE_1xRTT:
return false; // ~ 50-100 kbps
case TelephonyManager.NETWORK_TYPE_CDMA:
return false; // ~ 14-64 kbps
case TelephonyManager.NETWORK_TYPE_EDGE:
return false; // ~ 50-100 kbps
case TelephonyManager.NETWORK_TYPE_EVDO_0:
return true; // ~ 400-1000 kbps
case TelephonyManager.NETWORK_TYPE_EVDO_A:
return true; // ~ 600-1400 kbps
case TelephonyManager.NETWORK_TYPE_GPRS:
return false; // ~ 100 kbps
case TelephonyManager.NETWORK_TYPE_HSDPA:
return true; // ~ 2-14 Mbps
case TelephonyManager.NETWORK_TYPE_HSPA:
return true; // ~ 700-1700 kbps
case TelephonyManager.NETWORK_TYPE_HSUPA:
return true; // ~ 1-23 Mbps
case TelephonyManager.NETWORK_TYPE_UMTS:
return true; // ~ 400-7000 kbps
/*
* Above API level 7, make sure to set android:targetSdkVersion
* to appropriate level to use these
*/
case TelephonyManager.NETWORK_TYPE_EHRPD: // API level 11
return true; // ~ 1-2 Mbps
case TelephonyManager.NETWORK_TYPE_EVDO_B: // API level 9
return true; // ~ 5 Mbps
case TelephonyManager.NETWORK_TYPE_HSPAP: // API level 13
return true; // ~ 10-20 Mbps
case TelephonyManager.NETWORK_TYPE_IDEN: // API level 8
return false; // ~25 kbps
case TelephonyManager.NETWORK_TYPE_LTE: // API level 11
return true; // ~ 10+ Mbps
// Unknown
case TelephonyManager.NETWORK_TYPE_UNKNOWN:
default:
return false;
}
}else{
return false;
}
}
public static String getNetworkClass(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = cm.getActiveNetworkInfo();
if (info == null || !info.isConnected())
return "-"; // not connected
if (info.getType() == ConnectivityManager.TYPE_WIFI)
return "WIFI";
if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
int networkType = info.getSubtype();
switch (networkType) {
case TelephonyManager.NETWORK_TYPE_GPRS:
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_1xRTT:
case TelephonyManager.NETWORK_TYPE_IDEN: // api< 8: replace by 11
case TelephonyManager.NETWORK_TYPE_GSM: // api<25: replace by 16
return "2G";
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_EVDO_B: // api< 9: replace by 12
case TelephonyManager.NETWORK_TYPE_EHRPD: // api<11: replace by 14
case TelephonyManager.NETWORK_TYPE_HSPAP: // api<13: replace by 15
case TelephonyManager.NETWORK_TYPE_TD_SCDMA: // api<25: replace by 17
return "3G";
case TelephonyManager.NETWORK_TYPE_LTE: // api<11: replace by 13
case TelephonyManager.NETWORK_TYPE_IWLAN: // api<25: replace by 18
case 19: // LTE_CA
return "4G";
default:
return "?";
}
}
return "?";
}
}
utilizzare questo seguendo la classe passare il contesto si otterrà lo stato della rete come tipo di rete, rete veloce, ecc.
Di seguito sono indicati diversi modi per farlo. Si noti che ci sono molti tipi di rete nella classe ConnectivityManager. Inoltre, se API> = 21, è possibile controllare i tipi di rete nella classe NetworkCapabilities.
ConnectivityMonitor connectivityMonitor = ConnectivityMonitor.getInstance(this);
boolean isWiFiConnected = connectivityMonitor.isWifiConnection();
boolean isMobileConnected = connectivityMonitor.isConnected(ConnectivityManager.TYPE_MOBILE);
Log.e(TAG, "onCreate: isWiFiConnected " + isWiFiConnected);
Log.e(TAG, "onCreate: isMobileConnected " + isMobileConnected);
ConnectivityMonitor.Listener connectivityListener = new ConnectivityMonitor.Listener() {
@Override
public void onConnectivityChanged(boolean connected, @Nullable NetworkInfo networkInfo) {
Log.e(TAG, "onConnectivityChanged: connected " + connected);
Log.e(TAG, "onConnectivityChanged: networkInfo " + networkInfo);
if (networkInfo != null) {
boolean isWiFiConnected = networkInfo.getType() == NetworkCapabilities.TRANSPORT_WIFI;
boolean isMobileConnected = networkInfo.getType() == NetworkCapabilities.TRANSPORT_CELLULAR;
Log.e(TAG, "onConnectivityChanged: isWiFiConnected " + isWiFiConnected);
Log.e(TAG, "onConnectivityChanged: isMobileConnected " + isMobileConnected);
}
}
};
connectivityMonitor.addListener(connectivityListener);
public static final int
. Quindi non è necessario eseguire "l'hacking". Semplicemente indirizzato al SDK più recente, il compilatore compila i valori reali (numeri interi) a cui puntano (non le loro istanze) in bytecode.