/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.support.v7.media;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Resources;
import android.media.AudioManager;
import android.os.Build;
import android.support.v7.mediarouter.R;
import android.view.Display;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
/**
* Provides routes for built-in system destinations such as the local display
* and speaker. On Jellybean and newer platform releases, queries the framework
* MediaRouter for framework-provided routes and registers non-framework-provided
* routes as user routes.
*/
abstract class SystemMediaRouteProvider extends MediaRouteProvider {
private static final String TAG = "SystemMediaRouteProvider";
public static final String PACKAGE_NAME = "android";
public static final String DEFAULT_ROUTE_ID = "DEFAULT_ROUTE";
protected SystemMediaRouteProvider(Context context) {
super(context, new ProviderMetadata(new ComponentName(PACKAGE_NAME,
SystemMediaRouteProvider.class.getName())));
}
public static SystemMediaRouteProvider obtain(Context context, SyncCallback syncCallback) {
if (Build.VERSION.SDK_INT >= 18) {
return new JellybeanMr2Impl(context, syncCallback);
}
if (Build.VERSION.SDK_INT >= 17) {
return new JellybeanMr1Impl(context, syncCallback);
}
if (Build.VERSION.SDK_INT >= 16) {
return new JellybeanImpl(context, syncCallback);
}
return new LegacyImpl(context);
}
/**
* Called by the media router when a route is added to synchronize state with
* the framework media router.
*/
public void onSyncRouteAdded(MediaRouter.RouteInfo route) {
}
/**
* Called by the media router when a route is removed to synchronize state with
* the framework media router.
*/
public void onSyncRouteRemoved(MediaRouter.RouteInfo route) {
}
/**
* Called by the media router when a route is changed to synchronize state with
* the framework media router.
*/
public void onSyncRouteChanged(MediaRouter.RouteInfo route) {
}
/**
* Called by the media router when a route is selected to synchronize state with
* the framework media router.
*/
public void onSyncRouteSelected(MediaRouter.RouteInfo route) {
}
/**
* Callbacks into the media router to synchronize state with the framework media router.
*/
public interface SyncCallback {
public MediaRouter.RouteInfo getSystemRouteByDescriptorId(String id);
}
/**
* Legacy implementation for platform versions prior to Jellybean.
*/
static class LegacyImpl extends SystemMediaRouteProvider {
private static final int PLAYBACK_STREAM = AudioManager.STREAM_MUSIC;
private static final ArrayList<IntentFilter> CONTROL_FILTERS;
static {
IntentFilter f = new IntentFilter();
f.addCategory(MediaControlIntent.CATEGORY_LIVE_AUDIO);
f.addCategory(MediaControlIntent.CATEGORY_LIVE_VIDEO);
CONTROL_FILTERS = new ArrayList<IntentFilter>();
CONTROL_FILTERS.add(f);
}
private final AudioManager mAudioManager;
private final VolumeChangeReceiver mVolumeChangeReceiver;
private int mLastReportedVolume = -1;
public LegacyImpl(Context context) {
super(context);
mAudioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
mVolumeChangeReceiver = new VolumeChangeReceiver();
context.registerReceiver(mVolumeChangeReceiver,
new IntentFilter(VolumeChangeReceiver.VOLUME_CHANGED_ACTION));
publishRoutes();
}
private void publishRoutes() {
Resources r = getContext().getResources();
int maxVolume = mAudioManager.getStreamMaxVolume(PLAYBACK_STREAM);
mLastReportedVolume = mAudioManager.getStreamVolume(PLAYBACK_STREAM);
MediaRouteDescriptor defaultRoute = new MediaRouteDescriptor.Builder(
DEFAULT_ROUTE_ID, r.getString(R.string.mr_system_route_name))
.addControlFilters(CONTROL_FILTERS)
.setPlaybackStream(PLAYBACK_STREAM)
.setPlaybackType(MediaRouter.RouteInfo.PLAYBACK_TYPE_LOCAL)
.setVolumeHandling(MediaRouter.RouteInfo.PLAYBACK_VOLUME_VARIABLE)
.setVolumeMax(maxVolume)
.setVolume(mLastReportedVolume)
.build();
MediaRouteProviderDescriptor providerDescriptor =
new MediaRouteProviderDescriptor.Builder()
.addRoute(defaultRoute)
.build();
setDescriptor(providerDescriptor);
}
@Override
public RouteController onCreateRouteController(String routeId) {
if (routeId.equals(DEFAULT_ROUTE_ID)) {
return new DefaultRouteController();
}
return null;
}
final class DefaultRouteController extends RouteController {
@Override
public void onSetVolume(int volume) {
mAudioManager.setStreamVolume(PLAYBACK_STREAM, volume, 0);
publishRoutes();
}
@Override
public void onUpdateVolume(int delta) {
int volume = mAudioManager.getStreamVolume(PLAYBACK_STREAM);
int maxVolume = mAudioManager.getStreamMaxVolume(PLAYBACK_STREAM);
int newVolume = Math.min(maxVolume, Math.max(0, volume + delta));
if (newVolume != volume) {
mAudioManager.setStreamVolume(PLAYBACK_STREAM, volume, 0);
}
publishRoutes();
}
}
final class VolumeChangeReceiver extends BroadcastReceiver {
// These constants come from AudioManager.
public static final String VOLUME_CHANGED_ACTION =
"android.media.VOLUME_CHANGED_ACTION";
public static final String EXTRA_VOLUME_STREAM_TYPE =
"android.media.EXTRA_VOLUME_STREAM_TYPE";
public static final String EXTRA_VOLUME_STREAM_VALUE =
"android.media.EXTRA_VOLUME_STREAM_VALUE";
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(VOLUME_CHANGED_ACTION)) {
final int streamType = intent.getIntExtra(EXTRA_VOLUME_STREAM_TYPE, -1);
if (streamType == PLAYBACK_STREAM) {
final int volume = intent.getIntExtra(EXTRA_VOLUME_STREAM_VALUE, -1);
if (volume >= 0 && volume != mLastReportedVolume) {
publishRoutes();
}
}
}
}
}
}
/**
* Jellybean implementation.
*/
static class JellybeanImpl extends SystemMediaRouteProvider
implements MediaRouterJellybean.Callback, MediaRouterJellybean.VolumeCallback {
private static final ArrayList<IntentFilter> LIVE_AUDIO_CONTROL_FILTERS;
static {
IntentFilter f = new IntentFilter();
f.addCategory(MediaControlIntent.CATEGORY_LIVE_AUDIO);
LIVE_AUDIO_CONTROL_FILTERS = new ArrayList<IntentFilter>();
LIVE_AUDIO_CONTROL_FILTERS.add(f);
}
private static final ArrayList<IntentFilter> LIVE_VIDEO_CONTROL_FILTERS;
static {
IntentFilter f = new IntentFilter();
f.addCategory(MediaControlIntent.CATEGORY_LIVE_VIDEO);
LIVE_VIDEO_CONTROL_FILTERS = new ArrayList<IntentFilter>();
LIVE_VIDEO_CONTROL_FILTERS.add(f);
}
private final SyncCallback mSyncCallback;
protected final Object mRouterObj;
protected final Object mCallbackObj;
protected final Object mVolumeCallbackObj;
protected final Object mUserRouteCategoryObj;
protected int mRouteTypes;
protected boolean mActiveScan;
protected boolean mCallbackRegistered;
// Maintains an association from framework routes to support library routes.
// Note that we cannot use the tag field for this because an application may
// have published its own user routes to the framework media router and already
// used the tag for its own purposes.
protected final ArrayList<SystemRouteRecord> mSystemRouteRecords =
new ArrayList<SystemRouteRecord>();
// Maintains an association from support library routes to framework routes.
protected final ArrayList<UserRouteRecord> mUserRouteRecords =
new ArrayList<UserRouteRecord>();
private MediaRouterJellybean.SelectRouteWorkaround mSelectRouteWorkaround;
private MediaRouterJellybean.GetDefaultRouteWorkaround mGetDefaultRouteWorkaround;
public JellybeanImpl(Context context, SyncCallback syncCallback) {
super(context);
mSyncCallback = syncCallback;
mRouterObj = MediaRouterJellybean.getMediaRouter(context);
mCallbackObj = createCallbackObj();
mVolumeCallbackObj = createVolumeCallbackObj();
Resources r = context.getResources();
mUserRouteCategoryObj = MediaRouterJellybean.createRouteCategory(
mRouterObj, r.getString(R.string.mr_user_route_category_name), false);
updateSystemRoutes();
}
@Override
public RouteController onCreateRouteController(String routeId) {
int index = findSystemRouteRecordByDescriptorId(routeId);
if (index >= 0) {
SystemRouteRecord record = mSystemRouteRecords.get(index);
return new SystemRouteController(record.mRouteObj);
}
return null;
}
@Override
public void onDiscoveryRequestChanged(MediaRouteDiscoveryRequest request) {
int newRouteTypes = 0;
boolean newActiveScan = false;
if (request != null) {
final MediaRouteSelector selector = request.getSelector();
final List<String> categories = selector.getControlCategories();
final int count = categories.size();
for (int i = 0; i < count; i++) {
String category = categories.get(i);
if (category.equals(MediaControlIntent.CATEGORY_LIVE_AUDIO)) {
newRouteTypes |= MediaRouterJellybean.ROUTE_TYPE_LIVE_AUDIO;
} else if (category.equals(MediaControlIntent.CATEGORY_LIVE_VIDEO)) {
newRouteTypes |= MediaRouterJellybean.ROUTE_TYPE_LIVE_VIDEO;
} else {
newRouteTypes |= MediaRouterJellybean.ROUTE_TYPE_USER;
}
}
newActiveScan = request.isActiveScan();
}
if (mRouteTypes != newRouteTypes || mActiveScan != newActiveScan) {
mRouteTypes = newRouteTypes;
mActiveScan = newActiveScan;
updateCallback();
updateSystemRoutes();
}
}
@Override
public void onRouteAdded(Object routeObj) {
if (addSystemRouteNoPublish(routeObj)) {
publishRoutes();
}
}
private void updateSystemRoutes() {
boolean changed = false;
for (Object routeObj : MediaRouterJellybean.getRoutes(mRouterObj)) {
changed |= addSystemRouteNoPublish(routeObj);
}
if (changed) {
publishRoutes();
}
}
private boolean addSystemRouteNoPublish(Object routeObj) {
if (getUserRouteRecord(routeObj) == null
&& findSystemRouteRecord(routeObj) < 0) {
String id = assignRouteId(routeObj);
SystemRouteRecord record = new SystemRouteRecord(routeObj, id);
updateSystemRouteDescriptor(record);
mSystemRouteRecords.add(record);
return true;
}
return false;
}
private String assignRouteId(Object routeObj) {
// TODO: The framework media router should supply a unique route id that
// we can use here. For now we use a hash of the route name and take care
// to dedupe it.
boolean isDefault = (getDefaultRoute() == routeObj);
String id = isDefault ? DEFAULT_ROUTE_ID :
String.format(Locale.US, "ROUTE_%08x", getRouteName(routeObj).hashCode());
if (findSystemRouteRecordByDescriptorId(id) < 0) {
return id;
}
for (int i = 2; ; i++) {
String newId = String.format(Locale.US, "%s_%d", id, i);
if (findSystemRouteRecordByDescriptorId(newId) < 0) {
return newId;
}
}
}
@Override
public void onRouteRemoved(Object routeObj) {
if (getUserRouteRecord(routeObj) == null) {
int index = findSystemRouteRecord(routeObj);
if (index >= 0) {
mSystemRouteRecords.remove(index);
publishRoutes();
}
}
}
@Override
public void onRouteChanged(Object routeObj) {
if (getUserRouteRecord(routeObj) == null) {
int index = findSystemRouteRecord(routeObj);
if (index >= 0) {
SystemRouteRecord record = mSystemRouteRecords.get(index);
updateSystemRouteDescriptor(record);
publishRoutes();
}
}
}
@Override
public void onRouteVolumeChanged(Object routeObj) {
if (getUserRouteRecord(routeObj) == null) {
int index = findSystemRouteRecord(routeObj);
if (index >= 0) {
SystemRouteRecord record = mSystemRouteRecords.get(index);
int newVolume = MediaRouterJellybean.RouteInfo.getVolume(routeObj);
if (newVolume != record.mRouteDescriptor.getVolume()) {
record.mRouteDescriptor =
new MediaRouteDescriptor.Builder(record.mRouteDescriptor)
.setVolume(newVolume)
.build();
publishRoutes();
}
}
}
}
@Override
public void onRouteSelected(int type, Object routeObj) {
if (routeObj != MediaRouterJellybean.getSelectedRoute(mRouterObj,
MediaRouterJellybean.ALL_ROUTE_TYPES)) {
// The currently selected route has already changed so this callback
// is stale. Drop it to prevent getting into sync loops.
return;
}
UserRouteRecord userRouteRecord = getUserRouteRecord(routeObj);
if (userRouteRecord != null) {
userRouteRecord.mRoute.select();
} else {
// Select the route if it already exists in the compat media router.
// If not, we will select it instead when the route is added.
int index = findSystemRouteRecord(routeObj);
if (index >= 0) {
SystemRouteRecord record = mSystemRouteRecords.get(index);
MediaRouter.RouteInfo route = mSyncCallback.getSystemRouteByDescriptorId(
record.mRouteDescriptorId);
if (route != null) {
route.select();
}
}
}
}
@Override
public void onRouteUnselected(int type, Object routeObj) {
// Nothing to do when a route is unselected.
// We only need to handle when a route is selected.
}
@Override
public void onRouteGrouped(Object routeObj, Object groupObj, int index) {
// Route grouping is deprecated and no longer supported.
}
@Override
public void onRouteUngrouped(Object routeObj, Object groupObj) {
// Route grouping is deprecated and no longer supported.
}
@Override
public void onVolumeSetRequest(Object routeObj, int volume) {
UserRouteRecord record = getUserRouteRecord(routeObj);
if (record != null) {
record.mRoute.requestSetVolume(volume);
}
}
@Override
public void onVolumeUpdateRequest(Object routeObj, int direction) {
UserRouteRecord record = getUserRouteRecord(routeObj);
if (record != null) {
record.mRoute.requestUpdateVolume(direction);
}
}
@Override
public void onSyncRouteAdded(MediaRouter.RouteInfo route) {
if (route.getProviderInstance() != this) {
Object routeObj = MediaRouterJellybean.createUserRoute(
mRouterObj, mUserRouteCategoryObj);
UserRouteRecord record = new UserRouteRecord(route, routeObj);
MediaRouterJellybean.RouteInfo.setTag(routeObj, record);
MediaRouterJellybean.UserRouteInfo.setVolumeCallback(routeObj, mVolumeCallbackObj);
updateUserRouteProperties(record);
mUserRouteRecords.add(record);
MediaRouterJellybean.addUserRoute(mRouterObj, routeObj);
} else {
// If the newly added route is the counterpart of the currently selected
// route in the framework media router then ensure it is selected in
// the compat media router.
Object routeObj = MediaRouterJellybean.getSelectedRoute(
mRouterObj, MediaRouterJellybean.ALL_ROUTE_TYPES);
int index = findSystemRouteRecord(routeObj);
if (index >= 0) {
SystemRouteRecord record = mSystemRouteRecords.get(index);
if (record.mRouteDescriptorId.equals(route.getDescriptorId())) {
route.select();
}
}
}
}
@Override
public void onSyncRouteRemoved(MediaRouter.RouteInfo route) {
if (route.getProviderInstance() != this) {
int index = findUserRouteRecord(route);
if (index >= 0) {
UserRouteRecord record = mUserRouteRecords.remove(index);
MediaRouterJellybean.RouteInfo.setTag(record.mRouteObj, null);
MediaRouterJellybean.UserRouteInfo.setVolumeCallback(record.mRouteObj, null);
MediaRouterJellybean.removeUserRoute(mRouterObj, record.mRouteObj);
}
}
}
@Override
public void onSyncRouteChanged(MediaRouter.RouteInfo route) {
if (route.getProviderInstance() != this) {
int index = findUserRouteRecord(route);
if (index >= 0) {
UserRouteRecord record = mUserRouteRecords.get(index);
updateUserRouteProperties(record);
}
}
}
@Override
public void onSyncRouteSelected(MediaRouter.RouteInfo route) {
if (!route.isSelected()) {
// The currently selected route has already changed so this callback
// is stale. Drop it to prevent getting into sync loops.
return;
}
if (route.getProviderInstance() != this) {
int index = findUserRouteRecord(route);
if (index >= 0) {
UserRouteRecord record = mUserRouteRecords.get(index);
selectRoute(record.mRouteObj);
}
} else {
int index = findSystemRouteRecordByDescriptorId(route.getDescriptorId());
if (index >= 0) {
SystemRouteRecord record = mSystemRouteRecords.get(index);
selectRoute(record.mRouteObj);
}
}
}
protected void publishRoutes() {
MediaRouteProviderDescriptor.Builder builder =
new MediaRouteProviderDescriptor.Builder();
int count = mSystemRouteRecords.size();
for (int i = 0; i < count; i++) {
builder.addRoute(mSystemRouteRecords.get(i).mRouteDescriptor);
}
setDescriptor(builder.build());
}
protected int findSystemRouteRecord(Object routeObj) {
final int count = mSystemRouteRecords.size();
for (int i = 0; i < count; i++) {
if (mSystemRouteRecords.get(i).mRouteObj == routeObj) {
return i;
}
}
return -1;
}
protected int findSystemRouteRecordByDescriptorId(String id) {
final int count = mSystemRouteRecords.size();
for (int i = 0; i < count; i++) {
if (mSystemRouteRecords.get(i).mRouteDescriptorId.equals(id)) {
return i;
}
}
return -1;
}
protected int findUserRouteRecord(MediaRouter.RouteInfo route) {
final int count = mUserRouteRecords.size();
for (int i = 0; i < count; i++) {
if (mUserRouteRecords.get(i).mRoute == route) {
return i;
}
}
return -1;
}
protected UserRouteRecord getUserRouteRecord(Object routeObj) {
Object tag = MediaRouterJellybean.RouteInfo.getTag(routeObj);
return tag instanceof UserRouteRecord ? (UserRouteRecord)tag : null;
}
protected void updateSystemRouteDescriptor(SystemRouteRecord record) {
// We must always recreate the route descriptor when making any changes
// because they are intended to be immutable once published.
MediaRouteDescriptor.Builder builder = new MediaRouteDescriptor.Builder(
record.mRouteDescriptorId, getRouteName(record.mRouteObj));
onBuildSystemRouteDescriptor(record, builder);
record.mRouteDescriptor = builder.build();
}
protected String getRouteName(Object routeObj) {
// Routes should not have null names but it may happen for badly configured
// user routes. We tolerate this by using an empty name string here but
// such unnamed routes will be discarded by the media router upstream
// (with a log message so we can track down the problem).
CharSequence name = MediaRouterJellybean.RouteInfo.getName(routeObj, getContext());
return name != null ? name.toString() : "";
}
protected void onBuildSystemRouteDescriptor(SystemRouteRecord record,
MediaRouteDescriptor.Builder builder) {
int supportedTypes = MediaRouterJellybean.RouteInfo.getSupportedTypes(
record.mRouteObj);
if ((supportedTypes & MediaRouterJellybean.ROUTE_TYPE_LIVE_AUDIO) != 0) {
builder.addControlFilters(LIVE_AUDIO_CONTROL_FILTERS);
}
if ((supportedTypes & MediaRouterJellybean.ROUTE_TYPE_LIVE_VIDEO) != 0) {
builder.addControlFilters(LIVE_VIDEO_CONTROL_FILTERS);
}
builder.setPlaybackType(
MediaRouterJellybean.RouteInfo.getPlaybackType(record.mRouteObj));
builder.setPlaybackStream(
MediaRouterJellybean.RouteInfo.getPlaybackStream(record.mRouteObj));
builder.setVolume(
MediaRouterJellybean.RouteInfo.getVolume(record.mRouteObj));
builder.setVolumeMax(
MediaRouterJellybean.RouteInfo.getVolumeMax(record.mRouteObj));
builder.setVolumeHandling(
MediaRouterJellybean.RouteInfo.getVolumeHandling(record.mRouteObj));
}
protected void updateUserRouteProperties(UserRouteRecord record) {
MediaRouterJellybean.UserRouteInfo.setName(
record.mRouteObj, record.mRoute.getName());
MediaRouterJellybean.UserRouteInfo.setPlaybackType(
record.mRouteObj, record.mRoute.getPlaybackType());
MediaRouterJellybean.UserRouteInfo.setPlaybackStream(
record.mRouteObj, record.mRoute.getPlaybackStream());
MediaRouterJellybean.UserRouteInfo.setVolume(
record.mRouteObj, record.mRoute.getVolume());
MediaRouterJellybean.UserRouteInfo.setVolumeMax(
record.mRouteObj, record.mRoute.getVolumeMax());
MediaRouterJellybean.UserRouteInfo.setVolumeHandling(
record.mRouteObj, record.mRoute.getVolumeHandling());
}
protected void updateCallback() {
if (mCallbackRegistered) {
mCallbackRegistered = false;
MediaRouterJellybean.removeCallback(mRouterObj, mCallbackObj);
}
if (mRouteTypes != 0) {
mCallbackRegistered = true;
MediaRouterJellybean.addCallback(mRouterObj, mRouteTypes, mCallbackObj);
}
}
protected Object createCallbackObj() {
return MediaRouterJellybean.createCallback(this);
}
protected Object createVolumeCallbackObj() {
return MediaRouterJellybean.createVolumeCallback(this);
}
protected void selectRoute(Object routeObj) {
if (mSelectRouteWorkaround == null) {
mSelectRouteWorkaround = new MediaRouterJellybean.SelectRouteWorkaround();
}
mSelectRouteWorkaround.selectRoute(mRouterObj,
MediaRouterJellybean.ALL_ROUTE_TYPES, routeObj);
}
protected Object getDefaultRoute() {
if (mGetDefaultRouteWorkaround == null) {
mGetDefaultRouteWorkaround = new MediaRouterJellybean.GetDefaultRouteWorkaround();
}
return mGetDefaultRouteWorkaround.getDefaultRoute(mRouterObj);
}
/**
* Represents a route that is provided by the framework media router
* and published by this route provider to the support library media router.
*/
protected static final class SystemRouteRecord {
public final Object mRouteObj;
public final String mRouteDescriptorId;
public MediaRouteDescriptor mRouteDescriptor; // assigned immediately after creation
public SystemRouteRecord(Object routeObj, String id) {
mRouteObj = routeObj;
mRouteDescriptorId = id;
}
}
/**
* Represents a route that is provided by the support library media router
* and published by this route provider to the framework media router.
*/
protected static final class UserRouteRecord {
public final MediaRouter.RouteInfo mRoute;
public final Object mRouteObj;
public UserRouteRecord(MediaRouter.RouteInfo route, Object routeObj) {
mRoute = route;
mRouteObj = routeObj;
}
}
protected final class SystemRouteController extends RouteController {
private final Object mRouteObj;
public SystemRouteController(Object routeObj) {
mRouteObj = routeObj;
}
@Override
public void onSetVolume(int volume) {
MediaRouterJellybean.RouteInfo.requestSetVolume(mRouteObj, volume);
}
@Override
public void onUpdateVolume(int delta) {
MediaRouterJellybean.RouteInfo.requestUpdateVolume(mRouteObj, delta);
}
}
}
/**
* Jellybean MR1 implementation.
*/
private static class JellybeanMr1Impl extends JellybeanImpl
implements MediaRouterJellybeanMr1.Callback {
private MediaRouterJellybeanMr1.ActiveScanWorkaround mActiveScanWorkaround;
private MediaRouterJellybeanMr1.IsConnectingWorkaround mIsConnectingWorkaround;
public JellybeanMr1Impl(Context context, SyncCallback syncCallback) {
super(context, syncCallback);
}
@Override
public void onRoutePresentationDisplayChanged(Object routeObj) {
int index = findSystemRouteRecord(routeObj);
if (index >= 0) {
SystemRouteRecord record = mSystemRouteRecords.get(index);
Display newPresentationDisplay =
MediaRouterJellybeanMr1.RouteInfo.getPresentationDisplay(routeObj);
int newPresentationDisplayId = (newPresentationDisplay != null
? newPresentationDisplay.getDisplayId() : -1);
if (newPresentationDisplayId
!= record.mRouteDescriptor.getPresentationDisplayId()) {
record.mRouteDescriptor =
new MediaRouteDescriptor.Builder(record.mRouteDescriptor)
.setPresentationDisplayId(newPresentationDisplayId)
.build();
publishRoutes();
}
}
}
@Override
protected void onBuildSystemRouteDescriptor(SystemRouteRecord record,
MediaRouteDescriptor.Builder builder) {
super.onBuildSystemRouteDescriptor(record, builder);
if (!MediaRouterJellybeanMr1.RouteInfo.isEnabled(record.mRouteObj)) {
builder.setEnabled(false);
}
if (isConnecting(record)) {
builder.setConnecting(true);
}
Display presentationDisplay =
MediaRouterJellybeanMr1.RouteInfo.getPresentationDisplay(record.mRouteObj);
if (presentationDisplay != null) {
builder.setPresentationDisplayId(presentationDisplay.getDisplayId());
}
}
@Override
protected void updateCallback() {
super.updateCallback();
if (mActiveScanWorkaround == null) {
mActiveScanWorkaround = new MediaRouterJellybeanMr1.ActiveScanWorkaround(
getContext(), getHandler());
}
mActiveScanWorkaround.setActiveScanRouteTypes(mActiveScan ? mRouteTypes : 0);
}
@Override
protected Object createCallbackObj() {
return MediaRouterJellybeanMr1.createCallback(this);
}
protected boolean isConnecting(SystemRouteRecord record) {
if (mIsConnectingWorkaround == null) {
mIsConnectingWorkaround = new MediaRouterJellybeanMr1.IsConnectingWorkaround();
}
return mIsConnectingWorkaround.isConnecting(record.mRouteObj);
}
}
/**
* Jellybean MR2 implementation.
*/
private static class JellybeanMr2Impl extends JellybeanMr1Impl {
public JellybeanMr2Impl(Context context, SyncCallback syncCallback) {
super(context, syncCallback);
}
@Override
protected void onBuildSystemRouteDescriptor(SystemRouteRecord record,
MediaRouteDescriptor.Builder builder) {
super.onBuildSystemRouteDescriptor(record, builder);
CharSequence description =
MediaRouterJellybeanMr2.RouteInfo.getDescription(record.mRouteObj);
if (description != null) {
builder.setDescription(description.toString());
}
}
@Override
protected void selectRoute(Object routeObj) {
MediaRouterJellybean.selectRoute(mRouterObj,
MediaRouterJellybean.ALL_ROUTE_TYPES, routeObj);
}
@Override
protected Object getDefaultRoute() {
return MediaRouterJellybeanMr2.getDefaultRoute(mRouterObj);
}
@Override
protected void updateUserRouteProperties(UserRouteRecord record) {
super.updateUserRouteProperties(record);
MediaRouterJellybeanMr2.UserRouteInfo.setDescription(
record.mRouteObj, record.mRoute.getDescription());
}
@Override
protected void updateCallback() {
if (mCallbackRegistered) {
MediaRouterJellybean.removeCallback(mRouterObj, mCallbackObj);
}
mCallbackRegistered = true;
MediaRouterJellybeanMr2.addCallback(mRouterObj, mRouteTypes, mCallbackObj,
MediaRouter.CALLBACK_FLAG_UNFILTERED_EVENTS
| (mActiveScan ? MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN : 0));
}
@Override
protected boolean isConnecting(SystemRouteRecord record) {
return MediaRouterJellybeanMr2.RouteInfo.isConnecting(record.mRouteObj);
}
}
}