그러나 compileSdkVersion 23 사용하여 9까지 지원합니다.
getNetworkInfo(int)
(23)에서 사용되지 않는 된 제안은 사용하는 것이 었 getAllNetworks()
하고 getNetworkInfo(Network)
대신. 그러나이 두 가지 모두 최소 API 21이 필요합니다.
이를 지원할 수있는 지원 패키지에 사용할 수있는 클래스가 있습니까?
나는 해결책이 이전 에 제안되었다는 것을 알고 있지만, 9의 최소 API 요구 사항에 대한 문제는 문제를 일으킨다.
답변
당신이 사용할 수있는:
getActiveNetworkInfo ();
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null) {
// connected to the internet
if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
// connected to wifi
} else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
// connected to mobile data
}
} else {
// not connected to the internet
}
또는 스위치 케이스
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null) {
// connected to the internet
switch (activeNetwork.getType()) {
case ConnectivityManager.TYPE_WIFI:
// connected to wifi
break;
case ConnectivityManager.TYPE_MOBILE:
// connected to mobile data
break;
default:
break;
}
} else {
// not connected to the internet
}
답변
2018 년 10 월부터는 답변이 더 이상 사용되지 않습니다.
getType()
및 유형 자체는 이제 API 레벨 28에서 더 이상 사용되지 않습니다. Javadoc에서 :
호출자는 NetworkCapabilities # TRANSPORT * 상수 중 하나를 사용하여 NetworkCapabilities # hasTransport 확인 대신 전환해야합니다.
를 사용하려면 인스턴스를 메소드 NetworkCapabilities
에 전달해야합니다 . 해당 인스턴스를 얻으려면 API 레벨 23에 추가 된 호출해야합니다 .Network
getNetworkCapabilities()
getActiveNetwork()
따라서 현재 Wi-Fi 또는 셀룰러 네트워크에 연결되어 있는지 안전하게 확인하는 올바른 방법은 다음과 같습니다.
public static boolean isNetworkConnected() {
final ConnectivityManager cm = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (cm != null) {
if (Build.VERSION.SDK_INT < 23) {
final NetworkInfo ni = cm.getActiveNetworkInfo();
if (ni != null) {
return (ni.isConnected() && (ni.getType() == ConnectivityManager.TYPE_WIFI || ni.getType() == ConnectivityManager.TYPE_MOBILE));
}
} else {
final Network n = cm.getActiveNetwork();
if (n != null) {
final NetworkCapabilities nc = cm.getNetworkCapabilities(n);
return (nc.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) || nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI));
}
}
}
return false;
}
다른 유형의을 확인할 수도 TRANSPORT
있습니다 ( 여기에서 찾을 수 있음) .
중요 사항 : Wi-Fi 및 VPN에 연결되어 있으면 현재 상태가 될 수 있으므로 TRANSPORT_VPN
확인해야 할 수도 있습니다.
AndroidManifest 파일에 다음 권한을 추가하는 것을 잊지 마십시오.
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
답변
2020 년 2 월 업데이트 :
허용 된 답변은에서 더 이상 사용되지 28 (Android P)
않지만 대체 방법은에서 작동합니다 23 (Android M)
. 구형 장치를 지원하기 위해에 도우미 기능을 작성했습니다.
사용하는 방법:
int type = getConnectionType(getApplicationContext());
를 반환하면 코드에서로 int
변경할 수 있습니다 enum
.
0 : 인터넷을 사용할 수 없습니다 (비행기 모드 또는 Wi-Fi 가입 중일 수 있음).
1 : 셀룰러 (모바일 데이터, 3G / 4G / LTE)
2 : Wi-Fi.
3 : VPN
Kotlin 또는 Java 버전의 도우미 함수를 복사 할 수 있습니다.
코 틀린 :
@IntRange(from = 0, to = 3)
fun getConnectionType(context: Context): Int {
var result = 0 // Returns connection type. 0: none; 1: mobile data; 2: wifi
val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
cm?.run {
cm.getNetworkCapabilities(cm.activeNetwork)?.run {
if (hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
result = 2
} else if (hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
result = 1
} else if (hasTransport(NetworkCapabilities.TRANSPORT_VPN)){
result = 3
}
}
}
} else {
cm?.run {
cm.activeNetworkInfo?.run {
if (type == ConnectivityManager.TYPE_WIFI) {
result = 2
} else if (type == ConnectivityManager.TYPE_MOBILE) {
result = 1
} else if(type == ConnectivityManager.TYPE_VPN) {
result = 3
}
}
}
}
return result
}
자바:
@IntRange(from = 0, to = 3)
public static int getConnectionType(Context context) {
int result = 0; // Returns connection type. 0: none; 1: mobile data; 2: wifi
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (cm != null) {
NetworkCapabilities capabilities = cm.getNetworkCapabilities(cm.getActiveNetwork());
if (capabilities != null) {
if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
result = 2;
} else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
result = 1;
} else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
result = 3;
}
}
}
} else {
if (cm != null) {
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null) {
// connected to the internet
if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
result = 2;
} else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
result = 1;
} else if (activeNetwork.getType() == ConnectivityManager.TYPE_VPN) {
result = 3;
}
}
}
}
return result;
}
답변
업데이트 된 답변 (19 : 07 : 2018) :
이 방법은 인터넷 연결이 가능한지 확인하는 데 도움이됩니다.
public static boolean isNetworkAvailable(Context context) {
ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectivityManager != null) {
NetworkInfo activeNetwork = connectivityManager.getActiveNetworkInfo();
return (activeNetwork != null && activeNetwork.isConnectedOrConnecting());
} else {
return false;
}
}
이전 답변 :
최상의 코드 재사용 연습을 위해 Cheese Bread 답변을 개선하십시오.
public static boolean isNetworkAvailable(Context context) {
int[] networkTypes = {ConnectivityManager.TYPE_MOBILE,
ConnectivityManager.TYPE_WIFI};
try {
ConnectivityManager connectivityManager =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
for (int networkType : networkTypes) {
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
if (activeNetworkInfo != null &&
activeNetworkInfo.getType() == networkType)
return true;
}
} catch (Exception e) {
return false;
}
return false;
}
코드는 Util 클래스에 배치 할 수 있으며 응용 프로그램의 어느 부분에서나 전화가 Wi-Fi 또는 모바일 인터넷을 통해 인터넷에 연결되어 있는지 확인하는 데 사용할 수 있습니다.
답변
수락 된 답변은 버전 28에서 더 이상 사용되지 않으므로 다음은 프로젝트에서 사용중인 솔루션입니다.
연결 유형을 반환합니다. false : 인터넷 연결이 없습니다. true : 모바일 데이터 || 와이파이
public static boolean isNetworkConnected(Context context) {
boolean result = false;
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (cm != null) {
NetworkCapabilities capabilities = cm.getNetworkCapabilities(cm.getActiveNetwork());
if (capabilities != null) {
if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
result = true;
} else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
result = true;
}
}
}
} else {
if (cm != null) {
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null) {
// connected to the internet
if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
result = true;
} else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
result = true;
}
}
}
}
return result;
}
답변
API.15에서 API.29까지 지원하는 2020 년 3 월 현재이 답변에 대한 업데이트가 있습니다. 원래 답변에 따라 찾을 수 있습니다.
2019 년 2 월 답변
온라인 상태인지 확인하려면 :
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;
}
안드로이드 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 년 3 월 업데이트
마찬가지로 NetworkInfo
지금부터 더 이상 사용되지 않으며 API 29로 우리가 사용해야하는 ConnectivityManager.NetworkCallback
네트워크 상태 변화 onAvailable()
및 onLost()
콜백.
용법:
- 이 라이브러리 를 사용 하거나이 라이브러리 의 일부인 아래의 유틸리티 클래스를 직접 사용할 수 있습니다.
풍모
- LifeCycle은
LifecycleObserver
일부 정리 작업을 수행하여 메모리 누수를 피하도록 구현함으로써 의식이onDestroy()
있습니다. - API 29 (Ice Cream Sandwich)부터 API 29 (Android Q)까지 지원
- API의 API (21)에 종래의 경우, 사용 상황에 기초
BoradcastReceiver
하고NetworkInfo
, 그리고 사용ConnectivityManager.NetworkCallback
API (21) 및 상기 대. - WiFi와 셀룰러 네트워크가 모두 켜져 있으면 셀룰러 네트워크로 전환하는 동안 WiFi 연결이 끊어지면 연결 리스너가 중단되지 않습니다.
- 셀룰러 네트워크가 켜져 있으면 WiFi가 연결되어 활성 네트워크 일 때 연결 리스너가 중단되지 않습니다 (이것이 선호하는 네트워크이므로).
- 라이브러리를 사용하려는 경우이 권한을 포함 할 필요가 없습니다
android.permission.ACCESS_NETWORK_STATE
. 유틸리티 클래스를 사용하려면 포함시켜야합니다.
기능
- 현재 연결 상태 (온라인 / 오프라인)를 가져옵니다.
- 인터넷 연결을 지속적으로 확인 / 청취하고 장치가 오프라인 또는 온라인 상태가되면 콜백을 트리거합니다.
- 활성 인터넷 연결 유형 (WiFi 또는 Cellular)을 가져옵니다.
- 사용 가능한 모든 네트워크 유형 (WiFi 또는 Cellular)을 가져옵니다. >> API 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;
}
}
}
}
답변
네트워크가 인터넷에 연결되어 있는지 확인하는 것이 좋습니다.
@Suppress("DEPRECATION")
fun isNetworkAvailable(context: Context): Boolean {
try {
val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
return if (Build.VERSION.SDK_INT > 22) {
val an = cm.activeNetwork ?: return false
val capabilities = cm.getNetworkCapabilities(an) ?: return false
capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
} else {
val a = cm.activeNetworkInfo ?: return false
a.isConnected && (a.type == ConnectivityManager.TYPE_WIFI || a.type == ConnectivityManager.TYPE_MOBILE)
}
} catch (e: Exception) {
e.printStackTrace()
}
return false
}