media/java/android/media/MediaRouter2.java - platform/frameworks/base - Gitiles

 /*
  * Copyright 2019 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.media;

 import static com.android.internal.util.function.pooled.PooledLambda.obtainMessage;

 import static java.lang.annotation.RetentionPolicy.SOURCE;

 import android.annotation.CallbackExecutor;
 import android.annotation.IntDef;
 import android.annotation.NonNull;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.RemoteException;
 import android.os.ServiceManager;
 import android.text.TextUtils;
 import android.util.Log;

 import com.android.internal.annotations.GuardedBy;

 import java.lang.annotation.Retention;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Executor;

 /**
  * A new Media Router
  * @hide
  */
 public class MediaRouter2 {

     /** @hide */
     @Retention(SOURCE)
     @IntDef(value = {
             SELECT_REASON_UNKNOWN,
             SELECT_REASON_USER_SELECTED,
             SELECT_REASON_FALLBACK,
             SELECT_REASON_SYSTEM_SELECTED})
     public @interface SelectReason {}

     /**
      * Passed to {@link Callback#onRouteSelected(MediaRoute2Info, int, Bundle)} when the reason
      * the route was selected is unknown.
      */
     public static final int SELECT_REASON_UNKNOWN = 0;

     /**
      * Passed to {@link Callback#onRouteSelected(MediaRoute2Info, int, Bundle)} when the route
      * is selected in response to a user's request. For example, when a user has selected
      * a different device to play media to.
      */
     public static final int SELECT_REASON_USER_SELECTED = 1;

     /**
      * Passed to {@link Callback#onRouteSelected(MediaRoute2Info, int, Bundle)} when the route
      * is selected as a fallback route. For example, when Wi-Fi is disconnected, the device speaker
      * may be selected as a fallback route.
      */
     public static final int SELECT_REASON_FALLBACK = 2;

     /**
      * This is passed from {@link com.android.server.media.MediaRouterService} when the route
      * is selected in response to a request from other apps (e.g. System UI).
      * @hide
      */
     public static final int SELECT_REASON_SYSTEM_SELECTED = 3;

     private static final String TAG = "MR2";
     private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
     private static final Object sLock = new Object();

     @GuardedBy("sLock")
     private static MediaRouter2 sInstance;

     private final Context mContext;
     private final IMediaRouterService mMediaRouterService;

     private final CopyOnWriteArrayList<CallbackRecord> mCallbackRecords =
             new CopyOnWriteArrayList<>();

     private final String mPackageName;
     private final Map<String, MediaRoute2Info> mRoutes = new HashMap<>();

     //TODO: Use a lock for this to cover the below use case
     // mRouter.setControlCategories(...);
     // routes = mRouter.getRoutes();
     // The current implementation returns empty list
     private volatile List<String> mControlCategories = Collections.emptyList();

     private MediaRoute2Info mSelectedRoute;
     @GuardedBy("sLock")
     private MediaRoute2Info mSelectingRoute;
     @GuardedBy("sLock")
     private Client2 mClient;

     final Handler mHandler;
     volatile List<MediaRoute2Info> mFilteredRoutes = Collections.emptyList();

     /**
      * Gets an instance of the media router associated with the context.
      */
     public static MediaRouter2 getInstance(@NonNull Context context) {
         Objects.requireNonNull(context, "context must not be null");
         synchronized (sLock) {
             if (sInstance == null) {
                 sInstance = new MediaRouter2(context.getApplicationContext());
             }
             return sInstance;
         }
     }

     private MediaRouter2(Context appContext) {
         mContext = appContext;
         mMediaRouterService = IMediaRouterService.Stub.asInterface(
                 ServiceManager.getService(Context.MEDIA_ROUTER_SERVICE));
         mPackageName = mContext.getPackageName();
         //TODO: read control categories from the manifest
         mHandler = new Handler(Looper.getMainLooper());

         List<MediaRoute2Info> currentSystemRoutes = null;
         try {
             currentSystemRoutes = mMediaRouterService.getSystemRoutes();
         } catch (RemoteException ex) {
             Log.e(TAG, "Unable to get current currentSystemRoutes", ex);
         }

         if (currentSystemRoutes == null || currentSystemRoutes.isEmpty()) {
             throw new RuntimeException("Null or empty currentSystemRoutes. Something is wrong.");
         }

         for (MediaRoute2Info route : currentSystemRoutes) {
             mRoutes.put(route.getId(), route);
         }
         // The first route is the currently selected system route.
         // For example, if there are two system routes (BT and device speaker),
         // BT will be the first route in the list.
         mSelectedRoute = currentSystemRoutes.get(0);
     }

     /**
      * Registers a callback to discover routes and to receive events when they change.
      */
     public void registerCallback(@NonNull @CallbackExecutor Executor executor,
             @NonNull Callback callback) {
         registerCallback(executor, callback, 0);
     }

     /**
      * Registers a callback to discover routes and to receive events when they change.
      * <p>
      * If you register the same callback twice or more, the previous arguments will be overwritten
      * with the new arguments.
      * </p>
      */
     public void registerCallback(@NonNull @CallbackExecutor Executor executor,
             @NonNull Callback callback, int flags) {
         Objects.requireNonNull(executor, "executor must not be null");
         Objects.requireNonNull(callback, "callback must not be null");

         CallbackRecord record;
         // This is required to prevent adding the same callback twice.
         synchronized (mCallbackRecords) {
             final int index = findCallbackRecordIndexLocked(callback);
             if (index < 0) {
                 record = new CallbackRecord(callback);
                 mCallbackRecords.add(record);
             } else {
                 record = mCallbackRecords.get(index);
             }
             record.mExecutor = executor;
             record.mFlags = flags;
         }

         synchronized (sLock) {
             if (mClient == null) {
                 Client2 client = new Client2();
                 try {
                     mMediaRouterService.registerClient2(client, mPackageName);
                     mMediaRouterService.setControlCategories(client, mControlCategories);
                     mClient = client;
                 } catch (RemoteException ex) {
                     Log.e(TAG, "Unable to register media router.", ex);
                 }
             }
         }
         //TODO: Is it thread-safe?
         record.notifyRoutes();

         //TODO: Update discovery request here.
     }

     /**
      * Unregisters the given callback. The callback will no longer receive events.
      * If the callback has not been added or been removed already, it is ignored.
      *
      * @param callback the callback to unregister
      * @see #registerCallback
      */
     public void unregisterCallback(@NonNull Callback callback) {
         Objects.requireNonNull(callback, "callback must not be null");

         synchronized (mCallbackRecords) {
             final int index = findCallbackRecordIndexLocked(callback);
             if (index < 0) {
                 Log.w(TAG, "Ignoring to remove unknown callback. " + callback);
                 return;
             }
             mCallbackRecords.remove(index);
             synchronized (sLock) {
                 if (mCallbackRecords.size() == 0 && mClient != null) {
                     try {
                         mMediaRouterService.unregisterClient2(mClient);
                     } catch (RemoteException ex) {
                         Log.e(TAG, "Unable to unregister media router.", ex);
                     }
                     //TODO: Clean up mRoutes. (onHandler?)
                     mClient = null;
                 }
             }
         }
     }

     //TODO(b/139033746): Rename "Control Category" when it's finalized.
     /**
      * Sets the control categories of the application.
      * Routes that support at least one of the given control categories only exists and are handled
      * by the media router.
      */
     public void setControlCategories(@NonNull Collection<String> controlCategories) {
         Objects.requireNonNull(controlCategories, "control categories must not be null");

         // To ensure invoking callbacks correctly according to control categories
         mHandler.sendMessage(obtainMessage(MediaRouter2::setControlCategoriesOnHandler,
                 MediaRouter2.this, new ArrayList<>(controlCategories)));
     }

     /**
      * Gets the unmodifiable list of {@link MediaRoute2Info routes} currently
      * known to the media router.
      *
      * @return the list of routes that support at least one of the control categories set by
      * the application
      */
     @NonNull
     public List<MediaRoute2Info> getRoutes() {
         return mFilteredRoutes;
     }

     /**
      * Gets the currently selected route.
      *
      * @return the selected route
      */
     @NonNull
     public MediaRoute2Info getSelectedRoute() {
         return mSelectedRoute;
     }

     /**
      * Request to select the specified route. When the route is selected,
      * {@link Callback#onRouteSelected(MediaRoute2Info, int, Bundle)} will be called.
      *
      * @param route the route to select
      */
     public void requestSelectRoute(@NonNull MediaRoute2Info route) {
         Objects.requireNonNull(route, "route must not be null");

         Client2 client;
         synchronized (sLock) {
             if (mSelectingRoute == route) {
                 Log.w(TAG, "The route selection request is already sent.");
                 return;
             }
             mSelectingRoute = route;
             client = mClient;
         }
         if (client != null) {
             try {
                 mMediaRouterService.requestSelectRoute2(client, route);
             } catch (RemoteException ex) {
                 Log.e(TAG, "Unable to request to select route.", ex);
             }
         }
     }

     /**
      * Sends a media control request to be performed asynchronously by the route's destination.
      *
      * @param route the route that will receive the control request
      * @param request the media control request
      */
     //TODO: Discuss what to use for request (e.g., Intent? Request class?)
     //TODO: Provide a way to obtain the result
     public void sendControlRequest(@NonNull MediaRoute2Info route, @NonNull Intent request) {
         Objects.requireNonNull(route, "route must not be null");
         Objects.requireNonNull(request, "request must not be null");

         Client2 client;
         synchronized (sLock) {
             client = mClient;
         }
         if (client != null) {
             try {
                 mMediaRouterService.sendControlRequest(client, route, request);
             } catch (RemoteException ex) {
                 Log.e(TAG, "Unable to send control request.", ex);
             }
         }
     }

     /**
      * Requests a volume change for the route asynchronously.
      * <p>
      * It may have no effect if the route is currently not selected.
      * </p>
      *
      * @param volume The new volume value between 0 and {@link MediaRoute2Info#getVolumeMax}.
      */
     public void requestSetVolume(@NonNull MediaRoute2Info route, int volume) {
         Objects.requireNonNull(route, "route must not be null");

         Client2 client;
         synchronized (sLock) {
             client = mClient;
         }
         if (client != null) {
             try {
                 mMediaRouterService.requestSetVolume2(client, route, volume);
             } catch (RemoteException ex) {
                 Log.e(TAG, "Unable to send control request.", ex);
             }
         }
     }

     /**
      * Requests an incremental volume update  for the route asynchronously.
      * <p>
      * It may have no effect if the route is currently not selected.
      * </p>
      *
      * @param delta The delta to add to the current volume.
      */
     public void requestUpdateVolume(@NonNull MediaRoute2Info route, int delta) {
         Objects.requireNonNull(route, "route must not be null");

         Client2 client;
         synchronized (sLock) {
             client = mClient;
         }
         if (client != null) {
             try {
                 mMediaRouterService.requestUpdateVolume2(client, route, delta);
             } catch (RemoteException ex) {
                 Log.e(TAG, "Unable to send control request.", ex);
             }
         }
     }

     @GuardedBy("mCallbackRecords")
     private int findCallbackRecordIndexLocked(Callback callback) {
         final int count = mCallbackRecords.size();
         for (int i = 0; i < count; i++) {
             CallbackRecord callbackRecord = mCallbackRecords.get(i);
             if (callbackRecord.mCallback == callback) {
                 return i;
             }
         }
         return -1;
     }

     private void setControlCategoriesOnHandler(List<String> newControlCategories) {
         List<String> prevControlCategories = mControlCategories;
         List<MediaRoute2Info> addedRoutes = new ArrayList<>();
         List<MediaRoute2Info> removedRoutes = new ArrayList<>();
         List<MediaRoute2Info> filteredRoutes = new ArrayList<>();

         mControlCategories = newControlCategories;
         Client2 client;
         synchronized (sLock) {
             client = mClient;
         }
         if (client != null) {
             try {
                 mMediaRouterService.setControlCategories(client, mControlCategories);
             } catch (RemoteException ex) {
                 Log.e(TAG, "Unable to set control categories.", ex);
             }
         }

         for (MediaRoute2Info route : mRoutes.values()) {
             boolean preSupported = route.supportsControlCategory(prevControlCategories);
             boolean postSupported = route.supportsControlCategory(newControlCategories);
             if (postSupported) {
                 filteredRoutes.add(route);
             }
             if (preSupported == postSupported) {
                 continue;
             }
             if (preSupported) {
                 removedRoutes.add(route);
             } else {
                 addedRoutes.add(route);
             }
         }
         mFilteredRoutes = Collections.unmodifiableList(filteredRoutes);

         if (removedRoutes.size() > 0) {
             notifyRoutesRemoved(removedRoutes);
         }
         if (addedRoutes.size() > 0) {
             notifyRoutesAdded(addedRoutes);
         }
     }

     void addRoutesOnHandler(List<MediaRoute2Info> routes) {
         // TODO: When onRoutesAdded is first called,
         //  1) clear mRoutes before adding the routes
         //  2) Call onRouteSelected(system_route, reason_fallback) if previously selected route
         //     does not exist anymore. => We may need 'boolean MediaRoute2Info#isSystemRoute()'.
         List<MediaRoute2Info> addedRoutes = new ArrayList<>();
         for (MediaRoute2Info route : routes) {
             mRoutes.put(route.getUniqueId(), route);
             if (route.supportsControlCategory(mControlCategories)) {
                 addedRoutes.add(route);
             }
         }
         if (addedRoutes.size() > 0) {
             refreshFilteredRoutes();
             notifyRoutesAdded(addedRoutes);
         }
     }

     void removeRoutesOnHandler(List<MediaRoute2Info> routes) {
         List<MediaRoute2Info> removedRoutes = new ArrayList<>();
         for (MediaRoute2Info route : routes) {
             mRoutes.remove(route.getUniqueId());
             if (route.supportsControlCategory(mControlCategories)) {
                 removedRoutes.add(route);
             }
         }
         if (removedRoutes.size() > 0) {
             refreshFilteredRoutes();
             notifyRoutesRemoved(removedRoutes);
         }
     }

     void changeRoutesOnHandler(List<MediaRoute2Info> routes) {
         List<MediaRoute2Info> changedRoutes = new ArrayList<>();
         for (MediaRoute2Info route : routes) {
             mRoutes.put(route.getUniqueId(), route);
             if (route.supportsControlCategory(mControlCategories)) {
                 changedRoutes.add(route);
             }
         }
         if (changedRoutes.size() > 0) {
             refreshFilteredRoutes();
             notifyRoutesChanged(changedRoutes);
         }
     }

     void selectRouteOnHandler(MediaRoute2Info route, int reason, Bundle controlHints) {
         synchronized (sLock) {
             if (reason == SELECT_REASON_USER_SELECTED) {
                 if (mSelectingRoute == null
                         || !TextUtils.equals(mSelectingRoute.getUniqueId(), route.getUniqueId())) {
                     Log.w(TAG, "Ignoring invalid or outdated notifyRouteSelected call. "
                             + "selectingRoute=" + mSelectingRoute + " route=" + route);
                     return;
                 }
             }
             mSelectingRoute = null;
         }
         if (reason == SELECT_REASON_SYSTEM_SELECTED) {
             reason = SELECT_REASON_USER_SELECTED;
         }
         mSelectedRoute = route;
         notifyRouteSelected(route, reason, controlHints);
     }

     private void refreshFilteredRoutes() {
         List<MediaRoute2Info> filteredRoutes = new ArrayList<>();

         for (MediaRoute2Info route : mRoutes.values()) {
             if (route.supportsControlCategory(mControlCategories)) {
                 filteredRoutes.add(route);
             }
         }
         mFilteredRoutes = Collections.unmodifiableList(filteredRoutes);
     }

     private void notifyRoutesAdded(List<MediaRoute2Info> routes) {
         for (CallbackRecord record: mCallbackRecords) {
             record.mExecutor.execute(
                     () -> record.mCallback.onRoutesAdded(routes));
         }
     }

     private void notifyRoutesRemoved(List<MediaRoute2Info> routes) {
         for (CallbackRecord record: mCallbackRecords) {
             record.mExecutor.execute(
                     () -> record.mCallback.onRoutesRemoved(routes));
         }
     }

     private void notifyRoutesChanged(List<MediaRoute2Info> routes) {
         for (CallbackRecord record: mCallbackRecords) {
             record.mExecutor.execute(
                     () -> record.mCallback.onRoutesChanged(routes));
         }
     }

     private void notifyRouteSelected(MediaRoute2Info route, int reason, Bundle controlHints) {
         for (CallbackRecord record: mCallbackRecords) {
             record.mExecutor.execute(
                     () -> record.mCallback.onRouteSelected(route, reason, controlHints));
         }
     }

     /**
      * Interface for receiving events about media routing changes.
      */
     public static class Callback {
         /**
          * Called when routes are added.
          * @param routes the list of routes that have been added. It's never empty.
          */
         public void onRoutesAdded(@NonNull List<MediaRoute2Info> routes) {}

         /**
          * Called when routes are removed.
          * @param routes the list of routes that have been removed. It's never empty.
          */
         public void onRoutesRemoved(@NonNull List<MediaRoute2Info> routes) {}

         /**
          * Called when routes are changed. For example, it is called when the route's name
          * or volume have been changed.
          *
          * TODO: Write here what the developers should do when this method is called.
          * How they can find the exact point how a route is changed?
          * It can be a volume, name, client package name, ....
          *
          * @param routes the list of routes that have been changed. It's never empty.
          */
         public void onRoutesChanged(@NonNull List<MediaRoute2Info> routes) {}

         /**
          * Called when a route is selected. Exactly one route can be selected at a time.
          * @param route the selected route.
          * @param reason the reason why the route is selected.
          * @param controlHints An optional bundle of provider-specific arguments which may be
          *                     used to control the selected route. Can be empty.
          * @see #SELECT_REASON_UNKNOWN
          * @see #SELECT_REASON_USER_SELECTED
          * @see #SELECT_REASON_FALLBACK
          * @see #getSelectedRoute()
          */
         public void onRouteSelected(@NonNull MediaRoute2Info route, @SelectReason int reason,
                 @NonNull Bundle controlHints) {}
     }

     final class CallbackRecord {
         public final Callback mCallback;
         public Executor mExecutor;
         public int mFlags;

         CallbackRecord(@NonNull Callback callback) {
             mCallback = callback;
         }

         void notifyRoutes() {
             final List<MediaRoute2Info> routes = mFilteredRoutes;
             // notify only when bound to media router service.
             if (routes.size() > 0) {
                 mExecutor.execute(() -> mCallback.onRoutesAdded(routes));
             }
         }
     }

     class Client2 extends IMediaRouter2Client.Stub {
         @Override
         public void notifyRestoreRoute() throws RemoteException {}

         @Override
         public void notifyRoutesAdded(List<MediaRoute2Info> routes) {
             mHandler.sendMessage(obtainMessage(MediaRouter2::addRoutesOnHandler,
                     MediaRouter2.this, routes));
         }

         @Override
         public void notifyRoutesRemoved(List<MediaRoute2Info> routes) {
             mHandler.sendMessage(obtainMessage(MediaRouter2::removeRoutesOnHandler,
                     MediaRouter2.this, routes));
         }

         @Override
         public void notifyRoutesChanged(List<MediaRoute2Info> routes) {
             mHandler.sendMessage(obtainMessage(MediaRouter2::changeRoutesOnHandler,
                     MediaRouter2.this, routes));
         }

         @Override
         public void notifyRouteSelected(MediaRoute2Info route, int reason,
                 Bundle controlHints) {
             mHandler.sendMessage(obtainMessage(MediaRouter2::selectRouteOnHandler,
                     MediaRouter2.this, route, reason, controlHints));
         }
     }
 }
	/*
	* Copyright 2019 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.media;

	import static com.android.internal.util.function.pooled.PooledLambda.obtainMessage;

	import static java.lang.annotation.RetentionPolicy.SOURCE;

	import android.annotation.CallbackExecutor;
	import android.annotation.IntDef;
	import android.annotation.NonNull;
	import android.content.Context;
	import android.content.Intent;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.Looper;
	import android.os.RemoteException;
	import android.os.ServiceManager;
	import android.text.TextUtils;
	import android.util.Log;

	import com.android.internal.annotations.GuardedBy;

	import java.lang.annotation.Retention;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Objects;
	import java.util.concurrent.CopyOnWriteArrayList;
	import java.util.concurrent.Executor;

	/**
	* A new Media Router
	* @hide
	*/
	public class MediaRouter2 {

	/** @hide */
	@Retention(SOURCE)
	@IntDef(value = {
	SELECT_REASON_UNKNOWN,
	SELECT_REASON_USER_SELECTED,
	SELECT_REASON_FALLBACK,
	SELECT_REASON_SYSTEM_SELECTED})
	public @interface SelectReason {}

	/**
	* Passed to {@link Callback#onRouteSelected(MediaRoute2Info, int, Bundle)} when the reason
	* the route was selected is unknown.
	*/
	public static final int SELECT_REASON_UNKNOWN = 0;

	/**
	* Passed to {@link Callback#onRouteSelected(MediaRoute2Info, int, Bundle)} when the route
	* is selected in response to a user's request. For example, when a user has selected
	* a different device to play media to.
	*/
	public static final int SELECT_REASON_USER_SELECTED = 1;

	/**
	* Passed to {@link Callback#onRouteSelected(MediaRoute2Info, int, Bundle)} when the route
	* is selected as a fallback route. For example, when Wi-Fi is disconnected, the device speaker
	* may be selected as a fallback route.
	*/
	public static final int SELECT_REASON_FALLBACK = 2;

	/**
	* This is passed from {@link com.android.server.media.MediaRouterService} when the route
	* is selected in response to a request from other apps (e.g. System UI).
	* @hide
	*/
	public static final int SELECT_REASON_SYSTEM_SELECTED = 3;

	private static final String TAG = "MR2";
	private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
	private static final Object sLock = new Object();

	@GuardedBy("sLock")
	private static MediaRouter2 sInstance;

	private final Context mContext;
	private final IMediaRouterService mMediaRouterService;

	private final CopyOnWriteArrayList<CallbackRecord> mCallbackRecords =
	new CopyOnWriteArrayList<>();

	private final String mPackageName;
	private final Map<String, MediaRoute2Info> mRoutes = new HashMap<>();

	//TODO: Use a lock for this to cover the below use case
	// mRouter.setControlCategories(...);
	// routes = mRouter.getRoutes();
	// The current implementation returns empty list
	private volatile List<String> mControlCategories = Collections.emptyList();

	private MediaRoute2Info mSelectedRoute;
	@GuardedBy("sLock")
	private MediaRoute2Info mSelectingRoute;
	@GuardedBy("sLock")
	private Client2 mClient;

	final Handler mHandler;
	volatile List<MediaRoute2Info> mFilteredRoutes = Collections.emptyList();

	/**
	* Gets an instance of the media router associated with the context.
	*/
	public static MediaRouter2 getInstance(@NonNull Context context) {
	Objects.requireNonNull(context, "context must not be null");
	synchronized (sLock) {
	if (sInstance == null) {
	sInstance = new MediaRouter2(context.getApplicationContext());
	}
	return sInstance;
	}
	}

	private MediaRouter2(Context appContext) {
	mContext = appContext;
	mMediaRouterService = IMediaRouterService.Stub.asInterface(
	ServiceManager.getService(Context.MEDIA_ROUTER_SERVICE));
	mPackageName = mContext.getPackageName();
	//TODO: read control categories from the manifest
	mHandler = new Handler(Looper.getMainLooper());

	List<MediaRoute2Info> currentSystemRoutes = null;
	try {
	currentSystemRoutes = mMediaRouterService.getSystemRoutes();
	} catch (RemoteException ex) {
	Log.e(TAG, "Unable to get current currentSystemRoutes", ex);
	}

	if (currentSystemRoutes == null \|\| currentSystemRoutes.isEmpty()) {
	throw new RuntimeException("Null or empty currentSystemRoutes. Something is wrong.");
	}

	for (MediaRoute2Info route : currentSystemRoutes) {
	mRoutes.put(route.getId(), route);
	}
	// The first route is the currently selected system route.
	// For example, if there are two system routes (BT and device speaker),
	// BT will be the first route in the list.
	mSelectedRoute = currentSystemRoutes.get(0);
	}

	/**
	* Registers a callback to discover routes and to receive events when they change.
	*/
	public void registerCallback(@NonNull @CallbackExecutor Executor executor,
	@NonNull Callback callback) {
	registerCallback(executor, callback, 0);
	}

	/**
	* Registers a callback to discover routes and to receive events when they change.
	* <p>
	* If you register the same callback twice or more, the previous arguments will be overwritten
	* with the new arguments.
	* </p>
	*/
	public void registerCallback(@NonNull @CallbackExecutor Executor executor,
	@NonNull Callback callback, int flags) {
	Objects.requireNonNull(executor, "executor must not be null");
	Objects.requireNonNull(callback, "callback must not be null");

	CallbackRecord record;
	// This is required to prevent adding the same callback twice.
	synchronized (mCallbackRecords) {
	final int index = findCallbackRecordIndexLocked(callback);
	if (index < 0) {
	record = new CallbackRecord(callback);
	mCallbackRecords.add(record);
	} else {
	record = mCallbackRecords.get(index);
	}
	record.mExecutor = executor;
	record.mFlags = flags;
	}

	synchronized (sLock) {
	if (mClient == null) {
	Client2 client = new Client2();
	try {
	mMediaRouterService.registerClient2(client, mPackageName);
	mMediaRouterService.setControlCategories(client, mControlCategories);
	mClient = client;
	} catch (RemoteException ex) {
	Log.e(TAG, "Unable to register media router.", ex);
	}
	}
	}
	//TODO: Is it thread-safe?
	record.notifyRoutes();

	//TODO: Update discovery request here.
	}

	/**
	* Unregisters the given callback. The callback will no longer receive events.
	* If the callback has not been added or been removed already, it is ignored.
	*
	* @param callback the callback to unregister
	* @see #registerCallback
	*/
	public void unregisterCallback(@NonNull Callback callback) {
	Objects.requireNonNull(callback, "callback must not be null");

	synchronized (mCallbackRecords) {
	final int index = findCallbackRecordIndexLocked(callback);
	if (index < 0) {
	Log.w(TAG, "Ignoring to remove unknown callback. " + callback);
	return;
	}
	mCallbackRecords.remove(index);
	synchronized (sLock) {
	if (mCallbackRecords.size() == 0 && mClient != null) {
	try {
	mMediaRouterService.unregisterClient2(mClient);
	} catch (RemoteException ex) {
	Log.e(TAG, "Unable to unregister media router.", ex);
	}
	//TODO: Clean up mRoutes. (onHandler?)
	mClient = null;
	}
	}
	}
	}

	//TODO(b/139033746): Rename "Control Category" when it's finalized.
	/**
	* Sets the control categories of the application.
	* Routes that support at least one of the given control categories only exists and are handled
	* by the media router.
	*/
	public void setControlCategories(@NonNull Collection<String> controlCategories) {
	Objects.requireNonNull(controlCategories, "control categories must not be null");

	// To ensure invoking callbacks correctly according to control categories
	mHandler.sendMessage(obtainMessage(MediaRouter2::setControlCategoriesOnHandler,
	MediaRouter2.this, new ArrayList<>(controlCategories)));
	}

	/**
	* Gets the unmodifiable list of {@link MediaRoute2Info routes} currently
	* known to the media router.
	*
	* @return the list of routes that support at least one of the control categories set by
	* the application
	*/
	@NonNull
	public List<MediaRoute2Info> getRoutes() {
	return mFilteredRoutes;
	}

	/**
	* Gets the currently selected route.
	*
	* @return the selected route
	*/
	@NonNull
	public MediaRoute2Info getSelectedRoute() {
	return mSelectedRoute;
	}

	/**
	* Request to select the specified route. When the route is selected,
	* {@link Callback#onRouteSelected(MediaRoute2Info, int, Bundle)} will be called.
	*
	* @param route the route to select
	*/
	public void requestSelectRoute(@NonNull MediaRoute2Info route) {
	Objects.requireNonNull(route, "route must not be null");

	Client2 client;
	synchronized (sLock) {
	if (mSelectingRoute == route) {
	Log.w(TAG, "The route selection request is already sent.");
	return;
	}
	mSelectingRoute = route;
	client = mClient;
	}
	if (client != null) {
	try {
	mMediaRouterService.requestSelectRoute2(client, route);
	} catch (RemoteException ex) {
	Log.e(TAG, "Unable to request to select route.", ex);
	}
	}
	}

	/**
	* Sends a media control request to be performed asynchronously by the route's destination.
	*
	* @param route the route that will receive the control request
	* @param request the media control request
	*/
	//TODO: Discuss what to use for request (e.g., Intent? Request class?)
	//TODO: Provide a way to obtain the result
	public void sendControlRequest(@NonNull MediaRoute2Info route, @NonNull Intent request) {
	Objects.requireNonNull(route, "route must not be null");
	Objects.requireNonNull(request, "request must not be null");

	Client2 client;
	synchronized (sLock) {
	client = mClient;
	}
	if (client != null) {
	try {
	mMediaRouterService.sendControlRequest(client, route, request);
	} catch (RemoteException ex) {
	Log.e(TAG, "Unable to send control request.", ex);
	}
	}
	}

	/**
	* Requests a volume change for the route asynchronously.
	* <p>
	* It may have no effect if the route is currently not selected.
	* </p>
	*
	* @param volume The new volume value between 0 and {@link MediaRoute2Info#getVolumeMax}.
	*/
	public void requestSetVolume(@NonNull MediaRoute2Info route, int volume) {
	Objects.requireNonNull(route, "route must not be null");

	Client2 client;
	synchronized (sLock) {
	client = mClient;
	}
	if (client != null) {
	try {
	mMediaRouterService.requestSetVolume2(client, route, volume);
	} catch (RemoteException ex) {
	Log.e(TAG, "Unable to send control request.", ex);
	}
	}
	}

	/**
	* Requests an incremental volume update for the route asynchronously.
	* <p>
	* It may have no effect if the route is currently not selected.
	* </p>
	*
	* @param delta The delta to add to the current volume.
	*/
	public void requestUpdateVolume(@NonNull MediaRoute2Info route, int delta) {
	Objects.requireNonNull(route, "route must not be null");

	Client2 client;
	synchronized (sLock) {
	client = mClient;
	}
	if (client != null) {
	try {
	mMediaRouterService.requestUpdateVolume2(client, route, delta);
	} catch (RemoteException ex) {
	Log.e(TAG, "Unable to send control request.", ex);
	}
	}
	}

	@GuardedBy("mCallbackRecords")
	private int findCallbackRecordIndexLocked(Callback callback) {
	final int count = mCallbackRecords.size();
	for (int i = 0; i < count; i++) {
	CallbackRecord callbackRecord = mCallbackRecords.get(i);
	if (callbackRecord.mCallback == callback) {
	return i;
	}
	}
	return -1;
	}

	private void setControlCategoriesOnHandler(List<String> newControlCategories) {
	List<String> prevControlCategories = mControlCategories;
	List<MediaRoute2Info> addedRoutes = new ArrayList<>();
	List<MediaRoute2Info> removedRoutes = new ArrayList<>();
	List<MediaRoute2Info> filteredRoutes = new ArrayList<>();

	mControlCategories = newControlCategories;
	Client2 client;
	synchronized (sLock) {
	client = mClient;
	}
	if (client != null) {
	try {
	mMediaRouterService.setControlCategories(client, mControlCategories);
	} catch (RemoteException ex) {
	Log.e(TAG, "Unable to set control categories.", ex);
	}
	}

	for (MediaRoute2Info route : mRoutes.values()) {
	boolean preSupported = route.supportsControlCategory(prevControlCategories);
	boolean postSupported = route.supportsControlCategory(newControlCategories);
	if (postSupported) {
	filteredRoutes.add(route);
	}
	if (preSupported == postSupported) {
	continue;
	}
	if (preSupported) {
	removedRoutes.add(route);
	} else {
	addedRoutes.add(route);
	}
	}
	mFilteredRoutes = Collections.unmodifiableList(filteredRoutes);

	if (removedRoutes.size() > 0) {
	notifyRoutesRemoved(removedRoutes);
	}
	if (addedRoutes.size() > 0) {
	notifyRoutesAdded(addedRoutes);
	}
	}

	void addRoutesOnHandler(List<MediaRoute2Info> routes) {
	// TODO: When onRoutesAdded is first called,
	// 1) clear mRoutes before adding the routes
	// 2) Call onRouteSelected(system_route, reason_fallback) if previously selected route
	// does not exist anymore. => We may need 'boolean MediaRoute2Info#isSystemRoute()'.
	List<MediaRoute2Info> addedRoutes = new ArrayList<>();
	for (MediaRoute2Info route : routes) {
	mRoutes.put(route.getUniqueId(), route);
	if (route.supportsControlCategory(mControlCategories)) {
	addedRoutes.add(route);
	}
	}
	if (addedRoutes.size() > 0) {
	refreshFilteredRoutes();
	notifyRoutesAdded(addedRoutes);
	}
	}

	void removeRoutesOnHandler(List<MediaRoute2Info> routes) {
	List<MediaRoute2Info> removedRoutes = new ArrayList<>();
	for (MediaRoute2Info route : routes) {
	mRoutes.remove(route.getUniqueId());
	if (route.supportsControlCategory(mControlCategories)) {
	removedRoutes.add(route);
	}
	}
	if (removedRoutes.size() > 0) {
	refreshFilteredRoutes();
	notifyRoutesRemoved(removedRoutes);
	}
	}

	void changeRoutesOnHandler(List<MediaRoute2Info> routes) {
	List<MediaRoute2Info> changedRoutes = new ArrayList<>();
	for (MediaRoute2Info route : routes) {
	mRoutes.put(route.getUniqueId(), route);
	if (route.supportsControlCategory(mControlCategories)) {
	changedRoutes.add(route);
	}
	}
	if (changedRoutes.size() > 0) {
	refreshFilteredRoutes();
	notifyRoutesChanged(changedRoutes);
	}
	}

	void selectRouteOnHandler(MediaRoute2Info route, int reason, Bundle controlHints) {
	synchronized (sLock) {
	if (reason == SELECT_REASON_USER_SELECTED) {
	if (mSelectingRoute == null
	\|\| !TextUtils.equals(mSelectingRoute.getUniqueId(), route.getUniqueId())) {
	Log.w(TAG, "Ignoring invalid or outdated notifyRouteSelected call. "
	+ "selectingRoute=" + mSelectingRoute + " route=" + route);
	return;
	}
	}
	mSelectingRoute = null;
	}
	if (reason == SELECT_REASON_SYSTEM_SELECTED) {
	reason = SELECT_REASON_USER_SELECTED;
	}
	mSelectedRoute = route;
	notifyRouteSelected(route, reason, controlHints);
	}

	private void refreshFilteredRoutes() {
	List<MediaRoute2Info> filteredRoutes = new ArrayList<>();

	for (MediaRoute2Info route : mRoutes.values()) {
	if (route.supportsControlCategory(mControlCategories)) {
	filteredRoutes.add(route);
	}
	}
	mFilteredRoutes = Collections.unmodifiableList(filteredRoutes);
	}

	private void notifyRoutesAdded(List<MediaRoute2Info> routes) {
	for (CallbackRecord record: mCallbackRecords) {
	record.mExecutor.execute(
	() -> record.mCallback.onRoutesAdded(routes));
	}
	}

	private void notifyRoutesRemoved(List<MediaRoute2Info> routes) {
	for (CallbackRecord record: mCallbackRecords) {
	record.mExecutor.execute(
	() -> record.mCallback.onRoutesRemoved(routes));
	}
	}

	private void notifyRoutesChanged(List<MediaRoute2Info> routes) {
	for (CallbackRecord record: mCallbackRecords) {
	record.mExecutor.execute(
	() -> record.mCallback.onRoutesChanged(routes));
	}
	}

	private void notifyRouteSelected(MediaRoute2Info route, int reason, Bundle controlHints) {
	for (CallbackRecord record: mCallbackRecords) {
	record.mExecutor.execute(
	() -> record.mCallback.onRouteSelected(route, reason, controlHints));
	}
	}

	/**
	* Interface for receiving events about media routing changes.
	*/
	public static class Callback {
	/**
	* Called when routes are added.
	* @param routes the list of routes that have been added. It's never empty.
	*/
	public void onRoutesAdded(@NonNull List<MediaRoute2Info> routes) {}

	/**
	* Called when routes are removed.
	* @param routes the list of routes that have been removed. It's never empty.
	*/
	public void onRoutesRemoved(@NonNull List<MediaRoute2Info> routes) {}

	/**
	* Called when routes are changed. For example, it is called when the route's name
	* or volume have been changed.
	*
	* TODO: Write here what the developers should do when this method is called.
	* How they can find the exact point how a route is changed?
	* It can be a volume, name, client package name, ....
	*
	* @param routes the list of routes that have been changed. It's never empty.
	*/
	public void onRoutesChanged(@NonNull List<MediaRoute2Info> routes) {}

	/**
	* Called when a route is selected. Exactly one route can be selected at a time.
	* @param route the selected route.
	* @param reason the reason why the route is selected.
	* @param controlHints An optional bundle of provider-specific arguments which may be
	* used to control the selected route. Can be empty.
	* @see #SELECT_REASON_UNKNOWN
	* @see #SELECT_REASON_USER_SELECTED
	* @see #SELECT_REASON_FALLBACK
	* @see #getSelectedRoute()
	*/
	public void onRouteSelected(@NonNull MediaRoute2Info route, @SelectReason int reason,
	@NonNull Bundle controlHints) {}
	}

	final class CallbackRecord {
	public final Callback mCallback;
	public Executor mExecutor;
	public int mFlags;

	CallbackRecord(@NonNull Callback callback) {
	mCallback = callback;
	}

	void notifyRoutes() {
	final List<MediaRoute2Info> routes = mFilteredRoutes;
	// notify only when bound to media router service.
	if (routes.size() > 0) {
	mExecutor.execute(() -> mCallback.onRoutesAdded(routes));
	}
	}
	}

	class Client2 extends IMediaRouter2Client.Stub {
	@Override
	public void notifyRestoreRoute() throws RemoteException {}

	@Override
	public void notifyRoutesAdded(List<MediaRoute2Info> routes) {
	mHandler.sendMessage(obtainMessage(MediaRouter2::addRoutesOnHandler,
	MediaRouter2.this, routes));
	}

	@Override
	public void notifyRoutesRemoved(List<MediaRoute2Info> routes) {
	mHandler.sendMessage(obtainMessage(MediaRouter2::removeRoutesOnHandler,
	MediaRouter2.this, routes));
	}

	@Override
	public void notifyRoutesChanged(List<MediaRoute2Info> routes) {
	mHandler.sendMessage(obtainMessage(MediaRouter2::changeRoutesOnHandler,
	MediaRouter2.this, routes));
	}

	@Override
	public void notifyRouteSelected(MediaRoute2Info route, int reason,
	Bundle controlHints) {
	mHandler.sendMessage(obtainMessage(MediaRouter2::selectRouteOnHandler,
	MediaRouter2.this, route, reason, controlHints));
	}
	}
	}