| /* |
| * 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.app; |
| |
| import static android.support.v7.media.MediaRouter.RouteInfo.CONNECTION_STATE_CONNECTED; |
| import static android.support.v7.media.MediaRouter.RouteInfo.CONNECTION_STATE_CONNECTING; |
| |
| import android.content.Context; |
| import android.content.res.TypedArray; |
| import android.graphics.drawable.Drawable; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.support.annotation.NonNull; |
| import android.support.v7.media.MediaRouteSelector; |
| import android.support.v7.media.MediaRouter; |
| import android.support.v7.mediarouter.R; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.view.Gravity; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.AdapterView; |
| import android.widget.ArrayAdapter; |
| import android.widget.ImageView; |
| import android.widget.ListView; |
| import android.widget.TextView; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.List; |
| |
| /** |
| * This class implements the route chooser dialog for {@link MediaRouter}. |
| * <p> |
| * This dialog allows the user to choose a route that matches a given selector. |
| * </p> |
| * |
| * @see MediaRouteButton |
| * @see MediaRouteActionProvider |
| */ |
| public class MediaRouteChooserDialog extends AppCompatDialog { |
| static final String TAG = "MediaRouteChooserDialog"; |
| |
| // Do not update the route list immediately to avoid unnatural dialog change. |
| private static final long UPDATE_ROUTES_DELAY_MS = 300L; |
| static final int MSG_UPDATE_ROUTES = 1; |
| |
| private final MediaRouter mRouter; |
| private final MediaRouterCallback mCallback; |
| |
| private TextView mTitleView; |
| private MediaRouteSelector mSelector = MediaRouteSelector.EMPTY; |
| private ArrayList<MediaRouter.RouteInfo> mRoutes; |
| private RouteAdapter mAdapter; |
| private ListView mListView; |
| private boolean mAttachedToWindow; |
| private long mLastUpdateTime; |
| private final Handler mHandler = new Handler() { |
| @Override |
| public void handleMessage(Message message) { |
| switch (message.what) { |
| case MSG_UPDATE_ROUTES: |
| updateRoutes((List<MediaRouter.RouteInfo>) message.obj); |
| break; |
| } |
| } |
| }; |
| |
| public MediaRouteChooserDialog(Context context) { |
| this(context, 0); |
| } |
| |
| public MediaRouteChooserDialog(Context context, int theme) { |
| // If we pass theme ID of 0 to AppCompatDialog, it will apply dialogTheme on the context, |
| // which may override our style settings. Passes our uppermost theme ID to prevent this. |
| super(MediaRouterThemeHelper.createThemedContext(context, theme), |
| theme == 0 ? MediaRouterThemeHelper.createThemeForDialog(context, theme) : theme); |
| context = getContext(); |
| |
| mRouter = MediaRouter.getInstance(context); |
| mCallback = new MediaRouterCallback(); |
| } |
| |
| /** |
| * Gets the media route selector for filtering the routes that the user can select. |
| * |
| * @return The selector, never null. |
| */ |
| @NonNull |
| public MediaRouteSelector getRouteSelector() { |
| return mSelector; |
| } |
| |
| /** |
| * Sets the media route selector for filtering the routes that the user can select. |
| * |
| * @param selector The selector, must not be null. |
| */ |
| public void setRouteSelector(@NonNull MediaRouteSelector selector) { |
| if (selector == null) { |
| throw new IllegalArgumentException("selector must not be null"); |
| } |
| |
| if (!mSelector.equals(selector)) { |
| mSelector = selector; |
| |
| if (mAttachedToWindow) { |
| mRouter.removeCallback(mCallback); |
| mRouter.addCallback(selector, mCallback, |
| MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN); |
| } |
| |
| refreshRoutes(); |
| } |
| } |
| |
| /** |
| * Called to filter the set of routes that should be included in the list. |
| * <p> |
| * The default implementation iterates over all routes in the provided list and |
| * removes those for which {@link #onFilterRoute} returns false. |
| * </p> |
| * |
| * @param routes The list of routes to filter in-place, never null. |
| */ |
| public void onFilterRoutes(@NonNull List<MediaRouter.RouteInfo> routes) { |
| for (int i = routes.size(); i-- > 0; ) { |
| if (!onFilterRoute(routes.get(i))) { |
| routes.remove(i); |
| } |
| } |
| } |
| |
| /** |
| * Returns true if the route should be included in the list. |
| * <p> |
| * The default implementation returns true for enabled non-default routes that |
| * match the selector. Subclasses can override this method to filter routes |
| * differently. |
| * </p> |
| * |
| * @param route The route to consider, never null. |
| * @return True if the route should be included in the chooser dialog. |
| */ |
| public boolean onFilterRoute(@NonNull MediaRouter.RouteInfo route) { |
| return !route.isDefaultOrBluetooth() && route.isEnabled() |
| && route.matchesSelector(mSelector); |
| } |
| |
| @Override |
| public void setTitle(CharSequence title) { |
| mTitleView.setText(title); |
| } |
| |
| @Override |
| public void setTitle(int titleId) { |
| mTitleView.setText(titleId); |
| } |
| |
| @Override |
| protected void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| |
| setContentView(R.layout.mr_chooser_dialog); |
| |
| mRoutes = new ArrayList<>(); |
| mAdapter = new RouteAdapter(getContext(), mRoutes); |
| mListView = (ListView)findViewById(R.id.mr_chooser_list); |
| mListView.setAdapter(mAdapter); |
| mListView.setOnItemClickListener(mAdapter); |
| mListView.setEmptyView(findViewById(android.R.id.empty)); |
| mTitleView = findViewById(R.id.mr_chooser_title); |
| |
| updateLayout(); |
| } |
| |
| /** |
| * Sets the width of the dialog. Also called when configuration changes. |
| */ |
| void updateLayout() { |
| getWindow().setLayout(MediaRouteDialogHelper.getDialogWidth(getContext()), |
| ViewGroup.LayoutParams.WRAP_CONTENT); |
| } |
| |
| @Override |
| public void onAttachedToWindow() { |
| super.onAttachedToWindow(); |
| |
| mAttachedToWindow = true; |
| mRouter.addCallback(mSelector, mCallback, MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN); |
| refreshRoutes(); |
| } |
| |
| @Override |
| public void onDetachedFromWindow() { |
| mAttachedToWindow = false; |
| mRouter.removeCallback(mCallback); |
| mHandler.removeMessages(MSG_UPDATE_ROUTES); |
| |
| super.onDetachedFromWindow(); |
| } |
| |
| /** |
| * Refreshes the list of routes that are shown in the chooser dialog. |
| */ |
| public void refreshRoutes() { |
| if (mAttachedToWindow) { |
| ArrayList<MediaRouter.RouteInfo> routes = new ArrayList<>(mRouter.getRoutes()); |
| onFilterRoutes(routes); |
| Collections.sort(routes, RouteComparator.sInstance); |
| if (SystemClock.uptimeMillis() - mLastUpdateTime >= UPDATE_ROUTES_DELAY_MS) { |
| updateRoutes(routes); |
| } else { |
| mHandler.removeMessages(MSG_UPDATE_ROUTES); |
| mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_UPDATE_ROUTES, routes), |
| mLastUpdateTime + UPDATE_ROUTES_DELAY_MS); |
| } |
| } |
| } |
| |
| void updateRoutes(List<MediaRouter.RouteInfo> routes) { |
| mLastUpdateTime = SystemClock.uptimeMillis(); |
| mRoutes.clear(); |
| mRoutes.addAll(routes); |
| mAdapter.notifyDataSetChanged(); |
| } |
| |
| private final class RouteAdapter extends ArrayAdapter<MediaRouter.RouteInfo> |
| implements ListView.OnItemClickListener { |
| private final LayoutInflater mInflater; |
| private final Drawable mDefaultIcon; |
| private final Drawable mTvIcon; |
| private final Drawable mSpeakerIcon; |
| private final Drawable mSpeakerGroupIcon; |
| |
| public RouteAdapter(Context context, List<MediaRouter.RouteInfo> routes) { |
| super(context, 0, routes); |
| mInflater = LayoutInflater.from(context); |
| TypedArray styledAttributes = getContext().obtainStyledAttributes(new int[] { |
| R.attr.mediaRouteDefaultIconDrawable, |
| R.attr.mediaRouteTvIconDrawable, |
| R.attr.mediaRouteSpeakerIconDrawable, |
| R.attr.mediaRouteSpeakerGroupIconDrawable}); |
| mDefaultIcon = styledAttributes.getDrawable(0); |
| mTvIcon = styledAttributes.getDrawable(1); |
| mSpeakerIcon = styledAttributes.getDrawable(2); |
| mSpeakerGroupIcon = styledAttributes.getDrawable(3); |
| styledAttributes.recycle(); |
| } |
| |
| @Override |
| public boolean areAllItemsEnabled() { |
| return false; |
| } |
| |
| @Override |
| public boolean isEnabled(int position) { |
| return getItem(position).isEnabled(); |
| } |
| |
| @Override |
| public View getView(int position, View convertView, ViewGroup parent) { |
| View view = convertView; |
| if (view == null) { |
| view = mInflater.inflate(R.layout.mr_chooser_list_item, parent, false); |
| } |
| |
| MediaRouter.RouteInfo route = getItem(position); |
| TextView text1 = (TextView) view.findViewById(R.id.mr_chooser_route_name); |
| TextView text2 = (TextView) view.findViewById(R.id.mr_chooser_route_desc); |
| text1.setText(route.getName()); |
| String description = route.getDescription(); |
| boolean isConnectedOrConnecting = |
| route.getConnectionState() == CONNECTION_STATE_CONNECTED |
| || route.getConnectionState() == CONNECTION_STATE_CONNECTING; |
| if (isConnectedOrConnecting && !TextUtils.isEmpty(description)) { |
| text1.setGravity(Gravity.BOTTOM); |
| text2.setVisibility(View.VISIBLE); |
| text2.setText(description); |
| } else { |
| text1.setGravity(Gravity.CENTER_VERTICAL); |
| text2.setVisibility(View.GONE); |
| text2.setText(""); |
| } |
| view.setEnabled(route.isEnabled()); |
| |
| ImageView iconView = (ImageView) view.findViewById(R.id.mr_chooser_route_icon); |
| if (iconView != null) { |
| iconView.setImageDrawable(getIconDrawable(route)); |
| } |
| return view; |
| } |
| |
| @Override |
| public void onItemClick(AdapterView<?> parent, View view, int position, long id) { |
| MediaRouter.RouteInfo route = getItem(position); |
| if (route.isEnabled()) { |
| route.select(); |
| dismiss(); |
| } |
| } |
| |
| private Drawable getIconDrawable(MediaRouter.RouteInfo route) { |
| Uri iconUri = route.getIconUri(); |
| if (iconUri != null) { |
| try { |
| InputStream is = getContext().getContentResolver().openInputStream(iconUri); |
| Drawable drawable = Drawable.createFromStream(is, null); |
| if (drawable != null) { |
| return drawable; |
| } |
| } catch (IOException e) { |
| Log.w(TAG, "Failed to load " + iconUri, e); |
| // Falls back. |
| } |
| } |
| return getDefaultIconDrawable(route); |
| } |
| |
| private Drawable getDefaultIconDrawable(MediaRouter.RouteInfo route) { |
| // If the type of the receiver device is specified, use it. |
| switch (route.getDeviceType()) { |
| case MediaRouter.RouteInfo.DEVICE_TYPE_TV: |
| return mTvIcon; |
| case MediaRouter.RouteInfo.DEVICE_TYPE_SPEAKER: |
| return mSpeakerIcon; |
| } |
| |
| // Otherwise, make the best guess based on other route information. |
| if (route instanceof MediaRouter.RouteGroup) { |
| // Only speakers can be grouped for now. |
| return mSpeakerGroupIcon; |
| } |
| return mDefaultIcon; |
| } |
| } |
| |
| private final class MediaRouterCallback extends MediaRouter.Callback { |
| MediaRouterCallback() { |
| } |
| |
| @Override |
| public void onRouteAdded(MediaRouter router, MediaRouter.RouteInfo info) { |
| refreshRoutes(); |
| } |
| |
| @Override |
| public void onRouteRemoved(MediaRouter router, MediaRouter.RouteInfo info) { |
| refreshRoutes(); |
| } |
| |
| @Override |
| public void onRouteChanged(MediaRouter router, MediaRouter.RouteInfo info) { |
| refreshRoutes(); |
| } |
| |
| @Override |
| public void onRouteSelected(MediaRouter router, MediaRouter.RouteInfo route) { |
| dismiss(); |
| } |
| } |
| |
| static final class RouteComparator implements Comparator<MediaRouter.RouteInfo> { |
| public static final RouteComparator sInstance = new RouteComparator(); |
| |
| @Override |
| public int compare(MediaRouter.RouteInfo lhs, MediaRouter.RouteInfo rhs) { |
| return lhs.getName().compareToIgnoreCase(rhs.getName()); |
| } |
| } |
| } |