lp542718520
lp542718520

Android WiFi从app到driver详解

分三大部分：

（1）    Wifi模块相关文件的解析

（2）    Wpa_supplicant解析

（3）    Wifi的启动流程（有代码供参考分析）

 

一，Wifi模块相关文件解析

1)     wifisettings.Java

packages/apps/Settings/src/com/android/settings/wifiwifisettings.java

       该类数据部分主要定义了下面几个类的变量：

[java]  view plain  copy
  1. {  
  2.   
  3. private final IntentFilter mFilter;  
  4.   
  5.    
  6.   
  7. //广播接收器，用来接收消息并做响应的处理工作  
  8.   
  9. privatefinal BroadcastReceiver mReceiver;  
  10.   
  11.    
  12.   
  13. //这是一个扫描类，会在用户手动扫描   AP时被调用  
  14.   
  15. privatefinal Scanner mScanner;                  
  16.   
  17. private WifiInfo mLastInfo;  
  18.   
  19.    
  20.   
  21.        //服务代理端，作为WifiService对外的接口类呈现  
  22.   
  23. privateWifiManager mWifiManager;  
  24.   
  25.    
  26.   
  27. //这个类主要实现Wifi的开闭工作  
  28.   
  29. privateWifiEnabler mWifiEnabler;  
  30.   
  31.    
  32.   
  33. //AP  
  34.   
  35. private AccessPoint mSelected;  
  36.   
  37. private WifiDialog mDialog;  
  38.   
  39. ……  
  40.   
  41. }  


       wifiSettings类的构造函数的主要工作：定义了一个IntentFilter（Intent过滤器）变量，并添加了六个动作，（了解Android的intent机制的同学都知道什么意思，不明白的同学参考Intent机制的资料）接着定义一个广播接收器，并有相应的消息处理函数，下面是该构造函数的定义：

 

[java]  view plain  copy
  1. public WifiSettings() {  
  2.   
  3. mFilter = new IntentFilter();  
  4.   
  5. //intent机制中的intent消息过滤器，下面添加可以处理的动作  
  6.   
  7.     mFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);  
  8.   
  9.       mFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);  
  10.   
  11.     mFilter.addAction(WifiManager.NETWORK_IDS_CHANGED_ACTION);  
  12.   
  13.    mFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);  
  14.   
  15.        mFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);  
  16.   
  17.     mFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);  
  18.   
  19.    
  20.   
  21. //注册了广播接收器，用来处理接收到的消息事件  
  22.   
  23.        mReceiver = new BroadcastReceiver() {  
  24.   
  25.            @Override  
  26.   
  27.             public void onReceive(Context context,Intent intent) {  
  28.   
  29.                handleEvent(intent); //事件处理函数  
  30.   
  31.             }  
  32.   
  33.         };  
  34.   
  35.    
  36.   
  37.         mScanner= new Scanner();     //手动扫描类  
  38.   
  39. }  


       在广播接收器中的相应函数onReceive函数中有个handleEvent函数，它就是用来处理广播接收器接受到的intent消息的，它的功能是根据intent消息中的动作类型，来执行相应的操作，每一种动作对应了activity的一项消息处理能力。

       在oncreate函数中实例化了mWifiManager和mWifiEnabler两个类，这两个类对wifiSettings来说至关重要，它后面的定义的一系列函数都是通过调用这两个类的相应接口来实现的。

[java]  view plain  copy
  1. ……  
  2.   
  3. mWifiManager = (WifiManager)getSystemService(Context.WIFI_SERVICE);  
  4.   
  5. mWifiEnabler = new WifiEnabler(this,  
  6.   
  7.                    (CheckBoxPreference) findPreference("enable_wifi"));  
  8.   
  9. ……  


       WifiSettings中还定义了显示菜单和响应菜单键的函数，即onCreateOptionsMenu（）和onOptionsItemSelected（）；还有响应配置对话框中按键的onClick()函数；最后定义了Scanner类，它是一个handler的继承类，实现了消息处理函数，用于处理手动扫描的动作。

 

2)     WifiEnabler.java:

packages/apps/Settings/src/com/android/settings/wifi/WifiEnabler.java

 

[java]  view plain  copy
  1. private final Context mContext;   
  2.   
  3. private final CheckBoxPreference mCheckBox;  
  4.   
  5.    
  6.   
  7. //两个重要成员  
  8.   
  9. private final WifiManager mWifiManager;  
  10.   
  11. private final IntentFilter mIntentFilter;  


 

       wifienabler类中定义了四个成员变量很重要，mContext，mCheckBox，mWifiManager和mReceiver，其中mContext用于获取mwifiManager实例，mReceiver用来接收底层发来的消息，mCheckBox用来改变UI的状态。

该类中定义了几个重要的函数onPreferenceChange，handleWifiStateChanged和handleStateChanged，onPreferenceChange用来处理按下的Enbler键，它会调用mWifiManager.setWifiEnabled(enable)，另外两个用来处理接受的消息事件。

 

       在类的构造函数中，主要做了一下工作：初始化了mContext,mCheckBox,mWifimanager，并且初始化了一个mIntentFilter变量，添加了三个动作，在构造函数的上面定义了一个广播接收器，用来接收下层传来的消息，并根据intent动作的类型调用相应的处理函数，这个广播接收器在onResum函数中被注册。

[java]  view plain  copy
  1. public WifiEnabler(Context context, CheckBoxPreferencecheckBox) {  
  2.   
  3.         mContext= context;  
  4.   
  5.        mCheckBox = checkBox;  
  6.   
  7.        mOriginalSummary = checkBox.getSummary();  
  8.   
  9.        checkBox.setPersistent(false);  
  10.   
  11.    
  12.   
  13.        mWifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE);  
  14.   
  15.         mIntentFilter= new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION);  
  16.   
  17.         // Theorder matters! We really should not depend on this. :(  
  18.   
  19.        mIntentFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);  
  20.   
  21.        mIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);  
  22.   
  23. }  


这里可以总结为：如果上层需要监听或收到下层的消息，那么就要通过定义一个BroadcastReciever，并将它注册，当然在接受到消息后应该有处理消息的函数，然后在onReciever函数中根据消息调用相应的处理函数，这里的消息通知机制是Intent，在BroadcastReciever类的onReciever函数的参数中可以看出。

该类成员函数的也是通过调用mWifimanager的接口来实现的。

 

 3) WifiManager:

       frameworks/base/wifi/java/android/net/wifi/WifiManager.java

       两个重要的数据成员：

//WifiService

IWifiManager mService;

    HandlermHandler;

IWifiManager mService和HandlermHandler，这个类拥有了一个WifiService实例，就可以通过它进行一系列的调用；WifiManager中定义了的wifi和ap的状态，这些状态会在其他很多类中有使用；然后定义了大量的函数，这些函数几乎都是对WifiService接口函数的封装，直接调用WifiService的函数。

该类的构造函数很简单：

[java]  view plain  copy
  1. public WifiManager(IWifiManager service,Handler handler) {  
  2.   
  3.        mService = service;  
  4.   
  5.        mHandler = handler;  
  6.   
  7.     }  


该类中还定义了一个WifiLock类，这个类用来保证在有应用程序使用Wifi无线电传输数据时，wifiradio可用，即当一个应用程序使用wifi的radio进行无线电数据传输时，就要先获得这个锁，如果该锁已被其他程序占有，就要等到该锁被释放后才能获得，只用当所有持有该锁的程序都释放该锁后，才能关闭radio功能。

 

 4)WifiService：

frameworks/base/services/java/com/android/server/WifiService.java

[java]  view plain  copy
  1. private final WifiStateTrackermWifiStateTracker;  
  2.   
  3. private Context mContext;  
  4.   
  5. private WifiWatchdogServicemWifiWatchdogService = null;  
  6.   
  7. private final  WifiHandler mWifiHandler;  


这是WifiService中的几个重要的数据成员。

在接下来的构造函数中初始化了mWifiStateTracker，mContext，然后动态生成mWifiThread子线程并启动，在主线程里用mWifiThread调用getLooper()函数获得线程的looper，来初始化创建一个mWifiHandler对象，这个WifiHandler在WifiService类的后面有定义，并重载了Handler类的handlermessage（）函数，这样消息就可以在主线程里被处理了，这是android的handlerthread消息处理机制，可参考相关资料，这里不予详述。在构造函数的最后，注册了两个广播接收器，分别用来ACTION_AIRPLANE_MODE_CHANGED和ACTION_TETHER_STATE_CHANGED这两个动作，这里是android的intent消息通知机制，请参考相关资料，代码如下：

 

[java]  view plain  copy
  1. mContext = context;  
  2.   
  3. mWifiStateTracker = tracker;  
  4.   
  5. mWifiStateTracker.enableRssiPolling(true);  
  6.   
  7. ……  
  8.   
  9. HandlerThread wifiThread = newHandlerThread("WifiService");  
  10.   
  11. wifiThread.start();  
  12.   
  13. mWifiHandler = newWifiHandler(wifiThread.getLooper());  
  14.   
  15. ……  


随后定义了一系列的函数，其中有服务器要发送的命令的系列函数，它通过mWifiStateTracker成员类调用自己的的发送命令的接口（其实就是对本地接口的一个封装），最后通过适配层发送命令给wpa_supplicant，而事件处理只到WifiStateTracker层被处理。

要注意的是，在WifiService中，定义了一些函数来创建消息，并通过mWifiHandler将消息发送到消息队列上，然后在mHandlerThread线程体run()分发\处理消息，在主线程中被mWifiHandler的handlerMessage（）函数处理，最后调用mWifiStateTracker的对应函数来实现的。这里我也不明白为什么WifiService不直接调用mWifiStateTracker对应的函数，还要通过消息处理机制，绕了一圈在调用，当然Google这么做肯定是有它道理的，忘高手指点。

 

 5) WifiStateTracker类：

frameworks/base/wifi/java/android/net/wifi/WifiStateTracker.java

NetworkStateTracker继承了handler类，而WifiStateTracker继承了NetworkStateTracker类，就是说WifiStateTracker间接继承了handler类，属于一个事件处理类。

WifiStateTracker类首先定义了事件日志和事件码（这里包含了所有可能的事件类型），还定义了如下的重要成员数据：

[java]  view plain  copy
  1.           //几个重要的数据成员  
  2.   
  3. private WifiMonitor mWifiMonitor;    //被启动用来监听supplicant传来的消息  
  4.   
  5. private WifiInfo mWifiInfo;           
  6.   
  7. private WifiManager mWM;             //服务代理  
  8.   
  9. private DhcpHandler mDhcpTarget;  //IP地址获取线程  
  10.   
  11. private DhcpInfo mDhcpInfo;            //Dhcp的相关信息都在这里  


               

类的构造函数中，初始化了系列成员变量，包括生成了WifiMonitor的实例，在构造函数中，因为WifiStateTracker是一个handler间接子类，所以他会自动调用handler的无参构造函数，获得looper和Queue消息队列。

然后定义了一些设置supplicant和更新网络信息的辅助函数。

       startEventLoop()函数很重要，用来启动WifiMonitor线程，进入消息循环检测。接着定义了系列通知函数，被WifiMonitor调用来向WifiStateTracker传递从wpa_supplicant接收到的消息，他会调用消息发送函数到消息队列，并被WifiStateTracker的handlermessage（）函数处理。这个handlermessage（）函数就是在随后被定义的，它主要是调用相应的辅助函数完成动作，并可能会将消息封装后，通过intent机制发送出去，被上层的UI活动接收处理。

这里也定义了很多的WfiNative接口函数，这是JNI的本地接口；类DhcpHandler extends Handler{}也是在该类中定义的，它也是一个handler的子类，用来处理DHCP相关的消息EVENT_DHCP_START，可以想到它和WifiStateTracker不是共用一个looper。

       注意：handleMessage是在该文件中定义的，用来处理经WifiMonitor转换过的消息。

 

 6) WifiMonitor

       frameworks/base/wifi/java/android/net/wifi/WifiMonitor.java

声明了一个重要的成员变量：mWifiStateTracker，并在构造函数中由参数提供初始化，还定义了一系列的可能从wpa_supplicant层接收的事件类型及其名字，这些是消息处理机制的基础。

startMonitoring（）函数，这是一个线程启动的封装函数，WifiStateTracker就是通过这个函数启动的WifiThread。

这个重要的类classMonitorThreadextends Thread{}；它是一个监控进程类，里面有一系列的事件处理函数和一个重要的Run()函数，run函数主要流程：connectToSupplicant()连接精灵进程wpa_supplicant，这里有一个mWifiStateTracker.notifySupplicantXXX()的调用，通知上层是否连接成功，然后就是一个轮询过程，其中调用了WifiNative.waitForEvent()本地轮询函数接口，并从返回的事件字符串类型中提取事件的名称，最后通过事件的名称调用相应的事件处理函数，并将事件转换成mWifiStateTracker能识别的类型上报。

       注意：这里的每个事件的捕获（由wifimonitor完成），最终都会调用相应的mWifiStateTracker的消息通知函数上报消息；轮询和事件处理都是在Monitor线程类中实现的。

 

 7)WifiNative

       frameworks/base/wifi/java/android/net/wifi/WifiNative.java

里面定义了一个类WifiNative：其中声明了许多本地接口，可由native的标志看出，这是Java代码和本地库之间的联系接口；

 

 8) android_net_wifi_Wifi.java

frameworks/base/core/jni/

       里面定义了许多的JNI的本地代码实现，每个实现中都会调用wpa_supplicant适配层的接口，通过包含适配层的头文件wifi.h获取适配层定义的接口；后面是一个JNINativeMethod数组，定义了每个本地接口和本地实现的对应关系；最后有一个注册函数regester_XXX_XX(),用以把上面的方法类数组注册到系统中。

       该类实现了本地接口的相关功能，并通过调用wpa的适配层的相关函数和wpa_supplicant通信，所以JNI是连接Java框架层和wpa适配层的桥梁.

 

 9)wpa_supplicant适配层，wifi.c:目录libhardware/wifi/

       里面定义很多字符串变量和适配层的接口实现，是对wpa_supplicant程序通信的接口封装，用来完成上层和wpa_supplicant的通信，头文件在libhardware/include/hardware下，这里的函数用来向JNI的本地实现提供调用接口。

       这里的函数，我把它们分为三类函数：

一类是命令相关的（控制）函数，就是在JNI层android_XXX_Command()函数所调用的：：Wifi_Command()函数，调用流程：android_XXX_command()=>docommand()=>wifi_command()=>wifi_send_command()=>wpa_ctrl_require()。

二类是监听函数，即Wifi_wait_for_event()函数，调用流程：android_net_wifi_Waitforevent()=>wifi_wait_for_event()=>wpa_ctrl_recv()。

三类是剩下的函数。

 

10）wpa_supplicant与上层的接口，wpa_ctrl.c：external/wpa_supplicant

定义了三类套接字，并分别实现了和wpa_supplicant的通信，因此wpa_supplicant适配层和wpa_supplicant层是通过socket通讯的。

要是从wifi.c中真的很难看出它和wpa_supplicant有什么关系，和它联系密切的是wpa_ctrl.h文件，这里面定义了一个类wpa_ctrl，这个类中声明了两个Socket套接口，一个是本地一个是要连接的套接口，wpa_ctrl与wpa_supplicant的通信就需要socket来帮忙了，而wpa_supplicant就是通过调用wpa_ctrl.h中定义的函数和wpa_supplicant进行通讯的，wpa_ctrl类（其实是其中的两个socket）就是他们之间的桥梁。

 

 11)wpa_supplicant和driver_wext驱动接口的联系：

       driver.h：该文件定义了系列结构，首先是一个wpa_scan_result结构，这是一个扫描结果的通用格式，里面包含了扫描的所有信息（如BSSID，SSID，信号质量，噪音水平，支持的最大波特率等等信息），每个驱动接口实现负责将从驱动中上传的扫描信息的格式转换到该通用的扫描信息格式；然后是一些宏定义和枚举定义，最后也是最重要的是wpa_driver_ops结构，该结构是wpa driver的操作函数集合，里面有驱动接口的名称和很多的函数指针。

       drviers.c：该文件很简单，首先是一些外部变量的引用声明，都是不同驱动操作接口的集合wpa_driver_XXX_ops变量；然后就是定义一个驱动操作接口集合的数组，根据宏定义添加对应的驱动操作接口集合的变量。

       drvier_XXX.h:这是不同驱动接口头文件，主要声明了操作接口

       drvier_XXX.c:实现操作接口，定义一个操作集合变量，并用上面定义的函数初始化其中的函数指针

       注意：下面要搞清楚wpa_supplicant守护进程是如何操作，最后调用驱动接口集合中的函数的；要知道wpa_supplicant是为不同驱动和操作系统具有更好移植性而被设计的，以便在wpa_supplicant层不用实现驱动的具体接口就可以添加新的驱动程序；在wpa_supplicant结构中有一个wpa_drv_ops类型的drvier成员，在wpa_supplicant进程中，经常通过Wpa_supplicant_XXX函数传递wpa_supplicant实例指针wpa_s参数给wpa_drv_XXX函数来调用它，在wpa_drv_XX中会通过wpa_s->driver->XXX()的流程来调用通用驱动接口，简单才是生活的真相，可android始终让我感到真相还是遥不可及。

 

 12)WifiWatchdogService：

首先声明了两个主要变量mWifiStateTracker，mWifiManager，需要这两个类对象来完成具体的控制工作，在WifiWatchdogService的构造函数中，创建了这两个类，并通过regesterForWifiBroadcasts()注册了BroadcastReceiver，BroadcastReceiver是用来获取网络变化的，然后启动了一个WatchdogTread线程，用来处理从WifiStateTracker接收到的消息。

 

frameworks/base/services/java/com/android/server/WifiWatchdogService.java

[java]  view plain  copy
  1. WifiWatchdogService(Context context,WifiStateTracker wifiStateTracker) {  
  2.   
  3.        mContext = context;  
  4.   
  5.        mContentResolver = context.getContentResolver();  
  6.   
  7.        mWifiStateTracker =wifiStateTracker;  
  8.   
  9.         mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);  
  10.   
  11.          
  12.   
  13.        createThread();  
  14.   
  15.          
  16.   
  17.        // The content observer to listen needs a handler, which createThreadcreates  
  18.   
  19.        registerForSettingsChanges();  
  20.   
  21.        if (isWatchdogEnabled()) {  
  22.   
  23.            registerForWifiBroadcasts();  
  24.   
  25.        }  
  26.   
  27.          
  28.   
  29.        if (V) {  
  30.   
  31.            myLogV("WifiWatchdogService: Created");  
  32.   
  33.        }  
  34.   
  35.     }  


       WifiWatchdogHandler继承了handler类，成为一个消息处理类，定义handlemessage()函数，处理消息队列上的消息。

 

二，wpa_supplicant再解析

1)wpa_ctrl.h:

       该文件中并没有定义structwpa_ctrl结构，因为在其他包含该文件的.c文件中不能直接使用该结构的成员，这里主要声明了几个用于使用socket通信的函数接口，包括：wpa_ctrl_open，wpa_ctrl_close，wpa_ctrl_attach，wpa_ctrl_detach，wpa_ctrl_cleanup，wpa_ctrl_recv,wpa_ctrl_request, wpa_ctrl_pending, wpa_ctrl_get_fd 等函数。

       这些函数的功能从名字上能看出，open函数就是创建一个socket接口，并绑定连接wpa_supplicant，attach函数用于定义一个控制接口为监听接口，pending函数用于查询有无消息可读处理，request和recv分别用来发送和读取消息。

       其实，这里就是一个使用socket通信的封装，具体内容可以参考socket编程。

 

2）wpa_ctrl.c：

       这里首先定义了一个wpa_ctrl结构，里面根据UDP，UNIX和命名管道三种domain类型来定义通信实体：

[cpp]  view plain  copy
  1. struct wpa_ctrl {  
  2.   
  3. #ifdefCONFIG_CTRL_IFACE_UDP  
  4.   
  5.        int s;  
  6.   
  7.        struct sockaddr_in local;  
  8.   
  9.        struct sockaddr_in dest;  
  10.   
  11.        char *cookie;  
  12.   
  13. #endif /*CONFIG_CTRL_IFACE_UDP */  
  14.   
  15. #ifdefCONFIG_CTRL_IFACE_UNIX  
  16.   
  17.        int s;  
  18.   
  19.        struct sockaddr_un local;  
  20.   
  21.        struct sockaddr_un dest;  
  22.   
  23. #endif /*CONFIG_CTRL_IFACE_UNIX */  
  24.   
  25. #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE  
  26.   
  27.        HANDLE pipe;  
  28.   
  29. #endif /*CONFIG_CTRL_IFACE_NAMED_PIPE */  
  30.   
  31. };  


       然后是根据上面三个类型分别实现了wpa_ctrl.h中声明的接口函数，这里就不做介绍了。

 

3)wpa_supplicant.h：

       首先，定义了一个枚举wpa_event_type，罗列了系列wpa的事件类型，然后就是wpa_event_data类型，随后是两个函数：wpa_supplicant_event和wpa_supplicant_rx_eapol。

wpa_supplicant.c：首先定义一个驱动操作数组externstruct wpa_driver_ops *wpa_supplicant_drivers[]，然后是系列wpa_supplicant_XXX()函数，很多函数里面调用wpa_drv_XXX()函数，这些函数是wpa_supplicant_i.h中实现的函数。几乎每个函数都需要一个wpa_supplicant结构，对其进行所有的控制和通信操作。

 

4)wpa_supplicant_i.h：

       开头定义了几个结构，如：wpa_blacklist，wpa_interface，wpa_params，wpa_global，wpa_client_mlme和wpa_supplicant等结构，其中wpa_supplicant最为重要，wpa_supplicant结构里有一个重要的driver成员，它是wpa_driver_ops类型，可以被用来调用抽象层的接口。

       接下来是系列函数声明，这些函数声明在wpa_supplicant.c中实现，然后就是wpa_drv_XXX函数，这些函数就是在wpa_supplicant.c中被wpa_supplicant_xxx函数调用的，而这些wpa_drv_xxx函数也都有一个wpa_supplicant结构的变量指针，用来调用封装的抽象接口。

       这里要注意的是：在wpa_suppliant.c文件中定义的很多函数是在该头文件中声明的，而不是在wpa_supplicant.h中声明的。

 

5)driver.h：

       该文件中定义了一个重要的数据结构：wpa_scan_result，这是一个从驱动发来的数据被封装成的通用的扫描结果数据结构，每个驱动结构的实现都要遵循的扫描结果格式，比如driver_wext.c中的实现。后面还有定义了很多的数据结构，这里不具表。

       文件中最重要的一个数据结构是：wpa_driver_ops，这是所有驱动接口层必须为之实现的API，是所有驱动类型的一个接口封装包，wpa_supplicant就是通过该接口来和驱动交互的。

 

6)driver_wext.h：

       该文件很简单，就是声明了该驱动的一些对应驱动API接口的函数。

driver_wext.c：

       此文件就是实现了上面的一些函数，最后初始化了一个wpa_drv_ops变量。

 

三，Wifi模块解析

1）框架分析

                             Android WiFi从app到driver详解_第1张图片

 

图示1：Wifi框架

       首先，用户程序使用WifiManager类来管理Wifi模块，它能够获得Wifi模块的状态，配置和控制Wifi模块，而所有这些操作都要依赖Wifiservice类来实现。

       WifiService和WifiMonitor类是Wifi框架的核心，如图所示。下面先来看看WifiService是什么时候，怎么被创建和初始化的。

       在systemServer启动之后，它会创建一个ConnectivityServer对象，这个对象的构造函数会创建一个WifiService的实例，代码如下所示：

 

framework/base/services/java/com/android/server/ConnectivityService.java

[java]  view plain  copy
  1. {  
  2.   
  3. ……  
  4.   
  5. case ConnectivityManager.TYPE_WIFI:  
  6.   
  7.                if (DBG) Slog.v(TAG, "Starting Wifi Service.");  
  8.   
  9.                WifiStateTracker wst = new WifiStateTracker(context, mHandler);                             //创建WifiStateTracker实例  
  10.   
  11.                 WifiService wifiService = newWifiService(context, wst);//创建WifiService实例  
  12.   
  13.                ServiceManager.addService(Context.WIFI_SERVICE, wifiService);           //向服务管理系统添加Wifi服务  
  14.   
  15.                wifiService.startWifi();     //启动Wifi  
  16.   
  17.                mNetTrackers[ConnectivityManager.TYPE_WIFI] = wst;  
  18.   
  19.                 wst.startMonitoring(); //启动WifiMonitor中的WifiThread线程  
  20.   
  21. ……  
  22.   
  23. }  


       WifiService的主要工作：WifiMonitor和Wpa_supplicant的启动和关闭，向Wpa_supplicant发送命令。

       WifiMonitor的主要工作：阻塞监听并接收来自Wpa_supplicant的消息，然后发送给WifiStateTracker。

       上面两个线程通过AF_UNIX套接字和Wpa_supplicant通信，在通信过程中有两种连接方式：控制连接和监听连接。它们创建代码如下：

[java]  view plain  copy
  1. ctrl_conn =wpa_ctrl_open(ifname);  
  2.   
  3. .. .. ..  
  4.   
  5.  monitor_conn = wpa_ctrl_open(ifname);  


 

 

2）Wifi启动流程

       （1）使能Wifi

       要想使用Wifi模块，必须首先使能Wifi，当你第一次按下Wifi使能按钮时，WirelessSettings会实例化一个WifiEnabler对象，实例化代码如下：

 

packages/apps/settings/src/com/android/settings/WirelessSettings.java

[java]  view plain  copy
  1. protected void onCreate(Bundle savedInstanceState) {  
  2.   
  3.        super.onCreate(savedInstanceState);  
  4.   
  5. ……  
  6.   
  7.               CheckBoxPreferencewifi = (CheckBoxPreference) findPreference(KEY_TOGGLE_WIFI);  
  8.   
  9.               mWifiEnabler= new WifiEnabler(this, wifi);  
  10.   
  11. ……  
  12.   
  13. }  


       WifiEnabler类的定义大致如下，它实现了一个监听接口，当WifiEnabler对象被初始化后，它监听到你按键的动作，会调用响应函数onPreferenceChange（），这个函数会调用WifiManager的setWifiEnabled（）函数。

[java]  view plain  copy
  1. public class WifiEnabler implementsPreference.OnPreferenceChangeListener {  
  2.   
  3. ……  
  4.   
  5. public boolean onPreferenceChange(Preference preference,Object value) {  
  6.   
  7.         booleanenable = (Boolean) value;  
  8.   
  9. ……  
  10.   
  11. if (mWifiManager.setWifiEnabled(enable)) {  
  12.   
  13.                 mCheckBox.setEnabled(false);  
  14.   
  15. ……  
  16.   
  17. }  
  18.   
  19. ……  
  20.   
  21. }  


       我们都知道Wifimanager只是个服务代理，所以它会调用WifiService的setWifiEnabled（）函数，而这个函数会调用sendEnableMessage（）函数，了解android消息处理机制的都知道，这个函数最终会给自己发送一个MESSAGE_ENABLE_WIFI的消息，被WifiService里面定义的handlermessage()函数处理，会调用setWifiEnabledBlocking（）函数。下面是调用流程：

 

mWifiEnabler.onpreferencechange()=>mWifiManage.setWifienabled()=>mWifiService.setWifiEnabled()=>mWifiService.sendEnableMessage()=>mWifiService.handleMessage()=>mWifiService.setWifiEnabledBlocking().

 

在setWifiEnabledBlocking()函数中主要做如下工作：加载Wifi驱动，启动wpa_supplicant，注册广播接收器，启动WifiThread监听线程。代码如下：

[java]  view plain  copy
  1. ……  
  2.   
  3. if (enable) {  
  4.   
  5.            if (!mWifiStateTracker.loadDriver()) {  
  6.   
  7.                Slog.e(TAG, "Failed toload Wi-Fi driver.");  
  8.   
  9.                setWifiEnabledState(WIFI_STATE_UNKNOWN, uid);  
  10.   
  11.                 return false;  
  12.   
  13.            }  
  14.   
  15.            if (!mWifiStateTracker.startSupplicant()) {  
  16.   
  17.                 mWifiStateTracker.unloadDriver();  
  18.   
  19.                 Slog.e(TAG, "Failed tostart supplicant daemon.");  
  20.   
  21.                setWifiEnabledState(WIFI_STATE_UNKNOWN, uid);  
  22.   
  23.                 return false;  
  24.   
  25.            }  
  26.   
  27.    
  28.   
  29.            registerForBroadcasts();  
  30.   
  31.            mWifiStateTracker.startEventLoop();  
  32.   
  33. ……  


       至此，Wifi使能结束，自动进入扫描阶段。

 

(2) 扫描AP

       当驱动加载成功后，如果配置文件的AP_SCAN = 1，扫描会自动开始，WifiMonitor将会从supplicant收到一个消息EVENT_DRIVER_STATE_CHANGED，调用handleDriverEvent（），然后调用mWifiStateTracker.notifyDriverStarted()，该函数向消息队列添加EVENT_DRIVER_STATE_CHANGED，handlermessage()函数处理消息时调用scan()函数，并通过WifiNative将扫描命令发送到wpa_supplicant。

 

Frameworks/base/wifi/java/android/net/wifi/WifiMonitor.java

[java]  view plain  copy
  1. private void handleDriverEvent(Stringstate) {  
  2.   
  3.            if (state == null) {  
  4.   
  5.                 return;  
  6.   
  7.            }  
  8.   
  9.            if (state.equals("STOPPED")) {  
  10.   
  11.                mWifiStateTracker.notifyDriverStopped();  
  12.   
  13.            } else if (state.equals("STARTED")) {  
  14.   
  15.                 mWifiStateTracker.notifyDriverStarted();  
  16.   
  17.            } else if (state.equals("HANGED")) {  
  18.   
  19.                 mWifiStateTracker.notifyDriverHung();  
  20.   
  21.            }  
  22.   
  23.        }  


 

Frameworks/base/wifi/java/android/net/wifi/WifiStateTracker.java

[java]  view plain  copy
  1. case EVENT_DRIVER_STATE_CHANGED:  
  2.   
  3.            
  4.   
  5.                 switch(msg.arg1) {  
  6.   
  7.                 case DRIVER_STARTED:  
  8.   
  9.                     /** 
  10.  
  11.                      *Set the number of allowed radio channels according 
  12.  
  13.                      *to the system setting, since it gets reset by the 
  14.  
  15.                      *driver upon changing to the STARTED state. 
  16.  
  17.                      */  
  18.   
  19.                     setNumAllowedChannels();  
  20.   
  21.                    synchronized (this) {  
  22.   
  23.                        if (mRunState == RUN_STATE_STARTING) {  
  24.   
  25.                            mRunState = RUN_STATE_RUNNING;  
  26.   
  27.                            if (!mIsScanOnly) {  
  28.   
  29.                                 reconnectCommand();  
  30.   
  31.                            } else {  
  32.   
  33.                                 // In somesituations, supplicant needs to be kickstarted to  
  34.   
  35.                                 // start thebackground scanning  
  36.   
  37.                                 scan(true);  
  38.   
  39.                            }  
  40.   
  41.                        }  
  42.   
  43.                     }  
  44.   
  45.                    break;        


       

 

上面是启动Wifi时，自动进行的AP的扫描，用户当然也可以手动扫描AP，这部分实现在WifiService里面，WifiService通过startScan()接口函数发送扫描命令到supplicant。

 

Frameworks/base/wifi/java/android/net/wifi/WifiStateTracker.java

[java]  view plain  copy
  1. public boolean startScan(booleanforceActive) {  
  2.   
  3.        enforceChangePermission();  
  4.   
  5.    
  6.   
  7.        switch (mWifiStateTracker.getSupplicantState()) {  
  8.   
  9.            case DISCONNECTED:  
  10.   
  11.            case INACTIVE:  
  12.   
  13.            case SCANNING:  
  14.   
  15.            case DORMANT:  
  16.   
  17.                 break;  
  18.   
  19.            default:  
  20.   
  21.                mWifiStateTracker.setScanResultHandling(  
  22.   
  23.                        WifiStateTracker.SUPPL_SCAN_HANDLING_LIST_ONLY);  
  24.   
  25.                 break;  
  26.   
  27.        }  
  28.   
  29.        return mWifiStateTracker.scan(forceActive);  
  30.   
  31.     }  


       然后下面的流程同上面的自动扫描，我们来分析一下手动扫描从哪里开始的。我们应该知道手动扫描是通过菜单键的扫描键来响应的，而响应该动作的应该是WifiSettings类中Scanner类的handlerMessage()函数，它调用WifiManager的startScanActive()，这才调用WifiService的startScan()。

 

packages/apps/Settings/src/com/android/settings/wifiwifisettings.java

[java]  view plain  copy
  1. public boolean onCreateOptionsMenu(Menu menu) {  
  2.   
  3.        menu.add(Menu.NONE, MENU_ID_SCAN, 0, R.string.wifi_menu_scan)  
  4.   
  5.                .setIcon(R.drawable.ic_menu_scan_network);  
  6.   
  7.        menu.add(Menu.NONE, MENU_ID_ADVANCED, 0, R.string.wifi_menu_advanced)  
  8.   
  9.                .setIcon(android.R.drawable.ic_menu_manage);  
  10.   
  11.        return super.onCreateOptionsMenu(menu);  
  12.   
  13.     }  


 

       当按下菜单键时，WifiSettings就会调用这个函数绘制菜单。如果选择扫描按钮，WifiSettings会调用onOptionsItemSelected()。

 

packages/apps/Settings/src/com/android/settings/wifiwifisettings.java

[java]  view plain  copy
  1. public booleanonOptionsItemSelected(MenuItem item) {  
  2.   
  3.        switch (item.getItemId()) {  
  4.   
  5.            case MENU_ID_SCAN:  
  6.   
  7.                 if(mWifiManager.isWifiEnabled()) {  
  8.   
  9.                     mScanner.resume();  
  10.   
  11.                 }  
  12.   
  13.                 return true;  
  14.   
  15.            case MENU_ID_ADVANCED:  
  16.   
  17.                 startActivity(new Intent(this,AdvancedSettings.class));  
  18.   
  19.                 return true;  
  20.   
  21.        }  
  22.   
  23.        return super.onOptionsItemSelected(item);  
  24.   
  25. }  
  26.   
  27.    
  28.   
  29. private class Scanner extends Handler {  
  30.   
  31.        private int mRetry = 0;  
  32.   
  33.    
  34.   
  35.        void resume() {  
  36.   
  37.            if (!hasMessages(0)) {  
  38.   
  39.                 sendEmptyMessage(0);  
  40.   
  41.            }  
  42.   
  43.        }  
  44.   
  45.    
  46.   
  47.        void pause() {  
  48.   
  49.            mRetry = 0;  
  50.   
  51.             mAccessPoints.setProgress(false);  
  52.   
  53.            removeMessages(0);  
  54.   
  55.        }  
  56.   
  57.    
  58.   
  59.        @Override  
  60.   
  61.        public void handleMessage(Message message) {  
  62.   
  63.            if (mWifiManager.startScanActive()){  
  64.   
  65.                 mRetry = 0;  
  66.   
  67.            } else if (++mRetry >= 3) {  
  68.   
  69.                 mRetry = 0;  
  70.   
  71.                Toast.makeText(WifiSettings.this, R.string.wifi_fail_to_scan,  
  72.   
  73.                        Toast.LENGTH_LONG).show();  
  74.   
  75.                 return;  
  76.   
  77.            }  
  78.   
  79.            mAccessPoints.setProgress(mRetry != 0);  
  80.   
  81.            sendEmptyMessageDelayed(0, 6000);  
  82.   
  83.        }  
  84.   
  85.     }  


      

这里的mWifiManager.startScanActive()就会调用WifiService里的startScan（）函数，下面的流程和上面的一样，这里不赘述。

当supplicant完成了这个扫描命令后，它会发送一个消息给上层，提醒他们扫描已经完成，WifiMonitor会接收到这消息，然后再发送给WifiStateTracker。

 

Frameworks/base/wifi/java/android/net/wifi/WifiMonitor.java

[java]  view plain  copy
  1. void handleEvent(int event, String remainder) {  
  2.   
  3.             switch (event) {  
  4.   
  5.                 caseDISCONNECTED:  
  6.   
  7.                    handleNetworkStateChange(NetworkInfo.DetailedState.DISCONNECTED,remainder);  
  8.   
  9.                     break;  
  10.   
  11.    
  12.   
  13.                 case CONNECTED:  
  14.   
  15.                    handleNetworkStateChange(NetworkInfo.DetailedState.CONNECTED,remainder);  
  16.   
  17.                     break;  
  18.   
  19.    
  20.   
  21.                 case SCAN_RESULTS:  
  22.   
  23.                     mWifiStateTracker.notifyScanResultsAvailable();  
  24.   
  25.                     break;  
  26.   
  27.    
  28.   
  29.                 case UNKNOWN:  
  30.   
  31.                     break;  
  32.   
  33.             }  
  34.   
  35.         }  


WifiStateTracker将会广播SCAN_RESULTS_AVAILABLE_ACTION消息：

 

Frameworks/base/wifi/java/android/net/wifi/WifiStateTracker.java

[java]  view plain  copy
  1. public voidhandleMessage(Message msg) {  
  2.   
  3.         Intent intent;  
  4.   
  5. ……  
  6.   
  7. case EVENT_SCAN_RESULTS_AVAILABLE:  
  8.   
  9.                 if(ActivityManagerNative.isSystemReady()) {  
  10.   
  11.                     mContext.sendBroadcast(new Intent(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));  
  12.   
  13.                 }  
  14.   
  15.                 sendScanResultsAvailable();  
  16.   
  17.                 /** 
  18.  
  19.                  * On receiving the first scanresults after connecting to 
  20.  
  21.                  * the supplicant, switch scanmode over to passive. 
  22.  
  23.                  */  
  24.   
  25.                 setScanMode(false);  
  26.   
  27.                 break;  
  28.   
  29. ……  
  30.   
  31. ｝  


       由于WifiSettings类注册了intent，能够处理SCAN_RESULTS_AVAILABLE_ACTION消息，它会调用handleEvent()，调用流程如下所示。

 

WifiSettings.handleEvent() =>WifiSettings.updateAccessPoints() => mWifiManager.getScanResults() => mService.getScanResults()=> mWifiStateTracker.scanResults() => WifiNative.scanResultsCommand()……

 

将获取AP列表的命令发送到supplicant，然后supplicant通过Socket发送扫描结果，由上层接收并显示。这和前面的消息获取流程基本相同。

 

(3)配置，连接AP

当用户选择一个活跃的AP时，WifiSettings响应打开一个对话框来配置AP，比如加密方法和连接AP的验证模式。配置好AP后，WifiService添加或更新网络连接到特定的AP。

 

packages/apps/settings/src/com/android/settings/wifi/WifiSetttings.java

[java]  view plain  copy
  1. public booleanonPreferenceTreeClick(PreferenceScreen screen, Preference preference) {  
  2.   
  3.        if (preference instanceof AccessPoint) {  
  4.   
  5.            mSelected = (AccessPoint) preference;  
  6.   
  7.            showDialog(mSelected, false);  
  8.   
  9.        } else if (preference == mAddNetwork) {  
  10.   
  11.            mSelected = null;  
  12.   
  13.            showDialog(null, true);  
  14.   
  15.        } else if (preference == mNotifyOpenNetworks) {  
  16.   
  17.            Secure.putInt(getContentResolver(),  
  18.   
  19.                    Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,  
  20.   
  21.                    mNotifyOpenNetworks.isChecked() ? 1 : 0);  
  22.   
  23.        } else {  
  24.   
  25.            return super.onPreferenceTreeClick(screen, preference);  
  26.   
  27.        }  
  28.   
  29.        return true;  
  30.   
  31.     }  
  32.   
  33.    


       配置好以后，当按下“Connect Press”时，WifiSettings通过发送LIST_NETWORK命令到supplicant来检查该网络是否配置。如果没有该网络或没有配置它，WifiService调用addorUpdateNetwork（）函数来添加或更新网络，然后发送命令给supplicant，连接到这个网络。下面是从响应连接按钮到WifiService发送连接命令的代码：

 

packages/apps/settings/src/com/android/settings/wifi/WifiSetttings.java

[java]  view plain  copy
  1. public void onClick(DialogInterfacedialogInterface, int button) {  
  2.   
  3.        if (button == WifiDialog.BUTTON_FORGET && mSelected != null) {  
  4.   
  5.            forget(mSelected.networkId);  
  6.   
  7.        } else if (button == WifiDialog.BUTTON_SUBMIT && mDialog !=null) {  
  8.   
  9.            WifiConfiguration config = mDialog.getConfig();  
  10.   
  11.    
  12.   
  13.            if (config == null) {  
  14.   
  15.                 if (mSelected != null&& !requireKeyStore(mSelected.getConfig())) {  
  16.   
  17.                     connect(mSelected.networkId);  
  18.   
  19.                 }  
  20.   
  21.            } else if (config.networkId != -1) {  
  22.   
  23.                 if (mSelected != null) {  
  24.   
  25.                     mWifiManager.updateNetwork(config);  
  26.   
  27.                     saveNetworks();  
  28.   
  29.                 }  
  30.   
  31.            } else {  
  32.   
  33.                 int networkId =mWifiManager.addNetwork(config);  
  34.   
  35.                 if (networkId != -1) {  
  36.   
  37.                    mWifiManager.enableNetwork(networkId, false);  
  38.   
  39.                     config.networkId =networkId;  
  40.   
  41.                     if (mDialog.edit || requireKeyStore(config)){  
  42.   
  43.                         saveNetworks();  
  44.   
  45.                     } else {  
  46.   
  47.                         connect(networkId);  
  48.   
  49.                     }  
  50.   
  51.                 }  
  52.   
  53.            }  
  54.   
  55.        }  
  56.   
  57.     }  


      

      

Frameworks\base\wifi\java\android\net\wifi\WifiManager.java

    

[java]  view plain  copy
  1.    public intupdateNetwork(WifiConfiguration config) {  
  2.   
  3.         if(config == null || config.networkId < 0) {  
  4.   
  5.            return -1;  
  6.   
  7.         }  
  8.   
  9.         return addOrUpdateNetwork(config);  
  10.   
  11. }  
  12.   
  13. private intaddOrUpdateNetwork(WifiConfiguration config) {  
  14.   
  15.        try {  
  16.   
  17.            return mService.addOrUpdateNetwork(config);  
  18.   
  19.        } catch (RemoteException e) {  
  20.   
  21.            return -1;  
  22.   
  23.        }  
  24.   
  25.     }  


 

WifiService.addOrUpdateNetwork()通过调用mWifiStateTracker.setNetworkVariable()将连接命令发送到Wpa_supplicant。

 

（4）获取IP地址

当连接到supplicant后，WifiMonitor就会通知WifiStateTracker。

 

Frameworks/base/wifi/java/android/net/wifi/WifiMonitor.java

[java]  view plain  copy
  1. Public void Run(){  
  2.   
  3. if (connectToSupplicant()) {  
  4.   
  5.                 // Send a message indicatingthat it is now possible to send commands  
  6.   
  7.                 // to the supplicant  
  8.   
  9.                 mWifiStateTracker.notifySupplicantConnection();  
  10.   
  11.            } else {  
  12.   
  13.                mWifiStateTracker.notifySupplicantLost();  
  14.   
  15.                 return;  
  16.   
  17.            }  
  18.   
  19. ……  
  20.   
  21. }  


 

WifiStateTracker发送EVENT_SUPPLICANT_CONNECTION消息到消息队列，这个消息有自己的handlermessage()函数处理，它会启动一个DHCP线程，而这个线程会一直等待一个消息事件，来启动DHCP协议分配IP地址。

 

frameworks/base/wifi/java/android/net/wifi/WifiStateTracker.java

[java]  view plain  copy
  1. void notifySupplicantConnection() {  
  2.   
  3.        sendEmptyMessage(EVENT_SUPPLICANT_CONNECTION);  
  4.   
  5. }  
  6.   
  7.    
  8.   
  9. public void handleMessage(Message msg) {  
  10.   
  11.        Intent intent;  
  12.   
  13.    
  14.   
  15.        switch (msg.what) {  
  16.   
  17.            case EVENT_SUPPLICANT_CONNECTION:  
  18.   
  19.              ……  
  20.   
  21.              HandlerThread dhcpThread = newHandlerThread("DHCP Handler Thread");  
  22.   
  23.                 dhcpThread.start();  
  24.   
  25.                 mDhcpTarget = newDhcpHandler(dhcpThread.getLooper(), this);  
  26.   
  27. ……  
  28.   
  29. ……  
  30.   
  31. }  


当Wpa_supplicant连接到AP后，它会发送一个消息给上层来通知连接成功，WifiMonitor会接受到这个消息并上报给WifiStateTracker。

 

Frameworks/base/wifi/java/android/net/wifi/WifiMonitor.java

[java]  view plain  copy
  1. void handleEvent(int event, String remainder) {  
  2.   
  3.            switch (event) {  
  4.   
  5.                case DISCONNECTED:  
  6.   
  7.                    handleNetworkStateChange(NetworkInfo.DetailedState.DISCONNECTED,remainder);  
  8.   
  9.                    break;  
  10.   
  11.    
  12.   
  13.                case CONNECTED:  
  14.   
  15.                    handleNetworkStateChange(NetworkInfo.DetailedState.CONNECTED,remainder);  
  16.   
  17.                    break;  
  18.   
  19.                 ……  
  20.   
  21. }  
  22.   
  23.    
  24.   
  25. private voidhandleNetworkStateChange(NetworkInfo.DetailedState newState, String data) {  
  26.   
  27.         StringBSSID = null;  
  28.   
  29.         intnetworkId = -1;  
  30.   
  31.         if(newState == NetworkInfo.DetailedState.CONNECTED) {  
  32.   
  33.            Matcher match = mConnectedEventPattern.matcher(data);  
  34.   
  35.             if(!match.find()) {  
  36.   
  37.                if (Config.LOGD) Log.d(TAG, "Could not find BSSID in CONNECTEDevent string");  
  38.   
  39.             }else {  
  40.   
  41.                BSSID = match.group(1);  
  42.   
  43.                try {  
  44.   
  45.                    networkId = Integer.parseInt(match.group(2));  
  46.   
  47.                } catch (NumberFormatException e) {  
  48.   
  49.                    networkId = -1;  
  50.   
  51.                 }  
  52.   
  53.             }  
  54.   
  55.         }  
  56.   
  57.         mWifiStateTracker.notifyStateChange(newState,BSSID, networkId);  
  58.   
  59. }  
  60.   
  61.          
  62.   
  63. void notifyStateChange(DetailedState newState, StringBSSID, int networkId) {  
  64.   
  65.         Messagemsg = Message.obtain(  
  66.   
  67.            this, EVENT_NETWORK_STATE_CHANGED,  
  68.   
  69.             newNetworkStateChangeResult(newState, BSSID, networkId));  
  70.   
  71.        msg.sendToTarget();  
  72.   
  73.     }  
  74.   
  75.    
  76.   
  77. caseEVENT_NETWORK_STATE_CHANGED:  
  78.   
  79. ……  
  80.   
  81. configureInterface();  
  82.   
  83. ……  
  84.   
  85.    
  86.   
  87. private void configureInterface() {  
  88.   
  89.        checkPollTimer();  
  90.   
  91.         mLastSignalLevel = -1;  
  92.   
  93.         if(!mUseStaticIp) {          //使用DHCP线程动态IP  
  94.   
  95.             if(!mHaveIpAddress && !mObtainingIpAddress) {  
  96.   
  97.                mObtainingIpAddress = true;  
  98.   
  99.    
  100.   
  101.                                    //发送启动DHCP线程获取IP  
  102.   
  103.                 mDhcpTarget.sendEmptyMessage(EVENT_DHCP_START);  
  104.   
  105.             }  
  106.   
  107.         } else {        //使用静态IP，IP信息从mDhcpInfo中获取  
  108.   
  109.             intevent;  
  110.   
  111.             if(NetworkUtils.configureInterface(mInterfaceName, mDhcpInfo)) {  
  112.   
  113.                mHaveIpAddress = true;  
  114.   
  115.                event = EVENT_INTERFACE_CONFIGURATION_SUCCEEDED;  
  116.   
  117.                if (LOCAL_LOGD) Log.v(TAG, "Static IP configurationsucceeded");  
  118.   
  119.             }else {  
  120.   
  121.                mHaveIpAddress = false;  
  122.   
  123.                event = EVENT_INTERFACE_CONFIGURATION_FAILED;  
  124.   
  125.                if (LOCAL_LOGD) Log.v(TAG, "Static IP configuration failed");  
  126.   
  127.             }  
  128.   
  129.            sendEmptyMessage(event);           //发送IP获得成功消息事件  
  130.   
  131.         }  
  132.   
  133.     }  


              DhcpThread获取EVENT_DHCP_START消息事件后，调用handleMessage（）函数，启动DHCP获取IP地址的服务。

 

[java]  view plain  copy
  1. public void handleMessage(Message msg) {  
  2.   
  3.             intevent;  
  4.   
  5. switch (msg.what) {  
  6.   
  7.                case EVENT_DHCP_START:  
  8.   
  9.    
  10.   
  11. ……  
  12.   
  13. Log.d(TAG, "DhcpHandler: DHCP requeststarted");  


 

//启动一个DHCPclient的精灵进程，为mInterfaceName请求分配一个IP地//址

   

[java]  view plain  copy
  1.  if (NetworkUtils.runDhcp(mInterfaceName, mDhcpInfo)) {  
  2.   
  3.      event= EVENT_INTERFACE_CONFIGURATION_SUCCEEDED;  
  4.   
  5.          if(LOCAL_LOGD) Log.v(TAG, "DhcpHandler: DHCP request succeeded");  
  6.   
  7.     } else {  
  8.   
  9.            event= EVENT_INTERFACE_CONFIGURATION_FAILED;  
  10.   
  11.            Log.i(TAG,"DhcpHandler: DHCP request failed: " +  
  12.   
  13.                             NetworkUtils.getDhcpError());  
  14.   
  15.         }  
  16.   
  17. ……  
  18.   
  19. }  


这里调用了一个NetworkUtils.runDhcp（）函数，NetworkUtils类是一个网络服务的辅助类，它主要定义了一些本地接口，这些接口会通过他们的JNI层android_net_NetUtils.cpp文件和DHCP client通信，并获取IP地址。

至此，IP地址获取完毕，Wifi启动流程结束。

你可能感兴趣的:(Linux,android)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • Linux sh命令 fengyehongWorld Linuxlinux
    目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
  • Linux vi常用命令 fengyehongWorld Linuxlinux
    参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G
  • Linux查看服务器日志 TPBoreas 运维linux运维
    一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • Linux CTF逆向入门 蚁景网络安全 linux运维CTF
    1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------
  • NPM私库搭建-verdaccio（Linux） Beam007 npmlinux前端
    1、安装nodelinux服务器安装nodea)、官网下载所需的node版本https://nodejs.org/dist/v14.21.0/b)、解压安装包若下载的是xxx.tar.xz文件，解压命令为tar-xvfxxx.tar.xzc)、修改环境变量修改：/etc/profile文件#SETPATHFORNODEJSexportNODE_HOME=NODEJS解压安装的路径exportPAT
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • linux脚本sed替换变量,sed 命令中替换值为shell变量 诺坎普之约 linux脚本sed替换变量
    文章目录sed命令中替换值为shell变量替换基本语法sed中替换使用shell变量总结参考文档sed命令中替换值为shell变量替换基本语法大家都是sed有很多用法，最多就应该是替换一些值了。让我们先回忆sed的替换语法。在sed进行替换的时候sed-i's/old/new/g'1.txtecho"hellooldfrank"|sed's/old/new/g'结果如下：hellonewfrank
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • linux 安装Sublime Text 3 hhyiyuanyu Python学习linuxsublimetext
    方法/步骤打开官网http://www.sublimetext.com/3，选择64位进行下载执行命令wgethttps://download.sublimetext.com/sublime_text_3_build_3126_x64.tar.bz2进行下载3、下载完成进行解压,执行tar-xvvfsublime_text_3_build_3126_x64.tar.bz解压4、解压完成以后，移动到
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • PHP如何实现二维数组排序？ IT独行者 二维数组PHP排序　
    二维数组在PHP开发中经常遇到，但是他的排序就不如一维数组那样用内置函数来的方便了，（一维数组排序可以参考本站另一篇文章【PHP中数组排序函数详解汇总】）。二维数组的排序需要我们自己写函数处理了，这里UncleToo给大家分享一个PHP二维数组排序的函数： 代码： functionarray_sort($arr,$keys,$type='asc'){ $keysvalue= $new_arr
  • 【Hadoop十七】HDFS HA配置 bit1129 hadoop
    基于Zookeeper的HDFS HA配置主要涉及两个文件,core-site和hdfs-site.xml。   测试环境有三台 hadoop.master hadoop.slave1 hadoop.slave2   hadoop.master包含的组件NameNode, JournalNode, Zookeeper，DFSZKFailoverController
  • 由wsdl生成的java vo类不适合做普通java vo darrenzhu VOwsdlwebservicerpc
    开发java webservice项目时，如果我们通过SOAP协议来输入输出，我们会利用工具从wsdl文件生成webservice的client端类，但是这里面生成的java data model类却不适合做为项目中的普通java vo类来使用，当然有一中情况例外，如果这个自动生成的类里面的properties都是基本数据类型，就没问题，但是如果有集合类，就不行。原因如下： 1)使用了集合如Li
  • JAVA海量数据处理之二（BitMap） 周凡杨 java算法bitmapbitset数据
           路漫漫其修远兮，吾将上下而求索。想要更快，就要深入挖掘 JAVA 基础的数据结构，从来分析出所编写的 JAVA 代码为什么把内存耗尽，思考有什么办法可以节省内存呢？ 啊哈！算法。这里采用了 BitMap 思想。   首先来看一个实验： 指定 VM 参数大小： -Xms256m -Xmx540m
  • java类型与数据库类型 g21121 java
    很多时候我们用hibernate的时候往往并不是十分关心数据库类型和java类型的对应关心，因为大多数hbm文件是自动生成的，但有些时候诸如：数据库设计、没有生成工具、使用原始JDBC、使用mybatis(ibatIS)等等情况，就会手动的去对应数据库与java的数据类型关心，当然比较简单的数据类型即使配置错了也会很快发现问题，但有些数据类型却并不是十分常见，这就给程序员带来了很多麻烦。 &nb
  • Linux命令 510888780 linux命令
    系统信息 arch 显示机器的处理器架构(1) uname -m 显示机器的处理器架构(2) uname -r 显示正在使用的内核版本 dmidecode -q 显示硬件系统部件 - (SMBIOS / DMI) hdparm -i /dev/hda 罗列一个磁盘的架构特性 hdparm -tT /dev/sda 在磁盘上执行测试性读取操作 cat /proc/cpuinfo 显示C
  • java常用JVM参数 墙头上一根草 javajvm参数
    -Xms：初始堆大小，默认为物理内存的1/64(<1GB)；默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制 -Xmx：最大堆大小，默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制 -Xmn：新生代的内存空间大小，注意：此处的大小是（eden+ 2
  • 我的spring学习笔记9-Spring使用工厂方法实例化Bean的注意点 aijuans Spring 3
    方法一： <bean id="musicBox" class="onlyfun.caterpillar.factory.MusicBoxFactory" factory-method="createMusicBoxStatic"></bean> 方法二：
  • mysql查询性能优化之二 annan211 UNIONmysql查询优化索引优化
    1 union的限制 有时mysql无法将限制条件从外层下推到内层，这使得原本能够限制部分返回结果的条件无法应用到内层 查询的优化上。 如果希望union的各个子句能够根据limit只取部分结果集，或者希望能够先排好序在 合并结果集的话，就需要在union的各个子句中分别使用这些子句。 例如 想将两个子查询结果联合起来，然后再取前20条记录，那么mys
  • 数据的备份与恢复 百合不是茶 oraclesql数据恢复数据备份
     数据的备份与恢复的方式有: 表,方案 ,数据库;     数据的备份: 导出到的常见命令; 参数 说明 USERID 确定执行导出实用程序的用户名和口令 BUFFER 确定导出数据时所使用的缓冲区大小，其大小用字节表示 FILE 指定导出的二进制文
  • 线程组 bijian1013 java多线程threadjava多线程线程组
    有些程序包含了相当数量的线程。这时，如果按照线程的功能将他们分成不同的类别将很有用。        线程组可以用来同时对一组线程进行操作。        创建线程组：ThreadGroup g = new ThreadGroup(groupName);  &nbs
  • top命令找到占用CPU最高的java线程 bijian1013 javalinuxtop
    上次分析系统中占用CPU高的问题，得到一些使用Java自身调试工具的经验，与大家分享。 (1)使用top命令找出占用cpu最高的JAVA进程PID:28174 (2)如下命令找出占用cpu最高的线程 top -Hp 28174 -d 1 -n 1 32694 root 20 0 3249m 2.0g 11m S 2 6.4 3:31.12 java
  • 【持久化框架MyBatis3四】MyBatis3一对一关联查询 bit1129 Mybatis3
      当两个实体具有1对1的对应关系时，可以使用One-To-One的进行映射关联查询   One-To-One示例数据 以学生表Student和地址信息表为例，每个学生都有都有1个唯一的地址(现实中，这种对应关系是不合适的，因为人和地址是多对一的关系)，这里只是演示目的   学生表   CREATE TABLE STUDENTS (
  • C/C++图片或文件的读写 bitcarter 写图片
    先看代码： /*strTmpResult是文件或图片字符串 * filePath文件需要写入的地址或路径 */ int writeFile(std::string &strTmpResult,std::string &filePath) { int i,len = strTmpResult.length(); unsigned cha
  • nginx自定义指定加载配置 ronin47
    进入 /usr/local/nginx/conf/include 目录，创建 nginx.node.conf 文件，在里面输入如下代码： upstream nodejs { server 127.0.0.1:3000; #server 127.0.0.1:3001; keepalive 64; } server { liste
  • java-71-数值的整数次方.实现函数double Power(double base, int exponent)，求base的exponent次方 bylijinnan double
    public class Power { /** *Q71-数值的整数次方 *实现函数double Power(double base, int exponent)，求base的exponent次方。不需要考虑溢出。 */ private static boolean InvalidInput=false; public static void main(
  • Android四大组件的理解 Cb123456 android四大组件的理解
     分享一下，今天在Android开发文档-开发者指南中看到的:                            App components are the essential building blocks of an Android
  • [宇宙与计算]涡旋场计算与拓扑分析 comsci 计算
         怎么阐述我这个理论呢？ 。。。。。。。。。       首先： 宇宙是一个非线性的拓扑结构与涡旋轨道时空的统一体。。。。       我们要在宇宙中寻找到一个适合人类居住的行星，时间非常重要，早一个刻度和晚一个刻度，这颗行星的
  • 同一个Tomcat不同Web应用之间共享会话Session cwqcwqmax9 session
    实现两个WEB之间通过session 共享数据 查看tomcat 关于 HTTP Connector 中有个emptySessionPath 其解释如下： If set to true, all paths for session cookies will be set to /. This can be useful for portlet specification impleme
  • springmvc Spring3 MVC，ajax，乱码 dashuaifu springjquerymvcAjax
      springmvc Spring3 MVC @ResponseBody返回，jquery ajax调用中文乱码问题解决   Spring3.0 MVC @ResponseBody 的作用是把返回值直接写到HTTP response body里。具体实现AnnotationMethodHandlerAdapter类handleResponseBody方法，具体实
  • 搭建WAMP环境 dcj3sjt126com wamp
    这里先解释一下WAMP是什么意思。W:windows，A：Apache，M：MYSQL，P：PHP。也就是说本文说明的是在windows系统下搭建以apache做服务器、MYSQL为数据库的PHP开发环境。      工欲善其事，必须先利其器。因为笔者的系统是WinXP，所以下文指的系统均为此系统。笔者所使用的Apache版本为apache_2.2.11-
  • yii2 使用raw http request dcj3sjt126com http
    Parses a raw HTTP request using yii\helpers\Json::decode()   To enable parsing for JSON requests you can configure yii\web\Request::$parsers using this class: 'request' =&g
  • Quartz-1.8.6 理论部分 eksliang quartz
    转载请出自出处：http://eksliang.iteye.com/blog/2207691 一.概述 基于Quartz-1.8.6进行学习，因为Quartz2.0以后的API发生的非常大的变化，统一采用了build模式进行构建； 什么是quartz?   答：简单的说他是一个开源的java作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。并且还能和Sp
  • 什么是POJO？ gupeng_ie javaPOJO框架Hibernate
    POJO--Plain Old Java Objects(简单的java对象)   POJO是一个简单的、正规Java对象，它不包含业务逻辑处理或持久化逻辑等，也不是JavaBean、EntityBean等，不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。   POJO对象有时也被称为Data对象，大量应用于表现现实中的对象。如果项目中使用了Hiber
  • jQuery网站顶部定时折叠广告 ini JavaScripthtmljqueryWebcss
    效果体验：http://hovertree.com/texiao/jquery/4.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>网页顶部定时收起广告jQuery特效 - HoverTree<
  • Spring boot内嵌的tomcat启动失败 kane_xie spring boot
    根据这篇guide创建了一个简单的spring boot应用，能运行且成功的访问。但移植到现有项目（基于hbase）中的时候，却报出以下错误：     SEVERE: A child container failed during start java.util.concurrent.ExecutionException: org.apache.catalina.Lif
  • leetcode: sort list michelle_0916 Algorithmlinked listsort
    Sort a linked list in O(n log n) time using constant space complexity. ====analysis======= mergeSort for singly-linked list  ====code=======   /** * Definition for sin
  • nginx的安装与配置,中途遇到问题的解决 qifeifei nginx
    我使用的是ubuntu13.04系统，在安装nginx的时候遇到如下几个问题，然后找思路解决的，nginx 的下载与安装   wget http://nginx.org/download/nginx-1.0.11.tar.gz tar zxvf nginx-1.0.11.tar.gz ./configure make make install   安装的时候出现
  • 用枚举来处理java自定义异常 tcrct javaenumexception
    在系统开发过程中，总少不免要自己处理一些异常信息，然后将异常信息变成友好的提示返回到客户端的这样一个过程，之前都是new一个自定义的异常，当然这个所谓的自定义异常也是继承RuntimeException的，但这样往往会造成异常信息说明不一致的情况，所以就想到了用枚举来解决的办法。 1，先创建一个接口，里面有两个方法，一个是getCode, 一个是getMessage public
  • erlang supervisor分析 wudixiaotie erlang
    当我们给supervisor指定需要创建的子进程的时候，会指定M,F,A,如果是simple_one_for_one的策略的话，启动子进程的方式是supervisor:start_child(SupName, OtherArgs),这种方式可以根据调用者的需求传不同的参数给需要启动的子进程的方法。和最初的参数合并成一个数组，A ++ OtherArgs。那么这个时候就有个问题了，既然参数不一致，那
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他