इस उत्तर के लिए मार्च 2020 तक अपडेट है जो API.29 के माध्यम से API.15 का समर्थन करता है, आप इसे मूल उत्तर के बाद पा सकते हैं
उत्तर फरवरी 2019
यह जांचने के लिए कि क्या आप ऑनलाइन हैं:
boolean isOnline() {
// Checking internet connectivity
ConnectivityManager connectivityMgr = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = null;
if (connectivityMgr != null) {
activeNetwork = connectivityMgr.getActiveNetworkInfo();
}
return activeNetwork != null;
}
Android M से पहले / बाद में इंटरनेट कनेक्टिविटी का प्रकार प्राप्त करने के लिए
void internetType() {
// Checking internet connectivity
ConnectivityManager connectivityMgr = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = null;
if (connectivityMgr != null) {
activeNetwork = connectivityMgr.getActiveNetworkInfo();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
NetworkCapabilities nc = connectivityMgr.getNetworkCapabilities(connectivityMgr.getActiveNetwork());
if (nc.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
// connected to mobile data
} else if (nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
// connected to wifi
}
} else {
if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
// connected to wifi
} else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
// connected to mobile data
}
}
}
}
सभी मामलों में नेटवर्क स्थिति तक पहुंचने के लिए अनुमति की आवश्यकता होती है
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
अद्यतन मार्च 2020
के रूप NetworkInfoमें पदावनत किया गया है और अब से एपीआई 29 के रूप में हमें ConnectivityManager.NetworkCallbackइसके नेटवर्क स्थिति परिवर्तन onAvailable()और onLost()कॉलबैक के साथ उपयोग करना है ।
उपयोग:
- आप या तो इस पुस्तकालय का उपयोग कर सकते हैं , या सीधे नीचे दिए गए उपयोगिता वर्ग का उपयोग कर सकते हैं जो इस पुस्तकालय का एक हिस्सा है।
विशेषताएं
- यह विधि
LifecycleObserverमें कुछ सफाई करके स्मृति रिसाव से बचने के लिए कार्यान्वित करके जीवन चक्र के प्रति सचेत है onDestroy()।
- यह एपीआई 29 (एंड्रॉयड क्यू) के माध्यम से एपीआई 15 (आइसक्रीम सैंडविच) से समर्थन करता है
- एपीआई 21 से पहले के एपीआई के लिए, यह एक संदर्भ-आधारित
BoradcastReceiverऔर NetworkInfo, और ConnectivityManager.NetworkCallbackएपीआई 21 और इसके बाद के संस्करण का उपयोग करता है।
- जब वाईफाई और सेलुलर नेटवर्क दोनों चालू होते हैं, तो सेलुलर नेटवर्क में संक्रमण के दौरान वाईफाई डिस्कनेक्ट होने पर कनेक्टिविटी श्रोता बाधित नहीं होगा।
- जब सेलुलर नेटवर्क चालू होता है, तो जब वाईफाई कनेक्ट होता है और सक्रिय नेटवर्क (जैसा कि यह पसंदीदा नेटवर्क है) होने पर कनेक्टिविटी श्रोता बाधित नहीं करेगा।
- यदि आप पुस्तकालय का उपयोग करने जा रहे हैं, तो इस अनुमति को शामिल करने की कोई आवश्यकता नहीं है
android.permission.ACCESS_NETWORK_STATE; लेकिन आपको इसे शामिल करना होगा यदि आप उपयोगिता वर्ग का उपयोग करने जा रहे हैं।
क्षमताओं
- वर्तमान कनेक्टिविटी स्थिति (ऑनलाइन / ऑफ़लाइन) प्राप्त करें।
- डिवाइस के ऑफ़लाइन या ऑनलाइन होने पर इंटरनेट कनेक्शन की लगातार जाँच / सुनना और कॉलबैक को ट्रिगर करना।
- सक्रिय इंटरनेट कनेक्शन (वाईफाई या सेलुलर) का प्रकार प्राप्त करें।
- सभी उपलब्ध नेटवर्क (वाईफाई या सेलुलर) का प्रकार प्राप्त करें। >> केवल एपीआई 21+ पर समर्थित है
- सभी उपलब्ध नेटवर्क की संख्या प्राप्त करें >> केवल API 21+ पर समर्थित है
@RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1)
public class ConnectionUtil implements LifecycleObserver {
private static final String TAG = "LOG_TAG";
private ConnectivityManager mConnectivityMgr;
private Context mContext;
private NetworkStateReceiver mNetworkStateReceiver;
/*
* boolean indicates if my device is connected to the internet or not
* */
private boolean mIsConnected = false;
private ConnectionMonitor mConnectionMonitor;
/**
* Indicates there is no available network.
*/
private static final int NO_NETWORK_AVAILABLE = -1;
/**
* Indicates this network uses a Cellular transport.
*/
public static final int TRANSPORT_CELLULAR = 0;
/**
* Indicates this network uses a Wi-Fi transport.
*/
public static final int TRANSPORT_WIFI = 1;
public interface ConnectionStateListener {
void onAvailable(boolean isAvailable);
}
public ConnectionUtil(Context context) {
mContext = context;
mConnectivityMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
((AppCompatActivity) mContext).getLifecycle().addObserver(this);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
mConnectionMonitor = new ConnectionMonitor();
NetworkRequest networkRequest = new NetworkRequest.Builder()
.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
.build();
mConnectivityMgr.registerNetworkCallback(networkRequest, mConnectionMonitor);
}
}
/**
* Returns true if connected to the internet, and false otherwise
*
* <p>
* NetworkInfo is deprecated in API 29
* https://developer.android.com/reference/android/net/NetworkInfo
* <p>
* getActiveNetworkInfo() is deprecated in API 29
* https://developer.android.com/reference/android/net/ConnectivityManager#getActiveNetworkInfo()
* <p>
* getNetworkInfo(int) is deprecated as of API 23
* https://developer.android.com/reference/android/net/ConnectivityManager#getNetworkInfo(int)
*/
public boolean isOnline() {
mIsConnected = false;
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
// Checking internet connectivity
NetworkInfo activeNetwork = null;
if (mConnectivityMgr != null) {
activeNetwork = mConnectivityMgr.getActiveNetworkInfo(); // Deprecated in API 29
}
mIsConnected = activeNetwork != null;
} else {
Network[] allNetworks = mConnectivityMgr.getAllNetworks(); // added in API 21 (Lollipop)
for (Network network : allNetworks) {
NetworkCapabilities networkCapabilities = mConnectivityMgr.getNetworkCapabilities(network);
if (networkCapabilities != null) {
if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
|| networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
|| networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET))
mIsConnected = true;
}
}
}
return mIsConnected;
}
/**
* Returns
* <p> <p>
* <p><p> NO_NETWORK_AVAILABLE >>> when you're offline
* <p><p> TRANSPORT_CELLULAR >> When Cellular is the active network
* <p><p> TRANSPORT_WIFI >> When Wi-Fi is the Active network
* <p>
*/
public int getActiveNetwork() {
NetworkInfo activeNetwork = mConnectivityMgr.getActiveNetworkInfo(); // Deprecated in API 29
if (activeNetwork != null)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
NetworkCapabilities capabilities = mConnectivityMgr.getNetworkCapabilities(mConnectivityMgr.getActiveNetwork());
if (capabilities != null)
if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
// connected to mobile data
return TRANSPORT_CELLULAR;
} else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
// connected to wifi
return TRANSPORT_WIFI;
}
} else {
if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) { // Deprecated in API 28
// connected to mobile data
return TRANSPORT_CELLULAR;
} else if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) { // Deprecated in API 28
// connected to wifi
return TRANSPORT_WIFI;
}
}
return NO_NETWORK_AVAILABLE;
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public int getAvailableNetworksCount() {
int count = 0;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
Network[] allNetworks = mConnectivityMgr.getAllNetworks(); // added in API 21 (Lollipop)
for (Network network : allNetworks) {
NetworkCapabilities networkCapabilities = mConnectivityMgr.getNetworkCapabilities(network);
if (networkCapabilities != null)
if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
|| networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR))
count++;
}
}
return count;
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public List<Integer> getAvailableNetworks() {
List<Integer> activeNetworks = new ArrayList<>();
Network[] allNetworks; // added in API 21 (Lollipop)
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
allNetworks = mConnectivityMgr.getAllNetworks();
for (Network network : allNetworks) {
NetworkCapabilities networkCapabilities = mConnectivityMgr.getNetworkCapabilities(network);
if (networkCapabilities != null) {
if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI))
activeNetworks.add(TRANSPORT_WIFI);
if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR))
activeNetworks.add(TRANSPORT_CELLULAR);
}
}
}
return activeNetworks;
}
public void onInternetStateListener(ConnectionStateListener listener) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
mNetworkStateReceiver = new NetworkStateReceiver(listener);
IntentFilter intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
mContext.registerReceiver(mNetworkStateReceiver, intentFilter);
} else {
mConnectionMonitor.setOnConnectionStateListener(listener);
}
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void onDestroy() {
Log.d(TAG, "onDestroy");
((AppCompatActivity) mContext).getLifecycle().removeObserver(this);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
if (mConnectionMonitor != null)
mConnectivityMgr.unregisterNetworkCallback(mConnectionMonitor);
} else {
if (mNetworkStateReceiver != null)
mContext.unregisterReceiver(mNetworkStateReceiver);
}
}
public class NetworkStateReceiver extends BroadcastReceiver {
ConnectionStateListener mListener;
public NetworkStateReceiver(ConnectionStateListener listener) {
mListener = listener;
}
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getExtras() != null) {
NetworkInfo activeNetworkInfo = mConnectivityMgr.getActiveNetworkInfo(); // deprecated in API 29
/*
* activeNetworkInfo.getState() deprecated in API 28
* NetworkInfo.State.CONNECTED deprecated in API 29
* */
if (!mIsConnected && activeNetworkInfo != null && activeNetworkInfo.getState() == NetworkInfo.State.CONNECTED) {
Log.d(TAG, "onReceive: " + "Connected To: " + activeNetworkInfo.getTypeName());
mIsConnected = true;
mListener.onAvailable(true);
} else if (intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, Boolean.FALSE)) {
if (!isOnline()) {
mListener.onAvailable(false);
mIsConnected = false;
}
}
}
}
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public class ConnectionMonitor extends ConnectivityManager.NetworkCallback {
private ConnectionStateListener mConnectionStateListener;
void setOnConnectionStateListener(ConnectionStateListener connectionStateListener) {
mConnectionStateListener = connectionStateListener;
}
@Override
public void onAvailable(@NonNull Network network) {
if (mIsConnected)
return;
Log.d(TAG, "onAvailable: ");
if (mConnectionStateListener != null) {
mConnectionStateListener.onAvailable(true);
mIsConnected = true;
}
}
@Override
public void onLost(@NonNull Network network) {
if (getAvailableNetworksCount() == 0) {
mConnectionStateListener.onAvailable(false);
mIsConnected = false;
}
}
}
}