581fc98d65
The main objective of this CL is to enable selecting BT device. For that it updates MRM and SystemMediaRoute2Provider such that - MRM.getRoutingControllers() returns a list including the system session - SystemMediaRoute2Provider marks routes as "transferable" - SystemMediaRoute2Provider sets provider id correctly - SystemMediaRoute2Provider handles transferToRoute() Bug: 147979868 Bug: 147122575 Test: atest mediaroutertest && manually selecting phone / bt devices from output switcher Change-Id: I2e2032fd6677f79b9f864c313c40846daa87f113
779 lines
27 KiB
Java
779 lines
27 KiB
Java
/*
|
|
* 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 android.annotation.CallbackExecutor;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.content.Context;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.RemoteException;
|
|
import android.os.ServiceManager;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
|
|
import com.android.internal.annotations.GuardedBy;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ConcurrentMap;
|
|
import java.util.concurrent.CopyOnWriteArrayList;
|
|
import java.util.concurrent.Executor;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public class MediaRouter2Manager {
|
|
private static final String TAG = "MR2Manager";
|
|
private static final Object sLock = new Object();
|
|
|
|
@GuardedBy("sLock")
|
|
private static MediaRouter2Manager sInstance;
|
|
|
|
final String mPackageName;
|
|
|
|
private Context mContext;
|
|
@GuardedBy("sLock")
|
|
private Client mClient;
|
|
private final IMediaRouterService mMediaRouterService;
|
|
final Handler mHandler;
|
|
final CopyOnWriteArrayList<CallbackRecord> mCallbackRecords = new CopyOnWriteArrayList<>();
|
|
|
|
private final Object mRoutesLock = new Object();
|
|
@GuardedBy("mRoutesLock")
|
|
private final Map<String, MediaRoute2Info> mRoutes = new HashMap<>();
|
|
@NonNull
|
|
final ConcurrentMap<String, List<String>> mPreferredFeaturesMap = new ConcurrentHashMap<>();
|
|
|
|
private AtomicInteger mNextRequestId = new AtomicInteger(1);
|
|
|
|
/**
|
|
* Gets an instance of media router manager that controls media route of other applications.
|
|
*
|
|
* @return The media router manager instance for the context.
|
|
*/
|
|
public static MediaRouter2Manager getInstance(@NonNull Context context) {
|
|
Objects.requireNonNull(context, "context must not be null");
|
|
synchronized (sLock) {
|
|
if (sInstance == null) {
|
|
sInstance = new MediaRouter2Manager(context);
|
|
}
|
|
return sInstance;
|
|
}
|
|
}
|
|
|
|
private MediaRouter2Manager(Context context) {
|
|
mContext = context.getApplicationContext();
|
|
mMediaRouterService = IMediaRouterService.Stub.asInterface(
|
|
ServiceManager.getService(Context.MEDIA_ROUTER_SERVICE));
|
|
mPackageName = mContext.getPackageName();
|
|
mHandler = new Handler(context.getMainLooper());
|
|
}
|
|
|
|
/**
|
|
* Registers a callback to listen route info.
|
|
*
|
|
* @param executor the executor that runs the callback
|
|
* @param callback the callback to add
|
|
*/
|
|
public void registerCallback(@NonNull @CallbackExecutor Executor executor,
|
|
@NonNull Callback callback) {
|
|
Objects.requireNonNull(executor, "executor must not be null");
|
|
Objects.requireNonNull(callback, "callback must not be null");
|
|
|
|
CallbackRecord callbackRecord = new CallbackRecord(executor, callback);
|
|
if (!mCallbackRecords.addIfAbsent(callbackRecord)) {
|
|
Log.w(TAG, "Ignoring to add the same callback twice.");
|
|
return;
|
|
}
|
|
|
|
synchronized (sLock) {
|
|
if (mClient == null) {
|
|
Client client = new Client();
|
|
try {
|
|
mMediaRouterService.registerManager(client, mPackageName);
|
|
mClient = client;
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to register media router manager.", ex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unregisters the specified callback.
|
|
*
|
|
* @param callback the callback to unregister
|
|
*/
|
|
public void unregisterCallback(@NonNull Callback callback) {
|
|
Objects.requireNonNull(callback, "callback must not be null");
|
|
|
|
if (!mCallbackRecords.remove(new CallbackRecord(null, callback))) {
|
|
Log.w(TAG, "unregisterCallback: Ignore unknown callback. " + callback);
|
|
return;
|
|
}
|
|
|
|
synchronized (sLock) {
|
|
if (mCallbackRecords.size() == 0 && mClient != null) {
|
|
try {
|
|
mMediaRouterService.unregisterManager(mClient);
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to unregister media router manager", ex);
|
|
}
|
|
//TODO: clear mRoutes?
|
|
mClient = null;
|
|
mPreferredFeaturesMap.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
//TODO: Use cache not to create array. For now, it's unclear when to purge the cache.
|
|
//Do this when we finalize how to set control categories.
|
|
/**
|
|
* Gets available routes for an application.
|
|
*
|
|
* @param packageName the package name of the application
|
|
*/
|
|
@NonNull
|
|
public List<MediaRoute2Info> getAvailableRoutes(@NonNull String packageName) {
|
|
Objects.requireNonNull(packageName, "packageName must not be null");
|
|
|
|
List<String> preferredFeatures = mPreferredFeaturesMap.get(packageName);
|
|
if (preferredFeatures == null) {
|
|
return Collections.emptyList();
|
|
}
|
|
List<MediaRoute2Info> routes = new ArrayList<>();
|
|
synchronized (mRoutesLock) {
|
|
for (MediaRoute2Info route : mRoutes.values()) {
|
|
if (route.hasAnyFeatures(preferredFeatures)) {
|
|
routes.add(route);
|
|
}
|
|
}
|
|
}
|
|
return routes;
|
|
}
|
|
|
|
/**
|
|
* Gets routing controllers of an application with the given package name.
|
|
* The first element of the returned list is the system routing controller.
|
|
*
|
|
* @see MediaRouter2#getSystemController()
|
|
*/
|
|
@NonNull
|
|
public List<RoutingController> getRoutingControllers(@NonNull String packageName) {
|
|
Objects.requireNonNull(packageName, "packageName must not be null");
|
|
|
|
List<RoutingController> controllers = new ArrayList<>();
|
|
|
|
for (RoutingSessionInfo sessionInfo : getActiveSessions()) {
|
|
if (sessionInfo.isSystemSession()
|
|
|| TextUtils.equals(sessionInfo.getClientPackageName(), packageName)) {
|
|
controllers.add(new RoutingController(sessionInfo));
|
|
}
|
|
}
|
|
return controllers;
|
|
}
|
|
|
|
/**
|
|
* Gets the list of all active routing sessions.
|
|
* The first element of the list is the system routing session containing
|
|
* phone speakers, wired headset, Bluetooth devices.
|
|
* The system routing session is shared by apps such that controlling it will affect
|
|
* all apps.
|
|
*/
|
|
@NonNull
|
|
public List<RoutingSessionInfo> getActiveSessions() {
|
|
Client client;
|
|
synchronized (sLock) {
|
|
client = mClient;
|
|
}
|
|
if (client != null) {
|
|
try {
|
|
return mMediaRouterService.getActiveSessions(client);
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to get sessions. Service probably died.", ex);
|
|
}
|
|
}
|
|
return Collections.emptyList();
|
|
}
|
|
|
|
/**
|
|
* Gets the list of all discovered routes
|
|
*/
|
|
@NonNull
|
|
public List<MediaRoute2Info> getAllRoutes() {
|
|
List<MediaRoute2Info> routes = new ArrayList<>();
|
|
synchronized (mRoutesLock) {
|
|
routes.addAll(mRoutes.values());
|
|
}
|
|
return routes;
|
|
}
|
|
|
|
/**
|
|
* Selects media route for the specified package name.
|
|
*
|
|
* If the given route is {@link RoutingController#getTransferrableRoutes() a transferrable
|
|
* route} of a routing session of the application, the session will be transferred to
|
|
* the route. If not, a new routing session will be created.
|
|
*
|
|
* @param packageName the package name of the application that should change it's media route
|
|
* @param route the route to be selected.
|
|
*/
|
|
public void selectRoute(@NonNull String packageName, @NonNull MediaRoute2Info route) {
|
|
Objects.requireNonNull(packageName, "packageName must not be null");
|
|
Objects.requireNonNull(route, "route must not be null");
|
|
|
|
for (RoutingController controller : getRoutingControllers(packageName)) {
|
|
if (controller.getSessionInfo().getTransferrableRoutes().contains(route.getId())) {
|
|
controller.transferToRoute(route);
|
|
return;
|
|
}
|
|
}
|
|
|
|
Client client;
|
|
synchronized (sLock) {
|
|
client = mClient;
|
|
}
|
|
if (client != null) {
|
|
try {
|
|
int requestId = mNextRequestId.getAndIncrement();
|
|
mMediaRouterService.requestCreateClientSession(
|
|
client, packageName, route, requestId);
|
|
//TODO: release the previous session?
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to select media route", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Requests a volume change for a 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");
|
|
|
|
Client client;
|
|
synchronized (sLock) {
|
|
client = mClient;
|
|
}
|
|
if (client != null) {
|
|
try {
|
|
mMediaRouterService.requestSetVolume2Manager(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");
|
|
|
|
Client client;
|
|
synchronized (sLock) {
|
|
client = mClient;
|
|
}
|
|
if (client != null) {
|
|
try {
|
|
mMediaRouterService.requestUpdateVolume2Manager(client, route, delta);
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to send control request.", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
void addRoutesOnHandler(List<MediaRoute2Info> routes) {
|
|
synchronized (mRoutesLock) {
|
|
for (MediaRoute2Info route : routes) {
|
|
mRoutes.put(route.getId(), route);
|
|
}
|
|
}
|
|
if (routes.size() > 0) {
|
|
notifyRoutesAdded(routes);
|
|
}
|
|
}
|
|
|
|
void removeRoutesOnHandler(List<MediaRoute2Info> routes) {
|
|
synchronized (mRoutesLock) {
|
|
for (MediaRoute2Info route : routes) {
|
|
mRoutes.remove(route.getId());
|
|
}
|
|
}
|
|
if (routes.size() > 0) {
|
|
notifyRoutesRemoved(routes);
|
|
}
|
|
}
|
|
|
|
void changeRoutesOnHandler(List<MediaRoute2Info> routes) {
|
|
synchronized (mRoutesLock) {
|
|
for (MediaRoute2Info route : routes) {
|
|
mRoutes.put(route.getId(), route);
|
|
}
|
|
}
|
|
if (routes.size() > 0) {
|
|
notifyRoutesChanged(routes);
|
|
}
|
|
}
|
|
|
|
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));
|
|
}
|
|
}
|
|
|
|
void notifySessionCreated(RoutingSessionInfo sessionInfo) {
|
|
for (CallbackRecord record : mCallbackRecords) {
|
|
record.mExecutor.execute(() -> record.mCallback.onSessionCreated(
|
|
new RoutingController(sessionInfo)));
|
|
}
|
|
}
|
|
|
|
void notifySessionInfosChanged() {
|
|
for (CallbackRecord record : mCallbackRecords) {
|
|
record.mExecutor.execute(() -> record.mCallback.onSessionsUpdated());
|
|
}
|
|
}
|
|
|
|
void updatePreferredFeatures(String packageName, List<String> preferredFeatures) {
|
|
List<String> prevFeatures = mPreferredFeaturesMap.put(packageName, preferredFeatures);
|
|
if ((prevFeatures == null && preferredFeatures.size() == 0)
|
|
|| Objects.equals(preferredFeatures, prevFeatures)) {
|
|
return;
|
|
}
|
|
for (CallbackRecord record : mCallbackRecords) {
|
|
record.mExecutor.execute(() -> record.mCallback
|
|
.onControlCategoriesChanged(packageName, preferredFeatures));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public RoutingController getControllerForSession(@NonNull RoutingSessionInfo sessionInfo) {
|
|
return new RoutingController(sessionInfo);
|
|
}
|
|
|
|
/**
|
|
* A class to control media routing session in media route provider.
|
|
* With routing controller, an application can select a route into the session or deselect
|
|
* a route in the session.
|
|
*/
|
|
public final class RoutingController {
|
|
private final Object mControllerLock = new Object();
|
|
@GuardedBy("mControllerLock")
|
|
private RoutingSessionInfo mSessionInfo;
|
|
|
|
RoutingController(@NonNull RoutingSessionInfo sessionInfo) {
|
|
mSessionInfo = sessionInfo;
|
|
}
|
|
|
|
/**
|
|
* Gets the ID of the session
|
|
*/
|
|
@NonNull
|
|
public String getSessionId() {
|
|
synchronized (mControllerLock) {
|
|
return mSessionInfo.getId();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the client package name of the session
|
|
*/
|
|
@NonNull
|
|
public String getClientPackageName() {
|
|
synchronized (mControllerLock) {
|
|
return mSessionInfo.getClientPackageName();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return the control hints used to control route session if available.
|
|
*/
|
|
@Nullable
|
|
public Bundle getControlHints() {
|
|
synchronized (mControllerLock) {
|
|
return mSessionInfo.getControlHints();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return the unmodifiable list of currently selected routes
|
|
*/
|
|
@NonNull
|
|
public List<MediaRoute2Info> getSelectedRoutes() {
|
|
List<String> routeIds;
|
|
synchronized (mControllerLock) {
|
|
routeIds = mSessionInfo.getSelectedRoutes();
|
|
}
|
|
return getRoutesWithIds(routeIds);
|
|
}
|
|
|
|
/**
|
|
* @return the unmodifiable list of selectable routes for the session.
|
|
*/
|
|
@NonNull
|
|
public List<MediaRoute2Info> getSelectableRoutes() {
|
|
List<String> routeIds;
|
|
synchronized (mControllerLock) {
|
|
routeIds = mSessionInfo.getSelectableRoutes();
|
|
}
|
|
return getRoutesWithIds(routeIds);
|
|
}
|
|
|
|
/**
|
|
* @return the unmodifiable list of deselectable routes for the session.
|
|
*/
|
|
@NonNull
|
|
public List<MediaRoute2Info> getDeselectableRoutes() {
|
|
List<String> routeIds;
|
|
synchronized (mControllerLock) {
|
|
routeIds = mSessionInfo.getDeselectableRoutes();
|
|
}
|
|
return getRoutesWithIds(routeIds);
|
|
}
|
|
|
|
/**
|
|
* @return the unmodifiable list of transferrable routes for the session.
|
|
*/
|
|
@NonNull
|
|
public List<MediaRoute2Info> getTransferrableRoutes() {
|
|
List<String> routeIds;
|
|
synchronized (mControllerLock) {
|
|
routeIds = mSessionInfo.getTransferrableRoutes();
|
|
}
|
|
return getRoutesWithIds(routeIds);
|
|
}
|
|
|
|
/**
|
|
* Selects a route for the remote session. The given route must satisfy all of the
|
|
* following conditions:
|
|
* <ul>
|
|
* <li>ID should not be included in {@link #getSelectedRoutes()}</li>
|
|
* <li>ID should be included in {@link #getSelectableRoutes()}</li>
|
|
* </ul>
|
|
* If the route doesn't meet any of above conditions, it will be ignored.
|
|
*
|
|
* @see #getSelectedRoutes()
|
|
* @see #getSelectableRoutes()
|
|
*/
|
|
public void selectRoute(@NonNull MediaRoute2Info route) {
|
|
Objects.requireNonNull(route, "route must not be null");
|
|
|
|
RoutingSessionInfo sessionInfo;
|
|
synchronized (mControllerLock) {
|
|
sessionInfo = mSessionInfo;
|
|
}
|
|
if (sessionInfo.getSelectedRoutes().contains(route.getId())) {
|
|
Log.w(TAG, "Ignoring selecting a route that is already selected. route=" + route);
|
|
return;
|
|
}
|
|
|
|
if (!sessionInfo.getSelectableRoutes().contains(route.getId())) {
|
|
Log.w(TAG, "Ignoring selecting a non-selectable route=" + route);
|
|
return;
|
|
}
|
|
|
|
Client client;
|
|
synchronized (sLock) {
|
|
client = mClient;
|
|
}
|
|
if (client != null) {
|
|
try {
|
|
mMediaRouterService.selectClientRoute(mClient, getSessionId(), route);
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to select route for session.", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deselects a route from the remote session. The given route must satisfy all of the
|
|
* following conditions:
|
|
* <ul>
|
|
* <li>ID should be included in {@link #getSelectedRoutes()}</li>
|
|
* <li>ID should be included in {@link #getDeselectableRoutes()}</li>
|
|
* </ul>
|
|
* If the route doesn't meet any of above conditions, it will be ignored.
|
|
*
|
|
* @see #getSelectedRoutes()
|
|
* @see #getDeselectableRoutes()
|
|
*/
|
|
public void deselectRoute(@NonNull MediaRoute2Info route) {
|
|
Objects.requireNonNull(route, "route must not be null");
|
|
RoutingSessionInfo sessionInfo;
|
|
synchronized (mControllerLock) {
|
|
sessionInfo = mSessionInfo;
|
|
}
|
|
|
|
if (!sessionInfo.getSelectedRoutes().contains(route.getId())) {
|
|
Log.w(TAG, "Ignoring deselecting a route that is not selected. route=" + route);
|
|
return;
|
|
}
|
|
|
|
if (!sessionInfo.getDeselectableRoutes().contains(route.getId())) {
|
|
Log.w(TAG, "Ignoring deselecting a non-deselectable route=" + route);
|
|
return;
|
|
}
|
|
|
|
Client client;
|
|
synchronized (sLock) {
|
|
client = mClient;
|
|
}
|
|
if (client != null) {
|
|
try {
|
|
mMediaRouterService.deselectClientRoute(mClient, getSessionId(), route);
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to remove route from session.", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Transfers to a given route for the remote session. The given route must satisfy
|
|
* all of the following conditions:
|
|
* <ul>
|
|
* <li>ID should not be included in {@link #getSelectedRoutes()}</li>
|
|
* <li>ID should be included in {@link #getTransferrableRoutes()}</li>
|
|
* </ul>
|
|
* If the route doesn't meet any of above conditions, it will be ignored.
|
|
*
|
|
* @see #getSelectedRoutes()
|
|
* @see #getTransferrableRoutes()
|
|
*/
|
|
public void transferToRoute(@NonNull MediaRoute2Info route) {
|
|
Objects.requireNonNull(route, "route must not be null");
|
|
RoutingSessionInfo sessionInfo;
|
|
synchronized (mControllerLock) {
|
|
sessionInfo = mSessionInfo;
|
|
}
|
|
|
|
if (sessionInfo.getSelectedRoutes().contains(route.getId())) {
|
|
Log.w(TAG, "Ignoring transferring to a route that is already added. route="
|
|
+ route);
|
|
return;
|
|
}
|
|
|
|
if (!sessionInfo.getTransferrableRoutes().contains(route.getId())) {
|
|
Log.w(TAG, "Ignoring transferring to a non-transferrable route=" + route);
|
|
return;
|
|
}
|
|
|
|
Client client;
|
|
synchronized (sLock) {
|
|
client = mClient;
|
|
}
|
|
if (client != null) {
|
|
try {
|
|
mMediaRouterService.transferToClientRoute(mClient, getSessionId(), route);
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to transfer to route for session.", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Release this session.
|
|
* Any operation on this session after calling this method will be ignored.
|
|
*/
|
|
public void release() {
|
|
Client client;
|
|
synchronized (sLock) {
|
|
client = mClient;
|
|
}
|
|
if (client != null) {
|
|
try {
|
|
mMediaRouterService.releaseClientSession(mClient, getSessionId());
|
|
} catch (RemoteException ex) {
|
|
Log.e(TAG, "Unable to notify of controller release", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the session info of the session
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public RoutingSessionInfo getSessionInfo() {
|
|
synchronized (mControllerLock) {
|
|
return mSessionInfo;
|
|
}
|
|
}
|
|
|
|
private List<MediaRoute2Info> getRoutesWithIds(List<String> routeIds) {
|
|
List<MediaRoute2Info> routes = new ArrayList<>();
|
|
synchronized (mRoutesLock) {
|
|
for (String routeId : routeIds) {
|
|
MediaRoute2Info route = mRoutes.get(routeId);
|
|
if (route != null) {
|
|
routes.add(route);
|
|
}
|
|
}
|
|
}
|
|
return Collections.unmodifiableList(routes);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* @param routes the list of routes that have been changed. It's never empty.
|
|
*/
|
|
public void onRoutesChanged(@NonNull List<MediaRoute2Info> routes) {}
|
|
|
|
/**
|
|
* Called when a routing session is created.
|
|
*
|
|
* @param controller the controller to control the created session
|
|
*/
|
|
public void onSessionCreated(@NonNull RoutingController controller) {}
|
|
|
|
/**
|
|
* Called when at least one session info is changed.
|
|
* Call {@link #getActiveSessions()} to get current active session info.
|
|
*/
|
|
public void onSessionsUpdated() {}
|
|
|
|
/**
|
|
* Called when the preferred route features of an app is changed.
|
|
*
|
|
* @param packageName the package name of the application
|
|
* @param preferredFeatures the list of preferred route features set by an application.
|
|
*/
|
|
public void onControlCategoriesChanged(@NonNull String packageName,
|
|
@NonNull List<String> preferredFeatures) {}
|
|
}
|
|
|
|
final class CallbackRecord {
|
|
public final Executor mExecutor;
|
|
public final Callback mCallback;
|
|
|
|
CallbackRecord(Executor executor, Callback callback) {
|
|
mExecutor = executor;
|
|
mCallback = callback;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof CallbackRecord)) {
|
|
return false;
|
|
}
|
|
return mCallback == ((CallbackRecord) obj).mCallback;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return mCallback.hashCode();
|
|
}
|
|
}
|
|
|
|
class Client extends IMediaRouter2Manager.Stub {
|
|
@Override
|
|
public void notifySessionCreated(RoutingSessionInfo sessionInfo) {
|
|
mHandler.sendMessage(obtainMessage(MediaRouter2Manager::notifySessionCreated,
|
|
MediaRouter2Manager.this, sessionInfo));
|
|
}
|
|
|
|
@Override
|
|
public void notifySessionsUpdated() {
|
|
mHandler.sendMessage(obtainMessage(MediaRouter2Manager::notifySessionInfosChanged,
|
|
MediaRouter2Manager.this));
|
|
// do nothing
|
|
}
|
|
|
|
@Override
|
|
public void notifyPreferredFeaturesChanged(String packageName, List<String> features) {
|
|
mHandler.sendMessage(obtainMessage(MediaRouter2Manager::updatePreferredFeatures,
|
|
MediaRouter2Manager.this, packageName, features));
|
|
}
|
|
|
|
@Override
|
|
public void notifyRoutesAdded(List<MediaRoute2Info> routes) {
|
|
mHandler.sendMessage(obtainMessage(MediaRouter2Manager::addRoutesOnHandler,
|
|
MediaRouter2Manager.this, routes));
|
|
}
|
|
|
|
@Override
|
|
public void notifyRoutesRemoved(List<MediaRoute2Info> routes) {
|
|
mHandler.sendMessage(obtainMessage(MediaRouter2Manager::removeRoutesOnHandler,
|
|
MediaRouter2Manager.this, routes));
|
|
}
|
|
|
|
@Override
|
|
public void notifyRoutesChanged(List<MediaRoute2Info> routes) {
|
|
mHandler.sendMessage(obtainMessage(MediaRouter2Manager::changeRoutesOnHandler,
|
|
MediaRouter2Manager.this, routes));
|
|
}
|
|
}
|
|
}
|