MediaSession

FLAG_HANDLES_MEDIA_BUTTONS

 public static final int FLAG_HANDLES_MEDIA_BUTTONS

This constant was deprecated in API level 26.
This flag is no longer used. All media sessions are expected to handle media button events now.

Set this flag on the session to indicate that it can handle media button events.

Constant Value: 1 (0x00000001)

FLAG_HANDLES_TRANSPORT_CONTROLS

 public static final int FLAG_HANDLES_TRANSPORT_CONTROLS

This constant was deprecated in API level 26.
This flag is no longer used. All media sessions are expected to handle transport controls now.

Set this flag on the session to indicate that it handles transport control commands through its Callback.

Constant Value: 2 (0x00000002)

MediaSession

 public MediaSession (Context context,                  String tag)

Creates a new session. The session will automatically be registered with the system but will not be published until setActive(true) is called. You must call release() when finished with the session.

Note that RuntimeException will be thrown if an app creates too many sessions.

MediaSession

 public MediaSession (Context context,                  String tag,                  Bundle sessionInfo)

Creates a new session. The session will automatically be registered with the system, but will not be published until setActive(true) is called. You must call release() when finished with the session.

The sessionInfo can include additional unchanging information about this session. For example, it can include the version of the application, or the list of the custom commands that this session supports.

Note that RuntimeException will be thrown if an app creates too many sessions.

getController

 public MediaController getController ()

Get a controller for this session. This is a convenience method to avoid having to cache your own controller in process.

getCurrentControllerInfo

 public MediaSessionManager.RemoteUserInfo getCurrentControllerInfo ()

Gets the controller information who sent the current request.

Note: This is only valid while in a request callback, such as Callback.onPlay.

getSessionToken

 public MediaSession.Token getSessionToken ()

Retrieve a token object that can be used by apps to create a MediaController for interacting with this session. The owner of the session is responsible for deciding how to distribute these tokens.

isActive

 public boolean isActive ()

Get the current active state of this session.

If false then your session's controller will not be discoverable via MediaSessionManager.getActiveSessions(ComponentName) by other apps, including system apps.

release

 public void release ()

This must be called when an app has finished performing playback. If playback is expected to start again shortly the session can be left open, but it must be released if your activity or service is being destroyed.

sendSessionEvent

 public void sendSessionEvent (String event,                  Bundle extras)

Send a proprietary event to all MediaControllers listening to this Session. It's up to the Controller/Session owner to determine the meaning of any events.

setActive

 public void setActive (boolean active)

Set if this session is currently active.

If set to false then your session's controller will not be discoverable via MediaSessionManager.getActiveSessions(ComponentName) by other apps, including system apps.

setCallback

 public void setCallback (MediaSession.Callback callback)

Set the callback to receive updates for the MediaSession. This includes media button events and transport controls. The caller's thread will be used to post updates.

Set the callback to null to stop receiving updates.

setCallback

 public void setCallback (MediaSession.Callback callback,                  Handler handler)

Set the callback to receive updates for the MediaSession. This includes media button events and transport controls.

Set the callback to null to stop receiving updates.

setExtras

 public void setExtras (Bundle extras)

Set some extras that can be associated with the MediaSession. No assumptions should be made as to how a MediaController will handle these extras. Keys should be fully qualified (e.g. com.example.MY_EXTRA) to avoid conflicts.

setFlags

 public void setFlags (int flags)

Set any flags for the session.

setMediaButtonBroadcastReceiver

 public void setMediaButtonBroadcastReceiver (ComponentName broadcastReceiver)

Set the component name of the manifest-declared BroadcastReceiver class that should receive media buttons. This allows restarting playback after the session has been stopped. If your app is started in this way an Intent.ACTION_MEDIA_BUTTON intent will be sent to the broadcast receiver. On apps targeting Android U and above, this will throw an IllegalArgumentException if the provided ComponentName does not resolve to an existing broadcast receiver.

Note: The given BroadcastReceiver should belong to the same package as the context that was given when creating MediaSession.

setMediaButtonReceiver

 public void setMediaButtonReceiver (PendingIntent mbr)

This method was deprecated in API level 31.
Use setMediaButtonBroadcastReceiver(android.content.ComponentName) instead.

Set a pending intent for your media button receiver to allow restarting playback after the session has been stopped.

If your app is started in this way an Intent.ACTION_MEDIA_BUTTON intent will be sent via the pending intent.

The provided PendingIntent must not target an activity. On apps targeting Android V and above, passing an activity pending intent to this method causes an IllegalArgumentException. On apps targeting Android U and below, passing an activity pending intent causes the call to be ignored. Refer to this guide for more information.

The pending intent is recommended to be explicit to follow the security recommendation of PendingIntent.getService.

setMetadata

 public void setMetadata (MediaMetadata metadata)

Update the current metadata. New metadata can be created using MediaMetadata.Builder. This operation may take time proportional to the size of the bitmap to replace large bitmaps with a scaled down copy.

setPlaybackState

 public void setPlaybackState (PlaybackState state)

Update the current playback state.

setPlaybackToLocal

 public void setPlaybackToLocal (AudioAttributes attributes)

Set the attributes for this session's audio. This will affect the system's volume handling for this session. If setPlaybackToRemote(VolumeProvider) was previously called it will stop receiving volume commands and the system will begin sending volume changes to the appropriate stream.

By default sessions use attributes for media.

setPlaybackToRemote

 public void setPlaybackToRemote (VolumeProvider volumeProvider)

Configure this session to use remote volume handling. This must be called to receive volume button events, otherwise the system will adjust the appropriate stream volume for this session. If setPlaybackToLocal(AudioAttributes) was previously called the system will stop handling volume changes for this session and pass them to the volume provider instead.

setQueue

 public void setQueue (List<MediaSession.QueueItem> queue)

Update the list of items in the play queue. It is an ordered list and should contain the current item, and previous or upcoming items if they exist. Specify null if there is no current play queue.

The queue should be of reasonable size. If the play queue is unbounded within your app, it is better to send a reasonable amount in a sliding window instead.

setQueueTitle

 public void setQueueTitle (CharSequence title)

Set the title of the play queue. The UI should display this title along with the play queue itself. e.g. "Play Queue", "Now Playing", or an album name.

setRatingType

 public void setRatingType (int type)

Set the style of rating used by this session. Apps trying to set the rating should use this style. Must be one of the following:

• Rating.RATING_NONE
• Rating.RATING_3_STARS
• Rating.RATING_4_STARS
• Rating.RATING_5_STARS
• Rating.RATING_HEART
• Rating.RATING_PERCENTAGE
• Rating.RATING_THUMB_UP_DOWN

setSessionActivity

 public void setSessionActivity (PendingIntent pi)

Set an intent for launching UI for this Session. This can be used as a quick link to an ongoing media screen. The intent should be for an activity that may be started using Activity.startActivity(Intent).

finalize

 protected void finalize ()

Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the finalize method to dispose of system resources or to perform other cleanup.

The general contract of finalize is that it is invoked if and when the Java virtual machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, except as a result of an action taken by the finalization of some other object or class which is ready to be finalized. The finalize method may take any action, including making this object available again to other threads; the usual purpose of finalize, however, is to perform cleanup actions before the object is irrevocably discarded. For example, the finalize method for an object that represents an input/output connection might perform explicit I/O transactions to break the connection before the object is permanently discarded.

The finalize method of class Object performs no special action; it simply returns normally. Subclasses of Object may override this definition.

The Java programming language does not guarantee which thread will invoke the finalize method for any given object. It is guaranteed, however, that the thread that invokes finalize will not be holding any user-visible synchronization locks when finalize is invoked. If an uncaught exception is thrown by the finalize method, the exception is ignored and finalization of that object terminates.

After the finalize method has been invoked for an object, no further action is taken until the Java virtual machine has again determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, including possible actions by other objects or classes which are ready to be finalized, at which point the object may be discarded.

The finalize method is never invoked more than once by a Java virtual machine for any given object.

Any exception thrown by the finalize method causes the finalization of this object to be halted, but is otherwise ignored.