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.