试谈android中WIFI源码

最新推荐文章于 2024-04-03 21:15:03 发布
最新推荐文章于 2024-04-03 21:15:03 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： android 文章标签： android开发

试谈android中WIFI源码

网上关于如何用代码设置wifi的文章一搜一大堆，小蒋在此就不再添乱了，我就试着给大家谈一谈wifi的源码吧。

首先，我还是得从代码入手，下面是设置打开wifi的相关代码：

view source
print ?
01private WifiManager mWifiManager;  
02 
03 
04public WifiAdmin(Context context){  
05    //取得WifiManager对象  
06    mWifiManager=(WifiManager)context.getSystemService(Context.WIFI_SERVICE);  
07    //取得WifiInfo对象  
08    mWifiInfo=mWifiManager.getConnectionInfo();  
09}  
10//打开wifi  
11public void openWifi(){  
12    if(!mWifiManager.isWifiEnabled()){  
13        mWifiManager.setWifiEnabled(true);  
14    }  
15}
很简单的一个函数--setWifiEnabled（ture），那我们开始分析吧！

首先找到WifiManager.java(frameworks/base/wifi/java/android/net/wifi)，里面有

view source
print ?
01public class WifiManager {
02  
03    IWifiManager mService;
04  
05     /**
06     * Enable or disable Wi-Fi.
07     * @param enabled {@code true} to enable, {@code false} to disable.
08     * @return {@code true} if the operation succeeds (or if the existing state
09     *         is the same as the requested state).
10     */
11    public boolean setWifiEnabled(boolean enabled) {
12        try {
13            return mService.setWifiEnabled(enabled);
14        } catch (RemoteException e) {
15            return false;
16        }
17    }
18  
19}

IWifiManager也是什么东西呢？在frameworks/base/wifi/java/android/net/wifi里面你会发现一个叫做IWifiManager.aidl的文件

view source
print ?
1interface IWifiManager
2{
3  
4    boolean setWifiEnabled(boolean enable);
5  
6    
7}

这是一个aidl文件，如果有不懂的请看我的其他文章，这个interface会在WifiService.java里面实现（frameworks/base/services/java/com/android/server）

view source
print ?
01/**
02 * WifiService handles remote WiFi operation requests by implementing
03 * the IWifiManager interface. It also creates a WifiMonitor to listen
04 * for Wifi-related events.
05 *
06 * @hide
07 */
08public class WifiService extends IWifiManager.Stub {
09  
10   private final  WifiHandler mWifiHandler;
11   private Context mContext;
12   private static PowerManager.WakeLock sWakeLock;
13    /**
14     * see {@link android.net.wifi.WifiManager#setWifiEnabled(boolean)}
15     * @param enable {@code true} to enable, {@code false} to disable.
16     * @return {@code true} if the enable/disable operation was
17     *         started or is already in the queue.
18     */
19    public boolean setWifiEnabled(boolean enable) {
20        enforceChangePermission();
21        if (mWifiHandler == null) return false;
22  
23        synchronized (mWifiHandler) {
24            // caller may not have WAKE_LOCK permission - it's not required here
25            long ident = Binder.clearCallingIdentity();
26            sWakeLock.acquire();
27            Binder.restoreCallingIdentity(ident);
28  
29            mLastEnableUid = Binder.getCallingUid();
30            // set a flag if the user is enabling Wifi while in airplane mode
31            mAirplaneModeOverwridden = (enable && isAirplaneModeOn() && isAirplaneToggleable());
32            sendEnableMessage(enable, true, Binder.getCallingUid());
33        }
34  
35        return true;
36    }
37  
38    private void enforceChangePermission() {
39        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.CHANGE_WIFI_STATE,
40                                                "WifiService");
41  
42    }
43     

enforceCallingOrSelfPermission(..,..)函数就是检查是否具有权限，若没有则抛出异常。Binder.clearCallingIdentity()和Binder.restoreCallingIdentity()这两个方法，它的主要作用是暂时获得系统权限,acquire函数就是申请一把锁，以后释放。后面的sendEnableMessage函数

view source
print ?
1private void sendEnableMessage(boolean enable, boolean persist, int uid) {
2    Message msg = Message.obtain(mWifiHandler,
3                                 (enable ? MESSAGE_ENABLE_WIFI : MESSAGE_DISABLE_WIFI),
4                                 (persist ? 1 : 0), uid);
5    msg.sendToTarget();
6}
这个学android的人应该都知道是什么吧，看看handler
view source
print ?
01/**
02   * Handler that allows posting to the WifiThread.
03   */
04  private class WifiHandler extends Handler {
05      public WifiHandler(Looper looper) {
06          super(looper);
07      }
08 
09      @Override
10      public void handleMessage(Message msg) {
11          switch (msg.what) {
12 
13              case MESSAGE_ENABLE_WIFI:
14                  setWifiEnabledBlocking(true, msg.arg1 == 1, msg.arg2);
15                  if (mWifiWatchdogService == null) {
16                      mWifiWatchdogService = new WifiWatchdogService(mContext, mWifiStateTracker);
17                  }
18                  sWakeLock.release();
19                  break;
20 
21          }
22      }
23  }

这里的msg.arg2就是uid，看下里面的setWifiEnabledBlocking函数，此代码段为代码段一！

view source
print ?
01/**
02 * Enables/disables Wi-Fi synchronously.
03 * @param enable {@code true} to turn Wi-Fi on, {@code false} to turn it off.
04 * @param persist {@code true} if the setting should be persisted.
05 * @param uid The UID of the process making the request.
06 * @return {@code true} if the operation succeeds (or if the existing state
07 *         is the same as the requested state)
08 */
09private boolean setWifiEnabledBlocking(boolean enable, boolean persist, int uid) {
10    final int eventualWifiState = enable ? WIFI_STATE_ENABLED : WIFI_STATE_DISABLED;
11    final int wifiState = mWifiStateTracker.getWifiState();
12 
13    if (wifiState == eventualWifiState) {
14        return true;
15    }
16    if (enable && isAirplaneModeOn() && !mAirplaneModeOverwridden) {
17        return false;
18    }
19 
20    /**
21     * Multiple calls to unregisterReceiver() cause exception and a system crash.
22     * This can happen if a supplicant is lost (or firmware crash occurs) and user indicates
23     * disable wifi at the same time.
24     * Avoid doing a disable when the current Wifi state is UNKNOWN
25     * TODO: Handle driver load fail and supplicant lost as seperate states
26     */
27    if ((wifiState == WIFI_STATE_UNKNOWN) && !enable) {
28        return false;
29    }
30 
31    /**
32     * Fail Wifi if AP is enabled
33     * TODO: Deprecate WIFI_STATE_UNKNOWN and rename it
34     * WIFI_STATE_FAILED
35     */
36    if ((mWifiApState == WIFI_AP_STATE_ENABLED) && enable) {
37        setWifiEnabledState(WIFI_STATE_UNKNOWN, uid);
38        return false;
39    }
40 
41    setWifiEnabledState(enable ? WIFI_STATE_ENABLING : WIFI_STATE_DISABLING, uid);
42 
43    if (enable) {
44        if (!mWifiStateTracker.loadDriver()) {
45            Slog.e(TAG, "Failed to load Wi-Fi driver.");
46            setWifiEnabledState(WIFI_STATE_UNKNOWN, uid);
47            return false;
48        }
49        if (!mWifiStateTracker.startSupplicant()) {
50            mWifiStateTracker.unloadDriver();
51            Slog.e(TAG, "Failed to start supplicant daemon.");
52            setWifiEnabledState(WIFI_STATE_UNKNOWN, uid);
53            return false;
54        }
55 
56        registerForBroadcasts();
57        mWifiStateTracker.startEventLoop();
58 
59    }
60}
关键的就是从WifiStateTracker的loadDriver和startSupplicant开始(frameworks/base/wifi/java/android/net/wifi)
view source
print ?
1public synchronized boolean loadDriver() {
2    return WifiNative.loadDriver();
3}
view source
print ?
1public synchronized boolean startSupplicant() {
2    return WifiNative.startSupplicant();
3}

这调用了WifiNative的loadDriver与startSupplicant函数，注意，所有的WifiNative中的调用都需要发生在WifiStateTracker类中，除了waitForEvent()

view source
print ?
1public class WifiNative {
2  
3    public native static boolean loadDriver();
4    public native static boolean startSupplicant();
5  
6}

这个native里面的调用是为了发送请求到supplicant daemon以及从获取异步事件。这个loadDriver实际上是通过JNI去实现的，实现于android_net_wifi_WIFI.cpp(frameworks/base/core/jni)
view source
print ?
1static jboolean android_net_wifi_loadDriver(JNIEnv* env, jobject clazz)
2{
3    return (jboolean)(::wifi_load_driver() == 0);
4}
5static jboolean android_net_wifi_startSupplicant(JNIEnv* env, jobject clazz)
6{
7    return (jboolean)(::wifi_start_supplicant() == 0);
8}
而这两个系统级的函数实现于wifi.c（hardware/libhardware_legacy）
view source
print ?
01int wifi_load_driver()
02{
03    char driver_status[PROPERTY_VALUE_MAX];
04    int count = 100; /* wait at most 20 seconds for completion */
05  
06    if (check_driver_loaded()) {
07        return 0;
08    }
09  
10    if (insmod(DRIVER_MODULE_PATH, DRIVER_MODULE_ARG) < 0)
11        return -1;
12  
13    if (strcmp(FIRMWARE_LOADER,"") == 0) {
14        usleep(WIFI_DRIVER_LOADER_DELAY);
15        property_set(DRIVER_PROP_NAME, "ok");
16    }
17    else {
18        property_set("ctl.start", FIRMWARE_LOADER);
19    }
20    sched_yield();
21    while (count-- > 0) {
22        if (property_get(DRIVER_PROP_NAME, driver_status, NULL)) {
23            if (strcmp(driver_status, "ok") == 0)
24                return 0;
25            else if (strcmp(DRIVER_PROP_NAME, "failed") == 0) {
26                wifi_unload_driver();
27                return -1;
28            }
29        }
30        usleep(200000);
31    }
32    property_set(DRIVER_PROP_NAME, "timeout");
33    wifi_unload_driver();
34    return -1;
35}
36  
37int wifi_unload_driver()
38{
39    int count = 20; /* wait at most 10 seconds for completion */
40  
41    if (rmmod(DRIVER_MODULE_NAME) == 0) {
42    while (count-- > 0) {
43        if (!check_driver_loaded())
44        break;
45            usleep(500000);
46    }
47    if (count) {
48            return 0;
49    }
50    return -1;
51    } else
52        return -1;
53}

这些都是驱动相关的信息，下面的是startSupplicant函数的实现

view source
print ?
01int wifi_start_supplicant()
02{
03    char supp_status[PROPERTY_VALUE_MAX] = {'\0'};
04    int count = 200; /* wait at most 20 seconds for completion */
05#ifdef HAVE_LIBC_SYSTEM_PROPERTIES
06    const prop_info *pi;
07    unsigned serial = 0;
08#endif
09  
10    /* Check whether already running */
11    if (property_get(SUPP_PROP_NAME, supp_status, NULL)
12            && strcmp(supp_status, "running") == 0) {
13        return 0;
14    }
15  
16    /* Before starting the daemon, make sure its config file exists */
17    if (ensure_config_file_exists() < 0) {
18        LOGE("Wi-Fi will not be enabled");
19        return -1;
20    }
21  
22    /* Clear out any stale socket files that might be left over. */
23    wpa_ctrl_cleanup();
24  
25#ifdef HAVE_LIBC_SYSTEM_PROPERTIES
26    /*
27     * Get a reference to the status property, so we can distinguish
28     * the case where it goes stopped => running => stopped (i.e.,
29     * it start up, but fails right away) from the case in which
30     * it starts in the stopped state and never manages to start
31     * running at all.
32     */
33    pi = __system_property_find(SUPP_PROP_NAME);
34    if (pi != NULL) {
35        serial = pi->serial;
36    }
37#endif
38    property_set("ctl.start", SUPPLICANT_NAME);
39    sched_yield();
40  
41    while (count-- > 0) {
42#ifdef HAVE_LIBC_SYSTEM_PROPERTIES
43        if (pi == NULL) {
44            pi = __system_property_find(SUPP_PROP_NAME);
45        }
46        if (pi != NULL) {
47            __system_property_read(pi, NULL, supp_status);
48            if (strcmp(supp_status, "running") == 0) {
49                return 0;
50            } else if (pi->serial != serial &&
51                    strcmp(supp_status, "stopped") == 0) {
52                return -1;
53            }
54        }
55#else
56        if (property_get(SUPP_PROP_NAME, supp_status, NULL)) {
57            if (strcmp(supp_status, "running") == 0)
58                return 0;
59        }
60#endif
61        usleep(100000);
62    }
63    return -1;
64}

这段代码是属于启动supplicant服务。

现在继续回到代码段一，往下走是setWifiEnabledState函数，此处为代码段二！

view source
print ?
01private void setWifiEnabledState(int wifiState, int uid) {
02    final int previousWifiState = mWifiStateTracker.getWifiState();
03 
04    long ident = Binder.clearCallingIdentity();
05    try {
06        if (wifiState == WIFI_STATE_ENABLED) {
07            mBatteryStats.noteWifiOn();
08        } else if (wifiState == WIFI_STATE_DISABLED) {
09            mBatteryStats.noteWifiOff();
10        }
11    } catch (RemoteException e) {
12    } finally {
13        Binder.restoreCallingIdentity(ident);
14    }
15 
16    // Update state
17    mWifiStateTracker.setWifiState(wifiState);
18 
19    // Broadcast
20    final Intent intent = new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION);
21    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
22    intent.putExtra(WifiManager.EXTRA_WIFI_STATE, wifiState);
23    intent.putExtra(WifiManager.EXTRA_PREVIOUS_WIFI_STATE, previousWifiState);
24    mContext.sendStickyBroadcast(intent);
25}
try那一块的功能就是在获得系统权限后根据wifi状态更改，同样是通过stub，BatteryStatsService.java里面实现（frameworks/base/services/java/com/android/server/am）
view source
print ?
01public final class BatteryStatsService extends IBatteryStats.Stub {
02  
03  
04    final BatteryStatsImpl mStats;
05  
06  
07    public void noteWifiOn() {
08        enforceCallingPermission();
09        synchronized (mStats) {
10            mStats.noteWifiOnLocked();
11        }
12    }
13  
14  
15}

查找BatteryStateImpl.java（freameworks/base/core/java/com/android/internal/os）

view source
print ?
01public void noteWifiOnLocked() {
02    if (!mWifiOn) {
03        mHistoryCur.states |= HistoryItem.STATE_WIFI_ON_FLAG;
04        if (DEBUG_HISTORY) Slog.v(TAG, "WIFI on to: "
05                + Integer.toHexString(mHistoryCur.states));
06        addHistoryRecordLocked(SystemClock.elapsedRealtime());
07        mWifiOn = true;
08        mWifiOnTimer.startRunningLocked(this);
09    }
10}
其中的mWifiOnTimer是个StopwatchTimer类型的对象，mWifiOn只是一个boolean类型。再看看代码段二
view source
print ?
1public void setWifiState(int wifiState) {
2    mWifiState.set(wifiState);
3}
而mWifistated的声明为
view source
print ?
01/**
02 * One of  {@link WifiManager#WIFI_STATE_DISABLED},
03 *         {@link WifiManager#WIFI_STATE_DISABLING},
04 *         {@link WifiManager#WIFI_STATE_ENABLED},
05 *         {@link WifiManager#WIFI_STATE_ENABLING},
06 *         {@link WifiManager#WIFI_STATE_UNKNOWN}
07 *
08 * getWifiState() is not synchronized to make sure it's always fast,
09 * even when the instance lock is held on other slow operations.
10 * Use a atomic variable for state.
11 */
12private final AtomicInteger mWifiState = new AtomicInteger(WIFI_STATE_UNKNOWN);

AtomicInteger，一个提供原子操作的Integer的类。在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。再接着看代码段二，就是讲wifi事件广播出去，通知监听此事件的事务。然而在wifisettings.java（packages/apps/settings/src/com/android/settings/wifi）里面会监听到此事件。

view source
print ?
1private void handleEvent(Intent intent) {
2    String action = intent.getAction();
3    if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) {
4        updateWifiState(intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
5                WifiManager.WIFI_STATE_UNKNOWN));
6    } else if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action)) {
7        updateAccessPoints();
8    }
9}
监听到进行updateWifiState处理, 此处为代码段三！
view source
print ?
1private void updateWifiState(int state) {
2    if (state == WifiManager.WIFI_STATE_ENABLED) {
3        mScanner.resume();
4        updateAccessPoints();
5    } else {
6        mScanner.pause();
7        mAccessPoints.removeAll();
8    }
9}
由于先前传入的就是WIFI_STATE_ENABLED，所以进行resume与updateAccessPoints函数处理。先看下Scanner吧
view source
print ?
01private class Scanner extends Handler {
02    private int mRetry = 0;
03 
04    void resume() {
05        if (!hasMessages(0)) {
06            sendEmptyMessage(0);
07        }
08    }
09 
10    void pause() {
11        mRetry = 0;
12        mAccessPoints.setProgress(false);
13        removeMessages(0);
14    }
15 
16    @Override
17    public void handleMessage(Message message) {
18        if (mWifiManager.startScanActive()) {
19            mRetry = 0;
20        } else if (++mRetry >= 3) {
21            mRetry = 0;
22            Toast.makeText(WifiSettings.this, R.string.wifi_fail_to_scan,
23                    Toast.LENGTH_LONG).show();
24            return;
25        }
26        mAccessPoints.setProgress(mRetry != 0);
27        sendEmptyMessageDelayed(0, 6000);
28    }
startScanActive他会调用wifiManager.java里面的startScanActive函数
view source
print ?
1public boolean startScanActive() {
2    try {
3        mService.startScan(true);
4        return true;
5    } catch (RemoteException e) {
6        return false;
7    }
8}
接着会调用wifiService.java里面的startScan函数
view source
print ?
1public void startScan(boolean forceActive) {
2      enforceChangePermission();
3      if (mWifiHandler == null) return;
4 
5      Message.obtain(mWifiHandler, MESSAGE_START_SCAN, forceActive ? 1 : 0, 0).sendToTarget();
6  }

发送消息到wifiHandler，那么看下对应的响应，此处为代码段四！

view source
print ?
01case MESSAGE_START_SCAN:
02    boolean forceActive = (msg.arg1 == 1);
03    switch (mWifiStateTracker.getSupplicantState()) {
04        case DISCONNECTED:
05        case INACTIVE:
06        case SCANNING:
07        case DORMANT:
08            break;
09        default:
10            mWifiStateTracker.setScanResultHandling(
11                    WifiStateTracker.SUPPL_SCAN_HANDLING_LIST_ONLY);
12            break;
13    }
14    mWifiStateTracker.scan(forceActive);
15    break;
首选根据supplicant的状态来执行不同的方法
view source
print ?
1public SupplicantState getSupplicantState() {
2    return mWifiInfo.getSupplicantState();
3}
从wifiInfo中获取supplicantState
view source
print ?
1public SupplicantState getSupplicantState() {
2    return mSupplicantState;
3}

这个返回的是supplicantState与AP协商后的详细状态。（Return the detailed state of the supplicant's negotiation with an access point）。接着看代码段四，下面遇到两个函数

view source
print ?
01public synchronized boolean scan(boolean forceActive) {
02    if (mWifiState.get() != WIFI_STATE_ENABLED || isDriverStopped()) {
03        return false;
04    }
05    return WifiNative.scanCommand(forceActive);
06}
07 
08/**
09 * Specifies whether the supplicant or driver
10 * take care of initiating scan and doing AP selection
11 *
12 * @param mode
13 *    SUPPL_SCAN_HANDLING_NORMAL
14 *    SUPPL_SCAN_HANDLING_LIST_ONLY
15 * @return {@code true} if the operation succeeds, {@code false} otherwise
16 */
17public synchronized boolean setScanResultHandling(int mode) {
18    if (mWifiState.get() != WIFI_STATE_ENABLED) {
19        return false;
20    }
21    return WifiNative.setScanResultHandlingCommand(mode);
22}
这个又遇到wifiNative，于是又要运用JNI去调用底层代码，在android_net_wifi_WIFI.cpp里面       
view source
print ?
01static jboolean android_net_wifi_scanCommand(JNIEnv* env, jobject clazz, jboolean forceActive)
02{
03    jboolean result;
04  
05    // Ignore any error from setting the scan mode.
06    // The scan will still work.
07    if (forceActive && !sScanModeActive)
08        doSetScanMode(true);
09    result = doBooleanCommand("SCAN", "OK");
10    if (forceActive && !sScanModeActive)
11        doSetScanMode(sScanModeActive);
12    return result;
13}
这里面的doSetScanMode其实也是调用的doBooleanCommand
view source
print ?
1static jboolean doSetScanMode(jboolean setActive)
2{
3    return doBooleanCommand((setActive ? "DRIVER SCAN-ACTIVE" : "DRIVER SCAN-PASSIVE"), "OK");
4}
那么doBooleanCommand是什么呢
view source
print ?
01static jboolean doBooleanCommand(const char *cmd, const char *expect)
02{
03    char reply[256];
04  
05    if (doCommand(cmd, reply, sizeof(reply)) != 0) {
06        return (jboolean)JNI_FALSE;
07    } else {
08        return (jboolean)(strcmp(reply, expect) == 0);
09    }
10}
11  
12static int doCommand(const char *cmd, char *replybuf, int replybuflen)
13{
14    size_t reply_len = replybuflen - 1;
15  
16    if (::wifi_command(cmd, replybuf, &reply_len) != 0)
17        return -1;
18    else {
19        // Strip off trailing newline
20        if (reply_len > 0 && replybuf[reply_len-1] == '\n')
21            replybuf[reply_len-1] = '\0';
22        else
23            replybuf[reply_len] = '\0';
24        return 0;
25    }
26}
而wifi_command在wifi.c中实现
view source
print ?
1int wifi_command(const char *command, char *reply, size_t *reply_len)
2{
3    return wifi_send_command(ctrl_conn, command, reply, reply_len);
4}

接下来看看wifi_send_command函数，在wifi.c里面

view source
print ?
01int wifi_send_command(struct wpa_ctrl *ctrl, const char *cmd, char *reply, size_t *reply_len)
02{
03    int ret;
04  
05    if (ctrl_conn == NULL) {
06        LOGV("Not connected to wpa_supplicant - \"%s\" command dropped.\n", cmd);
07        return -1;
08    }
09    ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), reply, reply_len, NULL);
10    if (ret == -2) {
11        LOGD("'%s' command timed out.\n", cmd);
12        return -2;
13    } else if (ret < 0 || strncmp(reply, "FAIL", 4) == 0) {
14        return -1;
15    }
16    if (strncmp(cmd, "PING", 4) == 0) {
17        reply[*reply_len] = '\0';
18    }
19    return 0;
20}
这里面有个struct，很重要
view source
print ?
01struct wpa_ctrl {
02#ifdef CONFIG_CTRL_IFACE_UDP
03    int s;
04    struct sockaddr_in local;
05    struct sockaddr_in dest;
06    char *cookie;
07#endif /* CONFIG_CTRL_IFACE_UDP */
08#ifdef CONFIG_CTRL_IFACE_UNIX
09    int s;
10    struct sockaddr_un local;
11    struct sockaddr_un dest;
12#endif /* CONFIG_CTRL_IFACE_UNIX */
13#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
14    HANDLE pipe;
15#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
16};
这个类中声明了两个Socket套接口，一个是本地一个是要连接的套接 口，wpa_ctrl与wpa_supplicant的通信就需要socket来帮忙了，而wpa_supplicant就是通过调用 wpa_ctrl.h中定义的函数和wpa_supplicant进行通讯的，wpa_ctrl类（其实是其中的两个socket）就是他们之间的桥梁。

wpa_ctrl_request，这个函数存放在wpa_ctrl.c(external/wpa_supplicant)

view source
print ?
01int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len,
02             char *reply, size_t *reply_len,
03             void (*msg_cb)(char *msg, size_t len))
04{
05    struct timeval tv;
06    int res;
07    fd_set rfds;
08    const char *_cmd;
09    char *cmd_buf = NULL;
10    size_t _cmd_len;
11  
12#ifdef CONFIG_CTRL_IFACE_UDP
13    if (ctrl->cookie) {
14        char *pos;
15        _cmd_len = strlen(ctrl->cookie) + 1 + cmd_len;
16        cmd_buf = os_malloc(_cmd_len );
17        if (cmd_buf == NULL)
18            return -1;
19        _cmd = cmd_buf;
20        pos = cmd_buf;
21        strcpy(pos, ctrl->cookie);
22        pos += strlen(ctrl->cookie);
23        *pos++ = ' ';
24        memcpy(pos, cmd, cmd_len);
25    } else
26#endif /* CONFIG_CTRL_IFACE_UDP */
27    {
28        _cmd = cmd;
29        _cmd_len = cmd_len;
30    }
31  
32    if (send(ctrl->s, _cmd, _cmd_len, 0) < 0) {
33        os_free(cmd_buf);
34        return -1;
35    }
36    os_free(cmd_buf);
37  
38    for (;;) {
39#ifdef ANDROID
40        tv.tv_sec = 10;
41#else
42        tv.tv_sec = 2;
43#endif
44        tv.tv_usec = 0;
45        FD_ZERO(&rfds);
46        FD_SET(ctrl->s, &rfds);
47        res = select(ctrl->s + 1, &rfds, NULL, NULL, &tv);
48        if (FD_ISSET(ctrl->s, &rfds)) {
49            res = recv(ctrl->s, reply, *reply_len, 0);
50            if (res < 0)
51                return res;
52            if (res > 0 && reply[0] == '<') {
53                /* This is an unsolicited message from
54                 * wpa_supplicant, not the reply to the
55                 * request. Use msg_cb to report this to the
56                 * caller. */
57                if (msg_cb) {
58                    /* Make sure the message is nul
59                     * terminated. */
60                    if ((size_t) res == *reply_len)
61                        res = (*reply_len) - 1;
62                    reply[res] = '\0';
63                    msg_cb(reply, res);
64                }
65                continue;
66            }
67            *reply_len = res;
68            break;
69        } else {
70            return -2;
71        }
72    }
73    return 0;
74}
This function is used to send commands to wpa_supplicant/hostapd. Received response will be written to reply and reply_len is set to the actual length of the reply. This function will block for up to two seconds while waiting for the reply. If unsolicited messages are received, the blocking time may be longer.

现在回到代码段三，后面有个update函数

view source
print ?
01private void updateAccessPoints() {
02    List<AccessPoint> accessPoints = new ArrayList<AccessPoint>();
03 
04    List<WifiConfiguration> configs = mWifiManager.getConfiguredNetworks();
05    if (configs != null) {
06        mLastPriority = 0;
07        for (WifiConfiguration config : configs) {
08            if (config.priority > mLastPriority) {
09                mLastPriority = config.priority;
10            }
11 
12            // Shift the status to make enableNetworks() more efficient.
13            if (config.status == Status.CURRENT) {
14                config.status = Status.ENABLED;
15            } else if (mResetNetworks && config.status == Status.DISABLED) {
16                config.status = Status.CURRENT;
17            }
18 
19            AccessPoint accessPoint = new AccessPoint(this, config);
20            accessPoint.update(mLastInfo, mLastState);
21            accessPoints.add(accessPoint);
22        }
23    }
24 
25    List<ScanResult> results = mWifiManager.getScanResults();
26    if (results != null) {
27        for (ScanResult result : results) {
28            // Ignore hidden and ad-hoc networks.
29            if (result.SSID == null || result.SSID.length() == 0 ||
30                    result.capabilities.contains("[IBSS]")) {
31                continue;
32            }
33 
34            boolean found = false;
35            for (AccessPoint accessPoint : accessPoints) {
36                if (accessPoint.update(result)) {
37                    found = true;
38                }
39            }
40            if (!found) {
41                accessPoints.add(new AccessPoint(this, result));
42            }
43        }
44    }
45 
46    mAccessPoints.removeAll();
47    for (AccessPoint accessPoint : accessPoints) {
48        mAccessPoints.addPreference(accessPoint);
49    }
50}
这个就是更新AP并通过GUI的形式列出来。  

引用自：http://my.oschina.net/JumpLong/blog/101147
zbird1988
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android实现WIFI连接源码
08-16
android连接WIFI源码，调用WIFI模块功能
android wifi源码分析,Wifi源码分析 (一) wifi初始化
weixin_31902781的博客
05-25 975
时序图:wifi初始化.png1. 系统启动wifiServer系统服务都是开机启动,不去说init什么等c的孵化器流程,直接进入run说起@frameworks/base/services/java/com/android/server/SystemServer.javaprivate static final String WIFI_SERVICE_CLASS ="com.android.se...
Android wifi属性简介 及 wifi信息获取（wifi列表、配置信息、热点信息）
2401_84009054的博客
04-03 1053
为什么很多程序员做不了架构师？1、良好健康的职业规划很重要，但大多数人都忽略了2、学习的习惯很重要，持之以恒才是正解。3、编程思维没能提升一个台阶，局限在了编码，业务，没考虑过选型、扩展4、身边没有好的架构师引导、培养。所处的圈子对程序员的成长影响巨大。金九银十面试季，跳槽季，整理面试题已经成了我多年的习惯！在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。
Wifi模块—源码分析Wifi启动（Android P）
BOJUE01的专栏
06-21 2232
一、前言 Android P在wifi这块改动挺大的，Wifi到AndoidO之后不再使用jni，所以AndroidP也一样不再使用jni来实现Java代码与本地的C/C++代码交互，而是使用HIDL，Hardware Interface Define Language。摒弃了以前的hardware/libhardware_legacy/wifi/wifi.c作为底层接口，所以得重新梳理下整个w...
Android系统WIFI设置源码解析
qq_21763489的博客
04-16 2670
Android系统设置界面中的WIFI页面是在packages\apps\Settings\src\com\android\settings\Settings$WifiSettingsActivity,. 下面我们对WIFISettingsActivity进行分析. 以下是onCreate方法 @Override protected void onCreate(Bundle savedState)...
Android wifi源码分析（一） Wifi启动流程
奋斗的菜鸟ing
09-06 4617
最近在解决wifi的一些问题，故研究下wifi源码。 该源码是基于Android4.3,其他版本略有改动，大致流程一样。 这篇主要说一下wifi的启动流程。
Android WIFI调试助手源码2.0
04-23
Android WIFI调试助手源码2.0 只支持十六进制发送与接收，支持高版本安卓系统。解释：这是我千辛万苦修改的WIFI调试助手源码https://download.csdn.net/download/weixin_44244812/12010411，...
Android项目源码安卓手机之间WIFI通信源码
07-29
Android项目源码安卓手机之间WIFI通信源码
Android WiFi 扫描源码
10-07
Android WiFi 扫描源码
安卓Android源码——androidGPS及WIFI基站定位坐标源码.zip
10-10
安卓Android源码——androidGPS及WIFI基站定位坐标源码.zip
Android系统WIFI直连demo源码
11-21
Android系统WIFI直连demo源码，可以给需要开发此功能的人员提供参考
Android例子源码自动连接已经配置好的指定的wifi的简单例子
07-29
本项目是一个实现自动连接指定的wifi的功能，可以检测要连接的wifi是否在可连接范围内，若在可连接范围内，则进行连接；否则提醒用户，程序结束。注意：此处要连接的wifi是已经配置好的，就是之前已经连接过的。程序比较简单，仅供参考，javaapk之前也发布过很多关于androidwifi开发的源码，需要更多wifi相关源码可以访问http://www./?s=wifi 本项目编码UTF-8编译版本4.0.3
Android wifi探究二：Wifi framework层源码分析
热门推荐
阳光玻璃杯
10-11 1万+
上一篇博客初步认识了wpa_supplicant的作用和使用方法，并且尝试着梳理了wifi的大框架，不过，java层的框架我们忽略了，没有分析，也就是说上一篇博客非常肤浅的支出了wifi代码的结构，仅此而已，那么这篇博客，将尝试梳理wifi的java层框架。
android wifi源码分析,android wifi打开过程源码解析及Wifi打开失败原因分析
weixin_33289151的博客
05-25 485
在android中wifi打开的状态从DISABLED-->ENABLING-->ENABLED1 WifiSettings.java--wifi界面wifi开关wifi开关定义在SettingsActivity.java中，传入WifiEnabler.java，并在WifiEnabler.java中响应。private SwitchBar mSwitchBar;public Swit...
druid-1.0.11.jar
05-21
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用
xmpcore-5.1.2.jar
05-21
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用
node-v4.6.2-headers.tar.xz
最新发布
05-21
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
node-v6.2.0-headers.tar.xz
05-21
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
ECharts-2.2.7.jar
05-21
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用
android 配置wifi RSSI阈值 源码
06-01
要在 Android 源码中配置 WiFi RSSI 阈值，您可以按照以下步骤进行操作： 1. 打开 Android 源码目录。 2. 找到以下文件：`frameworks/base/packages/SettingsProvider/res/values/defaults.xml` 3. 在 `defaults.xml` 文件中，找到以下行： ```xml <integer name="wifi_poll_rssi">-70</integer> <integer name="wifi_poll_interval">180</integer> <integer name="wifi_supplicant_scan_interval">15</integer> ``` 这些行定义了默认的 WiFi RSSI 值和扫描间隔。 4. 修改 `wifi_poll_rssi` 值以设置 RSSI 阈值。例如，将其设置为 -80 dBm： ```xml <integer name="wifi_poll_rssi">-80</integer> ``` 5. 重新编译 Android 源码。 6. 刷入您的设备。 请注意，这些步骤可能会因设备制造商和操作系统版本而有所不同。在进行修改之前，请务必备份您的设备，并了解您正在进行的操作可能会导致设备出现问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值