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

2023年4月5日 243次阅读 来源: Android源码分析

在看一下代码之前需要简单了解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
  
  1.  private static class Scanner extends Handler {  
  2. 176        private int mRetry = 0;  
  3. 177        private WifiSettings mWifiSettings = null;  
  4. 178  
  5. 179        Scanner(WifiSettings wifiSettings) {  
  6. 180            mWifiSettings = wifiSettings;  
  7. 181        }  
  8. 182  
  9. 183        void resume() {  
  10. 184            if (!hasMessages(0)) {  
  11. 185                sendEmptyMessage(0);  
  12. 186            }  
  13. 187        }  
  14. 188  
  15. 189        void forceScan() {  
  16. 190            removeMessages(0);  
  17. 191            sendEmptyMessage(0);  
  18. 192        }  
  19. 193  
  20. 194        void pause() {  
  21. 195            mRetry = 0;  
  22. 196            removeMessages(0);  
  23. 197        }  
  24. 198  
  25. 199        @Override  
  26. 200        public void handleMessage(Message message) {  
  27. 201            if (mWifiSettings.mWifiManager.startScan()) {  
  28. 202                mRetry = 0;                                       //当中有一次扫描成功mRetry=0；  
  29. 203            } else if (++mRetry >= 3) {                         //开始扫描的操作失败mRetry+1与3比较，超过三次就return  
  30. 204                mRetry = 0;  
  31. 205                Activity activity = mWifiSettings.getActivity();  
  32. 206                if (activity != null) {  
  33. 207                    Toast.makeText(activity, R.string.wifi_fail_to_scan, Toast.LENGTH_LONG).show();  
  34. 208                }  
  35. 209                return;  
  36. 210            }  
  37. 211            sendEmptyMessageDelayed(0, WIFI_RESCAN_INTERVAL_MS); //每隔10秒，发起扫描的操作  
  38. 212        }  
  39. 213    }  
  40. 214  
[java]
 view plain
  copy
  
  1. </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
  
  1. <pre name=“code” class=“java”>       public WifiSettings() {  
  2. 216        super(DISALLOW_CONFIG_WIFI);  
  3. 217        mFilter = new IntentFilter();  
  4. 218        mFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);  
  5. 219        mFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);  
  6. 220        mFilter.addAction(WifiManager.NETWORK_IDS_CHANGED_ACTION);  
  7. 221        mFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);  
  8. 222        mFilter.addAction(WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION);  
  9. 223        mFilter.addAction(WifiManager.LINK_CONFIGURATION_CHANGED_ACTION);  
  10. 224        mFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);  
  11. 225        mFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);  
  12. 226  
  13. 227        mReceiver = new BroadcastReceiver() {  
  14. 228            @Override  
  15. 229            public void onReceive(Context context, Intent intent) {  
  16. 230                handleEvent(intent);  
  17. 231            }  
  18. 232        };  
  19. 233  
  20. 234        mScanner = new Scanner(this);  
  21. 235    }  
[java]
 view plain
  copy
  
  1.   
[java]
 view plain
  copy
  
  1.   
 但是在
 HandleEvent方法中却只有
 6个action的处理，NETWORK_IDS_CHANGED_ACTION与SUPPLICANT_STATE_CHANGED_ACTION却没有处理，那么加入的目的？
HandleEvent处理广播的代码：
[java]
 view plain
  copy
  
  1. 777    private void handleEvent(Intent intent) {  
  2. 778        String action = intent.getAction();  
  3. 779        if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) {  
  4. 780            updateWifiState(intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,  
  5. 781                    WifiManager.WIFI_STATE_UNKNOWN));                           //更新wifi状态改变,Enabled Enabling Disabled  
  6. 782        } else if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action) ||  
  7. 783                WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION.equals(action) ||  
  8. 784                WifiManager.LINK_CONFIGURATION_CHANGED_ACTION.equals(action)) {  
  9. 785                updateAccessPoints();                                           //更新AccessPoints  
  10. 786        } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) {  
  11. 787            NetworkInfo info = (NetworkInfo) intent.getParcelableExtra(  
  12. 788                    WifiManager.EXTRA_NETWORK_INFO);  
  13. 789            mConnected.set(info.isConnected());  
  14. 790            changeNextButtonState(info.isConnected());  
  15. 791            updateAccessPoints();   
  16. 792            updateNetworkInfo(info);                                              //更新ap再更新网络信息                                                                      
  17. 793        } else if (WifiManager.RSSI_CHANGED_ACTION.equals(action)) {  
  18. 794            updateNetworkInfo(null);  
  19. 795        }  
  20. 796    }  
  21. 797  
不同的action对应处理不同的事件：
WIFI_STATE_CHANGED_ACTION:当wifi状态改变的时候，updataWifiState(int state),根据不同的状态，做不同的处理：
[java]
 view plain
  copy
  
  1. 827    private void updateWifiState(int state) {  
  2. 828        Activity activity = getActivity();  
  3. 829        if (activity != null) {  
  4. 830            activity.invalidateOptionsMenu();  
  5. 831        }  
  6. 832  
  7. 833        switch (state) {  
  8. 834            case WifiManager.WIFI_STATE_ENABLED:  
  9. 835                mScanner.resume();                                //enabled的时候，发送扫描信息startScan()  
  10. 836                return; // not break, to avoid the call to pause() below  //避免调用mScanner.pause()停止扫描  
  11. 837   
  12. 838            case WifiManager.WIFI_STATE_ENABLING:  
  13. 839                addMessagePreference(R.string.wifi_starting);    //加入“正在打开wifi”  
  14. 840                break;  
  15. 841  
  16. 842            case WifiManager.WIFI_STATE_DISABLED:  
  17. 843                setOffMessage();                                //wifi不可用的时候，显示一些其他信息(通过provider判断)  
  18. 844                break;  
  19. 845        }  
  20. 846  
  21. 847        mLastInfo = null;  
  22. 848        mLastNetworkInfo = null;  
  23. 849        mScanner.pause();                                      //停止扫描  
  24. 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
  
  1. 640    private void updateAccessPoints() {  
  2. 641        // Safeguard from some delayed event handling  
  3. 642        if (getActivity() == null) return;  
  4. 643  
  5. 644        if (isUiRestricted())   
  6. 645            addMessagePreference(R.string.wifi_empty_list_user_restricted);     //判断是否有限制  
  7. 646            return;  
  8. 647        }  
  9. 648        final int wifiState = mWifiManager.getWifiState();  
  10. 649  
  11. 650        //when we update the screen, check if verbose logging has been turned on or off  
  12. 651        mVerboseLogging = mWifiManager.getVerboseLoggingLevel();  
  13. 652  
  14. 653        switch (wifiState) {                                                  //根据wifi状态来处理  
  15. 654            case WifiManager.WIFI_STATE_ENABLED:                              //当wifi状态可用的情况下  
  16. 655                // AccessPoints are automatically sorted with TreeSet.  
  17. 656                final Collection<AccessPoint> accessPoints =  
  18. 657                        constructAccessPoints(getActivity(), mWifiManager, mLastInfo,  
  19. 658                                mLastNetworkInfo);                           //主要通过constructAccessPoints进行更新  
  20. 659                getPreferenceScreen().removeAll();  
  21. 660                if (accessPoints.size() == 0) {  
  22. 661                    addMessagePreference(R.string.wifi_empty_list_wifi_on); //如果ap没有，则显示“正在搜索wlan网络”  
  23. 662                }  
  24. 663  
  25. 664                for (AccessPoint accessPoint : accessPoints) {  
  26. 665                    // Ignore access points that are out of range.  
  27. 666                    if (accessPoint.getLevel() != –1) {  
  28. 667                        getPreferenceScreen().addPreference(accessPoint);  //遍历，增加到preferenceScreen中（可以阅读相关资料了解）  
  29. 668                    }  
  30. 669                }  
  31. 670                break;  
  32. 671  
  33. 672            case WifiManager.WIFI_STATE_ENABLING:  
  34. 673                getPreferenceScreen().removeAll();                         //enabling的情况下，移出preferenceScreen中所有的ap  
  35. 674                break;  
  36. 675  
  37. 676            case WifiManager.WIFI_STATE_DISABLING:  
  38. 677                addMessagePreference(R.string.wifi_stopping);             //显示“正在关闭“                     
  39. 678                break;  
  40. 679  
  41. 680            case WifiManager.WIFI_STATE_DISABLED:                        //不可用的时候，显示其他信息  
  42. 681                setOffMessage();  
  43. 682                break;  
  44. 683        }  
  45. 684    }  
  46. 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
  
  1. 798    private void updateNetworkInfo(NetworkInfo networkInfo) {  
  2. 799        /* sticky broadcasts can call this when wifi is disabled */  
  3. 800        if (!mWifiManager.isWifiEnabled()) {                                                     
  4. 801            mScanner.pause();                                                          
  5. 802            return;  
  6. 803        }  
  7. 804  
  8. 805        if (networkInfo != null &&  
  9. 806                networkInfo.getDetailedState() == DetailedState.OBTAINING_IPADDR) {  
  10. 807            mScanner.pause();  
  11. 808        } else {  
  12. 809            mScanner.resume();  
  13. 810        }  
  14. 811  
  15. 812        mLastInfo = mWifiManager.getConnectionInfo();  
  16. 813        if (networkInfo != null) {  
  17. 814            mLastNetworkInfo = networkInfo;  
  18. 815        }  
  19. 816                                                                      //倒序更新AccessPoint的信息,应该是更新了修改配置之后的ap的信息  
  20. 817        for (int i = getPreferenceScreen().getPreferenceCount() – 1; i >= 0; –i) {  
  21. 818            // Maybe there’s a WifiConfigPreference  
  22. 819            Preference preference = getPreferenceScreen().getPreference(i);  
  23. 820            if (preference instanceof AccessPoint) {  
  24. 821                final AccessPoint accessPoint = (AccessPoint) preference;  
  25. 822                accessPoint.update(mLastInfo, mLastNetworkInfo);                        
  26. 823            }  
  27. 824        }  
  28. 825    }  
RSSI_CHANGED_ACTION
 The RSSI (signal strength) has changed.
显而易见，这指的是信号强度被改变的action,调用updateNetworkInfo，更新一下网络信息就可以了
以上是handleEvent的
=============================================
 handleEvent分割线======================================================================
之前看到在updataAccessPoints中调用了这个方法：constructAccessPoints,看一下这个方法的源码把
[java]
 view plain
  copy
  
  1. private static List<AccessPoint> constructAccessPoints(Context context,  
  2. 719            WifiManager wifiManager, WifiInfo lastInfo, NetworkInfo lastNetworkInfo) {  
  3. 720        ArrayList<AccessPoint> accessPoints = new ArrayList<AccessPoint>();       //存放ap的ArrayList，用来返回  
  4. 721        /** Lookup table to more quickly update AccessPoints by only considering objects with the 
  5. 722         * correct SSID.  Maps SSID -> List of AccessPoints with the given SSID.  */  
  6. 723        Multimap<String, AccessPoint> apMap = new Multimap<String, AccessPoint>();//多重映射，键SSID(网络名)–值（ap）  
  7. 724  
  8. 725        final List<WifiConfiguration> configs = wifiManager.getConfiguredNetworks();//获取手机中保存过配置的连接信息  
  9. 726        if (configs != null) {  
  10. 727            // Update “Saved Networks” menu option.                //更新选项“saved Networks”的状态  
  11. 728            if (savedNetworksExist != (configs.size() > 0)) {      //比较式前后一致的返回值，更新Saved Networks的菜单选项  
  12.                                                                       //例如:没有存储的wifi信息，那么savedNetworksExist为flase  
  13.                                                                       //例如:有存储的wifi信息，那么savedNetworksExist为true  
  14. 729                savedNetworksExist = !savedNetworksExist;  
  15. 730                if (context instanceof Activity) {  
  16. 731                    ((Activity) context).invalidateOptionsMenu();   //刷新optionMenu  
  17. 732                }  
  18. 733            }  
  19. 734            for (WifiConfiguration config : configs) {                   //对配置过的信息进行遍历  
  20. 735                if (config.selfAdded && config.numAssociation == 0) {    // Number of time we associated to this configuration  
  21. 736                    continue;                                            //跳过本次循环     
  22. 737                }  
  23. 738                AccessPoint accessPoint = new AccessPoint(context, config);  
  24. 739                if (lastInfo != null && lastNetworkInfo != null) {  
  25. 740                    accessPoint.update(lastInfo, lastNetworkInfo);        
  26. 741                }  
  27. 742                accessPoints.add(accessPoint);                          //把ap加入List中  
  28. 743                apMap.put(accessPoint.ssid, accessPoint);  
  29. 744            }  
  30. 745        }  
  31. 746  
  32. 747        final List<ScanResult> results = wifiManager.getScanResults();   //wifi扫描结果的的处理  
  33. 748        if (results != null) {  
  34. 749            for (ScanResult result : results) {                          //遍历扫描结果  
  35. 750                // Ignore hidden and ad-hoc networks.                    //忽略隐藏的（没有SSID）以及ad-hoc(IBSS?)  
  36. 751                if (result.SSID == null || result.SSID.length() == 0 ||  
  37. 752                        result.capabilities.contains(“[IBSS]”)) {  
  38. 753                    continue;  
  39. 754                }  
  40. 755  
  41. 756                boolean found = false;                                  //第一次的apMap中存放了配置过的信息  
  42. 757                for (AccessPoint accessPoint : apMap.getAll(result.SSID)) {  
  43. 758                    if (accessPoint.update(result))                     //判断扫描结果ssid和security安全协议是否存在过，存在更新  
  44. 759                        found = true;                                   
  45. 760                }  
  46. 761                if (!found) {                                            //未找到的情况下，加入accesspoints的  
  47. 762                    AccessPoint accessPoint = new AccessPoint(context, result);  
  48. 763                    if (lastInfo != null && lastNetworkInfo != null) {  
  49. 764                        accessPoint.update(lastInfo, lastNetworkInfo);  
  50. 765                    }  
  51. 766                    accessPoints.add(accessPoint);  
  52. 767                    apMap.put(accessPoint.ssid, accessPoint);           //放入apMap，再次遍历会调用  
  53. 768                }  
  54. 769            }  
  55. 770        }  
  56. 771  
  57. 772        // Pre-sort accessPoints to speed preference insertion  
  58. 773        Collections.sort(accessPoints);  
  59. 774        return accessPoints;  
  60. 775    }  
 ==============================================================================================================
来了解一下所有的重写的方法：OptionsMenu：调用addOptionsMenuItems方法进行初始化
[java]
 view plain
  copy
  
  1. 397    void addOptionsMenuItems(Menu menu) {       //这里的通过wifi是否打开的状态设置menu中元素的enable状态  
  2. 398        final boolean wifiIsEnabled = mWifiManager.isWifiEnabled();  
  3. 399        TypedArray ta = getActivity().getTheme().obtainStyledAttributes(  
  4. 400                new int[] {R.attr.ic_menu_add, R.attr.ic_wps});  
  5. 401        menu.add(Menu.NONE, MENU_ID_ADD_NETWORK, 0, R.string.wifi_add_network)  
  6. 402                .setIcon(ta.getDrawable(0))  
  7. 403                .setEnabled(wifiIsEnabled)          //增加网络，当wifi不可用的时候为false，不能点击  
  8. 404                .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);  
  9. 405        if (savedNetworksExist) {  
  10. 406            menu.add(Menu.NONE, MENU_ID_SAVED_NETWORK, 0, R.string.wifi_saved_access_points_label)  
  11. 407                    .setIcon(ta.getDrawable(0))  
  12. 408                    .setEnabled(wifiIsEnabled)       //通过判断是否存在保存的网络，来决定显示与否  
  13. 409                    .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);  
  14. 410        }  
  15. 411        menu.add(Menu.NONE, MENU_ID_SCAN, 0, R.string.menu_stats_refresh)  
  16. 412               .setEnabled(wifiIsEnabled)  
  17. 413               .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);//刷新，通过判断wifi状态来决定是否能刷新  
  18. 414        menu.add(Menu.NONE, MENU_ID_ADVANCED, 0, R.string.wifi_menu_advanced)  
  19. 415                .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); //高级选项  
  20. 416        ta.recycle();  
  21. 417      
 OptionMenuItems对应的点击事件为：onOptionsItemSelected，根据不同的item点开对应的dialog，
当然，onCrateContextMenu中对应的点击事件为onContextItemSelected,根据不同的选项执行不同的操作
当然还有一些重写的方法，那就是生命周期的重写：如：
先执行构造方法，然后方法如下：
重写onActivityCreated（参数）
1.获得系统服务WifiManager
2.注册监听,connect,save,forget
3.savedInstanceState的状态判断，进行一些初始化
 [java]
 view plain
  copy
  
  1. <pre name=“code” class=“java”>@Override  
  2. 238    public void onActivityCreated(Bundle savedInstanceState) {  
  3. 239        super.onActivityCreated(savedInstanceState);  
  4. 240        //获得服务  
  5. 241        mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);  
  6. 242        //三种监听  
  7. 243        mConnectListener = new WifiManager.ActionListener() {  
  8. 244                                   @Override  
  9. 245                                   public void onSuccess() {  
  10. 246                                   }  
  11. 247                                   @Override  
  12. 248                                   public void onFailure(int reason) {  
  13. 249                                       Activity activity = getActivity();  
  14. 250                                       if (activity != null) {  
  15. 251                                           Toast.makeText(activity,  
  16. 252                                                R.string.wifi_failed_connect_message,  
  17. 253                                                Toast.LENGTH_SHORT).show();  
  18. 254                                       }  
  19. 255                                   }  
  20. 256                               };  
  21. 257  
  22. 258        mSaveListener = new WifiManager.ActionListener() {  
  23. 259                                @Override  
  24. 260                                public void onSuccess() {  
  25. 261                                }  
  26. 262                                @Override  
  27. 263                                public void onFailure(int reason) {  
  28. 264                                    Activity activity = getActivity();  
  29. 265                                    if (activity != null) {  
  30. 266                                        Toast.makeText(activity,  
  31. 267                                            R.string.wifi_failed_save_message,  
  32. 268                                            Toast.LENGTH_SHORT).show();  
  33. 269                                    }  
  34. 270                                }  
  35. 271                            };  
  36. 272  
  37. 273        mForgetListener = new WifiManager.ActionListener() {  
  38. 274                                   @Override  
  39. 275                                   public void onSuccess() {  
  40. 276                                   }  
  41. 277                                   @Override  
  42. 278                                   public void onFailure(int reason) {  
  43. 279                                       Activity activity = getActivity();  
  44. 280                                       if (activity != null) {  
  45. 281                                           Toast.makeText(activity,  
  46. 282                                               R.string.wifi_failed_forget_message,  
  47. 283                                               Toast.LENGTH_SHORT).show();  
  48. 284                                       }  
  49. 285                                   }  
  50. 286                               };  
  51. 287          
  52. 288        if (savedInstanceState != null) {  
  53. 289            mDlgEdit = savedInstanceState.getBoolean(SAVE_DIALOG_EDIT_MODE);  
  54. 290            if (savedInstanceState.containsKey(SAVE_DIALOG_ACCESS_POINT_STATE)) {  
  55. 291                mAccessPointSavedState =  
  56. 292                    savedInstanceState.getBundle(SAVE_DIALOG_ACCESS_POINT_STATE);  
  57. 293            }  
  58. 294        }  
  59. 295  
  60. 296        // if we’re supposed to enable/disable the Next button based on our current connection  
  61. 297        // state, start it off in the right state  
  62. 298        Intent intent = getActivity().getIntent();  
  63. 299        mEnableNextOnConnection = intent.getBooleanExtra(EXTRA_ENABLE_NEXT_ON_CONNECT, false);  
  64. 300  
  65. 301        if (mEnableNextOnConnection) {  
  66. 302            if (hasNextButton()) {  
  67. 303                final ConnectivityManager connectivity = (ConnectivityManager)  
  68. 304                        getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);  
  69. 305                if (connectivity != null) {  
  70. 306                    NetworkInfo info = connectivity.getNetworkInfo(  
  71. 307                            ConnectivityManager.TYPE_WIFI);  
  72. 308                    changeNextButtonState(info.isConnected());  
  73. 309                }  
  74. 310            }  
  75. 311        }  
  76. 312  
  77. 313        addPreferencesFromResource(R.xml.wifi_settings);  
  78. 314            
  79. 315        mEmptyView = initEmptyView();                       
  80. 316              registerForContextMenu(getListView()); //这样会调用onCreateContextMenu(ContextMenu, View, ContextMenuInfo) 的方法  
  81. 317        setHasOptionsMenu(true);                     //会调用onCreateOptionsMenu  
  82. 318          
  83. 319        if (intent.hasExtra(EXTRA_START_CONNECT_SSID)) {  
  84. 320            String ssid = intent.getStringExtra(EXTRA_START_CONNECT_SSID);  
  85. 321            updateAccessPoints();  
  86. 322            PreferenceScreen preferenceScreen = getPreferenceScreen();  
  87. 323            for (int i = 0; i < preferenceScreen.getPreferenceCount(); i++) {  
  88. 324                Preference preference = preferenceScreen.getPreference(i);  
  89. 325                if (preference instanceof AccessPoint) {  
  90. 326                    AccessPoint accessPoint = (AccessPoint) preference;  
  91. 327                    if (ssid.equals(accessPoint.ssid) && accessPoint.networkId == –1  
  92. 328                            && accessPoint.security != AccessPoint.SECURITY_NONE) {  
  93. 329                        onPreferenceTreeClick(preferenceScreen, preference);  
  94. 330                        break;  
  95. 331                    }  
  96. 332                }  
  97. 333            }  
  98. 334        }  
  99. 335    }  
  100. 336  
重写onstart(参数) 
对WifiEnabler进行创建对象：主要是对switchbar进行操作
在wifiEnabler的构造方法中，加入intent-filter来接受广播
 [java]
 view plain
  copy
  
  1. 346    @Override  
  2. 347    public void onStart() {  
  3. 348        super.onStart();  
  4. 349  
  5. 350        // On/off switch is hidden for Setup Wizard (returns null)  
  6. 351        mWifiEnabler = createWifiEnabler();  
  7. 352    }  
重写onResume(参数)
做了三件事情：1加入switchbar的广播注册，加入switch的监听
 2.WifiSettings注册广播
 3更新ap
[java]
 view plain
  copy
  
  1. 362    @Override  
  2. 363    public void onResume() {  
  3. 364        final Activity activity = getActivity();  
  4. 365        super.onResume();  
  5. 366        if (mWifiEnabler != null) {  
  6. 367            mWifiEnabler.resume(activity);  
  7. 368        }  
  8. 369  
  9. 370        activity.registerReceiver(mReceiver, mFilter);  
  10. 371        updateAccessPoints();  
  11. 372    }  
重写onPause(参数)
做了三件事：1wifiEnabler中解除广播注册，移出switch监听
 2.WifiSettings移出广播
 3.停止扫描移出scanner中的message
[java]
 view plain
  copy
  
  1. 374    @Override  
  2. 375    public void onPause() {  
  3. 376        super.onPause();  
  4. 377        if (mWifiEnabler != null) {  
  5. 378            mWifiEnabler.pause();  
  6. 379        }  
  7. 380  
  8. 381        getActivity().unregisterReceiver(mReceiver);  
  9. 382        mScanner.pause();  
  10. 383    }  
重写onDestroyView(参数):
 1.隐藏switchbar:teardownSwitchbar()
[java]
 view plain
  copy
  
  1. 337    @Override  
  2. 338    public void onDestroyView() {  
  3. 339        super.onDestroyView();  
  4. 340  
  5. 341        if (mWifiEnabler != null) {  
  6. 342            mWifiEnabler.teardownSwitchBar();  
  7. 343        }  
  8. 344    }  
     原文作者：Android源码分析
     原文地址: https://blog.csdn.net/the_sunshine_of_king/article/details/77838777
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。 
  点赞