Android 5.1系统源码Wifi模块中wifiSettings源码分析

在看一下代码之前需要简单了解wifi的基本知识：

802.11协议：wifi用到的是802.11b,802.11g(是802.11b的后继标准)

station：携带无线网卡的设备，如智能手机，笔记本,底层会启动 wpa-supplicant:实现station对无线网络的管理和控制功能。

AP:accesspoint本身也是一个station,能为关联的STA提供分布式服务（ds），如路由器

DS:distributionservice:分布式服务,BSS和LAN组合在一起构成一个ESS的就是ds,ds一般是指有线网络（通过它接入互联网）

BSS:BasicService Set,是由上述原件组成的网络

基础结构型BSS:通常是指的Infrastructurebasic Service Set,有 ap参与。

独立型BSS:通常是指IndependentBSS,不需要ap,各个sta直接互联，自组网络对等网络

           通常我们所说的BSS是指基础结构型

ESS:ExtendedService Set扩展服务集，包含一个或者多个BSS.

SSID:ServiceSet Identification:网络名

BSSID:在基础结构型网络中，他就是ap的MAC地址，在独立型BSS中为随机生成，

wpa-supplicant:使得无线网卡工作在managed模式，

softap:软AP底层启动:hostapd的后台管理进程， 常见的为hotspot

hostapd:切换为master模式，模拟ap,建立一个无线开放的网络，

在谷歌提供的安卓源码中，网址如下：http://androidxref.com ，初学者学习，分析，留疑问，并且长期更新，修改错误，补充。

安卓的系统wifi模块，一般在设置----->Wifi中
WifiSettings显示的就是打开wifi的那个界面

需要先了解一些wifi模块的api如WifiManager类等。

WifiSettings继承SettingsPreferenceFragment，具有fragement的生命周期（可百度看一下）如sethasOptionsMenu(true)这方法是Fragment中的

这个界面一般包括

一个switchbar(控制开关，在WifiEnaber中实现)，控制wifi的开关，

主要用WifiEnabler中的onSwitchChanged方法中实现

调用wifiManager的setWifiEnabled(boolean ischeck)方法进行开关

  preferenceScreen(用来显示ap（如路由器）列表)

OptionsMenu

选项菜单，通过sethasOptionsMenu(true)会自动调用oncreateOptionsMenu方法，

方法中调用addOptionsMenuItems进行初始

   包括新增网络，保存的网络，刷新，高级(会有条件具体显示的菜单，如通过savedNetworksExist来判断“保存的网络”是否显示在菜单上)

  ContextMenu

长按ap会弹出内容菜单，通过RegisterForContextMenu(listview),会自动调用OnCreateContextMenu方法，

包括连接，忘记，修改，写入NFC的功能（会有条件具体显示的菜单，如连接的，保存的，未连接的的ap）

 这些方法在wifiSettings中都有具体的实现代码，可以分析

WifiSettings位于packages/apps/Settings/src/com/Android/settings/wifi/WifiSettings.Java

其中有两个类，其中的Multimap为多重映射，在constructAccessPoints方法中会被调用

Multimap<String,AccessPoint> apMap = new Multimap<String, AccessPoint>()

apMap用来存放ssid与accesspoint的键值，其中，相同的键可以有多个值（意味着可能存在ssid相同的多个ap）

负责扫描，发送消息扫描，间隔10秒，startScan(),连续三次扫描都失败就停止扫描。这个类在WifiSettings构造方法中被初始化，

[java] view plain copy 
 private static class Scanner extends Handler {  
176        private int mRetry = 0;  
177        private WifiSettings mWifiSettings = null;  
178  
179        Scanner(WifiSettings wifiSettings) {  
180            mWifiSettings = wifiSettings;  
181        }  
182  
183        void resume() {  
184            if (!hasMessages(0)) {  
185                sendEmptyMessage(0);  
186            }  
187        }  
188  
189        void forceScan() {  
190            removeMessages(0);  
191            sendEmptyMessage(0);  
192        }  
193  
194        void pause() {  
195            mRetry = 0;  
196            removeMessages(0);  
197        }  
198  
199        @Override  
200        public void handleMessage(Message message) {  
201            if (mWifiSettings.mWifiManager.startScan()) {  
202                mRetry = 0;                                       //当中有一次扫描成功mRetry=0；  
203            } else if (++mRetry >= 3) {                         //开始扫描的操作失败mRetry+1与3比较，超过三次就return  
204                mRetry = 0;  
205                Activity activity = mWifiSettings.getActivity();  
206                if (activity != null) {  
207                    Toast.makeText(activity, R.string.wifi_fail_to_scan, Toast.LENGTH_LONG).show();  
208                }  
209                return;  
210            }  
211            sendEmptyMessageDelayed(0, WIFI_RESCAN_INTERVAL_MS); //每隔10秒，发起扫描的操作  
212        }  
213    }  
214  
[java] view plain copy 
</pre><span style="font-size:10px;"><a target=_blank target="_blank" class="l" name="214" href="http://androidxref.com/5.1.0_r1/xref/packages/apps/Settings/src/com/android/settings/wifi/WifiSettings.java#214"></a></span>  
在wifiSettings构造方法中，增加了Intent过滤器和广播接受者，其中广播接受者的时间在HandleEvent(Intent intent)中处理
但是我有一个问题：为啥过滤器中注册了8个Action
[java] view plain copy 
<pre name="code" class="java">       public WifiSettings() {  
216        super(DISALLOW_CONFIG_WIFI);  
217        mFilter = new IntentFilter();  
218        mFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);  
219        mFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);  
220        mFilter.addAction(WifiManager.NETWORK_IDS_CHANGED_ACTION);  
221        mFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);  
222        mFilter.addAction(WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION);  
223        mFilter.addAction(WifiManager.LINK_CONFIGURATION_CHANGED_ACTION);  
224        mFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);  
225        mFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);  
226  
227        mReceiver = new BroadcastReceiver() {  
228            @Override  
229            public void onReceive(Context context, Intent intent) {  
230                handleEvent(intent);  
231            }  
232        };  
233  
234        mScanner = new Scanner(this);  
235    }  
[java] view plain copy 
  
[java] view plain copy 
  
但是在HandleEvent方法中却只有6个action的处理，NETWORK_IDS_CHANGED_ACTION与SUPPLICANT_STATE_CHANGED_ACTION却没有处理，那么加入的目的？
HandleEvent处理广播的代码：
[java] view plain copy 
777    private void handleEvent(Intent intent) {  
778        String action = intent.getAction();  
779        if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) {  
780            updateWifiState(intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,  
781                    WifiManager.WIFI_STATE_UNKNOWN));                           //更新wifi状态改变,Enabled Enabling Disabled  
782        } else if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action) ||  
783                WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION.equals(action) ||  
784                WifiManager.LINK_CONFIGURATION_CHANGED_ACTION.equals(action)) {  
785                updateAccessPoints();                                           //更新AccessPoints  
786        } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) {  
787            NetworkInfo info = (NetworkInfo) intent.getParcelableExtra(  
788                    WifiManager.EXTRA_NETWORK_INFO);  
789            mConnected.set(info.isConnected());  
790            changeNextButtonState(info.isConnected());  
791            updateAccessPoints();   
792            updateNetworkInfo(info);                                              //更新ap再更新网络信息                                                                      
793        } else if (WifiManager.RSSI_CHANGED_ACTION.equals(action)) {  
794            updateNetworkInfo(null);  
795        }  
796    }  
797  


不同的action对应处理不同的事件：
WIFI_STATE_CHANGED_ACTION:当wifi状态改变的时候，updataWifiState(int state),根据不同的状态，做不同的处理：
[java] view plain copy 
827    private void updateWifiState(int state) {  
828        Activity activity = getActivity();  
829        if (activity != null) {  
830            activity.invalidateOptionsMenu();  
831        }  
832  
833        switch (state) {  
834            case WifiManager.WIFI_STATE_ENABLED:  
835                mScanner.resume();                                //enabled的时候，发送扫描信息startScan()  
836                return; // not break, to avoid the call to pause() below  //避免调用mScanner.pause()停止扫描  
837   
838            case WifiManager.WIFI_STATE_ENABLING:  
839                addMessagePreference(R.string.wifi_starting);    //加入“正在打开wifi”  
840                break;  
841  
842            case WifiManager.WIFI_STATE_DISABLED:  
843                setOffMessage();                                //wifi不可用的时候，显示一些其他信息(通过provider判断)  
844                break;  
845        }  
846  
847        mLastInfo = null;  
848        mLastNetworkInfo = null;  
849        mScanner.pause();                                      //停止扫描  
850    }  
第二个的判断条件中有三个action:分别对应的是
SCAN_RESULTS_AVAILABLE_ACTION：
An access point scan has completed, and results are available from the supplicant.
一个AP扫描完成，并且从supplicant获得的结果是可用的
CONFIGURED_NETWORKS_CHANGED_ACTION：
Broadcast intent action indicating that the configured networks changed. This can be as a result of adding/updating/deleting a network
广播intent的动作表明配置的网络已经改变，比如增加/更新/删除一个网络
LINK_CONFIGURATION_CHANGED_ACTION：
Broadcast intent action indicating that the link configuration changed on wifi
广播intent的动作表明连接的配置已经改变
在这些情况下，都会更新wifi的信息updateAccessPoints();
[java] view plain copy 
640    private void updateAccessPoints() {  
641        // Safeguard from some delayed event handling  
642        if (getActivity() == null) return;  
643  
644        if (isUiRestricted())   
645            addMessagePreference(R.string.wifi_empty_list_user_restricted);     //判断是否有限制  
646            return;  
647        }  
648        final int wifiState = mWifiManager.getWifiState();  
649  
650        //when we update the screen, check if verbose logging has been turned on or off  
651        mVerboseLogging = mWifiManager.getVerboseLoggingLevel();  
652  
653        switch (wifiState) {                                                  //根据wifi状态来处理  
654            case WifiManager.WIFI_STATE_ENABLED:                              //当wifi状态可用的情况下  
655                // AccessPoints are automatically sorted with TreeSet.  
656                final Collection<AccessPoint> accessPoints =  
657                        constructAccessPoints(getActivity(), mWifiManager, mLastInfo,  
658                                mLastNetworkInfo);                           //主要通过constructAccessPoints进行更新  
659                getPreferenceScreen().removeAll();  
660                if (accessPoints.size() == 0) {  
661                    addMessagePreference(R.string.wifi_empty_list_wifi_on); //如果ap没有，则显示“正在搜索wlan网络”  
662                }  
663  
664                for (AccessPoint accessPoint : accessPoints) {  
665                    // Ignore access points that are out of range.  
666                    if (accessPoint.getLevel() != -1) {  
667                        getPreferenceScreen().addPreference(accessPoint);  //遍历，增加到preferenceScreen中（可以阅读相关资料了解）  
668                    }  
669                }  
670                break;  
671  
672            case WifiManager.WIFI_STATE_ENABLING:  
673                getPreferenceScreen().removeAll();                         //enabling的情况下，移出preferenceScreen中所有的ap  
674                break;  
675  
676            case WifiManager.WIFI_STATE_DISABLING:  
677                addMessagePreference(R.string.wifi_stopping);             //显示“正在关闭“                     
678                break;  
679  
680            case WifiManager.WIFI_STATE_DISABLED:                        //不可用的时候，显示其他信息  
681                setOffMessage();  
682                break;  
683        }  
684    }  
685  
这里面最主要的方法就是constructAccessPoints这个方法了，之后在学习把。。NETWORK_STATE_CHANGED_ACTIONBroadcast intent action indicating that the state of Wi-Fi connectivity has changed. One extra provides the new statewifi连通性被改变，提供了新的状态更新ap的同时，更新NetworkInfo，在安卓5.0的情况下名字为updateConnectionState（估计认为这是网络状态？怕理解成connected的ap???）
[java] view plain copy 
798    private void updateNetworkInfo(NetworkInfo networkInfo) {  
799        /* sticky broadcasts can call this when wifi is disabled */  
800        if (!mWifiManager.isWifiEnabled()) {                                                     
801            mScanner.pause();                                                          
802            return;  
803        }  
804  
805        if (networkInfo != null &&  
806                networkInfo.getDetailedState() == DetailedState.OBTAINING_IPADDR) {  
807            mScanner.pause();  
808        } else {  
809            mScanner.resume();  
810        }  
811  
812        mLastInfo = mWifiManager.getConnectionInfo();  
813        if (networkInfo != null) {  
814            mLastNetworkInfo = networkInfo;  
815        }  
816                                                                      //倒序更新AccessPoint的信息,应该是更新了修改配置之后的ap的信息  
817        for (int i = getPreferenceScreen().getPreferenceCount() - 1; i >= 0; --i) {  
818            // Maybe there's a WifiConfigPreference  
819            Preference preference = getPreferenceScreen().getPreference(i);  
820            if (preference instanceof AccessPoint) {  
821                final AccessPoint accessPoint = (AccessPoint) preference;  
822                accessPoint.update(mLastInfo, mLastNetworkInfo);                        
823            }  
824        }  
825    }  
RSSI_CHANGED_ACTION
The RSSI (signal strength) has changed.
显而易见，这指的是信号强度被改变的action,调用updateNetworkInfo，更新一下网络信息就可以了
以上是handleEvent的
=============================================handleEvent分割线======================================================================
之前看到在updataAccessPoints中调用了这个方法：constructAccessPoints,看一下这个方法的源码把
[java] view plain copy 
private static List<AccessPoint> constructAccessPoints(Context context,  
719            WifiManager wifiManager, WifiInfo lastInfo, NetworkInfo lastNetworkInfo) {  
720        ArrayList<AccessPoint> accessPoints = new ArrayList<AccessPoint>();       //存放ap的ArrayList，用来返回  
721        /** Lookup table to more quickly update AccessPoints by only considering objects with the 
722         * correct SSID.  Maps SSID -> List of AccessPoints with the given SSID.  */  
723        Multimap<String, AccessPoint> apMap = new Multimap<String, AccessPoint>();//多重映射，键SSID(网络名)--值（ap）  
724  
725        final List<WifiConfiguration> configs = wifiManager.getConfiguredNetworks();//获取手机中保存过配置的连接信息  
726        if (configs != null) {  
727            // Update "Saved Networks" menu option.                //更新选项“saved Networks”的状态  
728            if (savedNetworksExist != (configs.size() > 0)) {      //比较式前后一致的返回值，更新Saved Networks的菜单选项  
                                                                      //例如:没有存储的wifi信息，那么savedNetworksExist为flase  
                                                                      //例如:有存储的wifi信息，那么savedNetworksExist为true  
729                savedNetworksExist = !savedNetworksExist;  
730                if (context instanceof Activity) {  
731                    ((Activity) context).invalidateOptionsMenu();   //刷新optionMenu  
732                }  
733            }  
734            for (WifiConfiguration config : configs) {                   //对配置过的信息进行遍历  
735                if (config.selfAdded && config.numAssociation == 0) {    // Number of time we associated to this configuration  
736                    continue;                                            //跳过本次循环     
737                }  
738                AccessPoint accessPoint = new AccessPoint(context, config);  
739                if (lastInfo != null && lastNetworkInfo != null) {  
740                    accessPoint.update(lastInfo, lastNetworkInfo);        
741                }  
742                accessPoints.add(accessPoint);                          //把ap加入List中  
743                apMap.put(accessPoint.ssid, accessPoint);  
744            }  
745        }  
746  
747        final List<ScanResult> results = wifiManager.getScanResults();   //wifi扫描结果的的处理  
748        if (results != null) {  
749            for (ScanResult result : results) {                          //遍历扫描结果  
750                // Ignore hidden and ad-hoc networks.                    //忽略隐藏的（没有SSID）以及ad-hoc(IBSS?)  
751                if (result.SSID == null || result.SSID.length() == 0 ||  
752                        result.capabilities.contains("[IBSS]")) {  
753                    continue;  
754                }  
755  
756                boolean found = false;                                  //第一次的apMap中存放了配置过的信息  
757                for (AccessPoint accessPoint : apMap.getAll(result.SSID)) {  
758                    if (accessPoint.update(result))                     //判断扫描结果ssid和security安全协议是否存在过，存在更新  
759                        found = true;                                   
760                }  
761                if (!found) {                                            //未找到的情况下，加入accesspoints的  
762                    AccessPoint accessPoint = new AccessPoint(context, result);  
763                    if (lastInfo != null && lastNetworkInfo != null) {  
764                        accessPoint.update(lastInfo, lastNetworkInfo);  
765                    }  
766                    accessPoints.add(accessPoint);  
767                    apMap.put(accessPoint.ssid, accessPoint);           //放入apMap，再次遍历会调用  
768                }  
769            }  
770        }  
771  
772        // Pre-sort accessPoints to speed preference insertion  
773        Collections.sort(accessPoints);  
774        return accessPoints;  
775    }  
==============================================================================================================
来了解一下所有的重写的方法：OptionsMenu：调用addOptionsMenuItems方法进行初始化
[java] view plain copy 
397    void addOptionsMenuItems(Menu menu) {       //这里的通过wifi是否打开的状态设置menu中元素的enable状态  
398        final boolean wifiIsEnabled = mWifiManager.isWifiEnabled();  
399        TypedArray ta = getActivity().getTheme().obtainStyledAttributes(  
400                new int[] {R.attr.ic_menu_add, R.attr.ic_wps});  
401        menu.add(Menu.NONE, MENU_ID_ADD_NETWORK, 0, R.string.wifi_add_network)  
402                .setIcon(ta.getDrawable(0))  
403                .setEnabled(wifiIsEnabled)          //增加网络，当wifi不可用的时候为false，不能点击  
404                .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);  
405        if (savedNetworksExist) {  
406            menu.add(Menu.NONE, MENU_ID_SAVED_NETWORK, 0, R.string.wifi_saved_access_points_label)  
407                    .setIcon(ta.getDrawable(0))  
408                    .setEnabled(wifiIsEnabled)       //通过判断是否存在保存的网络，来决定显示与否  
409                    .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);  
410        }  
411        menu.add(Menu.NONE, MENU_ID_SCAN, 0, R.string.menu_stats_refresh)  
412               .setEnabled(wifiIsEnabled)  
413               .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);//刷新，通过判断wifi状态来决定是否能刷新  
414        menu.add(Menu.NONE, MENU_ID_ADVANCED, 0, R.string.wifi_menu_advanced)  
415                .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); //高级选项  
416        ta.recycle();  
417      
OptionMenuItems对应的点击事件为：onOptionsItemSelected，根据不同的item点开对应的dialog，
当然，onCrateContextMenu中对应的点击事件为onContextItemSelected,根据不同的选项执行不同的操作
当然还有一些重写的方法，那就是生命周期的重写：如：
先执行构造方法，然后方法如下：
重写onActivityCreated（参数）
1.获得系统服务WifiManager
2.注册监听,connect,save,forget
3.savedInstanceState的状态判断，进行一些初始化

[java] view plain copy 
<pre name="code" class="java">@Override  
238    public void onActivityCreated(Bundle savedInstanceState) {  
239        super.onActivityCreated(savedInstanceState);  
240        //获得服务  
241        mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);  
242        //三种监听  
243        mConnectListener = new WifiManager.ActionListener() {  
244                                   @Override  
245                                   public void onSuccess() {  
246                                   }  
247                                   @Override  
248                                   public void onFailure(int reason) {  
249                                       Activity activity = getActivity();  
250                                       if (activity != null) {  
251                                           Toast.makeText(activity,  
252                                                R.string.wifi_failed_connect_message,  
253                                                Toast.LENGTH_SHORT).show();  
254                                       }  
255                                   }  
256                               };  
257  
258        mSaveListener = new WifiManager.ActionListener() {  
259                                @Override  
260                                public void onSuccess() {  
261                                }  
262                                @Override  
263                                public void onFailure(int reason) {  
264                                    Activity activity = getActivity();  
265                                    if (activity != null) {  
266                                        Toast.makeText(activity,  
267                                            R.string.wifi_failed_save_message,  
268                                            Toast.LENGTH_SHORT).show();  
269                                    }  
270                                }  
271                            };  
272  
273        mForgetListener = new WifiManager.ActionListener() {  
274                                   @Override  
275                                   public void onSuccess() {  
276                                   }  
277                                   @Override  
278                                   public void onFailure(int reason) {  
279                                       Activity activity = getActivity();  
280                                       if (activity != null) {  
281                                           Toast.makeText(activity,  
282                                               R.string.wifi_failed_forget_message,  
283                                               Toast.LENGTH_SHORT).show();  
284                                       }  
285                                   }  
286                               };  
287          
288        if (savedInstanceState != null) {  
289            mDlgEdit = savedInstanceState.getBoolean(SAVE_DIALOG_EDIT_MODE);  
290            if (savedInstanceState.containsKey(SAVE_DIALOG_ACCESS_POINT_STATE)) {  
291                mAccessPointSavedState =  
292                    savedInstanceState.getBundle(SAVE_DIALOG_ACCESS_POINT_STATE);  
293            }  
294        }  
295  
296        // if we're supposed to enable/disable the Next button based on our current connection  
297        // state, start it off in the right state  
298        Intent intent = getActivity().getIntent();  
299        mEnableNextOnConnection = intent.getBooleanExtra(EXTRA_ENABLE_NEXT_ON_CONNECT, false);  
300  
301        if (mEnableNextOnConnection) {  
302            if (hasNextButton()) {  
303                final ConnectivityManager connectivity = (ConnectivityManager)  
304                        getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);  
305                if (connectivity != null) {  
306                    NetworkInfo info = connectivity.getNetworkInfo(  
307                            ConnectivityManager.TYPE_WIFI);  
308                    changeNextButtonState(info.isConnected());  
309                }  
310            }  
311        }  
312  
313        addPreferencesFromResource(R.xml.wifi_settings);  
314            
315        mEmptyView = initEmptyView();                       
316              registerForContextMenu(getListView()); //这样会调用onCreateContextMenu(ContextMenu, View, ContextMenuInfo) 的方法  
317        setHasOptionsMenu(true);                     //会调用onCreateOptionsMenu  
318          
319        if (intent.hasExtra(EXTRA_START_CONNECT_SSID)) {  
320            String ssid = intent.getStringExtra(EXTRA_START_CONNECT_SSID);  
321            updateAccessPoints();  
322            PreferenceScreen preferenceScreen = getPreferenceScreen();  
323            for (int i = 0; i < preferenceScreen.getPreferenceCount(); i++) {  
324                Preference preference = preferenceScreen.getPreference(i);  
325                if (preference instanceof AccessPoint) {  
326                    AccessPoint accessPoint = (AccessPoint) preference;  
327                    if (ssid.equals(accessPoint.ssid) && accessPoint.networkId == -1  
328                            && accessPoint.security != AccessPoint.SECURITY_NONE) {  
329                        onPreferenceTreeClick(preferenceScreen, preference);  
330                        break;  
331                    }  
332                }  
333            }  
334        }  
335    }  
336  

重写onstart(参数)
对WifiEnabler进行创建对象：主要是对switchbar进行操作
在wifiEnabler的构造方法中，加入intent-filter来接受广播

[java] view plain copy 
346    @Override  
347    public void onStart() {  
348        super.onStart();  
349  
350        // On/off switch is hidden for Setup Wizard (returns null)  
351        mWifiEnabler = createWifiEnabler();  
352    }  


重写onResume(参数)
做了三件事情：1加入switchbar的广播注册，加入switch的监听
2.WifiSettings注册广播
3更新ap
[java] view plain copy 
362    @Override  
363    public void onResume() {  
364        final Activity activity = getActivity();  
365        super.onResume();  
366        if (mWifiEnabler != null) {  
367            mWifiEnabler.resume(activity);  
368        }  
369  
370        activity.registerReceiver(mReceiver, mFilter);  
371        updateAccessPoints();  
372    }  


重写onPause(参数)
做了三件事：1wifiEnabler中解除广播注册，移出switch监听
      2.WifiSettings移出广播
      3.停止扫描移出scanner中的message
[java] view plain copy 
374    @Override  
375    public void onPause() {  
376        super.onPause();  
377        if (mWifiEnabler != null) {  
378            mWifiEnabler.pause();  
379        }  
380  
381        getActivity().unregisterReceiver(mReceiver);  
382        mScanner.pause();  
383    }  



重写onDestroyView(参数):
     1.隐藏switchbar:teardownSwitchbar()
[java] view plain copy 
337    @Override  
338    public void onDestroyView() {  
339        super.onDestroyView();  
340  
341        if (mWifiEnabler != null) {  
342            mWifiEnabler.teardownSwitchBar();  
343        }  
344    }