代码

private void sendReceiver() {
        Log.i("tag", "sendReceiver");
        IntentFilter filter = new IntentFilter();
        filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        filter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
        wifiStateReceiver = new WifiStateReceiver();
        mContext.registerReceiver(wifiStateReceiver, filter);
    }
    
private void stopReceiver() {
        Log.i("tag", "stopReceiver");
        if (wifiStateReceiver != null) {
            mContext.unregisterReceiver(wifiStateReceiver);
            wifiStateReceiver = null;
        }
    }

 private class WifiStateReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            // 这个监听wifi的打开与关闭，与wifi的连接无关
            if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                Log.i("tag", "WIFI_STATE_CHANGED_ACTION");
                int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
                switch (wifiState) {
                    case WifiManager.WIFI_STATE_DISABLED:
                        break;
                    case WifiManager.WIFI_STATE_DISABLING:
                        break;
                    case WifiManager.WIFI_STATE_ENABLED:
                        break;
                    case WifiManager.WIFI_STATE_ENABLING:
                        break;
                    case WifiManager.WIFI_STATE_UNKNOWN:
                        break;
                }
            }
            // 这个监听wifi的连接状态即是否连上了一个有效无线路由，
            // 当上边广播的状态是WifiManager.WIFI_STATE_DISABLING，和WIFI_STATE_DISABLED的时候，根本不会接到这个广播。
            // 在上边广播接到广播是WifiManager.WIFI_STATE_ENABLED状态的同时也会接到这个广播，
            // 当然刚打开wifi肯定还没有连接到有效的无线
            if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                Log.i("tag", "NETWORK_STATE_CHANGED_ACTION");
                Parcelable parcelableExtra = intent
                        .getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                if (null != parcelableExtra) {
                    NetworkInfo networkInfo = (NetworkInfo) parcelableExtra;
                    NetworkInfo.State state = networkInfo.getState();
                    boolean isConnected = state == NetworkInfo.State.CONNECTED;// 当然，这边可以更精确的确定状态
                    if (isConnected) {
                    } else {
                    }
                }
            }
            // 这个监听网络连接的设置，包括wifi和移动数据的打开和关闭。.
            // 最好用的还是这个监听。
            // wifi如果打开，关闭，以及连接上可用的连接都会接到监听。
            // 这个广播的最大弊端是比上边两个广播的反应要慢，如果只是要监听wifi，我觉得还是用上边两个配合比较合适
            if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
                Log.i("tag", "CONNECTIVITY_ACTION");
                ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
                NetworkInfo gprs = manager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
                NetworkInfo wifi = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
                Log.i("tag", "网络状态改变:" + wifi.isConnected() + " 3g:" + gprs.isConnected());
                NetworkInfo info = intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
     
                if (info != null) {
                    Log.i("tag", "info.getTypeName():" + info.getTypeName());
                    Log.i("tag", "getSubtypeName():" + info.getSubtypeName());
                    Log.i("tag", "getState():" + info.getState());
                    Log.i("tag", "getDetailedState():" + info.getDetailedState().name());
                    Log.i("tag", "getDetailedState():" + info.getExtraInfo());
                    Log.i("tag", "getType():" + info.getType());

                    if (NetworkInfo.State.CONNECTED == info.getState()) {
                    } else if (info.getType() == 1) {
                        if (NetworkInfo.State.DISCONNECTING == info.getState()) {
                        }
                    }
                }
            }
            if (WifiManager.SUPPLICANT_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                Log.i("tag", "SUPPLICANT_STATE_CHANGED_ACTION");
//                WifiManager.WIFI_STATE_DISABLED ==1
//                WifiManager.WIFI_STATE_DISABLING ==0
//                WifiManager. WIFI_STATE_ENABLED==3
//                WifiManager. WIFI_STATE_ENABLING==2
//                WifiManager. WIFI_STATE_UNKNOWN==4
                int linkWifiResult = intent.getIntExtra(WifiManager.EXTRA_SUPPLICANT_ERROR, -1);
                Log.i("tag", "linkWifiResult -> " + linkWifiResult);
            }
        }
    }

权限

还需要再AndroidManifest.xml里添加一些网络权限

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

Linux中c语言实现获取wifi状态

    获取wifi信息有两种方案，参考ifconfig程序使用c语言实现，或者使用命令抓取关键词。

1、c语言实现

    废话不多说直接上代码。

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/wireless.h>
#include <string.h> 
#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>

#define NET_PORT 53
#define NET_IP "8.8.8.8" //谷歌DNS

int main()
{
	int sockfd;
	struct iwreq wreq;
	struct iw_statistics stats;
	char buffer[32];
	int in_len=0;
  	struct sockaddr_in servaddr;
	memset(buffer, 0, 32);
	memset(&stats, 0, sizeof(stats));
	memset(&wreq, 0, sizeof(wreq));
	strcpy(wreq.ifr_name, "wlan0");
	
	if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) //建立socket，用于接收来自ioctl函数的消息。由于是sock_DGRAM,所以是UDP。如果是SOCK_STREAM,则是TCP。
	{
		perror("Could not create simple datagram socket");
		exit(EXIT_FAILURE);
	}

	in_len = sizeof(struct sockaddr_in);
    /*设置默认服务器的信息*/
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(NET_PORT);
	servaddr.sin_addr.s_addr = inet_addr(NET_IP);
	memset(servaddr.sin_zero,0,sizeof(servaddr.sin_zero));
	/*connect 函数*/
	if(connect(sockfd,(struct sockaddr* )&servaddr,in_len) < 0 ) 
	{   

	    printf("not connect to internet!\n ");
	    close(sockfd);
	    return 0; 
	}else{   
	    printf("       connect ok!       \n");
	}  

//ioctl获取Signal level
	wreq.u.data.pointer = &stats;
	wreq.u.data.length = sizeof(iw_statistics);
	if(ioctl(sockfd, SIOCGIWSTATS, &wreq) == -1) 
	{
		perror("Error performing SIOCGIWSTATS");
		close(sockfd);
		exit(EXIT_FAILURE);
	}else{
		// IW_QUAL_DBM表示Level + Noise are dBmm
		printf("Signal level%s is %d%s.\n",(stats.qual.updated & IW_QUAL_DBM ? " (in dBm)" :""),(signed char)stats.qual.level,
		(stats.qual.updated & IW_QUAL_LEVEL_UPDATED ? " (updated)" :""));
	}

//ioctl获取essid
	wreq.u.essid.pointer = buffer;//如果不写这行可能会错误
	wreq.u.essid.length = 32; 
	if (ioctl(sockfd,SIOCGIWESSID, &wreq) == -1) {
	 	perror("IOCTL SIOCGIWESSID Failed,error");
	 	exit(2);
	}else {	
	 	//printf("IOCTL SIOCGIWESSID Successfull\n");
		printf("The essid is:%s\n",wreq.u.essid.pointer);        //network name
	}
	close(sockfd);
	return 0;
}

    首先建立socket，函数原型即：int socket(int domain, int type, int protocol)，再建立connect连接，我是用的谷歌的DNS:8.8.8.8来测试连接外网。如果连接成功后就可获取wifi名字和强度了。
    接下来使用ioctl函数，ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，它的调用个数如下：
int ioctl(int fd, ind cmd, …)；
    其中fd是用户程序打开设备时使用open函数返回的文件标示符，cmd是用户程序对设备的控制命令，至于后面的省略号，那是一些补充参数，一般最多一个，这个参数的有无和cmd的意义相关。
    ioctl函数是文件结构中的一个属性分量，就是说如果你的驱动程序提供了对ioctl的支持，用户就可以在用户程序中使用ioctl函数来控制设备的I/O通道。

2、命令抓取方式

    FILE* fp=NULL;
    char buf[100] = {0};    
    char command[300] = " sudo iwlist wlan0 scan";
    char str1[100];
    char str2[100];
    char *q = NULL;
    memset(str1, '\0', sizeof(str1));
    memset(str2, '\0', sizeof(str2));
    if((fp = popen(command, "r")) != NULL)
    {
     //   printf("popen command success\n");
        while(fgets(buf, sizeof(buf), fp) != NULL)
        {
            //printf("buf=%s\n", buf);
            q = strstr(buf, "ESSID:");
            if (q != NULL)
            {
                //	printf("q =NULL\n");
                sscanf(q, "ESSID:\"%[^\"]\"", str1);
                q = NULL;
            }
            q = strstr(buf, "Signal level=");
            if (q != NULL)
            {
                //	printf("q =NULL\n");
                sscanf(q, "Signal level=%[^/]", str2);
                q = NULL;
                strcat(str1,"");
                strcat(str1,str2);
                wifilist.append(str1);
            }
        }
        pclose(fp);
    }

    popen将命令sudo iwlist wlan0 scan通过管道读到fp，fgets函数从指定的流中读取数据，每次读取一行。其原型为：
    char *fgets(char *str, int n, FILE *stream);从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。使用strstr进行配对，再sscanf扫毛，函数具体实现可自行百度。
    小编是实习小白，查了很多资料来用c语言实现，但是对于ioctl函数得到wifi信息方式概念还是很模糊，希望对你们有所帮助吧。

版权声明：本文为博主原创文章，未经博主允许不得转载。https://blog.csdn.net/huangweiqing80/article/details/82494498
1. WifiController状态机
WifiController 是高级别的wifi状态机，它管理的状态是wifi开关，wifi热点开关等状态。只有在wifi开关等具体状态下，判断wifi处于启动扫描附近热点状态等才是有意义的。

1.1 WifiController状态机的创建

mWifiController = new WifiController(mContext, mWifiStateMachine, mSettingsStore,
                mLockManager, mWifiServiceHandlerThread.getLooper(), mFrameworkFacade); 

状态机初始化三部曲：

addState
setInitialState
start

状态机无非就是一个定义了很多状态的机器，它收到消息后，会根据消息来切换这个机器的状态。WifiController 的状态构造在它的构造方法中。当我们创建一个状态机时，需要使用addState方法给状态机添加状态
frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiController.java

    WifiController(Context context, WifiStateMachine wsm, WifiSettingsStore wss,
            WifiLockManager wifiLockManager, Looper looper, FrameworkFacade f) {
    ...

        addState(mDefaultState);
            addState(mApStaDisabledState, mDefaultState);
            addState(mStaEnabledState, mDefaultState);
                addState(mDeviceActiveState, mStaEnabledState);
                addState(mDeviceInactiveState, mStaEnabledState);
                    addState(mScanOnlyLockHeldState, mDeviceInactiveState);
                    addState(mFullLockHeldState, mDeviceInactiveState);
                    addState(mFullHighPerfLockHeldState, mDeviceInactiveState);
                    addState(mNoLockHeldState, mDeviceInactiveState);
            addState(mStaDisabledWithScanState, mDefaultState);
            addState(mApEnabledState, mDefaultState);
            addState(mEcmState, mDefaultState);

        boolean isAirplaneModeOn = mSettingsStore.isAirplaneModeOn();
        boolean isWifiEnabled = mSettingsStore.isWifiToggleEnabled();
        boolean isScanningAlwaysAvailable = mSettingsStore.isScanAlwaysAvailable();

        log("isAirplaneModeOn = " + isAirplaneModeOn +
                ", isWifiEnabled = " + isWifiEnabled +
                ", isScanningAvailable = " + isScanningAlwaysAvailable);

        if (isScanningAlwaysAvailable) {
            setInitialState(mStaDisabledWithScanState);
        } else {
            setInitialState(mApStaDisabledState);
        }

从WifiController的构造函数中，我们可以看到使用addState方法给状态机添加了状态，用setInitialState给状态机设置了初始状态mApStaDisabledState

而WifiController的start方法是由WifiService的onBootPhase方法调用WifiServiceImpl的checkAndStartWifi调用的：

    /**
     * Check if we are ready to start wifi.
     *
     * First check if we will be restarting system services to decrypt the device. If the device is
     * not encrypted, check if Wi-Fi needs to be enabled and start if needed
     *
     * This function is used only at boot time.
     */
    public void checkAndStartWifi() {
        ...
        mWifiController.start();
        ...
    }

WifiController状态机的状态结构图如下

2 mWifiStateMachine状态机
WifiStateMachine状态机的创建

        mWifiStateMachine = new WifiStateMachine(mContext, mFrameworkFacade,
                wifiStateMachineLooper, UserManager.get(mContext),
                this, mBackupManagerProxy, mCountryCode, mWifiNative,
                new WrongPasswordNotifier(mContext, mFrameworkFacade));

mWifiStateMachine 则表述wifi更加细致的状态，它的状态构建也是在构造函数中：
frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiStateMachine.java

public WifiStateMachine(Context context, FrameworkFacade facade, Looper looper,
                        UserManager userManager, WifiInjector wifiInjector,
                        BackupManagerProxy backupManagerProxy, WifiCountryCode countryCode,
                        WifiNative wifiNative,
                        WrongPasswordNotifier wrongPasswordNotifier) {
  ...
    // CHECKSTYLE:OFF IndentationCheck
    addState(mDefaultState);
        addState(mInitialState, mDefaultState);
        addState(mSupplicantStartingState, mDefaultState);
        addState(mSupplicantStartedState, mDefaultState);
                addState(mScanModeState, mSupplicantStartedState);
                addState(mConnectModeState, mSupplicantStartedState);
                    addState(mL2ConnectedState, mConnectModeState);
                        addState(mObtainingIpState, mL2ConnectedState);
                        addState(mConnectedState, mL2ConnectedState);
                        addState(mRoamingState, mL2ConnectedState);
                    addState(mDisconnectingState, mConnectModeState);
                    addState(mDisconnectedState, mConnectModeState);
                    addState(mWpsRunningState, mConnectModeState);
            addState(mWaitForP2pDisableState, mSupplicantStartedState);
        addState(mSupplicantStoppingState, mDefaultState);
        addState(mSoftApState, mDefaultState);
    // CHECKSTYLE:ON IndentationCheck

    setInitialState(mInitialState);

    setLogRecSize(NUM_LOG_RECS_NORMAL);
    setLogOnlyTransitions(false);

    //start the state machine
    start();

从WifiStateMachine的构造函数中，我们可以看到使用addState方法给状态机添加了状态，用setInitialState给状态机设置了初始状态mInitialState，用start()启动状态机
WifiStateMachine状态机的状态结构图如下

以上Android wifi框架中两个重要的状态机，那么状态机的工作机制是怎么样的呢？

3 状态机工作原理简介：
状态机中会有多种状态，状态机中的每一个状态是由State类的实例表示，State实例必须实现processMessage方法用来处理消息。并且可选的实现enter/exit/getName三个方法，enter/exit 等价于类的构造方法和销毁方法，本例用于初始化和清理一个状态。getName方法返回State的名字，默认的实现是返回类名。
当我们创建一个状态机时，需要使用addState方法给状态机添加状态，正如前面所展示的那样。 用于初始化一个状态机的初始状态。构建好一个状态机以后，我们需要调用start方法启动这个状态机，它就像一个机器，造好以后，加油或者充电，然后发动它，它就进入工作状态了。这个过程会调用初始化状态的enter方法初始化初始状态，如果初始状态由父状态，就会递归调用父状态，直到所有父状态的enter方法被调用。这样才算是完全初始化好了一个状态机，start方法还会使状态机进入已经构造结束阶段，这个时候，当有消息到来时，状态机就可以处理消息了。
处理消息的过程和初始化类似。当消息到来以后，当前状态就会调用processMessage来处理消息，如果当前消息能够处理消息，那么消息处理过程就结束了，此时会根据具体情况选择切换或者不切换状态机的状态。如果当前State不能处理消息，那么就会递交父State的processMessage来处理，父状态如果还不能处理就继续往上递交。如果一个消息从未被处理，unhandledMessage方法会被调用，这是最后处理这个消息的机会了。
如果我们期望停止状态机，可以调用quitNow或者quit方法。
当我们切换状态时，旧State的exit方法会被调用而新State的enter方法会被调用，同时他们父State也会做相同的事情。但是如果两个状态由相同的父状态，那么这个时候他们父状态就没有必要做任何操作了，因为它的状态其实并没有变。
以上就是一个状态机的工作原理的简要概述。下面我举个例子，当应用程序需要扫描附近的热点时，如果wifi状态机正处于开启状态，那么上层的操作会导致wifi状态机接收到一个消息，开启的状态对它处理后，发现需要把wifi状态机切换到scan状态，（在processMessage中调用transitionTo切换状态）于是开启状态的exit方法被调用，scan状态的enter方法被调用。切换不应该只是wifi状态机状态的切换，这个过程应该会调用底层的代码真正的把wifi的状态切换到对应的状态。切换过去以后底层kernel会返回响应的事件，这又会导致响应的消息被wifi状态机接受，从而又促使wifi状态机状态的切换。

start()方法用于启动状态机，transitionTo()方法用于设置新状态performTransitions（）是去切换新状态，sendMessage()方法用于向mSmHandler发送消息，mSmHandler的handleMessage方法会把消息抛个当前状态的proccessMessage()方法处理。