WIFI操作流程源码分析—启动

WIFI操作流程源码分析—启动

初始化

在 SystemServer 启动的时候,会生成WifiService和ConnectivityService 的实例,在SystemServer.java中

try {

     wifi = new WifiService(context);

     ServiceManager.addService(Context.WIFI_SERVICE, wifi);

} catch (Throwable e) {

     reportWtf("starting Wi-Fi Service", e);

}

/*********************************************************/

try {

   Slog.i(TAG, "Connectivity Service");

   connectivity = new ConnectivityService(

            context, networkManagement, networkStats, networkPolicy);

   ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);

   networkStats.bindConnectivityManager(connectivity);

   networkPolicy.bindConnectivityManager(connectivity);

   wifi.checkAndStartWifi();

   wifiP2p.connectivityServiceReady();

} catch (Throwable e) {

    reportWtf("starting Connectivity Service", e);

}

在ConnectivityService.java中构造函数ConnectivityService中创建DefaultNetworkFactory对象

public ConnectivityService(Context context, INetworkManagementService netManager,

            INetworkStatsService statsService, INetworkPolicyManager policyManager,

            NetworkFactory netFactory) {

           if (netFactory == null) {

            netFactory = new DefaultNetworkFactory(context, mTrackerHandler);

        }

}

在DefaultNetworkFactory.java中创建类WifiStateTracker对象

private static class DefaultNetworkFactory implements NetworkFactory {

    @Override

        public NetworkStateTracker createTracker(int targetNetworkType, NetworkConfig config) {

            switch (config.radio) {

                case TYPE_WIFI:

                    return new WifiStateTracker(targetNetworkType, config.name);

              }

        }

}

ConnectivityService 的构造函数会创建 mWifiStateTracker,而WifiStateTracker会创建 WifiMonitor 接收来自底层的事件,WifiService和 WifiMonitor 是整个模块的核心。WifiService负责启动关闭 wpa_supplicant、启动关闭 WifiMonitor监视线程和把命令下发给 wpa_supplicant,而 WifiMonitor则负责从 wpa_supplicant 接收事件通知。

 

使能 WIFI

WifiSettings 在初始化的时候onActivityCreated配置了由 WifiEnabler来处理 Wifi 按钮,

@Override

    public void onActivityCreated(Bundle savedInstanceState) {

 

    Switch actionBarSwitch = new Switch(activity);

 

    mWifiEnabler = new WifiEnabler(activity, actionBarSwitch);

 

}

当用户按下 Wifi 切换按钮后,Android 会调用 WifiEnabler的 onCheckedChanged,

public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {

       

        if (mWifiManager.setWifiEnabled(isChecked)) {

            // Intent has been taken into account, disable until new state is active

            mSwitch.setEnabled(false);

        } else {

            // Error

            Toast.makeText(mContext, R.string.wifi_error, Toast.LENGTH_SHORT).show();

        }

    }

再由 WifiEnabler调用 WifiManager的 setWifiEnabled 接口函数,

public boolean setWifiEnabled(boolean enabled) {

        try {

            return mService.setWifiEnabled(enabled);

        } catch (RemoteException e) {

            return false;

        }

}

通过 AIDL,实际调用的是 WifiService的setWifiEnabled 函数,

public synchronized boolean setWifiEnabled(boolean enable) {

        Slog.d(TAG, "setWifiEnabled: " + enable + " pid=" + Binder.getCallingPid()

                + ", uid=" + Binder.getCallingUid());

        enforceChangePermission();

        mAirplaneModeOn.set(isAirplaneModeOn());

        if (mWifiStateMachine.hasCustomizedAutoConnect() && enable && mAirplaneModeOn.get()) {

            SXlog.i(TAG, "Can't enable wifi when airplane mode is on for customization.");

            return false;

        }

        if (DBG) {

            Slog.e(TAG, "Invoking mWifiStateMachine.setWifiEnabled\n");

        }

 

        if (enable) {

            reportStartWorkSource();

        }

        mWifiStateMachine.setWifiEnabled(enable);

 

        /*

         * Caller might not have WRITE_SECURE_SETTINGS,

         * only CHANGE_WIFI_STATE is enforced

         */

 

        long ident = Binder.clearCallingIdentity();

        try {

            handleWifiToggled(enable);

        } finally {

            Binder.restoreCallingIdentity(ident);

        }

 

        if (enable) {

            if (!mIsReceiverRegistered) {

                registerForBroadcasts();

                mIsReceiverRegistered = true;

            }

        } else if (mIsReceiverRegistered) {

            mContext.unregisterReceiver(mReceiver);

            mIsReceiverRegistered = false;

        }

 

        return true;

    }

WifiService 接着通过WifiStateMachine中函数setWifiEnabled发送WIFI_STATE_ENABLING消息,

public void setWifiEnabled(boolean enable) {

        mLastEnableUid.set(Binder.getCallingUid());

        if (enable) {

            /* Argument is the state that is entered prior to load */

            sendMessage(obtainMessage(CMD_LOAD_DRIVER, WIFI_STATE_ENABLING, 0));

            sendMessage(CMD_START_SUPPLICANT);

        } else {

            sendMessage(CMD_STOP_SUPPLICANT);

            /* Argument is the state that is entered upon success */

            sendMessage(obtainMessage(CMD_UNLOAD_DRIVER, WIFI_STATE_DISABLED, 0));

        }

    }

它做了两个动作，向状态机发送了2个消息

sendMessage(obtainMessage(CMD_LOAD_DRIVER, WIFI_STATE_ENABLING, 0));加载驱动

sendMessage(CMD_START_SUPPLICANT);开启supplicant

加载驱动

状态机构造函数初始化时候，设置有个一个初始状态

        setInitialState(mInitialState);

我们进入mInitialState状态看看

        public void enter() {

            if (WifiNative.isDriverLoaded()) {

                transitionTo(mDriverLoadedState);

            }

            else {

                transitionTo(mDriverUnloadedState);

            }

因为最开始驱动都是没有加载的，所以进入transitionTo(mDriverUnloadedState);

transitionTo函数是状态切换的函数。

DriverUnloadedState类如下：

    class DriverUnloadedState extends State {

         @Override

        public boolean processMessage(Message message) {

               switch (message.what) {

                case CMD_LOAD_DRIVER:

                    mWifiP2pChannel.sendMessage(WIFI_ENABLE_PENDING);

                   transitionTo(mWaitForP2pDisableState);

                    break;

                case WifiP2pService.P2P_ENABLE_PENDING:

                    mReplyChannel.replyToMessage(message, P2P_ENABLE_PROCEED);

                    break;

                default:

                    return NOT_HANDLED;

            }

            EventLog.writeEvent(EVENTLOG_WIFI_EVENT_HANDLED, message.what);

            return HANDLED;

        }

    }

这里会处理刚才的CMD_LOAD_DRIVER这个消息，继续切换到mWaitForP2pDisableState

    class WaitForP2pDisableState extends State {

        @Override

        public boolean processMessage(Message message) {

            if (DBG) log(getName() + message.toString() + "\n");

            switch(message.what) {

                case WifiP2pService.WIFI_ENABLE_PROCEED:

                    //restore argument from original message (CMD_LOAD_DRIVER)

                    message.arg1 = mSavedArg;

                    transitionTo(mDriverLoadingState);

                    break;

    }

状态继续切换到mDriverLoadingState。

这里回调用WifiNative.loadDriver()加载驱动，成功后发送消息CMD_LOAD_DRIVER_SUCCESS，否则CMD_LOAD_DRIVER_FAILURE，

static JNINativeMethod gWifiMethods[] = {

    /* name, signature, funcPtr */

    { "loadDriver", "()Z",  (void *)android_net_wifi_loadDriver },

};

由此可知会进入JNI

static jboolean android_net_wifi_loadDriver(JNIEnv* env, jobject)

{

    return (jboolean)(::wifi_load_driver() == 0);

}

继续到wifi.c处理

int wifi_load_driver()

{

#ifdef WIFI_DRIVER_MODULE_PATH

    char driver_status[PROPERTY_VALUE_MAX];

    int count = 100; /* wait at most 20 seconds for completion */

    int status = -1;

 

    if (is_wifi_driver_loaded()) {

        return 0;

    }

    /* ensure that wlan driver config file exists (if specified) */

    if (ensure_wlan_driver_config_file_exists()) {

        return -1;

    }

    property_set(DRIVER_PROP_NAME, "loading");

 

    if(system(SDIO_POLLING_ON))

        LOGW("Couldn't turn on SDIO polling: %s", SDIO_POLLING_ON);

 

    if ('\0' != *DRIVER_SDIO_IF_MODULE_PATH) {

       if (insmod(DRIVER_SDIO_IF_MODULE_PATH, DRIVER_SDIO_IF_MODULE_ARG) < 0) {

           goto end;

       }

    }

 

    if (insmod(DRIVER_MODULE_PATH, DRIVER_MODULE_ARG) < 0) {

        if ('\0' != *DRIVER_SDIO_IF_MODULE_NAME) {

           rmmod(DRIVER_SDIO_IF_MODULE_NAME);

        }

        goto end;

    }

 

    if (strcmp(FIRMWARE_LOADER,"") == 0) {

        /* usleep(WIFI_DRIVER_LOADER_DELAY); */

        property_set(DRIVER_PROP_NAME, "ok");

    }

    else {

        property_set("ctl.start", FIRMWARE_LOADER);

    }

 

    sched_yield();

    while (count-- > 0) {

        if (property_get(DRIVER_PROP_NAME, driver_status, NULL)) {

            if (strcmp(driver_status, "ok") == 0) {

                status = 0;

                goto end;

            }

            else if (strcmp(driver_status, "failed") == 0) {

                _wifi_unload_driver();

                goto end;

            }

        }

        usleep(200000);

    }

    property_set(DRIVER_PROP_NAME, "timeout");

    wifi_unload_driver();

end:

    system(SDIO_POLLING_OFF);

    return status;

#else

    property_set(DRIVER_PROP_NAME, "ok");

    return 0;

#endif

}

这里有几个比较重要的宏

#define WIFI_DRIVER_MODULE_PATH         "/system/lib/modules/wlan.ko"驱动模块地址

 

static const char SUPP_CONFIG_FILE[]    = "/data/misc/wifi/wpa_supplicant.conf";  supplicant配置文件

在这里wifi.c会跟wpa_supplicant通信，加载驱动

开启supplicant

另一个消息sendMessage(CMD_START_SUPPLICANT);在DriverLoadedState处理

    class DriverLoadedState extends State {

        @Override

        public boolean processMessage(Message message) {

       

                case CMD_START_SUPPLICANT:

                    try {

                        mNwService.wifiFirmwareReload(mInterfaceName, "STA");

                    } catch (Exception e) {

                        loge("Failed to reload STA firmware " + e);

                        // continue

                    }

                   try {

                         mNwService.setInterfaceIpv6PrivacyExtensions(mInterfaceName, true);

                    } catch (RemoteException re) {

                        loge("Unable to change interface settings: " + re);

                    } catch (IllegalStateException ie) {

                        loge("Unable to change interface settings: " + ie);

                    }

 

                    if(WifiNative.startSupplicant()) {

                        if (DBG) log("Supplicant start successful");

                        mWifiMonitor.startMonitoring();

                        transitionTo(mSupplicantStartingState);

                    } else {

                        loge("Failed to start supplicant!");

                        sendMessage(obtainMessage(CMD_UNLOAD_DRIVER, WIFI_STATE_UNKNOWN, 0));

                    }

                    break;

继续调用JNI，WifiNative.startSupplicant()，过程差不多最后在wifi.c处理

int wifi_start_supplicant()

{

    return wifi_start_supplicant_common(SUPP_CONFIG_FILE);

}

int wifi_start_supplicant_common(const char *config_file)

最后也是在这里跟Wpa_supplicant驱动通信

WIFI状态切换

在wifi状态发生改变的时候，wifistatemachine会通过setwifistate发送WIFI_STATE_CHANGED_ACTION消息通知外面

    private void setWifiState(int wifiState) {

        final Intent intent = new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION);

        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

        intent.putExtra(WifiManager.EXTRA_WIFI_STATE, wifiState);

        intent.putExtra(WifiManager.EXTRA_PREVIOUS_WIFI_STATE, previousWifiState);

        mContext.sendStickyBroadcast(intent);

}

例如在驱动加载状态

    class DriverLoadingState extends State {

            new Thread(new Runnable() {

                public void run() {

                    mWakeLock.acquire();

                    //enabling state

                    switch(message.arg1) {

                        case WIFI_STATE_ENABLING:

                            setWifiState(WIFI_STATE_ENABLING);

                            break;

                        case WIFI_AP_STATE_ENABLING:

                            setWifiApState(WIFI_AP_STATE_ENABLING);

                            break;

                    }

    }

在wifisettings里面也有广播监听器

    public WifiSettings() {

        mFilter = new IntentFilter();

        mFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);

 

        mReceiver = new BroadcastReceiver() {

            @Override

            public void onReceive(Context context, Intent intent) {

                handleEvent(context, intent);

            }

        };

        mScanner = new Scanner();

    }

 

当接受到广播会相应处理handleEvent

    private void handleEvent(Context context, Intent intent) {

        String action = intent.getAction();

        if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) {

            updateWifiState(intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,

                   WifiManager.WIFI_STATE_UNKNOWN));

        }

    }

更新wifi状态

    private void updateWifiState(int state) {

        getActivity().invalidateOptionsMenu();

        switch (state) {

            case WifiManager.WIFI_STATE_ENABLED:

                mScanner.resume();

                return; // not break, to avoid the call to pause() below

            case WifiManager.WIFI_STATE_ENABLING:

                addMessagePreference(R.string.wifi_starting);

                break;

            case WifiManager.WIFI_STATE_DISABLED:

                addMessagePreference(R.string.wifi_empty_list_wifi_off);

                break;

        }

    }

比如 case WifiManager.WIFI_STATE_ENABLED:当WIFI可用通知接受到的时候

  mScanner.resume();

Scanner resume函数

        void resume() {

            if (!hasMessages(0)) {

                sendEmptyMessage(0);

            }

        }

处理函数如下：

        @Override

        public void handleMessage(Message message) {

            if (mWifiManager.startScanActive()) {

                mRetry = 0;

            } else if (++mRetry >= 3) {

                mRetry = 0;

                Toast.makeText(getActivity(), R.string.wifi_fail_to_scan,

                        Toast.LENGTH_LONG).show();

                return;

            }

            sendEmptyMessageDelayed(0, WIFI_RESCAN_INTERVAL_MS);

        }

    }

会调用mWifiManager.startScanActive()进行ap的扫描。

所以当你点击wifi按钮，到驱动加载完成，发出WIFI_STATE_ENABLED消息的时候，wifi已经启动。