Android wifi探究四:Wifi P2P framework层源码分析

上一篇博客对应用程序下使用Wi-Fi P2P Api连接附近的设备的过程做了一个简单的梳理,我们只是学会了怎么使用api,但对api背后的机制一无所知。那么这篇博客就开始尝试分析api背后的实现机制,也就是android framework中Wi-Fi P2P的工作机制。
Wifi P2P在framework层也是一个Service,它的启动过程和WifiService一样:

                mSystemServiceManager.startService(WIFI_P2P_SERVICE_CLASS);
                mSystemServiceManager.startService(WIFI_SERVICE_CLASS);

所以就在不啰嗦了,感兴趣可惜浏览下 Android wifi探究二:java层的wifi框架 这篇文章,我们感兴趣的是WifiP2pServiceImpl是怎么工作的,怎么和应用程序交互的。比如当应用程序调用discoverPeers方法发起查找时,WifiP2pServiceImpl做了什么工作。
回顾上一篇博客的内容,我们使用Wifi P2P服务时,首先要获取到WifiP2pManager 的实例:

mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);

之后的操作都是调用WifiP2pManager 中的方法实现的。我们知道我们向系统注册的Wi-Fi P2P服务是WifiP2pServiceImpl,他们之间会使用一定的机制进行通信,当然主要就是Binder了,不过,还有一个很重要的知识点,那就是Messenger。

一.Messenger

浏览下WifiP2pServiceImpl的实现,因为之前已经分析过WifiServiceImpl的实现,对比我们就知道WifiP2pServiceImpl内部也有个状态机,状态机是消息驱动的,我们需要给状态机发消息才能促使状态机切换状态,那么我们能不能在WifiP2pManager 中直接给WifiP2pServiceImpl发消息呢?答案是能。怎么发呢?就是这里要介绍的Messenger。
我们看一下Api文档中对它的介绍:
Reference to a Handler, which others can use to send messages to it. This allows for the implementation of message-based communication across processes, by creating a Messenger pointing to a Handler in one process, and handing that Messenger to another process.

Note: the implementation underneath is just a simple wrapper around a Binder that is used to perform the communication. This means semantically you should treat it as such: this class does not impact process lifecycle management (you must be using some higher-level component to tell the system that your process needs to continue running), the connection will break if your process goes away for any reason,

翻译(英语太菜,翻译有误请包涵):
我们可以使用Handler引用来发消息,我们可以创建一个Messenger实例,这个实例指向一个进程中的Handler,这样我们可以在另一个进程中处理Messenger 发过来的消息。这样就实现了基于消息的进程间的通信。
注意:实现的原理就是对Binder做一个封装。这意味着:这个类不影响进程的生命周期(你必须使用高级别的组件告诉系统的进程需要继续运行),如果另一进程消失了的话,连接就会断开。
那么,Messanger是怎么获取的呢?
WifiP2pManager 中:

    public Messenger getMessenger() {
        try {
            return mService.getMessenger();
        } catch (RemoteException e) {
            return null;
        }
    }

mService就是WifiP2pServiceImpl的客户端,我们看下WifiP2pServiceImpl中的getMessenger方法:

    public Messenger getMessenger() {
        enforceAccessPermission();
        enforceChangePermission();
        return new Messenger(mClientHandler);
    }

mClientHandler就是WifiP2pServiceImpl用来发送和处理消息的Handler实例,因此我们可以知道,WifiP2pManager 中的Messenger 是Binder的一个客户端,调用WifiP2pManager 中Messenger 的send方法发送消息,最终会导致WifiP2pServiceImpl中ClientHandler的handleMessage方法被调用。理解了这一点,我们就可以往下看代码了。

二.WifiP2pServiceImpl

从构造函数看起:

    public WifiP2pServiceImpl(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);

        HandlerThread wifiP2pThread = new HandlerThread("WifiP2pService");
        wifiP2pThread.start();
        mClientHandler = new ClientHandler(wifiP2pThread.getLooper());

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

构造函数主要做了两件事:
1.创建mP2pStateMachine 状态机,并且启动这个状态机。
2.创建HandlerThread ,用来监听消息,并绑定一个mClientHandler 来发送和处理消息。
因此,重点还是在mP2pStateMachine这个状态机上面。

三.P2pStateMachine

P2pStateMachine是一个状态机,他负责维护Wi-Fi P2P的各种状态,并通过消息的驱动,在状态之间切换,和WifiStateMachine相同的是,它也有下面连个成员:

        private WifiNative mWifiNative = new WifiNative(mInterface);
        private WifiMonitor mWifiMonitor = new WifiMonitor(this, mWifiNative);

这就意味着,它的底层还是使用WifiNative来和c/c++代码交互的,并且wpa_supplicant时间还是由WifiMonitor来监听的。也就是说,P2pStateMachine的工作原理和WifiStateMachine完全相同。因此这里就不展开分析它的工作原理了,WifiStateMachine的工作原理之前的博客已经分析过了。
四.自上而下的调用过程

当我们在应用程序中连接附近设备时,会有如下api调用:
1. mChannel = mManager.initialize(this, getMainLooper(), null);
2. mManager.discoverPeers
3. mManager.requestPeers(mChannel, peerListListener);
4. mManager.connect
5. mManager.requestConnectionInfo(mChannel, connectionListener);
下面,我们典型的分析几个api的内部实现原理:

3.1initialize

也就是所谓的初始化工作:

    public Channel initialize(Context srcContext, Looper srcLooper, ChannelListener listener) {
        return initalizeChannel(srcContext, srcLooper, listener, getMessenger());
    }
    private Channel initalizeChannel(Context srcContext, Looper srcLooper, ChannelListener listener,
                                     Messenger messenger) {
        if (messenger == null) return null;

        Channel c = new Channel(srcContext, srcLooper, listener);
        if (c.mAsyncChannel.connectSync(srcContext, c.mHandler, messenger)
                == AsyncChannel.STATUS_SUCCESSFUL) {
            return c;
        } else {
            return null;
        }
    }

这里的核心工作就是构建Channel 对象,然后调用Channel 的connectSync方法,这个方法如下:

    public int connectSync(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
        if (DBG) log("halfConnectSync srcHandler to the dstMessenger  E");

        // We are connected
        connected(srcContext, srcHandler, dstMessenger);

        if (DBG) log("halfConnectSync srcHandler to the dstMessenger X");
        return STATUS_SUCCESSFUL;
    }

调用connected方法进一步处理:

    public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
        if (DBG) log("connected srcHandler to the dstMessenger  E");

        // Initialize source fields
        mSrcContext = srcContext;
        mSrcHandler = srcHandler;
        mSrcMessenger = new Messenger(mSrcHandler);

        // Initialize destination fields
        mDstMessenger = dstMessenger;

        if (DBG) log("connected srcHandler to the dstMessenger X");
    }

我们看到这里有两个Messenger,一个是“源”,一个是“目的”,这个很好理解,我们使用mDstMessenger 向WifiP2pServiceImpl发送消息,也需要接收WifiP2pServiceImpl返回的消息呀,这不就得用mSrcMessenger 吗?mSrcHandler 当然是用来处理消息的呀。
也就是说,通过初始化,我们创建了Channel ,而Channel封装了两个Messenger,分别用于发送和接受消息,因此Channel 是WifiP2PManager和WifiP2pServiceImpl之间的桥梁,正是它把二者联系在一起,因此几乎所有的API都要使用Channel 对象。或者说的严谨一点,所有需要向WifiP2pServiceImpl发送消息的api都需要这个Channel 的实例。

那么,接下来,我们通过具体的api来分析Channel 在这个过程中的核心作用。

3.2 discoverPeers

看看discoverPeers的实现:

    public void discoverPeers(Channel c, ActionListener listener) {
        checkChannel(c);
        c.mAsyncChannel.sendMessage(DISCOVER_PEERS, 0, c.putListener(listener));
    }

看到了吧:c就是一个Channel实例,使我们initialize方法中构造好并且返回的一个值,把它作为discoverPeers的第一个参数,就是要使用它来和WifiP2pServiceImpl通信的,我们具体看看通信的过程,也就是c.mAsyncChannel.sendMessage这个方法的实现:

    public void sendMessage(int what, int arg1, int arg2) {
        Message msg = Message.obtain();
        msg.what = what;
        msg.arg1 = arg1;
        msg.arg2 = arg2;
        sendMessage(msg);
    }

调用sendMessage进一步处理:

    public void sendMessage(Message msg) {
        msg.replyTo = mSrcMessenger;
        try {
            mDstMessenger.send(msg);
        } catch (RemoteException e) {
            replyDisconnected(STATUS_SEND_UNSUCCESSFUL);
        }
    }

看到了吧:msg.replyTo就是接收WifiP2pServiceImpl返回的消息的,要把它也发送给WifiP2pServiceImpl,真正发送消息的是mDstMessenger.send(msg);mDstMessenger我们在initialize方法中讲过了,它就是真正用来向WifiP2pServiceImpl发送消息的Messenger实例。发送完消息以后WifiP2pServiceImpl中的ClientHandler的handleMessage方法会被调用,着我们之前也说过了。
ClientHandler的handleMessage方法如下:

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
              case WifiP2pManager.SET_DEVICE_NAME:
              case WifiP2pManager.SET_WFD_INFO:
              case WifiP2pManager.DISCOVER_PEERS:
              case WifiP2pManager.STOP_DISCOVERY:
              case WifiP2pManager.CONNECT:
              case WifiP2pManager.CANCEL_CONNECT:
              case WifiP2pManager.CREATE_GROUP:
              case WifiP2pManager.REMOVE_GROUP:
              case WifiP2pManager.START_LISTEN:
              case WifiP2pManager.STOP_LISTEN:
              case WifiP2pManager.SET_CHANNEL:
              case WifiP2pManager.START_WPS:
              case WifiP2pManager.ADD_LOCAL_SERVICE:
              case WifiP2pManager.REMOVE_LOCAL_SERVICE:
              case WifiP2pManager.CLEAR_LOCAL_SERVICES:
              case WifiP2pManager.DISCOVER_SERVICES:
              case WifiP2pManager.ADD_SERVICE_REQUEST:
              case WifiP2pManager.REMOVE_SERVICE_REQUEST:
              case WifiP2pManager.CLEAR_SERVICE_REQUESTS:
              case WifiP2pManager.REQUEST_PEERS:
              case WifiP2pManager.REQUEST_CONNECTION_INFO:
              case WifiP2pManager.REQUEST_GROUP_INFO:
              case WifiP2pManager.DELETE_PERSISTENT_GROUP:
              case WifiP2pManager.REQUEST_PERSISTENT_GROUP_INFO:
              // MStar Android Patch Begin
              case WifiP2pManager.MCAST_LISTEN:
              // MStar Android Patch End
                mP2pStateMachine.sendMessage(Message.obtain(msg));
                break;
              default:
                Slog.d(TAG, "ClientHandler.handleMessage ignoring msg=" + msg);
                break;
            }
        }
    }

它的作用就是把消息转发给mP2pStateMachine。
当我们打开wifi以后,系统也会使能Wi-Fi P2P,这个时候mP2pStateMachine处于P2pEnabledState状态,这个时候,如果收到DISCOVER_PEERS消息,就会执行如下代码:

                case WifiP2pManager.DISCOVER_PEERS:
                    if (mDiscoveryBlocked) {
                        replyToMessage(message, WifiP2pManager.DISCOVER_PEERS_FAILED,
                                WifiP2pManager.BUSY);
                        break;
                    }
                    // do not send service discovery request while normal find operation.
                    clearSupplicantServiceRequest();
                    if (mWifiNative.p2pFind(DISCOVER_TIMEOUT_S)) {
                        replyToMessage(message, WifiP2pManager.DISCOVER_PEERS_SUCCEEDED);
                        sendP2pDiscoveryChangedBroadcast(true);
                    } else {
                        replyToMessage(message, WifiP2pManager.DISCOVER_PEERS_FAILED,
                                WifiP2pManager.ERROR);
                    }
                    break;

这里做了下面几件事:
1. 清楚wpa_supplicant原有的查找请求。
2. 调用mWifiNative.p2pFind(DISCOVER_TIMEOUT_S)开始查找。
3. 处理查找结果:如果查找成功,向WifiP2pManager返回成功的消息,并且发送查找结果改变的广播,也就是如下广播: public static final String WIFI_P2P_DISCOVERY_CHANGED_ACTION =
“android.net.wifi.p2p.DISCOVERY_STATE_CHANGE”; 如果查找失败,则给WifiP2pManager返回查找失败的消息。

四总结

虽然我们只分析了两个方法的实现原理,还有很多的api都没有分析,当然,也不可能都分析一遍了,因为我们关注的是框架,而不是具体的细节。虽然这里面还有很多东西我们都忽略了,这也是因为能力有限,不能分析的面面俱到,但是通过这种框架层面的源码追踪和分析,我们能理解这些api工作的原理,能理解WifiP2pManager与WifiP2pServiceImpl的交互过程,以及WifiMonitor、P2pStateMachine和WifiNative各自的扮演的角色和作用。对比WifiService,我们发现他们的设计思路都是一样的,WifiServiceImpl的分析过程中,我尝试这绘制了一些图来帮助理解,这里就不再又一遍区绘制这些图了,因为他们设计的思路是相同的。感兴趣的可以先搞明白WifiService的框架,然后再来梳理WifiP2pService的框架,这时就会发现,一切都会变简单了。

你可能感兴趣的:(Android,wifi框架分析,android,wi-fi,p2p,框架,源码)