diff --git a/core/api/module-lib-current.txt b/core/api/module-lib-current.txt
index 94a6576..d6b7b08 100644
--- a/core/api/module-lib-current.txt
+++ b/core/api/module-lib-current.txt
@@ -116,14 +116,14 @@
     method public void dispatchVolumeKeyEventAsSystemService(@NonNull android.view.KeyEvent, int);
     method public void dispatchVolumeKeyEventToSessionAsSystemService(@NonNull android.view.KeyEvent, @NonNull android.media.session.MediaSession.Token);
     method @NonNull public java.util.List<android.media.session.MediaController> getActiveSessionsForUser(@Nullable android.content.ComponentName, int);
-    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);
+    method public void registerRemoteSessionCallback(@NonNull java.util.concurrent.Executor, @NonNull android.media.session.MediaSessionManager.RemoteSessionCallback);
+    method public void unregisterRemoteSessionCallback(@NonNull android.media.session.MediaSessionManager.RemoteSessionCallback);
     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);
+  public static interface MediaSessionManager.RemoteSessionCallback {
+    method public void onDefaultRemoteSessionChanged(@Nullable android.media.session.MediaSession.Token);
     method public void onVolumeChanged(@NonNull android.media.session.MediaSession.Token, int);
   }
 
diff --git a/media/java/android/media/IRemoteVolumeControllerCallback.aidl b/media/java/android/media/IRemoteSessionCallback.aidl
similarity index 95%
rename from media/java/android/media/IRemoteVolumeControllerCallback.aidl
rename to media/java/android/media/IRemoteSessionCallback.aidl
index 34c6361..e16c87e 100644
--- a/media/java/android/media/IRemoteVolumeControllerCallback.aidl
+++ b/media/java/android/media/IRemoteSessionCallback.aidl
@@ -25,7 +25,7 @@
  * TODO add in better support for multiple remote sessions.
  * @hide
  */
-oneway interface IRemoteVolumeControllerCallback {
+oneway interface IRemoteSessionCallback {
     void onVolumeChanged(in MediaSession.Token sessionToken, int flags);
     // sets the default session to use with the slider, replaces remoteSliderVisibility
     // on IVolumeController
diff --git a/media/java/android/media/session/ISessionManager.aidl b/media/java/android/media/session/ISessionManager.aidl
index f157d7f..66d5794 100644
--- a/media/java/android/media/session/ISessionManager.aidl
+++ b/media/java/android/media/session/ISessionManager.aidl
@@ -17,7 +17,7 @@
 
 import android.content.ComponentName;
 import android.content.pm.ParceledListSlice;
-import android.media.IRemoteVolumeControllerCallback;
+import android.media.IRemoteSessionCallback;
 import android.media.Session2Token;
 import android.media.session.IActiveSessionsListener;
 import android.media.session.IOnMediaKeyEventDispatchedListener;
@@ -57,8 +57,8 @@
     void addSession2TokensListener(in ISession2TokensListener listener, int userId);
     void removeSession2TokensListener(in ISession2TokensListener listener);
 
-    void registerRemoteVolumeControllerCallback(in IRemoteVolumeControllerCallback rvc);
-    void unregisterRemoteVolumeControllerCallback(in IRemoteVolumeControllerCallback rvc);
+    void registerRemoteSessionCallback(in IRemoteSessionCallback rvc);
+    void unregisterRemoteSessionCallback(in IRemoteSessionCallback 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 00ee914..f22bcd8 100644
--- a/media/java/android/media/session/MediaSessionManager.java
+++ b/media/java/android/media/session/MediaSessionManager.java
@@ -27,10 +27,11 @@
 import android.content.Context;
 import android.content.pm.ParceledListSlice;
 import android.media.AudioManager;
-import android.media.IRemoteVolumeControllerCallback;
+import android.media.IRemoteSessionCallback;
 import android.media.MediaFrameworkPlatformInitializer;
 import android.media.MediaSession2;
 import android.media.Session2Token;
+import android.media.VolumeProvider;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.RemoteException;
@@ -87,8 +88,8 @@
     private final OnMediaKeyEventSessionChangedListenerStub
             mOnMediaKeyEventSessionChangedListenerStub =
             new OnMediaKeyEventSessionChangedListenerStub();
-    private final RemoteVolumeControllerCallbackStub mRemoteVolumeControllerCallbackStub =
-            new RemoteVolumeControllerCallbackStub();
+    private final RemoteSessionCallbackStub mRemoteSessionCallbackStub =
+            new RemoteSessionCallbackStub();
 
     private final Object mLock = new Object();
     @GuardedBy("mLock")
@@ -108,8 +109,8 @@
     @GuardedBy("mLock")
     private MediaSession.Token mCurMediaKeyEventSession;
     @GuardedBy("mLock")
-    private final Map<RemoteVolumeControllerCallback, Executor>
-            mRemoteVolumeControllerCallbacks = new ArrayMap<>();
+    private final Map<RemoteSessionCallback, Executor>
+            mRemoteSessionCallbacks = new ArrayMap<>();
 
     private Context mContext;
     private OnVolumeKeyLongPressListenerImpl mOnVolumeKeyLongPressListener;
@@ -482,27 +483,29 @@
      * Set the remote volume controller callback to receive volume updates on.
      * Only for use by System UI and Settings application.
      *
+     * @param executor The executor on which the callback should be invoked
      * @param callback The volume controller callback to receive updates on.
+     *
      * @hide
      */
     @SystemApi(client = SystemApi.Client.MODULE_LIBRARIES)
-    public void registerRemoteVolumeControllerCallback(
+    public void registerRemoteSessionCallback(
             @NonNull @CallbackExecutor Executor executor,
-            @NonNull RemoteVolumeControllerCallback callback) {
+            @NonNull RemoteSessionCallback 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) {
+            int prevCallbackCount = mRemoteSessionCallbacks.size();
+            mRemoteSessionCallbacks.put(callback, executor);
+            if (prevCallbackCount == 0 && mRemoteSessionCallbacks.size() == 1) {
                 shouldRegisterCallback = true;
             }
         }
         if (shouldRegisterCallback) {
             try {
-                mService.registerRemoteVolumeControllerCallback(
-                        mRemoteVolumeControllerCallbackStub);
+                mService.registerRemoteSessionCallback(
+                        mRemoteSessionCallbackStub);
             } catch (RemoteException e) {
                 Log.e(TAG, "Failed to register remote volume controller callback", e);
             }
@@ -511,27 +514,27 @@
 
     /**
      * Unregisters the remote volume controller callback which was previously registered with
-     * {@link #registerRemoteVolumeControllerCallback(Executor, RemoteVolumeControllerCallback)}.
+     * {@link #registerRemoteSessionCallback(Executor, RemoteSessionCallback)}.
      * Only for use by System UI and Settings application.
      *
      * @param callback The volume controller callback to receive updates on.
      * @hide
      */
     @SystemApi(client = SystemApi.Client.MODULE_LIBRARIES)
-    public void unregisterRemoteVolumeControllerCallback(
-            @NonNull RemoteVolumeControllerCallback callback) {
+    public void unregisterRemoteSessionCallback(
+            @NonNull RemoteSessionCallback callback) {
         Objects.requireNonNull(callback, "callback shouldn't be null");
         boolean shouldUnregisterCallback = false;
         synchronized (mLock) {
-            if (mRemoteVolumeControllerCallbacks.remove(callback) != null
-                    && mRemoteVolumeControllerCallbacks.size() == 0) {
+            if (mRemoteSessionCallbacks.remove(callback) != null
+                    && mRemoteSessionCallbacks.size() == 0) {
                 shouldUnregisterCallback = true;
             }
         }
         try {
             if (shouldUnregisterCallback) {
-                mService.unregisterRemoteVolumeControllerCallback(
-                        mRemoteVolumeControllerCallbackStub);
+                mService.unregisterRemoteSessionCallback(
+                        mRemoteSessionCallbackStub);
             }
         } catch (RemoteException e) {
             Log.e(TAG, "Failed to unregister remote volume controller callback", e);
@@ -1107,26 +1110,34 @@
     }
 
     /**
-     * Callback to receive changes in the remote volume controller.
+     * Callback to receive changes in the existing remote sessions. A remote session is a
+     * {@link MediaSession} that is connected to a remote player via
+     * {@link MediaSession#setPlaybackToRemote(VolumeProvider)}
      *
      * @hide
      */
     @SystemApi(client = SystemApi.Client.MODULE_LIBRARIES)
-    public interface RemoteVolumeControllerCallback {
+    public interface RemoteSessionCallback {
         /**
-         * Called when the volume is changed.
+         * Called when the volume is changed for the given session. Flags that are defined in
+         * {@link AudioManager} will also be sent and will contain information about how to
+         * handle the volume change. For example, {@link AudioManager#FLAG_SHOW_UI} indicates that a
+         * toast showing the volume should be shown.
          *
          * @param sessionToken the remote media session token
-         * @param flags any of the flags from {@link AudioManager}
+         * @param flags extra information about how to handle the volume change
          */
         void onVolumeChanged(@NonNull MediaSession.Token sessionToken, int flags);
 
         /**
-         * Called when the session for the default remote controller is changed.
+         * Called when the default remote session is changed where the default remote session
+         * denotes an active remote session that has the highest priority for receiving key events.
+         * Null will be sent if there are currently no active remote sessions.
          *
-         * @param sessionToken the remote media session token
+         * @param sessionToken the token of the default remote session, a session with the highest
+         *                     priority for receiving key events.
          */
-        void onSessionChanged(@Nullable MediaSession.Token sessionToken);
+        void onDefaultRemoteSessionChanged(@Nullable MediaSession.Token sessionToken);
     }
 
     /**
@@ -1362,27 +1373,27 @@
         }
     }
 
-    private final class RemoteVolumeControllerCallbackStub
-            extends IRemoteVolumeControllerCallback.Stub {
+    private final class RemoteSessionCallbackStub
+            extends IRemoteSessionCallback.Stub {
         @Override
         public void onVolumeChanged(MediaSession.Token sessionToken, int flags) {
-            Map<RemoteVolumeControllerCallback, Executor> callbacks = new ArrayMap<>();
+            Map<RemoteSessionCallback, Executor> callbacks = new ArrayMap<>();
             synchronized (mLock) {
-                callbacks.putAll(mRemoteVolumeControllerCallbacks);
+                callbacks.putAll(mRemoteSessionCallbacks);
             }
-            for (Map.Entry<RemoteVolumeControllerCallback, Executor> e : callbacks.entrySet()) {
+            for (Map.Entry<RemoteSessionCallback, Executor> e : callbacks.entrySet()) {
                 e.getValue().execute(() -> e.getKey().onVolumeChanged(sessionToken, flags));
             }
         }
 
         @Override
         public void onSessionChanged(MediaSession.Token sessionToken) {
-            Map<RemoteVolumeControllerCallback, Executor> callbacks = new ArrayMap<>();
+            Map<RemoteSessionCallback, Executor> callbacks = new ArrayMap<>();
             synchronized (mLock) {
-                callbacks.putAll(mRemoteVolumeControllerCallbacks);
+                callbacks.putAll(mRemoteSessionCallbacks);
             }
-            for (Map.Entry<RemoteVolumeControllerCallback, Executor> e : callbacks.entrySet()) {
-                e.getValue().execute(() -> e.getKey().onSessionChanged(sessionToken));
+            for (Map.Entry<RemoteSessionCallback, Executor> e : callbacks.entrySet()) {
+                e.getValue().execute(() -> e.getKey().onDefaultRemoteSessionChanged(sessionToken));
             }
         }
     }
diff --git a/packages/SettingsLib/src/com/android/settingslib/volume/MediaSessions.java b/packages/SettingsLib/src/com/android/settingslib/volume/MediaSessions.java
index 12ef639..fbf8a2f 100644
--- a/packages/SettingsLib/src/com/android/settingslib/volume/MediaSessions.java
+++ b/packages/SettingsLib/src/com/android/settingslib/volume/MediaSessions.java
@@ -33,7 +33,7 @@
 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.MediaSessionManager.RemoteSessionCallback;
 import android.media.session.PlaybackState;
 import android.os.Bundle;
 import android.os.Handler;
@@ -100,8 +100,8 @@
         mMgr.addOnActiveSessionsChangedListener(mSessionsListener, null, mHandler);
         mInit = true;
         postUpdateSessions();
-        mMgr.registerRemoteVolumeControllerCallback(mHandlerExecutor,
-                mRemoteVolumeControllerCallback);
+        mMgr.registerRemoteSessionCallback(mHandlerExecutor,
+                mRemoteSessionCallback);
     }
 
     protected void postUpdateSessions() {
@@ -116,7 +116,7 @@
         if (D.BUG) Log.d(TAG, "destroy");
         mInit = false;
         mMgr.removeOnActiveSessionsChangedListener(mSessionsListener);
-        mMgr.unregisterRemoteVolumeControllerCallback(mRemoteVolumeControllerCallback);
+        mMgr.unregisterRemoteSessionCallback(mRemoteSessionCallback);
     }
 
     /**
@@ -142,11 +142,11 @@
         mCallbacks.onRemoteVolumeChanged(token, flags);
     }
 
-    private void onUpdateRemoteControllerH(Token sessionToken) {
+    private void onUpdateRemoteSessionListH(Token sessionToken) {
         final MediaController controller =
                 sessionToken != null ? new MediaController(mContext, sessionToken) : null;
         final String pkg = controller != null ? controller.getPackageName() : null;
-        if (D.BUG) Log.d(TAG, "updateRemoteControllerH " + pkg);
+        if (D.BUG) Log.d(TAG, "onUpdateRemoteSessionListH " + pkg);
         // this may be our only indication that a remote session is changed, refresh
         postUpdateSessions();
     }
@@ -336,8 +336,8 @@
                 }
             };
 
-    private final RemoteVolumeControllerCallback mRemoteVolumeControllerCallback =
-            new RemoteVolumeControllerCallback() {
+    private final RemoteSessionCallback mRemoteSessionCallback =
+            new RemoteSessionCallback() {
                 @Override
                 public void onVolumeChanged(@NonNull MediaSession.Token sessionToken,
                         int flags) {
@@ -346,15 +346,17 @@
                 }
 
                 @Override
-                public void onSessionChanged(@Nullable MediaSession.Token sessionToken) {
-                    mHandler.obtainMessage(H.UPDATE_REMOTE_CONTROLLER, sessionToken).sendToTarget();
+                public void onDefaultRemoteSessionChanged(
+                        @Nullable MediaSession.Token sessionToken) {
+                    mHandler.obtainMessage(H.UPDATE_REMOTE_SESSION_LIST,
+                            sessionToken).sendToTarget();
                 }
     };
 
     private final class H extends Handler {
         private static final int UPDATE_SESSIONS = 1;
         private static final int REMOTE_VOLUME_CHANGED = 2;
-        private static final int UPDATE_REMOTE_CONTROLLER = 3;
+        private static final int UPDATE_REMOTE_SESSION_LIST = 3;
 
         private H(Looper looper) {
             super(looper);
@@ -369,8 +371,8 @@
                 case REMOTE_VOLUME_CHANGED:
                     onRemoteVolumeChangedH((Token) msg.obj, msg.arg1);
                     break;
-                case UPDATE_REMOTE_CONTROLLER:
-                    onUpdateRemoteControllerH((Token) msg.obj);
+                case UPDATE_REMOTE_SESSION_LIST:
+                    onUpdateRemoteSessionListH((Token) msg.obj);
                     break;
             }
         }
diff --git a/services/core/java/com/android/server/media/MediaSessionService.java b/services/core/java/com/android/server/media/MediaSessionService.java
index 17ceb15..1b27ef4 100644
--- a/services/core/java/com/android/server/media/MediaSessionService.java
+++ b/services/core/java/com/android/server/media/MediaSessionService.java
@@ -43,7 +43,7 @@
 import android.content.pm.ParceledListSlice;
 import android.media.AudioManager;
 import android.media.AudioPlaybackConfiguration;
-import android.media.IRemoteVolumeControllerCallback;
+import android.media.IRemoteSessionCallback;
 import android.media.Session2Token;
 import android.media.session.IActiveSessionsListener;
 import android.media.session.IOnMediaKeyEventDispatchedListener;
@@ -142,7 +142,7 @@
 
     // Used to notify System UI and Settings when remote volume was changed.
     @GuardedBy("mLock")
-    final RemoteCallbackList<IRemoteVolumeControllerCallback> mRemoteVolumeControllers =
+    final RemoteCallbackList<IRemoteSessionCallback> mRemoteVolumeControllers =
             new RemoteCallbackList<>();
 
     private SessionPolicyProvider mCustomSessionPolicyProvider;
@@ -304,7 +304,7 @@
             MediaSession.Token token = session.getSessionToken();
             for (int i = size - 1; i >= 0; i--) {
                 try {
-                    IRemoteVolumeControllerCallback cb =
+                    IRemoteSessionCallback cb =
                             mRemoteVolumeControllers.getBroadcastItem(i);
                     cb.onVolumeChanged(token, flags);
                 } catch (Exception e) {
@@ -713,7 +713,7 @@
 
             for (int i = size - 1; i >= 0; i--) {
                 try {
-                    IRemoteVolumeControllerCallback cb =
+                    IRemoteSessionCallback cb =
                             mRemoteVolumeControllers.getBroadcastItem(i);
                     cb.onSessionChanged(token);
                 } catch (Exception e) {
@@ -1839,7 +1839,7 @@
         }
 
         @Override
-        public void registerRemoteVolumeControllerCallback(IRemoteVolumeControllerCallback rvc) {
+        public void registerRemoteSessionCallback(IRemoteSessionCallback rvc) {
             final int pid = Binder.getCallingPid();
             final int uid = Binder.getCallingUid();
             final long token = Binder.clearCallingIdentity();
@@ -1854,7 +1854,7 @@
         }
 
         @Override
-        public void unregisterRemoteVolumeControllerCallback(IRemoteVolumeControllerCallback rvc) {
+        public void unregisterRemoteSessionCallback(IRemoteSessionCallback rvc) {
             final int pid = Binder.getCallingPid();
             final int uid = Binder.getCallingUid();
             final long token = Binder.clearCallingIdentity();