Como ver se o Wi-Fi está conectado no Android?


237

Não quero que meu usuário tente fazer o download de algo, a menos que tenha o Wi-Fi conectado. No entanto, só consigo saber se o Wi-Fi está ativado, mas eles ainda podem ter uma conexão 3G.

android.net.wifi.WifiManager m = (WifiManager) getSystemService(WIFI_SERVICE);
android.net.wifi.SupplicantState s = m.getConnectionInfo().getSupplicantState();
NetworkInfo.DetailedState state = WifiInfo.getDetailedStateOf(s);
if (state != NetworkInfo.DetailedState.CONNECTED) {
    return false;
}

No entanto, o estado não é o que eu esperaria. Embora o Wi-Fi esteja conectado, estou conseguindo OBTAINING_IPADDRo estado.

Respostas:


463

Você deve poder usar o ConnectivityManager para obter o estado do adaptador Wi-Fi. A partir daí, você pode verificar se está conectado ou mesmo disponível .

ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

if (mWifi.isConnected()) {
    // Do whatever
}

NOTA: Deve-se notar (para nós, n00bies aqui) que você precisa adicionar

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

para o seu

AndroidManifest.xml para que isso funcione.

NOTA 2 : public NetworkInfo getNetworkInfo (int networkType)agora está obsoleto:

Este método foi preterido no nível 23 da API. Este método não suporta várias redes conectadas do mesmo tipo. Use getAllNetworks () e getNetworkInfo (android.net.Network).

NOTA 3 : public static final int TYPE_WIFIagora está obsoleto:

Essa constante foi preterida no nível 28 da API. Os aplicativos devem usar NetworkCapabilities.hasTransport (int) ou requestNetwork (NetworkRequest, NetworkCallback) para solicitar uma rede apropriada. para transportes suportados.


72
Note-se (para nós noobies aqui) que você precisa adicionar android.permission.ACCESS_NETWORK_STATEao seu AndroidManifest.xml para que isso funcione.
— mgalgs

10
Nas versões muito recentes do Android, você precisa verificar NULL no mWiFi ... seu código aqui pode gerar um erro de ponteiro nulo. Veja developer.android.com/training/basics/network-ops/managing.html e, em particular, "O método getActiveNetworkInfo () retorna um NetworkInfo ..."
— eb80

1
Funcionou para mim também com interface Ethernet. Acabei de mudar para ConnectivityManager.TYPE_ETHERNET
— MBH

3
O método NetworkInfo.isConnected () agora está obsoleto na API-23. Estou postando uma solução abaixo.
— revolucionário

1
NetworkInfo.getType () e ConnectivityManager.TYPE_WIFI estão agora obsoleto na API 28. Para fiapos Aviso Evite você deve usar algo comoconnectivityManager.getNetworkCapabilities(network).hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
— Vadik

75

Como o método NetworkInfo.isConnected () agora está obsoleto na API-23 , eis um método que detecta se o adaptador Wi-Fi está ativado e também conectado a um ponto de acesso usando o WifiManager:

private boolean checkWifiOnAndConnected() {
    WifiManager wifiMgr = (WifiManager) getSystemService(Context.WIFI_SERVICE);

    if (wifiMgr.isWifiEnabled()) { // Wi-Fi adapter is ON

        WifiInfo wifiInfo = wifiMgr.getConnectionInfo();

        if( wifiInfo.getNetworkId() == -1 ){
            return false; // Not connected to an access point
        }
        return true; // Connected to an access point
    }
    else {
        return false; // Wi-Fi adapter is OFF
    }
}

4
Vale a pena mencionar que wifiInfo pode ser nulo, então eu acho que você deve verificar se há nula antes de começar ID de rede
— nonos

2
NetworkInfo.isConnected()não parece obsoleto para mim.
— EricRobertBrewer

Não se esqueça de adicionar permissão:android.permission.ACCESS_WIFI_STATE
— Ton Snoei

1
Isso não funcionará mais no Android Q sem a permissão de localização e o modo de localização ativados, consulte issuetracker.google.com/issues/136021574 .
— Konsumierer 27/06/19

O comentário @EricRobertBrewer não está mais atualizado. agora é, API 29+ obsoleta.
— nuKs

35

Eu simplesmente uso o seguinte:

SupplicantState supState; 
wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
supState = wifiInfo.getSupplicantState();

Que retornará um desses estados no momento em que você chama getSupplicantState ();

ASSOCIADO - Associação concluída.

ASSOCIANDO - Tentando se associar a um ponto de acesso.

CONCLUÍDO - Toda a autenticação concluída.

DESCONECTADO - Este estado indica que o cliente não está associado, mas é provável que comece a procurar um ponto de acesso.

DORMANT - Um estado adicionado ao Android que é relatado quando um cliente emite um comando DISCONNECT explícito.

FOUR_WAY_HANDSHAKE - Handshake de chave de 4 vias WPA em andamento.

GROUP_HANDSHAKE - Handshake de chave de grupo WPA em andamento.

INATIVO - Estado inativo.

INVÁLIDO - Um pseudo-estado que normalmente nunca deve ser visto.

DIGITALIZAÇÃO - Procurando uma rede.

NÃO INICIALIZADO - Sem conexão.


Oi Donal.I usei da mesma maneira para saber se o nosso dispositivo está conectado ao wifi.Mas além disso, eu preciso saber o nome do aplicativo atualmente usando WIFI.Como isso pode ser feito?
— AbhishekB

@AbhishekB, desculpe, mas eu não tenho nenhuma experiência com isso, talvez tente examinar alguns dos aplicativos de monitoramento Wi-Fi, veja se existe um de código aberto onde você pode revisar o código.
— Donal Rafferty

Suspeito dessa solução porque o suplicante é usado apenas se o WPA (ou alguma variação do WPA) for utilizado: se o usuário se conectar a um AP sem autenticação ou WEP, o suplicante não estará envolvido.
— Tom

2
Ele ainda aparece como "CONCLUÍDO", mesmo que eu não esteja usando o wifi
— Evan Parsons

1
existe alguma intenção de transmissão do sistema para os estados mencionados acima? @DonalRafferty
— Rohit Singh

19

Estou usando isso em meus aplicativos para verificar se a rede ativa é Wi-Fi:

ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo ni = cm.getActiveNetworkInfo();
if (ni != null && ni.getType() == ConnectivityManager.TYPE_WIFI)
{

    // Do your work here

}

Esta é a melhor resposta, porque garante que a activerede (o que será usado para fazer o download) é WiFi
— Gavriel

1
É também a melhor resposta agora que NetworkInfo#isConnectedestá obsoleto
— Tash Pemhiwa

Definitivamente a melhor resposta para este ano (2017).
— Daniel Nugent

18

Dei uma olhada em algumas perguntas como essa e surgiu com isso:

ConnectivityManager connManager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo wifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
NetworkInfo mobile = connManager .getNetworkInfo(ConnectivityManager.TYPE_MOBILE);

if (wifi.isConnected()){
    // If Wi-Fi connected
}

if (mobile.isConnected()) {
    // If Internet connected
}

Eu uso se para minha licença verificar no Root Toolbox PRO, e parece funcionar muito bem.


8
parece bom, mas não sei por que você recebe uma segunda referência ao ConnectivityManager. Neste exemplo connManager e connManager1 são ambos o mesmo objecto
— Nathan Schwermann

1
TYPE_MOBLIE significa 3gnet ou gprs net?
— precisa saber é o seguinte

1
TYPE_MOBILE significa quaisquer dados usando sua operadora - 2G (GPRS ...), 3G (HSDPA ...) ou 4G (LTE ...).
— Eugen Pechanec 21/03

1
você pode adicionar TYPE_ETHERNET, que funcionou bem ao conectar o Android à Ethernet
— MBH

1
Vale lembrar, que getNetworkInfo()retornará um nulo, se a rede não existir. Portanto, se o dispositivo não tiver conexão móvel, isso gerará um erro. Na maioria dos casos, TYPE_ETHERNET causará um valor nulo neste caso, pois a maioria dos dispositivos não terá uma conexão Ethernet.
— Knossos

7

Enquanto a resposta de Jason está correta, hoje em dia getNetWorkInfo (int) é um método obsoleto. Portanto, a próxima função seria uma boa alternativa:

public static boolean isWifiAvailable (Context context)
{
    boolean br = false;
    ConnectivityManager cm = null;
    NetworkInfo ni = null;

    cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    ni = cm.getActiveNetworkInfo();
    br = ((null != ni) && (ni.isConnected()) && (ni.getType() == ConnectivityManager.TYPE_WIFI));

    return br;
}

3

Usando WifiManagervocê pode fazer:

WifiManager wifi = (WifiManager) getSystemService (Context.WIFI_SERVICE);
if (wifi.getConnectionInfo().getNetworkId() != -1) {/* connected */}

O método getNeworkId retorna -1 somente quando não está conectado a uma rede;


WIFI_STATE_DISABLED Valor Constante: 1 (0x00000001) WIFI_STATE_DISABLING Constante Valor: 0 (0x00000000) WIFI_STATE_ENABLED Valor Constante: 3 (0x00000003) WIFI_STATE_ENABLING Valor Constante: 2 (0x00000002) WIFI_STATE_UNKNOWN Valor Constante: 4 (0x00000004)
— Lou Morda


Isso não funcionará mais no Android Q sem a permissão de localização e o modo de localização ativados, consulte issuetracker.google.com/issues/136021574 .
— Konsumierer 27/06/19

3
ConnectivityManager manager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
boolean is3g = manager.getNetworkInfo(
                  ConnectivityManager.TYPE_MOBILE).isConnectedOrConnecting();
boolean isWifi = manager.getNetworkInfo(
                    ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();

Log.v("", is3g + " ConnectivityManager Test " + isWifi);
if (!is3g && !isWifi) {
    Toast.makeText(
        getApplicationContext(),
        "Please make sure, your network connection is ON ",
        Toast.LENGTH_LONG).show();
}
else {
    // Put your function() to go further;
}

1
seria melhor adicionar alguma explicação ao invés de apenas código.
— EdChum 28/10/12

2
Eu usaria isConnected () , os documentos dizem: boolean isConnectedOrConnecting ()Indica se a conectividade de rede existe ou está em processo de estabelecimento. Isso é bom para aplicativos que precisam fazer qualquer coisa relacionada à rede que não seja ler ou gravar dados. Para o último, ligue em isConnected()vez disso, o que garante que a rede seja totalmente utilizável.
— 18446744073709551615

3

O código a seguir (no Kotlin) funciona da API 21 até pelo menos a versão atual da API (API 29). A função getWifiState () retorna um dos três valores possíveis para o estado da rede WiFi: Disable, EnabledNotConnected e Connected que foram definidos em uma classe enum. Isso permite tomar decisões mais granulares, como informar o usuário para ativar o Wi-Fi ou, se já estiver ativado, conectar-se a uma das redes disponíveis. Mas se tudo o que for necessário é um booleano indicando se a interface WiFi está conectada a uma rede, a outra função é Wi-FiConnected (). Ele usa o anterior e compara o resultado ao Conectado.

Ele se inspira em algumas das respostas anteriores, mas tenta resolver os problemas introduzidos pela evolução das APIs do Android ou pela crescente disponibilidade do IP V6. O truque era usar:

wifiManager.connectionInfo.bssid != null 

ao invés de:

  1. getIpAddress () == 0 que é válido apenas para IP V4 ou
  2. getNetworkId () == -1 que agora requer outra permissão especial (Local)

De acordo com a documentação: https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid, ele retornará nulo se não estiver conectado a uma rede. E mesmo se não tivermos permissão para obter o valor real, ele ainda retornará algo diferente de nulo se estivermos conectados.

Lembre-se também do seguinte:

Nas versões anteriores ao android.os.Build.VERSION_CODES # N, esse objeto deve ser obtido apenas em um contexto # getApplicationContext () e não em qualquer outro contexto derivado para evitar vazamentos de memória no processo de chamada.

No manifesto, não esqueça de adicionar:

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

O código proposto é:

class MyViewModel(application: Application) : AndroidViewModel(application) {

   // Get application context
    private val myAppContext: Context = getApplication<Application>().applicationContext

   // Define the different possible states for the WiFi Connection
    internal enum class WifiState {
        Disabled,               // WiFi is not enabled
        EnabledNotConnected,    // WiFi is enabled but we are not connected to any WiFi network
        Connected,              // Connected to a WiFi network
    }

    // Get the current state of the WiFi network
    private fun getWifiState() : WifiState {

        val wifiManager : WifiManager = myAppContext.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager

        return if (wifiManager.isWifiEnabled) {
                    if (wifiManager.connectionInfo.bssid != null)
                        WifiState.Connected
                    else
                        WifiState.EnabledNotConnected
               } else {
                    WifiState.Disabled
               }
    }

    // Returns true if we are connected to a WiFi network
    private fun isWiFiConnected() : Boolean {
        return (getWifiState() == WifiState.Connected)
    }
}

3

A NetworkInfoclasse foi descontinuada no nível 29 da API, juntamente com os métodos de acesso relacionados, como ConnectivityManager#getNetworkInfo()e ConnectivityManager#getActiveNetworkInfo().

A documentação agora sugere que as pessoas usem a ConnectivityManager.NetworkCallbackAPI para monitoramento de retorno de chamada assíncrono, ou use ConnectivityManager#getNetworkCapabilitiesou ConnectivityManager#getLinkPropertiespara acesso sincronizado às informações da rede

Os chamadores devem usar a API ConnectivityManager.NetworkCallback para aprender sobre alterações de conectividade ou alternar para usar o ConnectivityManager # getNetworkCapabilities ou o ConnectivityManager # getLinkProperties para obter informações de forma síncrona.


Para verificar se o Wi-Fi está conectado, eis o código que eu uso:

Kotlin:

val connMgr = applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
connMgr?: return false
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    val network: Network = connMgr.activeNetwork ?: return false
    val capabilities = connMgr.getNetworkCapabilities(network)
    return capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
} else {
    val networkInfo = connMgr.activeNetworkInfo ?: return false
    return networkInfo.isConnected && networkInfo.type == ConnectivityManager.TYPE_WIFI
}

Java:

ConnectivityManager connMgr = (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
if (connMgr == null) {
    return false;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    Network network = connMgr.getActiveNetwork();
    if (network == null) return false;
    NetworkCapabilities capabilities = connMgr.getNetworkCapabilities(network);
    return capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
} else {
    NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
    return networkInfo.isConnected() && networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
}

Lembre-se de adicionar também permissão ACCESS_NETWORK_STATEao seu arquivo de manifesto.


2

Experimente este método.

public boolean isInternetConnected() {
    ConnectivityManager conMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    boolean ret = true;
    if (conMgr != null) {
        NetworkInfo i = conMgr.getActiveNetworkInfo();

        if (i != null) {
            if (!i.isConnected()) {
                ret = false;
            }

            if (!i.isAvailable()) {
                ret = false;
            }
        }

        if (i == null)
            ret = false;
    } else
        ret = false;
    return ret;
}

Este método ajudará a encontrar a conexão à Internet disponível ou não.


1
Eu estava procurando especificamente se a conexão ativa é wifi. Além disso, não é necessário fazer uma verificação nula no conMgr, pois ela nunca será nula.
— Nathan Schwermann

Você pode verificar esta pergunta, por favor? :(
— Skizo-ozᴉʞS

2

Isso funciona para mim:

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

    // Mobile
    State mobile = conMan.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState();

    // Wi-Fi
    State wifi = conMan.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState();

    // And then use it like this:

    if (mobile == NetworkInfo.State.CONNECTED || mobile == NetworkInfo.State.CONNECTING)
    {
        Toast.makeText(Wifi_Gprs.this,"Mobile is Enabled :) ....",Toast.LENGTH_LONG).show();
    }
    else if (wifi == NetworkInfo.State.CONNECTED || wifi == NetworkInfo.State.CONNECTING)
    {
        Toast.makeText(Wifi_Gprs.this,"Wifi is Enabled  :) ....",Toast.LENGTH_LONG).show();
    }
    else
    {
        Toast.makeText(Wifi_Gprs.this,"No Wifi or Gprs Enabled :( ....",Toast.LENGTH_LONG).show();
    }

E adicione esta permissão:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

2

Muitas das respostas usam código obsoleto ou código disponível nas versões da API higer. Agora eu uso algo assim

ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if(connectivityManager != null) {
            for (Network net : connectivityManager.getAllNetworks()) {
                NetworkCapabilities nc = connectivityManager.getNetworkCapabilities(net);
                if (nc != null && nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
                        && nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET))
                    return true;
            }
        }
        return false;

1

Aqui está o que eu uso como método utilitário nos meus aplicativos:

public static boolean isDeviceOnWifi(final Context context) {
        ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        return mWifi != null && mWifi.isConnectedOrConnecting();
}

É bom ressaltar que o método isConnectedOrConnecting é importante quando você está verificando o estabelecimento da conexão. O método IsConnected não funcionou para mim.
— vincent

1

Na nova versão Android

private void getWifiInfo(Context context) {
    ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    Network[] networks = connManager.getAllNetworks();

    if(networks == null || networks.length == 0)
        return;

    for( int i = 0; i < networks.length; i++) {
        Network ntk = networks[i];
        NetworkInfo ntkInfo = connManager.getNetworkInfo(ntk);
        if (ntkInfo.getType() == ConnectivityManager.TYPE_WIFI && ntkInfo.isConnected() ) {
            final WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
            final WifiInfo connectionInfo = wifiManager.getConnectionInfo();
            if (connectionInfo != null) {
                // add some code here
            }
        }

    }
}

e adicionar premissa também


connManager.getAllNetworks()requer o nível 21. da API
— Jawand Singh 01/04/19

1

Semelhante à resposta de Jason Knight, mas da maneira Kotlin:

val connManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)

if (mWifi.isConnected) {
     // Do whatever
}

ConnectivityManager.TYPE_WIFIestá obsoleto
— Jérôme Pietri 03/02

0

Esta é uma solução mais fácil. Consulte Pergunta sobre estouro de pilha Verificando o Wi-Fi ativado ou não no Android .

PS Não esqueça de adicionar o código ao arquivo manifest.xml para permitir permissão. Como mostrado abaixo.

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" >
</uses-permission>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" >
</uses-permission>
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" >
</uses-permission>

0

Experimentar

wifiManager.getConnectionInfo().getIpAddress()

Isso retorna 0 até que o dispositivo tenha uma conexão utilizável (na minha máquina, um Samsung SM-T280, Android 5.1.1).


0

Você pode ativar o WIFI se não estiver ativado da seguinte maneira 1. verifique o estado do WIFI conforme respondido por @ Jason Knight 2. se não estiver ativado, ative-o, não se esqueça de adicionar permissão WIFI no arquivo de manifesto

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Sua classe Java deve ser assim

public class TestApp extends Activity {
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    //check WIFI activation
    ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

    if (mWifi.isConnected() == false) {
        showWIFIDisabledAlertToUser();
    }
    else {
        Toast.makeText(this, "WIFI is Enabled in your devide", Toast.LENGTH_SHORT).show();
    }
}


private void showWIFIDisabledAlertToUser(){
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    alertDialogBuilder.setMessage("WIFI is disabled in your device. Would you like to enable it?")
            .setCancelable(false)
            .setPositiveButton("Goto Settings Page To Enable WIFI",
                    new DialogInterface.OnClickListener(){
                        public void onClick(DialogInterface dialog, int id){
                            Intent callGPSSettingIntent = new Intent(
                                    Settings.ACTION_WIFI_SETTINGS);
                            startActivity(callGPSSettingIntent);
                        }
                    });
    alertDialogBuilder.setNegativeButton("Cancel",
            new DialogInterface.OnClickListener(){
                public void onClick(DialogInterface dialog, int id){
                    dialog.cancel();
                }
            });
    AlertDialog alert = alertDialogBuilder.create();
    alert.show();
}

}


0

Adicione isto para JAVA:

public boolean CheckWifiConnection() {
        ConnectivityManager conMgr = (ConnectivityManager) getSystemService (Context.CONNECTIVITY_SERVICE);
        if (conMgr.getActiveNetworkInfo() != null
                && conMgr.getActiveNetworkInfo().isAvailable()
                && conMgr.getActiveNetworkInfo().isConnected()) {
            return true;
        } else {
            return false;
        }
    }

no arquivo manifesto, adicione as seguintes permissões:

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />

0

Tipo de pergunta antiga, mas é isso que eu uso. requer min api nível 21 também leva em consideração Networkinfo apis.

boolean isWifiConn = false;
    ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        Network network = connMgr.getActiveNetwork();
        if (network == null) return false;
        NetworkCapabilities capabilities = connMgr.getNetworkCapabilities(network);
        if(capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)){
            isWifiConn = true;
            Toast.makeText(context,"Wifi connected Api >= "+Build.VERSION_CODES.M,Toast.LENGTH_LONG).show();
        }else{
            Toast.makeText(context,"Wifi not connected Api >= "+Build.VERSION_CODES.M,Toast.LENGTH_LONG).show();
        }
    } else {
        for (Network network : connMgr.getAllNetworks()) {
            NetworkInfo networkInfo = connMgr.getNetworkInfo(network);
            if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI && networkInfo.isConnected()) {
                isWifiConn = true;
                Toast.makeText(context,"Wifi connected ",Toast.LENGTH_LONG).show();
                break;
            }else{
                Toast.makeText(context,"Wifi not connected ",Toast.LENGTH_LONG).show();
            }
        }
    }
    return isWifiConn;
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.