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

网址:http://www.2cto.com/kf/201404/290996.html

 

最近在学习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方法:

 

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


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

 

 

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


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

 

 

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


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

 

 

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


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

 

 

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


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

 

 

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


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连接/断开等。

 

 

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

 

这里主要注册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方法,代码如下:

 

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


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

 

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

 

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


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

 

 

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



 

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

 

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

上面接收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:

 

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

 

 

Enable WifiDisplay

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

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


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

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


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

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


这个函数体比较长,主要通过注册的一系列的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中去分析:

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


当初次进入到WifiDisplaySettings中,并没有去optionMenu中enable wifi display时,上面code中的mWfdEnabled为false,所以会跳出前面的if语句;后面的else语句中mDiscoverPeersInProgress也为false,因为这个变量只有在scan时才会被置为true。 
接着来分析当用户点击了optionMenu中enable wifi display后的流程,先看WifiDisplaySettings的代码:

?
1
2
3
4
5
6
7
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case MENU_ID_ENABLE_WIFI_DISPLAY:
            mWifiDisplayOnSetting = !item.isChecked();
            item.setChecked(mWifiDisplayOnSetting);
            Settings.Global.putInt(getContentResolver(),
                    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的代码:

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


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

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


首先调用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的实现:

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


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

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


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

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

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


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

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


这里调用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去获取所有扫描到的设备列表,下面来看这个函数的实现:

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


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

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


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

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


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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
        public void onScanResults(WifiDisplay[] availableDisplays) {
            synchronized (getSyncRoot()) {
                availableDisplays = mPersistentDataStore.applyWifiDisplayAliases(
                        availableDisplays);
                boolean changed = !Arrays.equals(mAvailableDisplays, availableDisplays);
                // Check whether any of the available displays changed canConnect status.
                for (int i = 0; !changed && i<br>
这里首先调用PersistentDateStore的applyWifiDisplayAliases方法去判断扫描到的设备中有没有以前连接过并记录下来的wifi display设备,比较方法是比较两者的MAC地址,如果在PersistentDateStore中找到,再比较两者的别名(Alias),如果不相同则更新results列表,细节的代码可以看applyWifiDisplayAlias中的实现。
<pre class="brush:java;">    public WifiDisplay[] applyWifiDisplayAliases(WifiDisplay[] displays) {
        WifiDisplay[] results = displays;
        if (results != null) {
            int count = displays.length;
            for (int i = 0; i < count; i++) {
                WifiDisplay result = applyWifiDisplayAlias(displays[i]);
                if (result != displays[i]) {
                    if (results == displays) {
                        results = new WifiDisplay[count];
                        System.arraycopy(displays, 0, results, 0, count);
                    }
                    results[i] = result;
                }
            }
        }
        return results;
    }</pre><br>
回到上面的onScanResults中,接着判断刚扫描到的设备列表(availableDisplays)和之前存储的设备列表(mAvailableDisplays)之间有没有变化,可以数组内容以及是否可连两个方面检查。如果有变化,则把刚扫描到的设备列表(availableDisplays)赋值给存储的设备列表(mAvailableDisplays)。接下来调用fixRememberedDisplayNamesFromAvailableDisplaysLocked来更新PersistentDateStore中存储的已经连接过的wifi
 display设备,更新的条件是设备的MAC地址一样,但设备的DeviceName和DeviceAlias有变化,这是就要更新到PersistentDateStore中,代码如下:
<pre class="brush:java;">    private void fixRememberedDisplayNamesFromAvailableDisplaysLocked() {
        boolean changed = false;
        for (int i = 0; i < mRememberedDisplays.length; i++) {
            WifiDisplay rememberedDisplay = mRememberedDisplays[i];
            WifiDisplay availableDisplay = findAvailableDisplayLocked(
                    rememberedDisplay.getDeviceAddress());
            if (availableDisplay != null && !rememberedDisplay.equals(availableDisplay)) {
                mRememberedDisplays[i] = availableDisplay;
                changed |= mPersistentDataStore.rememberWifiDisplay(availableDisplay);
            }
        }
        if (changed) {
            mPersistentDataStore.saveIfNeeded();
        }
    }</pre>如果扫描到的设备列表中有wifi display设备的名字或者别名发生了变化,就会调用到PersistentDataStore.saveIfNeeded方法把数据写到/data/system/display-manager-state.xml中。
<br>
回到onScanResults中,接下来会调用updateDisplaysLocked来更新返回给MediaRouter的设备列表信息,在这里会把扫描到的设备以及之前存储下来的设备做一次合并,共同保存到mDisplays数组中,后面在发送broadcast的时候,就会把mDisplays保存到WifiDisplayStatus对象中,并在broadcast带上这个对象。
<pre class="brush:java;">    private void updateDisplaysLocked() {
        List<wifidisplay> displays = new ArrayList<wifidisplay>(
                mAvailableDisplays.length + mRememberedDisplays.length);
        boolean[] remembered = new boolean[mAvailableDisplays.length];
        for (WifiDisplay d : mRememberedDisplays) {
            boolean available = false;
            for (int i = 0; i < mAvailableDisplays.length; i++) {
                if (d.equals(mAvailableDisplays[i])) {
                    remembered[i] = available = true;
                    break;
                }
            }
            if (!available) {
                displays.add(new WifiDisplay(d.getDeviceAddress(), d.getDeviceName(),
                        d.getDeviceAlias(), false, false, true));
            }
        }
        for (int i = 0; i < mAvailableDisplays.length; i++) {
            WifiDisplay d = mAvailableDisplays[i];
            displays.add(new WifiDisplay(d.getDeviceAddress(), d.getDeviceName(),
                    d.getDeviceAlias(), true, d.canConnect(), remembered[i]));
        }
        mDisplays = displays.toArray(WifiDisplay.EMPTY_ARRAY);
    }</wifidisplay></wifidisplay></pre><br>
上面的实现中先从mRememberedDisplays逐个添加wifi display设备到displays数组中,如果在mAvailableDisplays有相同的设备,则不添加到displays数组;后面再把mAvailableDisplays所有元素添加到displays数组,并全部赋值给mDisplays数组。
<br>
再回到onScanResults中,就会调用scheduleStatusChangedBroadcastLocked向WifiDisplayHandler发送MSG_SEND_STATUS_CHANGE_BROADCAST消息,这个我们在前面已经讲过了,然后会发送broadcast,并带上一个WifiDisplayStatus对象。现在我们再到MediaRouter和WifiDisplaySettings中看如何处理这个broadcast,先来看MediaRouter如何解析WifiDisplayStatus对象。updateWifiDisplayStatus的实现如下:<br>
<pre class="brush:java;">    static void updateWifiDisplayStatus(WifiDisplayStatus status) {
        WifiDisplay[] displays;
        WifiDisplay activeDisplay;
        if (status.getFeatureState() == WifiDisplayStatus.FEATURE_STATE_ON) {
            displays = status.getDisplays();
            activeDisplay = status.getActiveDisplay();
        } else {
            displays = WifiDisplay.EMPTY_ARRAY;
            activeDisplay = null;
        }
        String activeDisplayAddress = activeDisplay != null ?
                activeDisplay.getDeviceAddress() : null;
        // Add or update routes.
        for (int i = 0; i < displays.length; i++) {
            final WifiDisplay d = displays[i];
            if (shouldShowWifiDisplay(d, activeDisplay)) {
                RouteInfo route = findWifiDisplayRoute(d);
                if (route == null) {
                    route = makeWifiDisplayRoute(d, status);
                    addRouteStatic(route);
                } else {
                    String address = d.getDeviceAddress();
                    boolean disconnected = !address.equals(activeDisplayAddress)
                            && address.equals(sStatic.mPreviousActiveWifiDisplayAddress);
                    updateWifiDisplayRoute(route, d, status, disconnected);
                }
                if (d.equals(activeDisplay)) {
                    selectRouteStatic(route.getSupportedTypes(), route, false);
                }
            }
        }
        // Remove stale routes.
        for (int i = sStatic.mRoutes.size(); i-- > 0; ) {
            RouteInfo route = sStatic.mRoutes.get(i);
            if (route.mDeviceAddress != null) {
                WifiDisplay d = findWifiDisplay(displays, route.mDeviceAddress);
                if (d == null || !shouldShowWifiDisplay(d, activeDisplay)) {
                    removeRouteStatic(route);
                }
            }
        }
        sStatic.mPreviousActiveWifiDisplayAddress = activeDisplayAddress;
    }</pre>
<br>
上面的代码中,首先从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设备。
<br>
我的一些简单理解:MediaRouter只保存已经配对上的remote display设备,包括Wifi diplay、蓝牙A2DP设备、chromecast设备等,用于提供给其它应用程序使用,比如youtube可以直接chromecast,当我们前面有成功和一个chromecast设备配对过后,youtube应用就可以从MediaRouter对象中获取到当前已经配对的chromecast设备信息,并可以把youtube的视频推送到chromecast上面播放;再举个例子,百度视频应用可以访问MediaRouter中的wifi
 display设备,当我们设备中有已经连接或已经保存的wifi display设备时,就可以很方便的从直接百度视频上面直接开始wifi display,而不需要用户再去Settings里面扫描连接。
<br>
再来看WifiDisplaySettings中如何处理MSG_SEND_STATUS_CHANGE_BROADCAST:
<pre class="brush:java;">    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED)) {
                scheduleUpdate(CHANGE_WIFI_DISPLAY_STATUS);
            }
        }
    };</pre><br>
从MediaRouter中的callback消息也会进入到scheduleUpdate中,只是后面的参数不一样,通过callback进来的参数是CHANGE_ROUTES,而broadcast进来的参数是CHANGE_WIFI_DISPLAY_STATUS,来看scheduleUpdate,最终实现是mUpdateRunnable<strong>中:</strong>
<pre class="brush:java;">    private void update(int changes) {
        boolean invalidateOptions = false;
        // Update wifi display state.
        if ((changes & CHANGE_WIFI_DISPLAY_STATUS) != 0) {
            mWifiDisplayStatus = mDisplayManager.getWifiDisplayStatus();
            // The wifi display feature state may have changed.
            invalidateOptions = true;
        }
        // Rebuild the routes.
        final PreferenceScreen preferenceScreen = getPreferenceScreen();
        preferenceScreen.removeAll();
        // Add all known remote display routes.
        final int routeCount = mRouter.getRouteCount();
        for (int i = 0; i < routeCount; i++) {
            MediaRouter.RouteInfo route = mRouter.getRouteAt(i);
            if (route.matchesTypes(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY)) {
                preferenceScreen.addPreference(createRoutePreference(route));
            }
        }
        // Additional features for wifi display routes.
        if (mWifiDisplayStatus != null
                && mWifiDisplayStatus.getFeatureState() == WifiDisplayStatus.FEATURE_STATE_ON) {
            // Add all unpaired wifi displays.
            for (WifiDisplay display : mWifiDisplayStatus.getDisplays()) {
                if (!display.isRemembered() && display.isAvailable()
                        && !display.equals(mWifiDisplayStatus.getActiveDisplay())) {
                    preferenceScreen.addPreference(new UnpairedWifiDisplayPreference(
                            getActivity(), display));
                }
            }
        }
    }</pre><br>
上面的代码比较简单,一个是从MediaRouter中获取mRoutes数组中存着的remote display设备;一个是从broadcast中的WifiDisplayStatus对象中获取mDisplay数组,两者相互合并构建整个listview展现给用户。至此,wifi display的扫描流程就介绍完了,下面是整体的流程图:
<img src="http://www.2cto.com/uploadfile/Collfiles/20140405/201404050

转载于:https://www.cnblogs.com/senior-engineer/p/4971396.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/375359.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Cortex-A15 Memory Hierarchy

ARM 平台为实现速度和成本的平衡&#xff0c;使用多个层次的内存架构。对于多核 CPU 组成的 SOC&#xff0c;每个CPU 内部都有一组高速缓存&#xff0c;包含&#xff1a;ICache、DCache 和 TLB。多个 CPU 共享一个更大的 L2 缓存。L2缓存再和 CPU 外部的DDR3 内存交互。ICache …

Android 图片的缩略图

<1>简介 之前往往是通过Bitmap、Drawable和Canvas配合完成&#xff0c;需要写一系列繁杂的逻辑去缩小原有图片&#xff0c;从而得到缩略图。 现在我给大家介绍一种比较简单的方法&#xff1a;&#xff08;网上有&#xff09; 在Android 2.2版本中&#xff0c;新增了一个T…

《JavaScript权威指南》学习笔记 第二天 下好一盘大棋

前段学习js的时候总是零零散散的&#xff0c;以至于很多东西都模棱两可。时间稍微一久&#xff0c;就容易忘记。最主要的原因是这些东西&#xff0c;原来学的时候就不是太懂&#xff0c;以至于和其他知识无法形成记忆链&#xff0c;所以孤零零的知识特别容易忘记。重温犀牛书&a…

SUID或SGID程序中能不能用system函数

system()函数的声明和说明如下&#xff1a; 注意它的描述那里&#xff0c;system()执行一个由command参数定义的命令&#xff0c;通过调用/bin/sh -c命令来实现这个功能。也就是说它的逻辑是这样的&#xff01; 进程调用system函数&#xff0c;system函数调用fork创建一个子进程…

Xamarin iOS编写第一个应用程序创建工程

Xamarin iOS编写第一个应用程序创建工程 在Xcode以及Xamarin安装好后&#xff0c;就可以在Xamarin Studio中编写程序了。本节将主要讲解在Xamarin Studio中如何进行工程的创建以及编写代码等内容XamariniOS编写第一个应用程序创建工程本文选自Xamarin iOS开发实战大学霸。 1.3.…

Birt使用总结

把report放到其他服务器要重新建立Data Source ,这是配置&#xff0c;拷贝项目时不会同时拷贝 (1)在EXTJs中利用Report实现报表的刷新 Ext.getCmp("showview").body.update("<iframe idshowviewframe src" "> </iframe>"…

【线性代数公开课MIT Linear Algebra】 第二十三课 微分方程与exp(At)

本系列笔记为方便日后自己查阅而写&#xff0c;更多的是个人见解&#xff0c;也算一种学习的复习与总结&#xff0c;望善始善终吧~ 一阶常系数微分方程 Aududt 将一阶常系数微分方程转换为线性代数问题的关键在于常系数微分方程的解一定是指数形式的。那么我们的需要求解的东西…

iOS学习之基本概念

学习iOS最重要的是态度和兴趣&#xff0c;如果你对于学习始终抱有不断的热情和端正的态度&#xff0c;那么&#xff0c;无论是什么&#xff0c;你总会成功的&#xff01; 有一句话与大家共勉&#xff1a;过程中跌倒多少次都没有关系&#xff0c;重要的是&#xff0c;跌倒后你能…

【转】gvim配置及相关插件安装

0.准备软件及插件。(a)gvim72.exe 地址ftp://ftp.vim.org/pub/vim/pc/gvim72.exe。(b)vimcdoc-1.7.0-setup.exe 地址http://prdownloads.sourceforge.net/vimcdoc/vimcdoc-1.7.0-setup.exe?download(c)ec57w32.zip 地址http://prdownloads.sourceforge.net/ctags/ec57w32.zip(…

Android 高级编程 RecyclerView 控件的使用

RecyclerView 是Android 新添加的一个用来取代ListView的控件&#xff0c;它的灵活性与可替代性比listview更好。 看一下继承关系&#xff1a; ava.lang.Object ↳android.view.View ↳android.view.ViewGroup ↳android.support.v7.widget.RecyclerViewKnown Direct …

jquery判断一个div的边界是否超出另外一个div的边界

摘要&#xff1a;本文简单介绍jquery判断一个div的边界是否超出另外一个div的边界&#xff0c;如果超出边界做出相应的处理。 1、实现效果 判断前 判断后 2、实现思路 实现类似的判断&#xff0c;主要是获取两个div在浏览器中的上下左右的四至&#xff0c;在jquery中&#xff0…

maven环境快速搭建(转)

最近&#xff0c;开发中要用到maven&#xff0c;所以对maven进行了简单的学习。因为有个maven高手在身边&#xff0c;所以&#xff0c;很快就上手了&#xff0c;我这里算是自我总结吧。关于maven是什么东东&#xff0c;请参考其它文章。 ----------------准备工作-------------…

cocos2d-x3.0 相对布局(一)

2dx相对布局和Android非常类似。假设前完成Android它应该是easy入门。Size widgetSize Director::getInstance()->getWinSize();Text* alert Text::create("Layout", "fonts/Marker Felt.ttf", 30 );alert->setColor(Color3B(159, 168, 176));aler…

夺命雷公狗---ECSHOP---08---商品页的拇改成星星

<strong>用户评价&#xff1a;</strong>{*---------商品评价星星开始----------*}<img src"./images/stars{$goods.comment_rank}.gif" alt"comment rank {$goods.comment_rank}">{*---------商品评价星星结束-------*} 这里主要是要有星…

文件指针

一.移动文件指针 SetFilePointer,hFile,lDistanceToMove,lpDistanceToMoveHigh,dwMoveMethod dwMoveMethod 指明移动的模式 FILE_BEGIN 不管文件处于什么地方,总是从文件的头部开始移动,这时的位置参数相当于指定了一个绝对位置 FILE_CURRENT 从当前的文件指针处开始移…

见证下的自我变化-2014全年总结

又是一年总结季&#xff0c;回过头看看看自己的成长&#xff0c;心里真的是满满的喜悦之情…… 一年前自己的总结博客&#xff1a;http://blog.csdn.net/huo065000/article/details/19632603 半年前自己的总结博客&#xff1a;http://blog.csdn.net/huo065000/article/details/…

【Linux学习篇】This virtual machine is configured for 64-bit guest operating systems.……

在学习Linux的基本操作的时候&#xff0c;安装虚拟环境则提示自己 This virtualmachine is configured for 64-bit guest operatingsystems.……起初由于各种拒绝的心理&#xff0c;所以屏蔽了这个错误&#xff0c;但是屏蔽永远也解决不了问题的&#xff0c;所以自己则尝试百度…

图解SSIS监视文件夹并自动导入数据

图解SSIS监视文件夹并自动导入数据 原文:图解SSIS监视文件夹并自动导入数据 演示案例&#xff1a;让系统自动监视文件夹&#xff0c;并把文件夹下面的excel文件导入到sql中&#xff0c;之后清空目录。这个过程以往都需要写程序来实现或者定时执行&#xff0c;现在可以用ssis来订…

WP8手机解锁时提示“请确保IPOVERUSBSVC服务正常运行”解决方法

如果你各种重启服务 卸载手机 重装驱动都试过了还不行&#xff0c;请看看你是否安装了Hyper-v或Vitualbox虚拟机&#xff0c;很有可能是虚拟交换机造成的。 我在网络连接属性里看到这个 把它卸载后&#xff0c;解锁成功。 解锁后记得重新安装卸载的那个网络服务转载于:https://…

浮点数的存储

-------------------------------------------------------------------------------- 在VC6.0----float环境一共32位 其中第一位是符号位 第二到第9位中间8位为小数点位置&#xff08;指数以127的二进制为原点向下为负指数 向上为正指数&#xff09;后面23位为数据位。 S EE…