在Android系統(tǒng)啟動的時候，會在./frameworks/base/services/java/com/android/server/SystemServer.java類中啟動許多服務(wù)，其中和Wifi相關(guān)的服務(wù)就在這里初始化。在SystemServer的main方法中，我們可以看到

thr.initAndLoop();

這里調(diào)用了它的內(nèi)部類對象的initAndLoop方法，在這個方法的作用主要就是初始化系統(tǒng)啟動需要加載的服務(wù)的，我們在這個方法中可以找到

try {
                    Slog.i(TAG, "Wi-Fi Service");
                    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);

                    wifiP2p.connectivityServiceReady();
                    wifi.checkAndStartWifi();
                } catch (Throwable e) {
                    reportWtf("starting Connectivity Service", e);
                }

這里我們可以看到初始化了一個WifiService和ConnectivityService對象，并把這2個對象注冊到ServiceManager中，然后通過創(chuàng)建的對象wifi 來調(diào)用checkAndStartWifi方法，具體的WifiService的分析我們下一章再做詳細(xì)介紹，現(xiàn)在我們簡單分析下ConnectivityService。
ConnectivityService是管理系統(tǒng)中所有的數(shù)據(jù)連接服務(wù)，其中就包括Wifi，我們來看看它的構(gòu)造函數(shù)，路徑：./frameworks/base/services/java/com/android/server/ConnectivityService.java

public ConnectivityService(Context context, INetworkManagementService netd,
            INetworkStatsService statsService, INetworkPolicyManager policyManager) {
        // Currently, omitting a NetworkFactory will create one internally
        // TODO: create here when we have cleaner WiMAX support
        this(context, netd, statsService, policyManager, null);
    }

這里就是調(diào)用了同名的構(gòu)造方法

public ConnectivityService(Context context, INetworkManagementService netManager,
            INetworkStatsService statsService, INetworkPolicyManager policyManager,
            NetworkFactory netFactory) {
        if (DBG) log("ConnectivityService starting up");

        HandlerThread handlerThread = new HandlerThread("ConnectivityServiceThread");
        handlerThread.start();
        mHandler = new InternalHandler(handlerThread.getLooper());
        mTrackerHandler = new NetworkStateTrackerHandler(handlerThread.getLooper());

// Create and start trackers for hard-coded networks
        for (int targetNetworkType : mPriorityList) {
            final NetworkConfig config = mNetConfigs[targetNetworkType];
            final NetworkStateTracker tracker;
            try {
                /** M: Hotspot Manager @{*/
                if(config.radio == TYPE_USB){
                    log("new UsbDataStateTracker");
                    mNetTrackers[targetNetworkType] = new UsbDataStateTracker(targetNetworkType, config.name, mNetd);
                    mNetTrackers[targetNetworkType].startMonitoring(context, mTrackerHandler);
                    continue;
                } 
                if(true == FeatureOption.MTK_ALPS_BOX_SUPPORT && config.radio == TYPE_ETHERNET){	
                    if (DBG) log("Starting Ethernet Service.");
                    mNetTrackers[TYPE_ETHERNET] = makeEthStateTracker(context);
                    if(mNetTrackers[TYPE_ETHERNET] != null){
                        if (DBG) log("mNetTrackers[TYPE_ETHERNET] != null");
                        mNetTrackers[TYPE_ETHERNET].startMonitoring(context, mTrackerHandler);
                        if (config.isDefault()) {
                            mNetTrackers[TYPE_ETHERNET].reconnect();
                        }  
                    }              
                    continue;                
                }
                /*@} */
		/*@} */
                ///M:new a Teledongle Data Tracker @by mtk94127 @{
                if(FeatureOption.MTK_EXTERNAL_DONGLE_SUPPORT && (config.radio == TYPE_TEDONGLE)) {
                    log("new TedongleDataStateTracker");
                    mNetTrackers[targetNetworkType] = makeTedongleDataTracker();
                    log("new TedongleDataStateTracker medium!");
                    mNetTrackers[targetNetworkType].startMonitoring(context, mTrackerHandler);
                    log("new TedongleDataStateTracker end!");
                    continue;
                }
                ///M:@}
                tracker = netFactory.createTracker(targetNetworkType, config);
                mNetTrackers[targetNetworkType] = tracker;
            } catch (IllegalArgumentException e) {
                Slog.e(TAG, "Problem creating " + getNetworkTypeName(targetNetworkType)
                        + " tracker: " + e);
                continue;
            }

            tracker.startMonitoring(context, mTrackerHandler);
            if (config.isDefault()) {
                tracker.reconnect();
            }
        }
}

這里根據(jù)com.android.internal.R.array.networkAttributes配置的屬性去創(chuàng)建一個個tracker，并監(jiān)聽其狀態(tài)，tracker.startMonitoring(context, mTrackerHandler);可以看出tracker可以通過mTrackerHandler向ConnectivityService發(fā)送消息，這些消息有

 /**
     * The network state has changed and the NetworkInfo object
     * contains the new state.
     *
     * msg.what = EVENT_STATE_CHANGED
     * msg.obj = NetworkInfo object
     */
    public static final int EVENT_STATE_CHANGED = BASE_NETWORK_STATE_TRACKER;

    /**
     * msg.what = EVENT_CONFIGURATION_CHANGED
     * msg.obj = NetworkInfo object
     */
    public static final int EVENT_CONFIGURATION_CHANGED = BASE_NETWORK_STATE_TRACKER + 1;

    /**
     * msg.what = EVENT_RESTORE_DEFAULT_NETWORK
     * msg.obj = FeatureUser object
     */
    public static final int EVENT_RESTORE_DEFAULT_NETWORK = BASE_NETWORK_STATE_TRACKER + 2;

    /**
     * msg.what = EVENT_NETWORK_SUBTYPE_CHANGED
     * msg.obj = NetworkInfo object
     */
    public static final int EVENT_NETWORK_SUBTYPE_CHANGED = BASE_NETWORK_STATE_TRACKER + 3;

    /**
     * msg.what = EVENT_NETWORK_CONNECTED
     * msg.obj = LinkProperties object
     */
    public static final int EVENT_NETWORK_CONNECTED = BASE_NETWORK_STATE_TRACKER + 4;

    /**
     * msg.what = EVENT_NETWORK_CONNECTION_DISCONNECTED
     * msg.obj = LinkProperties object, same iface name
     */
    public static final int EVENT_NETWORK_DISCONNECTED = BASE_NETWORK_STATE_TRACKER + 5;

當(dāng)WiFi的連接AP成功后，就會想 ConnectivityService發(fā)送一個EVENT_STATE_CHANGED消息。
接著我們來看創(chuàng)建了哪些tracker，找到createTracker方法

 @Override
        public NetworkStateTracker createTracker(int targetNetworkType, NetworkConfig config) {
            switch (config.radio) {
                case TYPE_WIFI:
                    return new WifiStateTracker(targetNetworkType, config.name);
                case TYPE_MOBILE:
                    return new MobileDataStateTracker(targetNetworkType, config.name);
                case TYPE_DUMMY:
                    return new DummyDataStateTracker(targetNetworkType, config.name);
                case TYPE_BLUETOOTH:
                    return BluetoothTetheringDataTracker.getInstance();
                case TYPE_WIMAX:
                    return makeWimaxStateTracker(mContext, mTrackerHandler);
                case TYPE_CSD:
                    return new CsdStateTracker(targetNetworkType, config.name);
                default:
                    throw new IllegalArgumentException(
                            "Trying to create a NetworkStateTracker for an unknown radio type: "
                            + config.radio);
            }
        }

這里我們主要關(guān)注TYPE_WIFI，創(chuàng)建了一個WifiStateTracker對象，進入到WifiStateTracker的構(gòu)造方法

 public WifiStateTracker(int netType, String networkName) {
        ///M:@{
        mNetType = netType;
        ///@}
        mNetworkInfo = new NetworkInfo(netType, 0, networkName, "");
        mLinkProperties = new LinkProperties();
        mLinkCapabilities = new LinkCapabilities();

        mNetworkInfo.setIsAvailable(false);
        setTeardownRequested(false);
    }

接著調(diào)用startMonitoring

 /**
     * Begin monitoring wifi connectivity
     */
    public void startMonitoring(Context context, Handler target) {
        mCsHandler = target;
        mContext = context;

        mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
        IntentFilter filter = new IntentFilter();
        ///M:seperate p2p and wifi @{
        if (mNetType == ConnectivityManager.TYPE_WIFI) {
           filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
           filter.addAction(WifiManager.LINK_CONFIGURATION_CHANGED_ACTION);
        }
        ///@}
        
        mWifiStateReceiver = new WifiStateReceiver();
        mContext.registerReceiver(mWifiStateReceiver, filter);
    }

 這里就是注冊了一個廣播用于接收NETWORK_STATE_CHANGED_ACTION和LINK_CONFIGURATION_CHANGED_ACTION廣播，ConnectivityService我們就分析到這里，下一章我們將詳細(xì)分析WifiService。