From 18b8febd6bd67916662d656db337ec137be04f48 Mon Sep 17 00:00:00 2001 From: Jin Seok Park Date: Tue, 27 Oct 2020 16:02:07 +0900 Subject: [PATCH] Expose remote volume controller-related APIs MediaSessionManager#registerRemoteVolumeController allows apps to attach a binder to media service in order to be notified when the session or volume of the remote volume controller is changed. Since binders cannot be exposed, this CL instead adds and exposes as system API a Callback interface that apps can implement. Bug: 161332642 Test: Manual test by changing volume when remote casting Change-Id: Ibb009559e818711ca40f7bc1b3694a49484960b3 --- api/module-lib-current.txt | 229 ++++++++++++++++++ core/api/module-lib-current.txt | 7 + ...l => IRemoteVolumeControllerCallback.aidl} | 6 +- .../media/session/ISessionManager.aidl | 6 +- .../media/session/MediaSessionManager.java | 110 +++++++-- .../settingslib/volume/MediaSessions.java | 38 +-- .../server/media/MediaSessionService.java | 18 +- 7 files changed, 370 insertions(+), 44 deletions(-) create mode 100644 api/module-lib-current.txt rename media/java/android/media/{IRemoteVolumeController.aidl => IRemoteVolumeControllerCallback.aidl} (84%) diff --git a/api/module-lib-current.txt b/api/module-lib-current.txt new file mode 100644 index 0000000000000..1a65064973540 --- /dev/null +++ b/api/module-lib-current.txt @@ -0,0 +1,229 @@ +// Signature format: 2.0 +package android.app { + + public class ActivityManager { + method @RequiresPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER) public void addHomeVisibilityListener(@NonNull java.util.concurrent.Executor, @NonNull android.app.HomeVisibilityListener); + method @RequiresPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER) public void removeHomeVisibilityListener(@NonNull android.app.HomeVisibilityListener); + } + + public class AppOpsManager { + field public static final String OPSTR_NO_ISOLATED_STORAGE = "android:no_isolated_storage"; + } + + public abstract class HomeVisibilityListener { + ctor public HomeVisibilityListener(); + method public abstract void onHomeVisibilityChanged(boolean); + } + + public class NotificationManager { + method public boolean hasEnabledNotificationListener(@NonNull String, @NonNull android.os.UserHandle); + field public static final String ACTION_NOTIFICATION_LISTENER_ENABLED_CHANGED = "android.app.action.NOTIFICATION_LISTENER_ENABLED_CHANGED"; + } + + public class StatusBarManager { + method @RequiresPermission(android.Manifest.permission.STATUS_BAR) public void setExpansionDisabledForSimNetworkLock(boolean); + } + +} + +package android.app.role { + + public final class RoleManager { + method @Nullable public String getSmsRoleHolder(int); + } + +} + +package android.content.rollback { + + public class RollbackManagerFrameworkInitializer { + method public static void initialize(); + } + +} + +package android.graphics { + + public final class Compatibility { + method public static void setTargetSdkVersion(int); + } + + public final class ImageDecoder implements java.lang.AutoCloseable { + method @AnyThread @NonNull public static android.graphics.ImageDecoder.Source createSource(@NonNull android.content.ContentResolver, @NonNull android.net.Uri, @Nullable android.content.res.Resources); + } + +} + +package android.media { + + public class AudioManager { + method public void adjustStreamVolumeForUid(int, int, int, @NonNull String, int, int, int); + method public void adjustSuggestedStreamVolumeForUid(int, int, int, @NonNull String, int, int, int); + method public void setStreamVolumeForUid(int, int, int, @NonNull String, int, int, int); + field public static final int FLAG_FROM_KEY = 4096; // 0x1000 + } + + public class MediaMetadataRetriever implements java.lang.AutoCloseable { + field public static final int METADATA_KEY_VIDEO_CODEC_MIME_TYPE = 40; // 0x28 + } + + @Deprecated public final class MediaParceledListSlice implements android.os.Parcelable { + ctor @Deprecated public MediaParceledListSlice(@NonNull java.util.List); + method @Deprecated public int describeContents(); + method @Deprecated @NonNull public static android.media.MediaParceledListSlice emptyList(); + method @Deprecated public java.util.List getList(); + method @Deprecated public void setInlineCountLimit(int); + method @Deprecated public void writeToParcel(android.os.Parcel, int); + field @Deprecated @NonNull public static final android.os.Parcelable.ClassLoaderCreator CREATOR; + } + +} + +package android.media.session { + + public static final class MediaController.PlaybackInfo implements android.os.Parcelable { + ctor public MediaController.PlaybackInfo(int, int, @IntRange(from=0) int, @IntRange(from=0) int, @NonNull android.media.AudioAttributes, @Nullable String); + } + + public final class MediaSession { + field public static final int FLAG_EXCLUSIVE_GLOBAL_PRIORITY = 65536; // 0x10000 + } + + public static final class MediaSession.Token implements android.os.Parcelable { + method public int getUid(); + } + + public final class MediaSessionManager { + method public void addOnActiveSessionsChangedListener(@NonNull android.media.session.MediaSessionManager.OnActiveSessionsChangedListener, @Nullable android.content.ComponentName, int, @Nullable android.os.Handler); + method public void dispatchMediaKeyEventAsSystemService(@NonNull android.view.KeyEvent); + method public boolean dispatchMediaKeyEventToSessionAsSystemService(@NonNull android.view.KeyEvent, @NonNull android.media.session.MediaSession.Token); + method public void dispatchVolumeKeyEventAsSystemService(@NonNull android.view.KeyEvent, int); + method public void dispatchVolumeKeyEventToSessionAsSystemService(@NonNull android.view.KeyEvent, @NonNull android.media.session.MediaSession.Token); + method public void registerRemoteVolumeControllerCallback(@NonNull java.util.concurrent.Executor, @NonNull android.media.session.MediaSessionManager.RemoteVolumeControllerCallback); + method public void unregisterRemoteVolumeControllerCallback(@NonNull android.media.session.MediaSessionManager.RemoteVolumeControllerCallback); + field public static final int RESULT_MEDIA_KEY_HANDLED = 1; // 0x1 + field public static final int RESULT_MEDIA_KEY_NOT_HANDLED = 0; // 0x0 + } + + public static interface MediaSessionManager.RemoteVolumeControllerCallback { + method public void onSessionChanged(@Nullable android.media.session.MediaSession.Token); + method public void onVolumeChanged(@NonNull android.media.session.MediaSession.Token, int); + } + + public final class PlaybackState implements android.os.Parcelable { + method public boolean isActiveState(); + } + +} + +package android.net { + + public final class TetheringConstants { + field public static final String EXTRA_ADD_TETHER_TYPE = "extraAddTetherType"; + field public static final String EXTRA_PROVISION_CALLBACK = "extraProvisionCallback"; + field public static final String EXTRA_REM_TETHER_TYPE = "extraRemTetherType"; + field public static final String EXTRA_RUN_PROVISION = "extraRunProvision"; + field public static final String EXTRA_SET_ALARM = "extraSetAlarm"; + } + + public class TetheringManager { + ctor public TetheringManager(@NonNull android.content.Context, @NonNull java.util.function.Supplier); + method public int getLastTetherError(@NonNull String); + method @NonNull public String[] getTetherableBluetoothRegexs(); + method @NonNull public String[] getTetherableIfaces(); + method @NonNull public String[] getTetherableUsbRegexs(); + method @NonNull public String[] getTetherableWifiRegexs(); + method @NonNull public String[] getTetheredIfaces(); + method @NonNull public String[] getTetheringErroredIfaces(); + method public boolean isTetheringSupported(); + method public boolean isTetheringSupported(@NonNull String); + method public void requestLatestTetheringEntitlementResult(int, @NonNull android.os.ResultReceiver, boolean); + method @Deprecated public int setUsbTethering(boolean); + method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void startTethering(int, @NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.StartTetheringCallback); + method @Deprecated public int tether(@NonNull String); + method @Deprecated public int untether(@NonNull String); + } + + public static interface TetheringManager.TetheringEventCallback { + method public default void onTetherableInterfaceRegexpsChanged(@NonNull android.net.TetheringManager.TetheringInterfaceRegexps); + } + + public static class TetheringManager.TetheringInterfaceRegexps { + method @NonNull public java.util.List getTetherableBluetoothRegexs(); + method @NonNull public java.util.List getTetherableUsbRegexs(); + method @NonNull public java.util.List getTetherableWifiRegexs(); + } + +} + +package android.os { + + public class Binder implements android.os.IBinder { + method public final void markVintfStability(); + } + + public interface Parcelable { + method public default int getStability(); + } + + public class StatsFrameworkInitializer { + method public static void registerServiceWrappers(); + method public static void setStatsServiceManager(@NonNull android.os.StatsServiceManager); + } + + public class StatsServiceManager { + method @NonNull public android.os.StatsServiceManager.ServiceRegisterer getStatsCompanionServiceRegisterer(); + method @NonNull public android.os.StatsServiceManager.ServiceRegisterer getStatsManagerServiceRegisterer(); + method @NonNull public android.os.StatsServiceManager.ServiceRegisterer getStatsdServiceRegisterer(); + } + + public static class StatsServiceManager.ServiceNotFoundException extends java.lang.Exception { + ctor public StatsServiceManager.ServiceNotFoundException(@NonNull String); + } + + public static final class StatsServiceManager.ServiceRegisterer { + method @Nullable public android.os.IBinder get(); + method @Nullable public android.os.IBinder getOrThrow() throws android.os.StatsServiceManager.ServiceNotFoundException; + } + +} + +package android.provider { + + public final class DeviceConfig { + field public static final String NAMESPACE_ALARM_MANAGER = "alarm_manager"; + field public static final String NAMESPACE_APP_STANDBY = "app_standby"; + field public static final String NAMESPACE_DEVICE_IDLE = "device_idle"; + } + +} + +package android.telephony { + + public abstract class CellSignalStrength { + method public static int getNumSignalStrengthLevels(); + } + + public class TelephonyManager { + method @NonNull public static int[] getAllNetworkTypes(); + } + +} + +package android.util { + + public class AtomicFile { + ctor public AtomicFile(@NonNull java.io.File, @Nullable android.util.SystemConfigFileCommitEventLogger); + } + + public final class Log { + method public static int logToRadioBuffer(int, @Nullable String, @Nullable String); + } + + public class SystemConfigFileCommitEventLogger { + ctor public SystemConfigFileCommitEventLogger(@NonNull String); + method public void setStartTime(long); + } + +} + diff --git a/core/api/module-lib-current.txt b/core/api/module-lib-current.txt index 06e6d9ccbbf01..40ac3cd85d98b 100644 --- a/core/api/module-lib-current.txt +++ b/core/api/module-lib-current.txt @@ -89,10 +89,17 @@ package android.media.session { method public boolean dispatchMediaKeyEventToSessionAsSystemService(@NonNull android.view.KeyEvent, @NonNull android.media.session.MediaSession.Token); method public void dispatchVolumeKeyEventAsSystemService(@NonNull android.view.KeyEvent, int); method public void dispatchVolumeKeyEventToSessionAsSystemService(@NonNull android.view.KeyEvent, @NonNull android.media.session.MediaSession.Token); + method public void registerRemoteVolumeControllerCallback(@NonNull java.util.concurrent.Executor, @NonNull android.media.session.MediaSessionManager.RemoteVolumeControllerCallback); + method public void unregisterRemoteVolumeControllerCallback(@NonNull android.media.session.MediaSessionManager.RemoteVolumeControllerCallback); field public static final int RESULT_MEDIA_KEY_HANDLED = 1; // 0x1 field public static final int RESULT_MEDIA_KEY_NOT_HANDLED = 0; // 0x0 } + public static interface MediaSessionManager.RemoteVolumeControllerCallback { + method public void onSessionChanged(@Nullable android.media.session.MediaSession.Token); + method public void onVolumeChanged(@NonNull android.media.session.MediaSession.Token, int); + } + public final class PlaybackState implements android.os.Parcelable { method public boolean isActiveState(); } diff --git a/media/java/android/media/IRemoteVolumeController.aidl b/media/java/android/media/IRemoteVolumeControllerCallback.aidl similarity index 84% rename from media/java/android/media/IRemoteVolumeController.aidl rename to media/java/android/media/IRemoteVolumeControllerCallback.aidl index 74c05c407571e..34c63612b9129 100644 --- a/media/java/android/media/IRemoteVolumeController.aidl +++ b/media/java/android/media/IRemoteVolumeControllerCallback.aidl @@ -25,9 +25,9 @@ import android.media.session.MediaSession; * TODO add in better support for multiple remote sessions. * @hide */ -oneway interface IRemoteVolumeController { - void remoteVolumeChanged(in MediaSession.Token sessionToken, int flags); +oneway interface IRemoteVolumeControllerCallback { + void onVolumeChanged(in MediaSession.Token sessionToken, int flags); // sets the default session to use with the slider, replaces remoteSliderVisibility // on IVolumeController - void updateRemoteController(in MediaSession.Token sessionToken); + void onSessionChanged(in MediaSession.Token sessionToken); } diff --git a/media/java/android/media/session/ISessionManager.aidl b/media/java/android/media/session/ISessionManager.aidl index 1557ea632b665..f157d7f4845d6 100644 --- a/media/java/android/media/session/ISessionManager.aidl +++ b/media/java/android/media/session/ISessionManager.aidl @@ -17,7 +17,7 @@ package android.media.session; import android.content.ComponentName; import android.content.pm.ParceledListSlice; -import android.media.IRemoteVolumeController; +import android.media.IRemoteVolumeControllerCallback; import android.media.Session2Token; import android.media.session.IActiveSessionsListener; import android.media.session.IOnMediaKeyEventDispatchedListener; @@ -57,8 +57,8 @@ interface ISessionManager { void addSession2TokensListener(in ISession2TokensListener listener, int userId); void removeSession2TokensListener(in ISession2TokensListener listener); - void registerRemoteVolumeController(in IRemoteVolumeController rvc); - void unregisterRemoteVolumeController(in IRemoteVolumeController rvc); + void registerRemoteVolumeControllerCallback(in IRemoteVolumeControllerCallback rvc); + void unregisterRemoteVolumeControllerCallback(in IRemoteVolumeControllerCallback rvc); // For PhoneWindowManager to precheck media keys boolean isGlobalPriorityActive(); diff --git a/media/java/android/media/session/MediaSessionManager.java b/media/java/android/media/session/MediaSessionManager.java index b7b9e4ba6f40e..477049a49ec9c 100644 --- a/media/java/android/media/session/MediaSessionManager.java +++ b/media/java/android/media/session/MediaSessionManager.java @@ -28,7 +28,7 @@ import android.content.ComponentName; import android.content.Context; import android.content.pm.ParceledListSlice; import android.media.AudioManager; -import android.media.IRemoteVolumeController; +import android.media.IRemoteVolumeControllerCallback; import android.media.MediaFrameworkInitializer; import android.media.MediaSession2; import android.media.Session2Token; @@ -88,6 +88,8 @@ public final class MediaSessionManager { private final OnMediaKeyEventSessionChangedListenerStub mOnMediaKeyEventSessionChangedListenerStub = new OnMediaKeyEventSessionChangedListenerStub(); + private final RemoteVolumeControllerCallbackStub mRemoteVolumeControllerCallbackStub = + new RemoteVolumeControllerCallbackStub(); private final Object mLock = new Object(); @GuardedBy("mLock") @@ -106,6 +108,9 @@ public final class MediaSessionManager { private String mCurMediaKeyEventSessionPackage; @GuardedBy("mLock") private MediaSession.Token mCurMediaKeyEventSession; + @GuardedBy("mLock") + private final Map + mRemoteVolumeControllerCallbacks = new ArrayMap<>(); private Context mContext; private OnVolumeKeyLongPressListenerImpl mOnVolumeKeyLongPressListener; @@ -462,33 +467,62 @@ public final class MediaSessionManager { } /** - * Set the remote volume controller to receive volume updates on. + * Set the remote volume controller callback to receive volume updates on. * Only for use by System UI and Settings application. * - * @param rvc The volume controller to receive updates on. + * @param callback The volume controller callback to receive updates on. * @hide */ - public void registerRemoteVolumeController(IRemoteVolumeController rvc) { - try { - mService.registerRemoteVolumeController(rvc); - } catch (RemoteException e) { - Log.e(TAG, "Error in registerRemoteVolumeController.", e); + @SystemApi(client = SystemApi.Client.MODULE_LIBRARIES) + public void registerRemoteVolumeControllerCallback( + @NonNull @CallbackExecutor Executor executor, + @NonNull RemoteVolumeControllerCallback callback) { + Objects.requireNonNull(executor, "executor shouldn't be null"); + Objects.requireNonNull(callback, "callback shouldn't be null"); + boolean shouldRegisterCallback = false; + synchronized (mLock) { + int prevCallbackCount = mRemoteVolumeControllerCallbacks.size(); + mRemoteVolumeControllerCallbacks.put(callback, executor); + if (prevCallbackCount == 0 && mRemoteVolumeControllerCallbacks.size() == 1) { + shouldRegisterCallback = true; + } + } + if (shouldRegisterCallback) { + try { + mService.registerRemoteVolumeControllerCallback( + mRemoteVolumeControllerCallbackStub); + } catch (RemoteException e) { + Log.e(TAG, "Failed to register remote volume controller callback", e); + } } } /** - * Unregisters the remote volume controller which was previously registered with - * {@link #registerRemoteVolumeController(IRemoteVolumeController)}. + * Unregisters the remote volume controller callback which was previously registered with + * {@link #registerRemoteVolumeControllerCallback(Executor, RemoteVolumeControllerCallback)}. * Only for use by System UI and Settings application. * - * @param rvc The volume controller which was registered. + * @param callback The volume controller callback to receive updates on. * @hide */ - public void unregisterRemoteVolumeController(IRemoteVolumeController rvc) { + @SystemApi(client = SystemApi.Client.MODULE_LIBRARIES) + public void unregisterRemoteVolumeControllerCallback( + @NonNull RemoteVolumeControllerCallback callback) { + Objects.requireNonNull(callback, "callback shouldn't be null"); + boolean shouldUnregisterCallback = false; + synchronized (mLock) { + if (mRemoteVolumeControllerCallbacks.remove(callback) != null + && mRemoteVolumeControllerCallbacks.size() == 0) { + shouldUnregisterCallback = true; + } + } try { - mService.unregisterRemoteVolumeController(rvc); + if (shouldUnregisterCallback) { + mService.unregisterRemoteVolumeControllerCallback( + mRemoteVolumeControllerCallbackStub); + } } catch (RemoteException e) { - Log.e(TAG, "Error in unregisterRemoteVolumeController.", e); + Log.e(TAG, "Failed to unregister remote volume controller callback", e); } } @@ -1058,6 +1092,29 @@ public final class MediaSessionManager { @Nullable MediaSession.Token sessionToken); } + /** + * Callback to receive changes in the remote volume controller. + * + * @hide + */ + @SystemApi(client = SystemApi.Client.MODULE_LIBRARIES) + public interface RemoteVolumeControllerCallback { + /** + * Called when the volume is changed. + * + * @param sessionToken the remote media session token + * @param flags any of the flags from {@link AudioManager} + */ + void onVolumeChanged(@NonNull MediaSession.Token sessionToken, int flags); + + /** + * Called when the session for the default remote controller is changed. + * + * @param sessionToken the remote media session token + */ + void onSessionChanged(@Nullable MediaSession.Token sessionToken); + } + /** * Information of a remote user of {@link MediaSession} or {@link MediaBrowserService}. * This can be used to decide whether the remote user is trusted app, and also differentiate @@ -1290,4 +1347,29 @@ public final class MediaSessionManager { } } } + + private final class RemoteVolumeControllerCallbackStub + extends IRemoteVolumeControllerCallback.Stub { + @Override + public void onVolumeChanged(MediaSession.Token sessionToken, int flags) { + Map callbacks = new ArrayMap<>(); + synchronized (mLock) { + callbacks.putAll(mRemoteVolumeControllerCallbacks); + } + for (Map.Entry e : callbacks.entrySet()) { + e.getValue().execute(() -> e.getKey().onVolumeChanged(sessionToken, flags)); + } + } + + @Override + public void onSessionChanged(MediaSession.Token sessionToken) { + Map callbacks = new ArrayMap<>(); + synchronized (mLock) { + callbacks.putAll(mRemoteVolumeControllerCallbacks); + } + for (Map.Entry e : callbacks.entrySet()) { + e.getValue().execute(() -> e.getKey().onSessionChanged(sessionToken)); + } + } + } } diff --git a/packages/SettingsLib/src/com/android/settingslib/volume/MediaSessions.java b/packages/SettingsLib/src/com/android/settingslib/volume/MediaSessions.java index f6cd971ec4f31..12ef639093bfe 100644 --- a/packages/SettingsLib/src/com/android/settingslib/volume/MediaSessions.java +++ b/packages/SettingsLib/src/com/android/settingslib/volume/MediaSessions.java @@ -16,6 +16,8 @@ package com.android.settingslib.volume; +import android.annotation.NonNull; +import android.annotation.Nullable; import android.app.PendingIntent; import android.content.Context; import android.content.Intent; @@ -23,20 +25,21 @@ import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.content.pm.PackageManager.NameNotFoundException; import android.content.pm.ResolveInfo; -import android.media.IRemoteVolumeController; import android.media.MediaMetadata; import android.media.session.MediaController; import android.media.session.MediaController.PlaybackInfo; +import android.media.session.MediaSession; import android.media.session.MediaSession.QueueItem; import android.media.session.MediaSession.Token; import android.media.session.MediaSessionManager; import android.media.session.MediaSessionManager.OnActiveSessionsChangedListener; +import android.media.session.MediaSessionManager.RemoteVolumeControllerCallback; import android.media.session.PlaybackState; import android.os.Bundle; import android.os.Handler; +import android.os.HandlerExecutor; import android.os.Looper; import android.os.Message; -import android.os.RemoteException; import android.util.Log; import java.io.PrintWriter; @@ -58,6 +61,7 @@ public class MediaSessions { private final Context mContext; private final H mHandler; + private final HandlerExecutor mHandlerExecutor; private final MediaSessionManager mMgr; private final Map mRecords = new HashMap<>(); private final Callbacks mCallbacks; @@ -67,6 +71,7 @@ public class MediaSessions { public MediaSessions(Context context, Looper looper, Callbacks callbacks) { mContext = context; mHandler = new H(looper); + mHandlerExecutor = new HandlerExecutor(mHandler); mMgr = (MediaSessionManager) context.getSystemService(Context.MEDIA_SESSION_SERVICE); mCallbacks = callbacks; } @@ -95,7 +100,8 @@ public class MediaSessions { mMgr.addOnActiveSessionsChangedListener(mSessionsListener, null, mHandler); mInit = true; postUpdateSessions(); - mMgr.registerRemoteVolumeController(mRvc); + mMgr.registerRemoteVolumeControllerCallback(mHandlerExecutor, + mRemoteVolumeControllerCallback); } protected void postUpdateSessions() { @@ -110,7 +116,7 @@ public class MediaSessions { if (D.BUG) Log.d(TAG, "destroy"); mInit = false; mMgr.removeOnActiveSessionsChangedListener(mSessionsListener); - mMgr.unregisterRemoteVolumeController(mRvc); + mMgr.unregisterRemoteVolumeControllerCallback(mRemoteVolumeControllerCallback); } /** @@ -330,19 +336,19 @@ public class MediaSessions { } }; - private final IRemoteVolumeController mRvc = new IRemoteVolumeController.Stub() { - @Override - public void remoteVolumeChanged(Token sessionToken, int flags) - throws RemoteException { - mHandler.obtainMessage(H.REMOTE_VOLUME_CHANGED, flags, 0, - sessionToken).sendToTarget(); - } + private final RemoteVolumeControllerCallback mRemoteVolumeControllerCallback = + new RemoteVolumeControllerCallback() { + @Override + public void onVolumeChanged(@NonNull MediaSession.Token sessionToken, + int flags) { + mHandler.obtainMessage(H.REMOTE_VOLUME_CHANGED, flags, 0, + sessionToken).sendToTarget(); + } - @Override - public void updateRemoteController(final Token sessionToken) - throws RemoteException { - mHandler.obtainMessage(H.UPDATE_REMOTE_CONTROLLER, sessionToken).sendToTarget(); - } + @Override + public void onSessionChanged(@Nullable MediaSession.Token sessionToken) { + mHandler.obtainMessage(H.UPDATE_REMOTE_CONTROLLER, sessionToken).sendToTarget(); + } }; private final class H extends Handler { diff --git a/services/core/java/com/android/server/media/MediaSessionService.java b/services/core/java/com/android/server/media/MediaSessionService.java index 828a0ac94c0cb..962a36a0d6ba5 100644 --- a/services/core/java/com/android/server/media/MediaSessionService.java +++ b/services/core/java/com/android/server/media/MediaSessionService.java @@ -44,7 +44,7 @@ import android.content.pm.UserInfo; import android.media.AudioManager; import android.media.AudioPlaybackConfiguration; import android.media.AudioSystem; -import android.media.IRemoteVolumeController; +import android.media.IRemoteVolumeControllerCallback; import android.media.Session2Token; import android.media.session.IActiveSessionsListener; import android.media.session.IOnMediaKeyEventDispatchedListener; @@ -146,7 +146,7 @@ public class MediaSessionService extends SystemService implements Monitor { // Used to notify System UI and Settings when remote volume was changed. @GuardedBy("mLock") - final RemoteCallbackList mRemoteVolumeControllers = + final RemoteCallbackList mRemoteVolumeControllers = new RemoteCallbackList<>(); private SessionPolicyProvider mCustomSessionPolicyProvider; @@ -309,8 +309,9 @@ public class MediaSessionService extends SystemService implements Monitor { MediaSession.Token token = session.getSessionToken(); for (int i = size - 1; i >= 0; i--) { try { - IRemoteVolumeController cb = mRemoteVolumeControllers.getBroadcastItem(i); - cb.remoteVolumeChanged(token, flags); + IRemoteVolumeControllerCallback cb = + mRemoteVolumeControllers.getBroadcastItem(i); + cb.onVolumeChanged(token, flags); } catch (Exception e) { Log.w(TAG, "Error sending volume change.", e); } @@ -715,8 +716,9 @@ public class MediaSessionService extends SystemService implements Monitor { for (int i = size - 1; i >= 0; i--) { try { - IRemoteVolumeController cb = mRemoteVolumeControllers.getBroadcastItem(i); - cb.updateRemoteController(token); + IRemoteVolumeControllerCallback cb = + mRemoteVolumeControllers.getBroadcastItem(i); + cb.onSessionChanged(token); } catch (Exception e) { Log.w(TAG, "Error sending default remote volume.", e); } @@ -1843,7 +1845,7 @@ public class MediaSessionService extends SystemService implements Monitor { } @Override - public void registerRemoteVolumeController(IRemoteVolumeController rvc) { + public void registerRemoteVolumeControllerCallback(IRemoteVolumeControllerCallback rvc) { final int pid = Binder.getCallingPid(); final int uid = Binder.getCallingUid(); final long token = Binder.clearCallingIdentity(); @@ -1858,7 +1860,7 @@ public class MediaSessionService extends SystemService implements Monitor { } @Override - public void unregisterRemoteVolumeController(IRemoteVolumeController rvc) { + public void unregisterRemoteVolumeControllerCallback(IRemoteVolumeControllerCallback rvc) { final int pid = Binder.getCallingPid(); final int uid = Binder.getCallingUid(); final long token = Binder.clearCallingIdentity();