Android WifiDisplay分析一：相关Service的启动

本文转载自：李炼  Android WifiDisplay分析一：相关Service的启动

原文地址：http://blog.csdn.net/lilian0118/article/details/22849249

最近在学习Android 4.4上面的WifiDisplay(Miracast)相关的模块，这里先从WifiDisplay用到的各个Service讲起，然后再从WifiDisplaySettings里面讲解打开wfd的流程。首先看下面的主要几个Service的架构图：

相关Service的启动

图中主要有以下几个模块，DisplayManagerService、MediaRouterService、WifiDisplayAdapter和WifiDisplayController。其中：

DisplayManagerService用于管理系统显示设备的生命周期，包含物理屏幕、虚拟屏幕、wifi display等，它用一组DiaplayAdapter来管理这些显示设备。

MediaRouterService用于管理各个应用程序的多媒体播放的行为。

MediaRouter用于和MediaRouterService交互一起管理多媒体的播放行为，并维护当前已经配对上的remote display设备，包括Wifi diplay、蓝牙A2DP设备、chromecast设备。

WifiDisplayAdapter是用于DisplayManagerService管理Wifi display显示的adapter。

WifiDisplayController用于控制扫描wifi display设备、连接、断开等操作。

先来顺着上面的架构图看各个Service的启动。首先来看DisplayManagerService，在SystemServer中先创建一个DisplayManagerService对象，然后调用systemReady方法：

[java]  view plain copy

1. public DisplayManagerService(Context context, Handler mainHandler) {  
2.     mContext = context;  
3.     mHeadless = SystemProperties.get(SYSTEM_HEADLESS).equals("1");  
4.   
5.     mHandler = new DisplayManagerHandler(mainHandler.getLooper());  
6.     mUiHandler = UiThread.getHandler();  
7.     mDisplayAdapterListener = new DisplayAdapterListener();  
8.     mSingleDisplayDemoMode = SystemProperties.getBoolean("persist.demo.singledisplay", false);  
9.   
10.     mHandler.sendEmptyMessage(MSG_REGISTER_DEFAULT_DISPLAY_ADAPTER);  
11. }  
12.   
13. public void systemReady(boolean safeMode, boolean onlyCore) {  
14.     synchronized (mSyncRoot) {  
15.         mSafeMode = safeMode;  
16.         mOnlyCore = onlyCore;  
17.     }  
18.   
19.     mHandler.sendEmptyMessage(MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS);  
20. }  

在DisplayManagerService的构造函数中，首先获取SYSTEM_HEADLESS属性，用于表明系统是否支持headless模式，默认为0。然后创建一个DisplayManagerHandler用于处理DisplayManagerService中的消息，mSigleDisplayDemoMode用于开发模式中。然后给自己发送MSG_REGISTER_DEFAULT_DISPLAY_ADAPTER，我们到DisplayManagerHandler看如何处理这个消息：

[java]  view plain copy

1. private final class DisplayManagerHandler extends Handler {  
2.     public DisplayManagerHandler(Looper looper) {  
3.         super(looper, null, true /*async*/);  
4.     }  
5.   
6.     @Override  
7.     public void handleMessage(Message msg) {  
8.         switch (msg.what) {  
9.             case MSG_REGISTER_DEFAULT_DISPLAY_ADAPTER:  
10.                 registerDefaultDisplayAdapter();  
11.                 break;  
12.   
13.             case MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS:  
14.                 registerAdditionalDisplayAdapters();  
15.                 break;  

处理MSG_REGISTER_DEFAULT_DISPLAY_ADAPTER消息就是调用registerDefaultDisplayAdapter来注册一个默认的DiaplayAdapter，DisplayManagerService维护一组DiaplayAdapter，用于管理这些显示设备。默认的DiaplayAdapter就是系统的物理屏幕，通过Surface flinger来控制输出。

[java]  view plain copy

1. private void registerDefaultDisplayAdapter() {  
2.     // Register default display adapter.  
3.     synchronized (mSyncRoot) {  
4.         if (mHeadless) {  
5.             registerDisplayAdapterLocked(new HeadlessDisplayAdapter(  
6.                     mSyncRoot, mContext, mHandler, mDisplayAdapterListener));  
7.         } else {  
8.             registerDisplayAdapterLocked(new LocalDisplayAdapter(  
9.                     mSyncRoot, mContext, mHandler, mDisplayAdapterListener));  
10.         }  
11.     }  
12. }  
13.   
14. private void registerDisplayAdapterLocked(DisplayAdapter adapter) {  
15.     mDisplayAdapters.add(adapter);  
16.     adapter.registerLocked();  
17. }  

管理surface finger的知识就不讲解了。接着来看systemReady函数中会发送MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS，这里就会调用registerAdditionalDisplayAdapters来注册其它的显示设备：

[java]  view plain copy

1. private void registerAdditionalDisplayAdapters() {  
2.     synchronized (mSyncRoot) {  
3.         if (shouldRegisterNonEssentialDisplayAdaptersLocked()) {  
4.             registerOverlayDisplayAdapterLocked();  
5.             registerWifiDisplayAdapterLocked();  
6.             registerVirtualDisplayAdapterLocked();  
7.         }  
8.     }  
9. }  

这里主要注册三种DisplayAdapter，一种是OverlayDiaplayAdapter用于开发模式用；一种是WifiDisplayAdapter用于wifi display，也是我们接下来要讲的；还有一种是虚拟显示。接下来只看registerWifiDisplayAdapterLocked：

[java]  view plain copy

1. private void registerWifiDisplayAdapterLocked() {  
2.     if (mContext.getResources().getBoolean(  
3.             com.android.internal.R.bool.config_enableWifiDisplay)  
4.             || SystemProperties.getInt(FORCE_WIFI_DISPLAY_ENABLE, -1) == 1) {  
5.         mWifiDisplayAdapter = new WifiDisplayAdapter(  
6.                 mSyncRoot, mContext, mHandler, mDisplayAdapterListener,  
7.                 mPersistentDataStore);  
8.         registerDisplayAdapterLocked(mWifiDisplayAdapter);  
9.     }  
10. }  

这里会创建WifiDisplayAdapter对象，我们到它的构造函数中去分析，并调用registerDisplayAdapterLocked添加到mDisplayAdapter中，这里会回调WifiDisplayAdapter的registerLocked方法：

[java]  view plain copy

1. public WifiDisplayAdapter(DisplayManagerService.SyncRoot syncRoot,  
2.         Context context, Handler handler, Listener listener,  
3.         PersistentDataStore persistentDataStore) {  
4.     super(syncRoot, context, handler, listener, TAG);  
5.     mHandler = new WifiDisplayHandler(handler.getLooper());  
6.     mPersistentDataStore = persistentDataStore;  
7.     mSupportsProtectedBuffers = context.getResources().getBoolean(  
8.             com.android.internal.R.bool.config_wifiDisplaySupportsProtectedBuffers);  
9.     mNotificationManager = (NotificationManager)context.getSystemService(  
10.             Context.NOTIFICATION_SERVICE);  
11. }  
12.   
13. public void registerLocked() {  
14.     super.registerLocked();  
15.   
16.     updateRememberedDisplaysLocked();  
17.   
18.     getHandler().post(new Runnable() {  
19.         @Override  
20.         public void run() {  
21.             mDisplayController = new WifiDisplayController(  
22.                     getContext(), getHandler(), mWifiDisplayListener);  
23.   
24.             getContext().registerReceiverAsUser(mBroadcastReceiver, UserHandle.ALL,  
25.                     new IntentFilter(ACTION_DISCONNECT), null, mHandler);  
26.         }  
27.     });  
28. }  

PersistentDateStore用于持久性存储连过的wifi display设备，用于在WifiDisplaySettings中显示前面已经连接过的设备列表。SupportsProtectedBuffer与gralloc显示相关。在registerLocked通过updateRememberedDisplaysLocked去加载/data/system/display-manager-state.xml中保存过的列表，并记录在mRememberedDisplays中。接着实例化一个WifiDisplayController对象，同时注册对ACTION_DISCONNECT的receiver。接着到WifiDisplayController去分析，注意WifiDisplayController最后一个参数用于回调通知WifiDisplayAdapter相关状态的改变，比如wifi display打开/关闭、wifi display连接/断开等。

[java]  view plain copy

1. public WifiDisplayController(Context context, Handler handler, Listener listener) {  
2.     mContext = context;  
3.     mHandler = handler;  
4.     mListener = listener;  
5.   
6.     mWifiP2pManager = (WifiP2pManager)context.getSystemService(Context.WIFI_P2P_SERVICE);  
7.     mWifiP2pChannel = mWifiP2pManager.initialize(context, handler.getLooper(), null);  
8.   
9.     IntentFilter intentFilter = new IntentFilter();  
10.     intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);  
11.     intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);  
12.     intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);  
13.     intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);  
14.     context.registerReceiver(mWifiP2pReceiver, intentFilter, null, mHandler);  
15.   
16.     ContentObserver settingsObserver = new ContentObserver(mHandler) {  
17.         @Override  
18.         public void onChange(boolean selfChange, Uri uri) {  
19.             updateSettings();  
20.         }  
21.     };  
22.   
23.     final ContentResolver resolver = mContext.getContentResolver();  
24.     resolver.registerContentObserver(Settings.Global.getUriFor(  
25.             Settings.Global.WIFI_DISPLAY_ON), false, settingsObserver);  
26.     resolver.registerContentObserver(Settings.Global.getUriFor(  
27.             Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON), false, settingsObserver);  
28.     resolver.registerContentObserver(Settings.Global.getUriFor(  
29.             Settings.Global.WIFI_DISPLAY_WPS_CONFIG), false, settingsObserver);  
30.     updateSettings();  
31. }  

这里主要注册WifiP2pReceiver用于接收处理WIFI_P2P_STATE_CHANGED_ACTION、WIFI_P2P_PEERS_CHANGED_ACTION、WIFI_P2P_CONNECTION_CHANGED_ACTION、WIFI_P2P_THIS_DEVICE_CHANGED_ACTION消息，然后注册ContentObserver来监控Settings.Global这个数据库里面的WIFI_DISPLAY_ON、WIFI_DISPLAY_CERTIFICATION_ON和WIFI_DISPLAY_WPS_CONFIG，这里比较重要，我们后面会看到在WifiDisplaySettings里面enable wifi display的时候，就会走到这个地方来。接着调用updateSettings来处理默认是否打开Wifi display，这里默认是关闭的，我们后面再来分析这一块。

接着来看MediaRouterService和MediaRouter，MediaRouter通过AIDL调用MediaRouterService的实现来完成一些工作。在SystemServer启动MediaRouterService的时候，主要创建一个MediaRouterService，然后调用它的systemRunning方法，代码如下：

[java]  view plain copy

1. public MediaRouterService(Context context) {  
2.     mContext = context;  
3.     Watchdog.getInstance().addMonitor(this);  
4. }  
5.   
6. public void systemRunning() {  
7.     IntentFilter filter = new IntentFilter(Intent.ACTION_USER_SWITCHED);  
8.     mContext.registerReceiver(new BroadcastReceiver() {  
9.         @Override  
10.         public void onReceive(Context context, Intent intent) {  
11.             if (intent.getAction().equals(Intent.ACTION_USER_SWITCHED)) {  
12.                 switchUser();  
13.             }  
14.         }  
15.     }, filter);  
16.   
17.     switchUser();  
18. }  

上面的方法比较简单，主要就是接收ACTION_USER_SWITCHED，这是关于多用户切换的操作。MediaRouterService的工作比较少，主要都是MediaRouter通过AIDL调用完成，接下来去看MediaRouter的部分，在Android官方文档中有说明MediaRouter的调用方法：

A MediaRouter is retrieved through Context.getSystemService() of a Context.MEDIA_ROUTER_SERVICE. 这样系统是实例化一个MediaRouter对象并返回，下面来看它的构造函数：

[java]  view plain copy

1. public MediaRouter(Context context) {  
2.     synchronized (Static.class) {  
3.         if (sStatic == null) {  
4.             final Context appContext = context.getApplicationContext();  
5.             sStatic = new Static(appContext);  
6.             sStatic.startMonitoringRoutes(appContext);  
7.         }  
8.     }  
9. }  
10.   
11.     Static(Context appContext) {  
12.         mAppContext = appContext;  
13.         mResources = Resources.getSystem();  
14.         mHandler = new Handler(appContext.getMainLooper());  
15.   
16.         IBinder b = ServiceManager.getService(Context.AUDIO_SERVICE);  
17.         mAudioService = IAudioService.Stub.asInterface(b);  
18.   
19.         mDisplayService = (DisplayManager) appContext.getSystemService(Context.DISPLAY_SERVICE);  
20.   
21.         mMediaRouterService = IMediaRouterService.Stub.asInterface(  
22.                 ServiceManager.getService(Context.MEDIA_ROUTER_SERVICE));  
23.   
24.         mSystemCategory = new RouteCategory(  
25.                 com.android.internal.R.string.default_audio_route_category_name,  
26.                 ROUTE_TYPE_LIVE_AUDIO | ROUTE_TYPE_LIVE_VIDEO, false);  
27.         mSystemCategory.mIsSystem = true;  
28.   
29.         mCanConfigureWifiDisplays = appContext.checkPermission(  
30.                 Manifest.permission.CONFIGURE_WIFI_DISPLAY,  
31.                 Process.myPid(), Process.myUid()) == PackageManager.PERMISSION_GRANTED;  
32.     }  

MediaRouter中主要通过Static对象来实现其大多数的方法，Static就是一个单例模式，先看Static的构造函数，也可以通过上面的图看到，MediaRouter包含DisplayManager对象和MediaRouterService的BpBinder引用，MediaRouter还持有AudioService的BpBind，用于控制audio数据的输出设备，例如可以用于蓝牙A2DP中使用。接着看Static的startMonitoringRoutes方法：

[java]  view plain copy

1. void startMonitoringRoutes(Context appContext) {  
2.     mDefaultAudioVideo = new RouteInfo(mSystemCategory);  
3.     mDefaultAudioVideo.mNameResId = com.android.internal.R.string.default_audio_route_name;  
4.     mDefaultAudioVideo.mSupportedTypes = ROUTE_TYPE_LIVE_AUDIO | ROUTE_TYPE_LIVE_VIDEO;  
5.     mDefaultAudioVideo.updatePresentationDisplay();  
6.     addRouteStatic(mDefaultAudioVideo);  
7.   
8.     // This will select the active wifi display route if there is one.  
9.     updateWifiDisplayStatus(mDisplayService.getWifiDisplayStatus());  
10.   
11.     appContext.registerReceiver(new WifiDisplayStatusChangedReceiver(),  
12.             new IntentFilter(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED));  
13.     appContext.registerReceiver(new VolumeChangeReceiver(),  
14.             new IntentFilter(AudioManager.VOLUME_CHANGED_ACTION));  
15.   
16.     mDisplayService.registerDisplayListener(this, mHandler);  
17.   
18.   
19.     // Bind to the media router service.  
20.     rebindAsUser(UserHandle.myUserId());  
21.   
22.     // Select the default route if the above didn't sync us up  
23.     // appropriately with relevant system state.  
24.     if (mSelectedRoute == null) {  
25.         selectDefaultRouteStatic();  
26.     }  
27. }  

首先注册系统中默认的AudioVideo输出设备，如果有处于活动状态的wifi display连接，就记录下当前处于活动连接的设备，默认为空。上面会注册两个broadcastReceiver，一个用于接收ACTION_WIFI_DISPLAY_STATUS_CHANGED，另一个接收VOLUME_CHANGED_ACTION，我们主要看前面接收ACTION_WIFI_DISPLAY_STATUS_CHANGED的receiver，如下：

[java]  view plain copy

1. static class WifiDisplayStatusChangedReceiver extends BroadcastReceiver {  
2.     @Override  
3.     public void onReceive(Context context, Intent intent) {  
4.         if (intent.getAction().equals(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED)) {  
5.             updateWifiDisplayStatus((WifiDisplayStatus) intent.getParcelableExtra(  
6.                     DisplayManager.EXTRA_WIFI_DISPLAY_STATUS));  
7.         }  
8.     }  

上面接收ACTION_WIFI_DISPLAY_STATUS_CHANGED，从Intent里面取出WifiDisplayStatus对象，WifiDisplayStatus内部的变量如下：

mFeatureState	表明现在wifi display是关闭还是打开状态
mScanState	表现现在wifi display是否在scanning状态
mActiveDisplayState	表明现在wifi display是在连接还是无连接状态
mActiveDisplay	处于正在连接或者连接中的WifiDisplay对象
mDisplays	扫描到的WifiDisplay对象数组
mSessionInfo	用于过Miracast认证时用

然后向DisplayManager注册一个回调函数，当有显示设备增加、删除或者改变的时候，就会有相应的回调函数来通知Static对象。接着绑定MediaRouterService：

[java]  view plain copy

1. void rebindAsUser(int userId) {  
2.     if (mCurrentUserId != userId || userId < 0 || mClient == null) {  
3.   
4.         mCurrentUserId = userId;  
5.   
6.         try {  
7.             Client client = new Client();  
8.             mMediaRouterService.registerClientAsUser(client,  
9.                     mAppContext.getPackageName(), userId);  
10.             mClient = client;  
11.         } catch (RemoteException ex) {  
12.             Log.e(TAG, "Unable to register media router client.", ex);  
13.         }  
14.   
15.         publishClientDiscoveryRequest();  
16.         publishClientSelectedRoute(false);  
17.         updateClientState();  
18.     }  
19. }  

Enable WifiDisplay

当用户进入WifiDisplaySettings界面，会调用其对应的onCreate和onStart方法：

[java]  view plain copy

1. public void onCreate(Bundle icicle) {  
2.     super.onCreate(icicle);  
3.   
4.     final Context context = getActivity();  
5.     mRouter = (MediaRouter)context.getSystemService(Context.MEDIA_ROUTER_SERVICE);  
6.     mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);  
7.     mWifiP2pManager = (WifiP2pManager)context.getSystemService(Context.WIFI_P2P_SERVICE);  
8.     mWifiP2pChannel = mWifiP2pManager.initialize(context, Looper.getMainLooper(), null);  
9.   
10.     addPreferencesFromResource(R.xml.wifi_display_settings);  
11.     setHasOptionsMenu(true);  
12. }  
13.   
14. public void onStart() {  
15.     super.onStart();  
16.     mStarted = true;  
17.   
18.     final Context context = getActivity();  
19.     IntentFilter filter = new IntentFilter();  
20.     filter.addAction(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED);  
21.     context.registerReceiver(mReceiver, filter);  
22.   
23.     getContentResolver().registerContentObserver(Settings.Global.getUriFor(  
24.             Settings.Global.WIFI_DISPLAY_ON), false, mSettingsObserver);  
25.     getContentResolver().registerContentObserver(Settings.Global.getUriFor(  
26.             Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON), false, mSettingsObserver);  
27.     getContentResolver().registerContentObserver(Settings.Global.getUriFor(  
28.             Settings.Global.WIFI_DISPLAY_WPS_CONFIG), false, mSettingsObserver);  
29.   
30.     mRouter.addCallback(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY, mRouterCallback,  
31.             MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN);  
32.   
33.     update(CHANGE_ALL);  
34. }  

首先注册对ACTION_WIFI_DISPLAY_STATUS_CHANGED的receiver，这个broadcast会在WifiDisplayAdapter里面当wifi display的状态发送改变时发送，包括扫描到新的设备、开始连接、连接成功、断开等消息都会被这个receiver接收到，后面我们会来分析这个receiver干了什么，然后在onStart中想MediaRouter对象注册一个callback函数，用于获取系统中remote display的相关回调信息。然后类似WifiDisplayController一样，注册一些对数据库改变的ContentObserver。接着来看MediaRouter.addCallback的实现：

[java]  view plain copy

1. public void addCallback(int types, Callback cb, int flags) {  
2.     CallbackInfo info;  
3.     int index = findCallbackInfo(cb);  
4.     if (index >= 0) {  
5.         info = sStatic.mCallbacks.get(index);  
6.         info.type |= types;  
7.         info.flags |= flags;  
8.     } else {  
9.         info = new CallbackInfo(cb, types, flags, this);  
10.         sStatic.mCallbacks.add(info);  
11.     }  
12.     sStatic.updateDiscoveryRequest();  
13. }  

Static的mCallbacks是一个CopyOnWriteArrayList数组，记录所有注册到MediaRouter中的回调函数。如果已经向MediaRouter注册过这个callback，则更新相关的type和flag；如果没有注册，则新建一个CallbackInfo对象并添加到mCallbacks数组中。然后调用Static的updateDiscoveryRequest去更新是否需要发送Discovery request请求：

[java]  view plain copy

1. void updateDiscoveryRequest() {  
2.             final int count = mCallbacks.size();  
3.             for (int i = 0; i < count; i++) {  
4.                 CallbackInfo cbi = mCallbacks.get(i);  
5.                 if ((cbi.flags & (CALLBACK_FLAG_PERFORM_ACTIVE_SCAN  
6.                         | CALLBACK_FLAG_REQUEST_DISCOVERY)) != 0) {  
7.                     // Discovery explicitly requested.  
8.                     routeTypes |= cbi.type;  
9.                 } else if ((cbi.flags & CALLBACK_FLAG_PASSIVE_DISCOVERY) != 0) {  
10.                     // Discovery only passively requested.  
11.                     passiveRouteTypes |= cbi.type;  
12.                 } else {  
13.                     // Legacy case since applications don't specify the discovery flag.  
14.                     // Unfortunately we just have to assume they always need discovery  
15.                     // whenever they have a callback registered.  
16.                     routeTypes |= cbi.type;  
17.                 }  
18.                 if ((cbi.flags & CALLBACK_FLAG_PERFORM_ACTIVE_SCAN) != 0) {  
19.                     activeScan = true;  
20.                     if ((cbi.type & ROUTE_TYPE_REMOTE_DISPLAY) != 0) {  
21.                         activeScanWifiDisplay = true;  
22.                     }  
23.                 }  
24.             }  
25.             if (routeTypes != 0 || activeScan) {  
26.                 // If someone else requests discovery then enable the passive listeners.  
27.                 // This is used by the MediaRouteButton and MediaRouteActionProvider since  
28.                 // they don't receive lifecycle callbacks from the Activity.  
29.                 routeTypes |= passiveRouteTypes;  
30.             }  
31.   
32.             // Update wifi display scanning.  
33.             // TODO: All of this should be managed by the media router service.  
34.             if (mCanConfigureWifiDisplays) {  
35.                 if (mSelectedRoute != null  
36.                         && mSelectedRoute.matchesTypes(ROUTE_TYPE_REMOTE_DISPLAY)) {  
37.                     // Don't scan while already connected to a remote display since  
38.                     // it may interfere with the ongoing transmission.  
39.                     activeScanWifiDisplay = false;  
40.                 }  
41.                 if (activeScanWifiDisplay) {  
42.                     if (!mActivelyScanningWifiDisplays) {  
43.                         mActivelyScanningWifiDisplays = true;  
44.                         mDisplayService.startWifiDisplayScan();  
45.                     }  
46.                 } else {  
47.                     if (mActivelyScanningWifiDisplays) {  
48.                         mActivelyScanningWifiDisplays = false;  
49.                         mDisplayService.stopWifiDisplayScan();  
50.                     }  
51.                 }  
52.             }  
53.         }  

这个函数体比较长，主要通过注册的一系列的callback类型来决定是否要进行wifiDisplay scan的动作，根据在WifiDisplaySettings里面注册callback的方法：    mRouter.addCallback(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY, mRouterCallback,
                MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN)，上面函数中的activeScanWifiDisplay会为true，接着会调用DisplayManagerService中的startWifiDisplayScan，如下图。

这里会通过WifiDisplayAdapter调用到WifiDisplayController的updateScanState动作，我们到updateScanState中去分析：

[java]  view plain copy

1. private void updateScanState() {  
2.     if (mScanRequested && mWfdEnabled && mDesiredDevice == null) {  
3.         if (!mDiscoverPeersInProgress) {  
4.             Slog.i(TAG, "Starting Wifi display scan.");  
5.             mDiscoverPeersInProgress = true;  
6.             handleScanStarted();  
7.             tryDiscoverPeers();  
8.         }  
9.     } else {  
10.         if (mDiscoverPeersInProgress) {  
11.             // Cancel automatic retry right away.  
12.             mHandler.removeCallbacks(mDiscoverPeers);  
13.   
14.             if (mDesiredDevice == null || mDesiredDevice == mConnectedDevice) {  
15.                 Slog.i(TAG, "Stopping Wifi display scan.");  
16.                 mDiscoverPeersInProgress = false;  
17.                 stopPeerDiscovery();  
18.                 handleScanFinished();  
19.             }  
20.         }  
21.     }  
22. }  

当初次进入到WifiDisplaySettings中，并没有去optionMenu中enable wifi display时，上面code中的mWfdEnabled为false，所以会跳出前面的if语句；后面的else语句中mDiscoverPeersInProgress也为false，因为这个变量只有在scan时才会被置为true。

接着来分析当用户点击了optionMenu中enable wifi display后的流程，先看WifiDisplaySettings的代码：

[java]  view plain copy

1. public boolean onOptionsItemSelected(MenuItem item) {  
2.     switch (item.getItemId()) {  
3.         case MENU_ID_ENABLE_WIFI_DISPLAY:  
4.             mWifiDisplayOnSetting = !item.isChecked();  
5.             item.setChecked(mWifiDisplayOnSetting);  
6.             Settings.Global.putInt(getContentResolver(),  
7.                     Settings.Global.WIFI_DISPLAY_ON, mWifiDisplayOnSetting ? 1 : 0);  

这里首先改变OptionMenu的状态，并置mWifiDisplayOnSetting为上次MenuItem相反的状态，然后改变Settings.Global数据库中WIFI_DISPLAY_ON的指为1。前面我们介绍过，在WifiDisplaySettings和WifiDisplayController都有注册ContentObserver来监控这个值的变化。其中WifiDisplaySettings在监控到这个值的变化后，主要是调用MediaRouter和DisplayManager的方法去获取系统中已经扫描到的remote display设备，并更新到listview列表上，显然这时候还没有开始scan，所以listview列表为空。接着看WifiDisplayController处理ContentOberver的代码：

[java]  view plain copy

1. private void updateSettings() {  
2.     final ContentResolver resolver = mContext.getContentResolver();  
3.     mWifiDisplayOnSetting = Settings.Global.getInt(resolver,  
4.             Settings.Global.WIFI_DISPLAY_ON, 0) != 0;  
5.     mWifiDisplayCertMode = Settings.Global.getInt(resolver,  
6.             Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON, 0) != 0;  
7.   
8.     mWifiDisplayWpsConfig = WpsInfo.INVALID;  
9.     if (mWifiDisplayCertMode) {  
10.         mWifiDisplayWpsConfig = Settings.Global.getInt(resolver,  
11.               Settings.Global.WIFI_DISPLAY_WPS_CONFIG, WpsInfo.INVALID);  
12.     }  
13.   
14.     updateWfdEnableState();  
15. }  

这里主要置mWifiDisplayOnSetting为true，然后就调用updateWfdEnableState去更新wfd的状态：

[java]  view plain copy

1. private void updateWfdEnableState() {  
2.     if (mWifiDisplayOnSetting && mWifiP2pEnabled) {  
3.         // WFD should be enabled.  
4.         if (!mWfdEnabled && !mWfdEnabling) {  
5.             mWfdEnabling = true;  
6.   
7.             WifiP2pWfdInfo wfdInfo = new WifiP2pWfdInfo();  
8.             wfdInfo.setWfdEnabled(true);  
9.             wfdInfo.setDeviceType(WifiP2pWfdInfo.WFD_SOURCE);  
10.             wfdInfo.setSessionAvailable(true);  
11.             wfdInfo.setControlPort(DEFAULT_CONTROL_PORT);  
12.             wfdInfo.setMaxThroughput(MAX_THROUGHPUT);  
13.             mWifiP2pManager.setWFDInfo(mWifiP2pChannel, wfdInfo, new ActionListener() {  
14.                 @Override  
15.                 public void onSuccess() {  
16.                     if (DEBUG) {  
17.                         Slog.d(TAG, "Successfully set WFD info.");  
18.                     }  
19.                     if (mWfdEnabling) {  
20.                         mWfdEnabling = false;  
21.                         mWfdEnabled = true;  
22.                         reportFeatureState();  
23.                         updateScanState();  
24.                     }  
25.                 }  
26.   
27.                 @Override  
28.                 public void onFailure(int reason) {  
29.                     if (DEBUG) {  
30.                         Slog.d(TAG, "Failed to set WFD info with reason " + reason + ".");  
31.                     }  
32.                     mWfdEnabling = false;  
33.                 }  
34.             });  
35.         }  

首先调用WifiP2pMananger的setWFDInfo把与wifi display相关的信息设置到wpa_supplicant，这些信息包括enable状态、device type（指为source还是sink）、session available（当前可否连接）、control port（用于rtsp连接）、maxThroughput（吞吐量），这些信息最终会随着P2P的IE信息在扫描阶段被对方知道。接着会调用reportFeatureState来通知WifiDisplayAdapter相应状态的变化，这里我们先看一下下面的流程图来了解一下WifiDisplaySettings、MediaRouter、DisplayMananger、WifiDisplayAdapter、WifiDisplayController是如何相互通知信息的，这其中有简单的callback，也有发送/接收broadcast，如下图：

通过上面的图我们可以看到实线部分是调用关系，虚线部分是回调关系。接着我们来看reportFeatureState的实现：

[java]  view plain copy

1. private void reportFeatureState() {  
2.     final int featureState = computeFeatureState();  
3.     mHandler.post(new Runnable() {  
4.         @Override  
5.         public void run() {  
6.             mListener.onFeatureStateChanged(featureState);  
7.         }  
8.     });  
9. }  
10.   
11. private int computeFeatureState() {  
12.     if (!mWifiP2pEnabled) {  
13.         return WifiDisplayStatus.FEATURE_STATE_DISABLED;  
14.     }  
15.     return mWifiDisplayOnSetting ? WifiDisplayStatus.FEATURE_STATE_ON :  
16.             WifiDisplayStatus.FEATURE_STATE_OFF;  
17. }  

直接回调WifiDisplayListener的onFeatureStateChanged，从上面的图我们可以看着WifiDisplayListener会由WifiDisplayAdapter注册的，去看这部分的实现：

[java]  view plain copy

1.     public void onFeatureStateChanged(int featureState) {  
2.         synchronized (getSyncRoot()) {  
3.             if (mFeatureState != featureState) {  
4.                 mFeatureState = featureState;  
5.                 scheduleStatusChangedBroadcastLocked();  
6.             }  
7.         }  
8.     }  
9.   
10. private void scheduleStatusChangedBroadcastLocked() {  
11.     mCurrentStatus = null;  
12.     if (!mPendingStatusChangeBroadcast) {  
13.         mPendingStatusChangeBroadcast = true;  
14.         mHandler.sendEmptyMessage(MSG_SEND_STATUS_CHANGE_BROADCAST);  
15.     }  
16. }  

这里最后通过WifiDisplayHandler的sendEmptyMessage的方法实现，目的是不要卡住了WifiDisplayController后面代码的执行，来看WifiDisplayHandler如何处理MSG_SEND_STATUS_CHANGE_BROADCAST：

[java]  view plain copy

1. public void handleMessage(Message msg) {  
2.     switch (msg.what) {  
3.         case MSG_SEND_STATUS_CHANGE_BROADCAST:  
4.             handleSendStatusChangeBroadcast();  
5.             break;  
6.   
7.         case MSG_UPDATE_NOTIFICATION:  
8.             handleUpdateNotification();  
9.             break;  
10.     }  
11.   
12. ate void handleSendStatusChangeBroadcast() {  
13. final Intent intent;  
14. synchronized (getSyncRoot()) {  
15.     if (!mPendingStatusChangeBroadcast) {  
16.         return;  
17.     }  
18.   
19.     mPendingStatusChangeBroadcast = false;  
20.     intent = new Intent(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED);  
21.     intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);  
22.     intent.putExtra(DisplayManager.EXTRA_WIFI_DISPLAY_STATUS,  
23.             getWifiDisplayStatusLocked());  
24. }  
25.   
26. // Send protected broadcast about wifi display status to registered receivers.  
27. getContext().sendBroadcastAsUser(intent, UserHandle.ALL);  

上面的代码都比较简单，在getWifiDisplayStatusLocked中会根据WifiDisplayAdapter中的变量mFeatureState、mScanState、mActiveDisplayState、mActiveDisplay、mDisplays、mSessionInfo去构造一个WifiDisplayStatus对象，在前面我们介绍过这几个变量的含义了，当然这几个变量会从WifiDisplayListener的各个callback分别去改变自己的值。接着我们到MediaRouter中去看如何处理这个broadcastReceiver，前面我们已经讲过了，WifiDisplayStatusChangedReceiver会接收这个broadcast，然后调用updateWifiDisplayStatus来更新状态，我们稍后来看这部分的实现。回到WifiDisplayController的updateWfdEnableState方法中，接着会调用updateScanState方法开始扫描WifiDisplay设备：

[java]  view plain copy

1. private void updateScanState() {  
2.     if (mScanRequested && mWfdEnabled && mDesiredDevice == null) {  
3.         if (!mDiscoverPeersInProgress) {  
4.             Slog.i(TAG, "Starting Wifi display scan.");  
5.             mDiscoverPeersInProgress = true;  
6.             handleScanStarted();  
7.             tryDiscoverPeers();  
8.         }  
9.     }  

handleScanStarted用于通知WifiDisplayAdapter扫描开始了，当然WifiDisplayAdapter也会发broadcast给MediaRouter。接着会调用tryDiscoverPeers：

[java]  view plain copy

1. private void tryDiscoverPeers() {  
2.     mWifiP2pManager.discoverPeers(mWifiP2pChannel, new ActionListener() {  
3.         @Override  
4.         public void onSuccess() {  
5.             if (DEBUG) {  
6.                 Slog.d(TAG, "Discover peers succeeded.  Requesting peers now.");  
7.             }  
8.             if (mDiscoverPeersInProgress) {  
9.                 requestPeers();  
10.             }  
11.         }  
12.     mHandler.postDelayed(mDiscoverPeers, DISCOVER_PEERS_INTERVAL_MILLIS);  
13. }  

这里调用WifiP2pManager的discoverPeers去扫描所有的p2p设备，比较重要是后面有发一个delay message，表示每间隔10秒就去发一下P2P_FIND。当然下了P2P_FIND命令后，并不能马上获取到对方设备，但因为我们前面有讲过在/data/system/display-manager-state.xml有保存过前面连接过的设备列表，所以这里会马上调用requestPeers去获取设备列表。当然在WifiDisplayController也会注册对WIFI_P2P_PEERS_CHANGED_ACTION的receiver，最终还是会调用reqeustPeers去获取所有扫描到的设备列表，下面来看这个函数的实现：

[java]  view plain copy

1. private void requestPeers() {  
2.     mWifiP2pManager.requestPeers(mWifiP2pChannel, new PeerListListener() {  
3.         @Override  
4.         public void onPeersAvailable(WifiP2pDeviceList peers) {  
5.             if (DEBUG) {  
6.                 Slog.d(TAG, "Received list of peers.");  
7.             }  
8.   
9.             mAvailableWifiDisplayPeers.clear();  
10.             for (WifiP2pDevice device : peers.getDeviceList()) {  
11.                 if (DEBUG) {  
12.                     Slog.d(TAG, "  " + describeWifiP2pDevice(device));  
13.                 }  
14.   
15.                 if (isWifiDisplay(device)) {  
16.                     mAvailableWifiDisplayPeers.add(device);  
17.                 }  
18.             }  
19.   
20.             if (mDiscoverPeersInProgress) {  
21.                 handleScanResults();  
22.             }  
23.         }  
24.     });  
25. }  

首先从扫描的设备列表中过滤掉不能做wifi display的设备，主要从三个方面过滤，一是纯粹的P2P设备，不会待用WfdInfo；第二是带有WfdInfo，但是暂时没有被enable；三是只能是PrimarySinkDevice，看起来Android还不支持SecondSink。并将过滤掉剩下的设备加入到mAvailableWifiDisplayPeers列表中，接着调用handleScanResults来组装WifiDisplay列表数组并notify给WifiDisplayAdapter：

[java]  view plain copy

1. private void handleScanResults() {  
2.     final int count = mAvailableWifiDisplayPeers.size();  
3.     final WifiDisplay[] displays = WifiDisplay.CREATOR.newArray(count);  
4.     for (int i = 0; i < count; i++) {  
5.         WifiP2pDevice device = mAvailableWifiDisplayPeers.get(i);  
6.         displays[i] = createWifiDisplay(device);  
7.         updateDesiredDevice(device);  
8.     }  
9.   
10.     mHandler.post(new Runnable() {  
11.         @Override  
12.         public void run() {  
13.             mListener.onScanResults(displays);  
14.         }  
15.     });  
16. }  

这里首先根据mAvailableWifiDisplayPeers的数目创建一个WifiDisplay数组，然后一个个构造WifiDisplay对象，WifiDiplay对象包含以下几个变量：

mDeviceAddress	设备的Mac地址
mDeviceName	设备的名字
mDeviceAlias	设备的别名，一般为NULL
mIsAvailable	是否可用状态
mCanConnect	WfdInfo中的SessionAvailable是否为1
mIsRemembered	是否被记录的

接着调用updateDesiredDevice用于判断扫描到的这个设备是否是现在正在连接或者连接上的设备，如果是，则更新它的一些信息，以后在连接Wifi display的时候再来分析这一块。接着就会向WifiDisplayAdapter回调onScanResults，回调函数中带有已经扫描到的wifi display设备列表（如果有）：

[java]  view plain copy

1. public void onScanResults(WifiDisplay[] availableDisplays) {  
2.     synchronized (getSyncRoot()) {  
3.         availableDisplays = mPersistentDataStore.applyWifiDisplayAliases(  
4.                 availableDisplays);  
5.   
6.         boolean changed = !Arrays.equals(mAvailableDisplays, availableDisplays);  
7.   
8.         // Check whether any of the available displays changed canConnect status.  
9.         for (int i = 0; !changed && i<availableDisplays.length; i++) {  
10.             changed = availableDisplays[i].canConnect()  
11.                     != mAvailableDisplays[i].canConnect();  
12.         }  
13.   
14.         if (changed) {  
15.             mAvailableDisplays = availableDisplays;  
16.             fixRememberedDisplayNamesFromAvailableDisplaysLocked();  
17.             updateDisplaysLocked();  
18.             scheduleStatusChangedBroadcastLocked();  
19.         }  
20.     }  
21. }  

这里首先调用PersistentDateStore的applyWifiDisplayAliases方法去判断扫描到的设备中有没有以前连接过并记录下来的wifi display设备，比较方法是比较两者的MAC地址，如果在PersistentDateStore中找到，再比较两者的别名（Alias），如果不相同则更新results列表，细节的代码可以看applyWifiDisplayAlias中的实现。

[java]  view plain copy

1. public WifiDisplay[] applyWifiDisplayAliases(WifiDisplay[] displays) {  
2.     WifiDisplay[] results = displays;  
3.     if (results != null) {  
4.         int count = displays.length;  
5.         for (int i = 0; i < count; i++) {  
6.             WifiDisplay result = applyWifiDisplayAlias(displays[i]);  
7.             if (result != displays[i]) {  
8.                 if (results == displays) {  
9.                     results = new WifiDisplay[count];  
10.                     System.arraycopy(displays, 0, results, 0, count);  
11.                 }  
12.                 results[i] = result;  
13.             }  
14.         }  
15.     }  
16.     return results;  
17. }  

回到上面的onScanResults中，接着判断刚扫描到的设备列表（availableDisplays）和之前存储的设备列表（mAvailableDisplays）之间有没有变化，可以数组内容以及是否可连两个方面检查。如果有变化，则把刚扫描到的设备列表（availableDisplays）赋值给存储的设备列表（mAvailableDisplays）。接下来调用fixRememberedDisplayNamesFromAvailableDisplaysLocked来更新PersistentDateStore中存储的已经连接过的wifi display设备，更新的条件是设备的MAC地址一样，但设备的DeviceName和DeviceAlias有变化，这是就要更新到PersistentDateStore中，代码如下：

[java]  view plain copy

1. private void fixRememberedDisplayNamesFromAvailableDisplaysLocked() {  
2.     boolean changed = false;  
3.     for (int i = 0; i < mRememberedDisplays.length; i++) {  
4.         WifiDisplay rememberedDisplay = mRememberedDisplays[i];  
5.         WifiDisplay availableDisplay = findAvailableDisplayLocked(  
6.                 rememberedDisplay.getDeviceAddress());  
7.         if (availableDisplay != null && !rememberedDisplay.equals(availableDisplay)) {  
8.             mRememberedDisplays[i] = availableDisplay;  
9.             changed |= mPersistentDataStore.rememberWifiDisplay(availableDisplay);  
10.         }  
11.     }  
12.     if (changed) {  
13.         mPersistentDataStore.saveIfNeeded();  
14.     }  
15. }  

如果扫描到的设备列表中有wifi display设备的名字或者别名发生了变化，就会调用到PersistentDataStore.saveIfNeeded方法把数据写到/data/system/display-manager-state.xml中。

回到onScanResults中，接下来会调用updateDisplaysLocked来更新返回给MediaRouter的设备列表信息，在这里会把扫描到的设备以及之前存储下来的设备做一次合并，共同保存到mDisplays数组中，后面在发送broadcast的时候，就会把mDisplays保存到WifiDisplayStatus对象中，并在broadcast带上这个对象。

[java]  view plain copy

1. private void updateDisplaysLocked() {  
2.     List<WifiDisplay> displays = new ArrayList<WifiDisplay>(  
3.             mAvailableDisplays.length + mRememberedDisplays.length);  
4.     boolean[] remembered = new boolean[mAvailableDisplays.length];  
5.     for (WifiDisplay d : mRememberedDisplays) {  
6.         boolean available = false;  
7.         for (int i = 0; i < mAvailableDisplays.length; i++) {  
8.             if (d.equals(mAvailableDisplays[i])) {  
9.                 remembered[i] = available = true;  
10.                 break;  
11.             }  
12.         }  
13.         if (!available) {  
14.             displays.add(new WifiDisplay(d.getDeviceAddress(), d.getDeviceName(),  
15.                     d.getDeviceAlias(), false, false, true));  
16.         }  
17.     }  
18.     for (int i = 0; i < mAvailableDisplays.length; i++) {  
19.         WifiDisplay d = mAvailableDisplays[i];  
20.         displays.add(new WifiDisplay(d.getDeviceAddress(), d.getDeviceName(),  
21.                 d.getDeviceAlias(), true, d.canConnect(), remembered[i]));  
22.     }  
23.     mDisplays = displays.toArray(WifiDisplay.EMPTY_ARRAY);  
24. }  

上面的实现中先从mRememberedDisplays逐个添加wifi display设备到displays数组中，如果在mAvailableDisplays有相同的设备，则不添加到displays数组；后面再把mAvailableDisplays所有元素添加到displays数组，并全部赋值给mDisplays数组。

再回到onScanResults中，就会调用scheduleStatusChangedBroadcastLocked向WifiDisplayHandler发送MSG_SEND_STATUS_CHANGE_BROADCAST消息，这个我们在前面已经讲过了，然后会发送broadcast，并带上一个WifiDisplayStatus对象。现在我们再到MediaRouter和WifiDisplaySettings中看如何处理这个broadcast，先来看MediaRouter如何解析WifiDisplayStatus对象。updateWifiDisplayStatus的实现如下：

[java]  view plain copy

1. static void updateWifiDisplayStatus(WifiDisplayStatus status) {  
2.     WifiDisplay[] displays;  
3.     WifiDisplay activeDisplay;  
4.     if (status.getFeatureState() == WifiDisplayStatus.FEATURE_STATE_ON) {  
5.         displays = status.getDisplays();  
6.         activeDisplay = status.getActiveDisplay();  
7.     } else {  
8.         displays = WifiDisplay.EMPTY_ARRAY;  
9.         activeDisplay = null;  
10.     }  
11.     String activeDisplayAddress = activeDisplay != null ?  
12.             activeDisplay.getDeviceAddress() : null;  
13.   
14.     // Add or update routes.  
15.     for (int i = 0; i < displays.length; i++) {  
16.         final WifiDisplay d = displays[i];  
17.         if (shouldShowWifiDisplay(d, activeDisplay)) {  
18.             RouteInfo route = findWifiDisplayRoute(d);  
19.             if (route == null) {  
20.                 route = makeWifiDisplayRoute(d, status);  
21.                 addRouteStatic(route);  
22.             } else {  
23.                 String address = d.getDeviceAddress();  
24.                 boolean disconnected = !address.equals(activeDisplayAddress)  
25.                         && address.equals(sStatic.mPreviousActiveWifiDisplayAddress);  
26.                 updateWifiDisplayRoute(route, d, status, disconnected);  
27.             }  
28.             if (d.equals(activeDisplay)) {  
29.                 selectRouteStatic(route.getSupportedTypes(), route, false);  
30.             }  
31.         }  
32.     }  
33.   
34.     // Remove stale routes.  
35.     for (int i = sStatic.mRoutes.size(); i-- > 0; ) {  
36.         RouteInfo route = sStatic.mRoutes.get(i);  
37.         if (route.mDeviceAddress != null) {  
38.             WifiDisplay d = findWifiDisplay(displays, route.mDeviceAddress);  
39.             if (d == null || !shouldShowWifiDisplay(d, activeDisplay)) {  
40.                 removeRouteStatic(route);  
41.             }  
42.         }  
43.     }  
44.   
45.     sStatic.mPreviousActiveWifiDisplayAddress = activeDisplayAddress;  
46. }  

上面的代码中，首先从WifiDisplayStatus取出已经扫描到的WifiDisplay设备数组和当前处于连接状态的WifiDisplay设备，然后shouldShowWifiDisplay用于过滤是否将这个wifi display设备加入到mRoutes数组中，判断条件是这个设备已经连过并且有保存在PersistentDateStore或者这个设备就是当前正在连接中的设备，对于其它的设备并没有加入到mRoutes中，这里就有个疑问了，其它没连过的设备将在哪里加入呢？ 我们后面分析WifiDisplaySettings再来看这部分。如果在mRoutes没有找到相同的wifi display设备，就会把这个设备加入到mRoutes中，并通知WifiDisplaySettings相应的变化；如果在mRoutes存在相同的wifi display设备，则检查它的名字或者状态（available、canConnect）有没有变化，如果有变化，则通知WifiDisplaySettings相应的改变。selectRouteStatic用于更新是否默认的router并dispatch相应的回调消息。最后会从mRoutes踢出有错误的wifi display设备。

我的一些简单理解：MediaRouter只保存已经配对上的remote display设备，包括Wifi diplay、蓝牙A2DP设备、chromecast设备等，用于提供给其它应用程序使用，比如youtube可以直接chromecast，当我们前面有成功和一个chromecast设备配对过后，youtube应用就可以从MediaRouter对象中获取到当前已经配对的chromecast设备信息，并可以把youtube的视频推送到chromecast上面播放；再举个例子，百度视频应用可以访问MediaRouter中的wifi display设备，当我们设备中有已经连接或已经保存的wifi display设备时，就可以很方便的从直接百度视频上面直接开始wifi display，而不需要用户再去Settings里面扫描连接。

再来看WifiDisplaySettings中如何处理MSG_SEND_STATUS_CHANGE_BROADCAST：

[java]  view plain copy

1. private final BroadcastReceiver mReceiver = new BroadcastReceiver() {  
2.     @Override  
3.     public void onReceive(Context context, Intent intent) {  
4.         String action = intent.getAction();  
5.         if (action.equals(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED)) {  
6.             scheduleUpdate(CHANGE_WIFI_DISPLAY_STATUS);  
7.         }  
8.     }  
9. };  

从MediaRouter中的callback消息也会进入到scheduleUpdate中，只是后面的参数不一样，通过callback进来的参数是CHANGE_ROUTES，而broadcast进来的参数是CHANGE_WIFI_DISPLAY_STATUS，来看scheduleUpdate，最终实现是mUpdateRunnable 中：

[java]  view plain copy

1. private void update(int changes) {  
2.     boolean invalidateOptions = false;  
3.   
4.     // Update wifi display state.  
5.     if ((changes & CHANGE_WIFI_DISPLAY_STATUS) != 0) {  
6.         mWifiDisplayStatus = mDisplayManager.getWifiDisplayStatus();  
7.   
8.         // The wifi display feature state may have changed.  
9.         invalidateOptions = true;  
10.     }  
11.   
12.     // Rebuild the routes.  
13.     final PreferenceScreen preferenceScreen = getPreferenceScreen();  
14.     preferenceScreen.removeAll();  
15.   
16.     // Add all known remote display routes.  
17.     final int routeCount = mRouter.getRouteCount();  
18.     for (int i = 0; i < routeCount; i++) {  
19.         MediaRouter.RouteInfo route = mRouter.getRouteAt(i);  
20.         if (route.matchesTypes(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY)) {  
21.             preferenceScreen.addPreference(createRoutePreference(route));  
22.         }  
23.     }  
24.   
25.     // Additional features for wifi display routes.  
26.     if (mWifiDisplayStatus != null  
27.             && mWifiDisplayStatus.getFeatureState() == WifiDisplayStatus.FEATURE_STATE_ON) {  
28.         // Add all unpaired wifi displays.  
29.         for (WifiDisplay display : mWifiDisplayStatus.getDisplays()) {  
30.             if (!display.isRemembered() && display.isAvailable()  
31.                     && !display.equals(mWifiDisplayStatus.getActiveDisplay())) {  
32.                 preferenceScreen.addPreference(new UnpairedWifiDisplayPreference(  
33.                         getActivity(), display));  
34.             }  
35.         }  
36.     }  
37.   
38. }  

上面的代码比较简单，一个是从MediaRouter中获取mRoutes数组中存着的remote display设备；一个是从broadcast中的WifiDisplayStatus对象中获取mDisplay数组，两者相互合并构建整个listview展现给用户。至此，wifi display的扫描流程就介绍完了，下面是整体的流程图：