मैं कैसे देखूं कि वाई-फाई एंड्रॉइड पर कनेक्ट है या नहीं?


237

मैं नहीं चाहता कि मेरा उपयोगकर्ता तब तक कुछ डाउनलोड करने का प्रयास करे जब तक कि उसके पास वाई-फाई कनेक्ट न हो। हालांकि, मैं केवल यह बताने में सक्षम हो सकता हूं कि वाई-फाई सक्षम है या नहीं, लेकिन उनके पास अभी भी 3 जी कनेक्शन हो सकता है।

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;
}

हालांकि, राज्य वह नहीं है जो मैं उम्मीद करूंगा। वाई-फाई से जुड़े होने OBTAINING_IPADDRके बावजूद मैं राज्य के रूप में काम कर रहा हूं ।

जवाबों:


463

वाई-फाई अडैप्टर की स्थिति प्राप्त करने के लिए आपको कनेक्टिविटी मैनजर का उपयोग करने में सक्षम होना चाहिए। वहां से आप जांच सकते हैं कि यह जुड़ा हुआ है या उपलब्ध भी है

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

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

नोट: यह ध्यान दिया जाना चाहिए (हमारे लिए n00bies यहां) जिसे आपको जोड़ने की आवश्यकता है

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

आपके

AndroidManifest.xml इसे काम करने के लिए।

NOTE2 : public NetworkInfo getNetworkInfo (int networkType)अब पदावनत हो गया है:

इस विधि को एपीआई स्तर 23 में पदावनत किया गया था। यह विधि एक ही प्रकार के कई जुड़े नेटवर्क का समर्थन नहीं करती है। इसके बजाय getAllNetworks () और getNetworkInfo (android.net.Network) का उपयोग करें।

NOTE3 : public static final int TYPE_WIFIअब पदावनत हो गया है:

यह स्थिरांक API स्तर 28 में पदावनत किया गया था। एक उपयुक्त नेटवर्क का अनुरोध करने के लिए अनुप्रयोगों को इसके बजाय NetworkCapabilities.hasTransport (int) या requestNetwork (NetworkRequest, NetworkCallback) का उपयोग करना चाहिए। समर्थित ट्रांसपोर्ट के लिए।


72
यह ध्यान दिया जाना चाहिए (यहाँ हमारे लिए noobies) जिसे आपको android.permission.ACCESS_NETWORK_STATEकाम करने के लिए अपने AndroidManifest.xml में जोड़ना होगा।
भागलपुर

10
एंड्रॉइड के हाल के संस्करणों में, आपको mWiFi में NULL की जांच करने की आवश्यकता है ... आपका कोड यहां एक शून्य पॉइंटर त्रुटि फेंक सकता है। देखें डेवलपर .android.com
training

1
यह मेरे लिए ईथरनेट इंटरफेस के साथ भी काम करता था। मैं बस करने के लिए बदल ConnectivityManager.TYPE_ETHERNET
MBH

3
NetworkInfo.isConnected () विधि अब API-23 में पदावनत हो गई है। मैं नीचे एक समाधान पोस्ट कर रहा हूं।
क्रांतिकारी

1
NetworkInfo.getType () और ConnectivityManager.TYPE_WIFI अब API 28 में पदावनत हो गए हैं। लिंट चेतावनी से बचने के लिए आपको कुछ का उपयोग करना चाहिए जैसेconnectivityManager.getNetworkCapabilities(network).hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
Vadik

75

चूंकि NetworkInfo.isConnected () विधि अब API-23 में पदावनत हो गई है , यहाँ एक विधि है जो पता लगाती है कि वाई-फाई अडैप्टर चालू है और इसके बजाय 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
यह उल्लेखनीय है कि wifiInfo अशक्त हो सकता है इसलिए मुझे लगता है कि आपको नेटवर्क आईडी प्राप्त करने से पहले अशक्त के लिए जांच करनी चाहिए
नॉनोस

2
NetworkInfo.isConnected()मुझे पदावनत नहीं देखता।
एररिकोबर्ट बीवर

अनुमति जोड़ना न भूलें:android.permission.ACCESS_WIFI_STATE
टन स्नोई

1
यह स्थान की अनुमति और स्थान मोड को चालू किए बिना एंड्रॉइड क्यू में काम नहीं करेगा, जारी करने वाले को देखें । URL/ues/136021574
कोंसुमियेर

@EricRobertBrewer टिप्पणी अब तक नहीं। अब यह अपग्रेडेड एपीआई 29+ है।
15

35

मैं बस निम्नलिखित का उपयोग करता हूं:

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

जब आप getSupplicantState () कॉल करते हैं, तो इनमें से एक राज्य वापस आ जाएगा;

एसोसिएटेड - एसोसिएशन पूरा हुआ।

ASSOCIATING - एक एक्सेस प्वाइंट के साथ जुड़ने की कोशिश करना।

पूरा - सभी प्रमाणीकरण पूर्ण।

DISCONNECTED - यह राज्य इंगित करता है कि क्लाइंट संबद्ध नहीं है, लेकिन एक एक्सेस प्वाइंट की तलाश शुरू करने की संभावना है।

DORMANT - एक एंड्रॉइड-एडेड स्थिति, जो तब बताई जाती है जब कोई क्लाइंट एक स्पष्ट डिसकनेक्ट कमांड देता है।

FOUR_WAY_HANDSHAKE - WPA 4-वे प्रमुख हैंडशेक प्रगति पर है।

GROUP_HANDSHAKE - WPA समूह कुंजी हैंडशेक प्रगति पर है।

INACTIVE - निष्क्रिय अवस्था।

INVALID - एक छद्म स्थिति जिसे आम तौर पर कभी नहीं देखा जाना चाहिए।

स्कैन - एक नेटवर्क के लिए स्कैनिंग।

UNINITIALIZED - कोई कनेक्शन नहीं।


हाय डोनल। मैंने यह पाने के लिए उसी तरह का उपयोग किया है कि क्या हमारा डिवाइस वाईफाई से जुड़ा हुआ है। लेकिन इसके अलावा, मुझे वर्तमान में WIFI का उपयोग करके ऐप का नाम जानना होगा। वह कैसे किया जा सकता है?
अभिषेक

@AbhishekB, क्षमा करें, लेकिन मेरे पास इसका कोई अनुभव नहीं है, शायद कुछ वाई-फाई मॉनिटरिंग ऐप्स को देखने का प्रयास करें, देखें कि क्या कोई खुला स्रोत है जहां आप कोड की समीक्षा कर सकते हैं।
डोनाल्ड रैफरटी

मुझे इस समाधान पर संदेह है क्योंकि डुप्लिकेट का उपयोग केवल तभी किया जाता है यदि WPA (या WPA के कुछ भिन्नता) का उपयोग किया जाता है: यदि उपयोगकर्ता AP से बिना किसी प्रमाणीकरण या WEP के जुड़ता है, तो वह उपयोक्ता शामिल नहीं है।
टॉम

2
यह अभी भी "कंप्लीटेड" के रूप में दिखाई देता है, भले ही मैं वाईफाई पर नहीं हूं
इवान पार्सन्स

1
क्या उपरोक्त राज्यों के लिए कोई सिस्टम प्रसारण इरादा है? @ डॉनलरफैर्टी
रोहित सिंह

19

मैं अपने ऐप्स में इसका उपयोग यह जांचने के लिए कर रहा हूं कि क्या सक्रिय नेटवर्क वाई-फाई है:

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

    // Do your work here

}

यह सबसे अच्छा जवाब है क्योंकि यह सुनिश्चित करता है कि activeनेटवर्क (जिसे डाउनलोड करने के लिए उपयोग किया जाएगा) वाईफाई है
गेवरियल

1
यह अब भी सबसे अच्छा जवाब है कि NetworkInfo#isConnectedपदावनत किया जाता है
ताश पेमहिवा

निश्चित रूप से इस वर्ष (2017) के लिए सबसे अच्छा जवाब।
डैनियल नुगेंट

18

मैं इस तरह से कुछ सवालों पर एक नज़र था और इस के साथ आया:

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
}

मैं रूट टूलबॉक्स प्रो में अपने लाइसेंस की जांच के लिए उपयोग करता हूं, और यह बहुत अच्छा काम करता है।


8
अच्छा लग रहा है, लेकिन मुझे यकीन नहीं है कि आपको ConnectivityManager का दूसरा संदर्भ क्यों मिला। इस उदाहरण में conManager और connManager1 दोनों एक ही वस्तु हैं
Nathan Schwermann

1
क्या TYPE_MOBLIE का मतलब 3Gnet या gprs net है?
हर्बर्ट

1
TYPE_MOBILE का अर्थ है कि आपके वाहक का उपयोग कर कोई डेटा - 2G (GPRS ...), 3G (HSDPA ...) या 4G (LTE ...)।
यूजेन पिनेक

1
आप TYPE_ETHERNET जोड़ सकते हैं जो Android पर ईथरनेट से कनेक्ट करते समय ठीक काम करता है
MBH

1
यह ध्यान में रखने योग्य है, कि getNetworkInfo()एक अशक्त वापस आ जाएगा, अगर नेटवर्क मौजूद नहीं है। इसलिए यदि डिवाइस में कोई मोबाइल कनेक्शन नहीं है, तो यह एक त्रुटि फेंक देगा। ज्यादातर मामलों में, TYPE_ETHERNET इस मामले में एक बुरा कारण होगा, क्योंकि अधिकांश उपकरणों में ईथरनेट कनेक्शन नहीं होगा।
नॉटोस

7

जबकि जेसन का जवाब सही है, आजकल getNetWorkInfo (int) एक पदावनत विधि है। इसलिए, अगला कार्य एक अच्छा विकल्प होगा:

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

WifiManagerआप का उपयोग कर सकते हैं:

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

विधि getNeworkId -1 को केवल तभी लौटाती है जब वह किसी नेटवर्क से कनेक्ट नहीं होता है;


WIFI_STATE_DISABLED लगातार मूल्य: 1 (0x00000001) WIFI_STATE_DISABLING स्थिरांक मान: 0 (0x00000000) WIFI_STATE_ENABLED लगातार मूल्य: 3 (0x00000003) स्थिर मूल्य WIFI_STATE_ENABLING: 2 (0x00000002) WIFI_STATE_UNKNOWN लगातार मूल्य: 4 (0x00000004)
लो Morda


यह स्थान की अनुमति और स्थान मोड को चालू किए बिना एंड्रॉइड क्यू में काम नहीं करेगा, जारी करने वाले को देखें । URL/ues/136021574
कोंसुमियेर

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
सिर्फ कोड के बजाय कुछ स्पष्टीकरण जोड़ना बेहतर होगा।
एडचम

2
मैं isConnected () का उपयोग करता हूं , डॉक्स कहता है: boolean isConnectedOrConnecting ()इंगित करता है कि नेटवर्क कनेक्टिविटी मौजूद है या स्थापित होने की प्रक्रिया में है। यह उन अनुप्रयोगों के लिए अच्छा है जो डेटा पढ़ने या लिखने के अलावा नेटवर्क से संबंधित कुछ भी करने की आवश्यकता है। बाद के लिए, isConnected()इसके बजाय कॉल करें , जो गारंटी देता है कि नेटवर्क पूरी तरह से उपयोग करने योग्य है।
18446744073709551615

3

निम्न कोड (कोटलिन में) एपीआई 21 से कम से कम वर्तमान एपीआई संस्करण (एपीआई 29) तक काम करता है। फ़ंक्शन getWifiState () WiFi नेटवर्क स्थिति के लिए 3 संभावित मानों में से एक देता है: अक्षम करें, EnabledNotConnected और Connected जो कि किसी enum वर्ग में परिभाषित किए गए थे। यह उपयोगकर्ता को वाईफाई को सक्षम करने के लिए सूचित करने जैसे या पहले से ही सक्षम नेटवर्क में से एक से कनेक्ट करने के लिए और अधिक बारीक निर्णय लेने की अनुमति देता है। लेकिन अगर वह सब आवश्यक है जो यह इंगित करता है कि यदि वाईफाई इंटरफ़ेस एक नेटवर्क से जुड़ा है, तो यह इंगित करता है, तो अन्य फ़ंक्शन WifiConnected () आपको देगा। यह पिछले एक का उपयोग करता है और परिणाम की तुलना कनेक्टेड से करता है।

यह पिछले कुछ जवाबों में प्रेरित है लेकिन Android API के विकास या IP V6 की धीरे-धीरे बढ़ती उपलब्धता के कारण शुरू हुई समस्याओं को हल करने की कोशिश कर रहा है। चाल का उपयोग करना था:

wifiManager.connectionInfo.bssid != null 

के बजाय:

  1. getIpAddress () == 0 जो केवल IP V4 या के लिए मान्य है
  2. getNetworkId () == -1 जिसे अब एक और विशेष अनुमति (स्थान) की आवश्यकता है

प्रलेखन के अनुसार: https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid यह नेटवर्क से कनेक्ट नहीं होने पर अशक्त लौट आएगा। और यहां तक ​​कि अगर हमारे पास वास्तविक मूल्य प्राप्त करने की अनुमति नहीं है, तो भी यह जुड़ा होने पर अशक्त के अलावा कुछ और लौटाएगा।

निम्नलिखित को भी ध्यान में रखें:

Android.os.Build.VERSION_CODES # N से पहले रिलीज़ होने पर, यह ऑब्जेक्ट केवल एक कॉन्सेप्ट # getApplicationContext () से प्राप्त किया जाना चाहिए, और कॉलिंग प्रक्रिया के भीतर मेमोरी लीक से बचने के लिए किसी अन्य व्युत्पन्न संदर्भ से नहीं।

मेनिफेस्ट में, जोड़ना न भूलें:

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

प्रस्तावित कोड है:

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

NetworkInfoवर्ग, एपीआई स्तर 29 के रूप में हटा दिया गया है जैसे संबंधित पहुँच तरीकों के साथ-साथ ConnectivityManager#getNetworkInfo()और ConnectivityManager#getActiveNetworkInfo()

प्रलेखन अब लोगों को पता चलता है का उपयोग करने के ConnectivityManager.NetworkCallbackasynchronized कॉलबैक निगरानी, या उपयोग के लिए एपीआई ConnectivityManager#getNetworkCapabilitiesया ConnectivityManager#getLinkPropertiesनेटवर्क की जानकारी के सिंक्रनाइज़ पहुँच के लिए

इसके बजाय कॉल करने वालों को कनेक्टिविटी परिवर्तन के बारे में जानने के लिए ConnectivityManager.NetworkCallback API का उपयोग करना चाहिए, या कनेक्टिवटी जानकारी प्राप्त करने के लिए ConnectivityManager # getNetworkCapabilities या ConnectivityManager # getLinkProperties का उपयोग करने के लिए स्विच करना चाहिए।


यह देखने के लिए कि क्या वाईफाई कनेक्ट है, यहां वह कोड है जो मैं उपयोग करता हूं:

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
}

जावा:

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;
}

याद रखें कि ACCESS_NETWORK_STATEअपने मैनिफ़ेस्ट फ़ाइल की अनुमति भी जोड़ें ।


2

इस विधि को आजमाएं।

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;
}

इस विधि से इंटरनेट कनेक्शन उपलब्ध होने या नहीं मिलने में मदद मिलेगी।


1
मैं विशेष रूप से देख रहा था यदि सक्रिय कनेक्शन वाईफ़ाई है। इसके अलावा, congrgr पर एक अशक्त जांच करने की कोई आवश्यकता नहीं है यह कभी भी अशक्त नहीं होगा।
नाथन श्वरमन

क्या आप कृपया इस प्रश्न की जाँच कर सकते हैं ? :(
स्किज़ो- oz AugS

2

यह मेरे लिए काम करता है:

    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();
    }

और यह अनुमति जोड़ें:

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

2

उत्तर के कई पदावनत कोड, या higer एपीआई संस्करणों पर उपलब्ध कोड का उपयोग करते हैं। अब मैं कुछ इस तरह का उपयोग करता हूं

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

यहाँ मैं अपने ऐप्स में एक उपयोगिता विधि के रूप में उपयोग कर रहा हूं:

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();
}

यह इंगित करना अच्छा है कि जब आप कनेक्शन स्थापित करने के लिए जाँच कर रहे हों तो .ConnectedOrConnecting विधि महत्वपूर्ण है। IsConnected विधि ने मेरे लिए काम नहीं किया।
विन्सेंट

1

नए संस्करण में 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
            }
        }

    }
}

और प्रीमीशन भी जोड़ें


connManager.getAllNetworks()एपीआई स्तर 21 की आवश्यकता होती है।
जवान सिंह

1

@ जैसन नाइट जवाब के समान, लेकिन कोटलिन में:

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

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

ConnectivityManager.TYPE_WIFIपदावनत किया गया है
Jérôme Pietri

0

यह एक आसान उपाय है। स्टैक ओवरफ्लो प्रश्न देखें एंड्रॉइड पर सक्षम वाई-फाई की जांच करना या नहीं

PS अनुमति देने के लिए मैनिफ़ेस्ट.xml फ़ाइल में कोड जोड़ना न भूलें। जैसा की नीचे दिखाया गया।

<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

प्रयत्न

wifiManager.getConnectionInfo().getIpAddress()

यह 0 देता है जब तक कि डिवाइस का उपयोग करने योग्य कनेक्शन (मेरी मशीन पर, एक सैमसंग SM-T280, Android 5.1.1) है।


0

यदि आप निम्न के रूप में सक्रिय नहीं हैं, तो आप वाईफ़ाई चालू कर सकते हैं। @ जैसन नाइट 2 द्वारा उत्तर दिए गए वाईफ़ाई राज्य की जाँच करें। यदि सक्रिय नहीं है, तो इसे सक्रिय करें, प्रकट फ़ाइल में वाईफ़ाई अनुमति जोड़ने के लिए मत भूलना

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

आपका जावा वर्ग ऐसा होना चाहिए

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

इसे जावा के लिए जोड़ें:

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;
        }
    }

मैनिफ़ेस्ट फ़ाइल में निम्न अनुमतियाँ जोड़ें:

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

0

पुराने एक प्रश्न की तरह, लेकिन यह वही है जो मैं उपयोग करता हूं। न्यूनतम एपीआई स्तर 21 की आवश्यकता होती है, यह भी सोचता है कि नेटवर्किनएफ़ एपिस को हटा दिया गया है।

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;
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.