WifiP2pService的启动以及P2P的连接

这一章主要总结从WifiP2pService的启动到用户通过四种连接方式连接P2P的过程，四种方式包括：主动连接、被动连接、主动invite和被动invite。首先来看WifiP2pService的启动。

WifiP2pService的启动

WifiP2pService的创建以及启动是在SystemServer中，主要代码如下：

                    wifiP2p = new WifiP2pService(context);
                    ServiceManager.addService(Context.WIFI_P2P_SERVICE, wifiP2p);

                    wifiP2p.connectivityServiceReady();

进入到WifiP2pService的构造函数分析：

    public WifiP2pService(Context context) {
        mContext = context;

        //STOPSHIP: get this from native side
        mInterface = "p2p0";
        mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI_P2P, 0, NETWORKTYPE, "");

        mP2pSupported = mContext.getPackageManager().hasSystemFeature(
                PackageManager.FEATURE_WIFI_DIRECT);

        mThisDevice.primaryDeviceType = mContext.getResources().getString(
                com.android.internal.R.string.config_wifi_p2p_device_type);

        mP2pStateMachine = new P2pStateMachine(TAG, mP2pSupported);
        mP2pStateMachine.start();
    }

WifiP2pService的构造函数很简单，主要是创建一个NetworkInfo的对象，然后通过PackageManagerService获取到系统是否支持P2P，然后创建一个P2pStateMachine并启动这个StateMachine，进入到P2pStateMachine中分析：

        P2pStateMachine(String name, boolean p2pSupported) {
            super(name);

            addState(mDefaultState);
                addState(mP2pNotSupportedState, mDefaultState);
                addState(mP2pDisablingState, mDefaultState);
                addState(mP2pDisabledState, mDefaultState);
                addState(mP2pEnablingState, mDefaultState);
                addState(mP2pEnabledState, mDefaultState);
                    addState(mInactiveState, mP2pEnabledState);
                    addState(mGroupCreatingState, mP2pEnabledState);
                        addState(mUserAuthorizingInviteRequestState, mGroupCreatingState);
                        addState(mUserAuthorizingNegotiationRequestState, mGroupCreatingState);
                        addState(mProvisionDiscoveryState, mGroupCreatingState);
                        addState(mGroupNegotiationState, mGroupCreatingState);
                        addState(mFrequencyConflictState, mGroupCreatingState);
                    addState(mGroupCreatedState, mP2pEnabledState);
                        addState(mUserAuthorizingJoinState, mGroupCreatedState);
                        addState(mOngoingGroupRemovalState, mGroupCreatedState);

            if (p2pSupported) {
                setInitialState(mP2pDisabledState);
            } else {
                setInitialState(mP2pNotSupportedState);
            }
            setLogRecSize(50);
            setLogOnlyTransitions(true);
        }

通过上面的构造函数，我们可以看出P2pStateMachine的各个State关系如下。并且若在支持P2P的情况下，InitialState是P2pDisabledState；若在不支持P2P的情况下，InitialState是P2pNotSupportedState。

接着回到SystemServer中，会调用到WifiP2pService的connectivityServiceReady函数，这个函数比较简单，首先通过ServiceManager获取NETWORKMANAGEMENT_SERVICE，然后记录到mNwService中。这样WifiP2pService的启动流程就介绍完毕了，下面再来看当Enable Wifi时，如何Enable P2p。

Enable P2p

还记得我们在Wifi toggle on这个章节有说过，在WifiStateMachine的DriverStartedState中，如平台支持P2P，还将会给WifiP2pService发送CMD_ENABLE_P2P的消息，在Android 4.4的平台上面，当打开Wifi时，会同时把P2p也enable，我们从这里开始分析。首先由前面的知识，我们进入P2pDisabledState看如何处理CMD_ENABLE_P2P消息：

    class P2pDisabledState extends State {
       @Override
        public void enter() {
            if (DBG) logd(getName());
        }

        @Override
        public boolean processMessage(Message message) {
            if (DBG) logd(getName() + message.toString());
            switch (message.what) {
                case WifiStateMachine.CMD_ENABLE_P2P:
                    try {
                        mNwService.setInterfaceUp(mInterface);
                    } catch (RemoteException re) {
                        loge("Unable to change interface settings: " + re);
                    } catch (IllegalStateException ie) {
                        loge("Unable to change interface settings: " + ie);
                    }
                    mWifiMonitor.startMonitoring();
                    transitionTo(mP2pEnablingState);
                    break;

首先通过NetworkManagementService将P2P0设置为up状态，然后通过WifiMonitor去和wpa_supplicant建立socket连接，因为在WifiStateMachine的DriverStartedState中，wpa_supplicant已经启动成功了，所以我们这里可以直接去和wpa_supplicant通信，最后转到P2pEnablingState处理和wpa_supplicant连接成功与否的消息。

    class P2pEnablingState extends State {
        @Override
        public void enter() {
            if (DBG) logd(getName());
        }

        @Override
        public boolean processMessage(Message message) {
            if (DBG) logd(getName() + message.toString());
            switch (message.what) {
                case WifiMonitor.SUP_CONNECTION_EVENT:
                    if (DBG) logd("P2p socket connection successful");
                    transitionTo(mInactiveState);
                    break;
                case WifiMonitor.SUP_DISCONNECTION_EVENT:
                    loge("P2p socket connection failed");
                    transitionTo(mP2pDisabledState);
                    break;
                case WifiStateMachine.CMD_ENABLE_P2P:
                case WifiStateMachine.CMD_DISABLE_P2P_REQ:
                    deferMessage(message);
                    break;
                default:
                    return NOT_HANDLED;
            }
            return HANDLED;
        }
    }

由Wifi toggle on的知识我们可以知道，当WifiMonitor与wpa_suppliant建立socket成功后，会给P2pStateMachine发送SUP_CONNECT_EVENT消息，P2pEnablingState这时会跳转到InactiveState中，由前面P2pStateMachine的State关系图我们可以知道，P2pEnabledState是InactiveState父State，我们先到P2pEnabledState的enter函数去分析：

    class P2pEnabledState extends State {
        @Override
        public void enter() {
            if (DBG) logd(getName());
            sendP2pStateChangedBroadcast(true);
            mNetworkInfo.setIsAvailable(true);
            sendP2pConnectionChangedBroadcast();
            initializeP2pSettings();
        }

这里主要发送两个broadcast，然后初始化一些P2p的设置，包括deviceName、DeviceType、ConfigMethods，并且获取以前persistent的相关device信息。

P2p设备扫描

当用户到Settings-->P2p中点击扫描后，就开始启动discoverPeers的流程了，首先来看一下WifiP2pManager提供给我们的文档说明：

The API is asynchronous and responses to requests from an application are on listener callbacks provided by the application. The application