FileDocCategorySizeDatePackage
MediaSessionManager.javaAPI DocAndroid 5.1 API14205Thu Mar 12 22:22:30 GMT 2015android.media.session

MediaSessionManager

public final class MediaSessionManager extends Object
Provides support for interacting with {@link MediaSession media sessions} that applications have published to express their ongoing media playback state.

Use Context.getSystemService(Context.MEDIA_SESSION_SERVICE) to get an instance of this class.

see
MediaSession
see
MediaController

Fields Summary
private static final String
TAG
private final android.util.ArrayMap
mListeners
private final Object
mLock
private final android.media.session.ISessionManager
mService
private android.content.Context
mContext
public static final int
DIRECTION_MUTE
Special flag for sending the mute key to dispatchAdjustVolume used by the system.
Constructors Summary
public MediaSessionManager(android.content.Context context)

hide


          
       
        // Consider rewriting like DisplayManagerGlobal
        // Decide if we need context
        mContext = context;
        IBinder b = ServiceManager.getService(Context.MEDIA_SESSION_SERVICE);
        mService = ISessionManager.Stub.asInterface(b);
Methods Summary
public voidaddOnActiveSessionsChangedListener(android.media.session.MediaSessionManager$OnActiveSessionsChangedListener sessionListener, android.content.ComponentName notificationListener)
Add a listener to be notified when the list of active sessions changes.This requires the android.Manifest.permission.MEDIA_CONTENT_CONTROL permission be held by the calling app. You may also retrieve this list if your app is an enabled notification listener using the {@link NotificationListenerService} APIs, in which case you must pass the {@link ComponentName} of your enabled listener. Updates will be posted to the thread that registered the listener.

param
sessionListener The listener to add.
param
notificationListener The enabled notification listener component. May be null.

        addOnActiveSessionsChangedListener(sessionListener, notificationListener, null);
public voidaddOnActiveSessionsChangedListener(android.media.session.MediaSessionManager$OnActiveSessionsChangedListener sessionListener, android.content.ComponentName notificationListener, android.os.Handler handler)
Add a listener to be notified when the list of active sessions changes.This requires the android.Manifest.permission.MEDIA_CONTENT_CONTROL permission be held by the calling app. You may also retrieve this list if your app is an enabled notification listener using the {@link NotificationListenerService} APIs, in which case you must pass the {@link ComponentName} of your enabled listener. Updates will be posted to the handler specified or to the caller's thread if the handler is null.

param
sessionListener The listener to add.
param
notificationListener The enabled notification listener component. May be null.
param
handler The handler to post events to.

        addOnActiveSessionsChangedListener(sessionListener, notificationListener,
                UserHandle.myUserId(), handler);
public voidaddOnActiveSessionsChangedListener(android.media.session.MediaSessionManager$OnActiveSessionsChangedListener sessionListener, android.content.ComponentName notificationListener, int userId, android.os.Handler handler)
Add a listener to be notified when the list of active sessions changes.This requires the android.Manifest.permission.MEDIA_CONTENT_CONTROL permission be held by the calling app. You may also retrieve this list if your app is an enabled notification listener using the {@link NotificationListenerService} APIs, in which case you must pass the {@link ComponentName} of your enabled listener.

param
sessionListener The listener to add.
param
notificationListener The enabled notification listener component. May be null.
param
userId The userId to listen for changes on.
param
handler The handler to post updates on.
hide

        if (sessionListener == null) {
            throw new IllegalArgumentException("listener may not be null");
        }
        if (handler == null) {
            handler = new Handler();
        }
        synchronized (mLock) {
            if (mListeners.get(sessionListener) != null) {
                Log.w(TAG, "Attempted to add session listener twice, ignoring.");
                return;
            }
            SessionsChangedWrapper wrapper = new SessionsChangedWrapper(sessionListener, handler);
            try {
                mService.addSessionsListener(wrapper.mStub, notificationListener, userId);
                mListeners.put(sessionListener, wrapper);
            } catch (RemoteException e) {
                Log.e(TAG, "Error in addOnActiveSessionsChangedListener.", e);
            }
        }
public ISessioncreateSession(MediaSession.CallbackStub cbStub, java.lang.String tag, int userId)
Create a new session in the system and get the binder for it.

param
tag A short name for debugging purposes.
return
The binder object from the system
hide

        return mService.createSession(mContext.getPackageName(), cbStub, tag, userId);
public voiddispatchAdjustVolume(int suggestedStream, int direction, int flags)
Dispatch an adjust volume request to the system. It will be sent to the most relevant audio stream or media session. The direction must be one of {@link AudioManager#ADJUST_LOWER}, {@link AudioManager#ADJUST_RAISE}, {@link AudioManager#ADJUST_SAME}.

param
suggestedStream The stream to fall back to if there isn't a relevant stream
param
direction The direction to adjust volume in.
param
flags Any flags to include with the volume change.
hide

        try {
            mService.dispatchAdjustVolume(suggestedStream, direction, flags);
        } catch (RemoteException e) {
            Log.e(TAG, "Failed to send adjust volume.", e);
        }
public voiddispatchMediaKeyEvent(android.view.KeyEvent keyEvent)
Send a media key event. The receiver will be selected automatically.

param
keyEvent The KeyEvent to send.
hide

        dispatchMediaKeyEvent(keyEvent, false);
public voiddispatchMediaKeyEvent(android.view.KeyEvent keyEvent, boolean needWakeLock)
Send a media key event. The receiver will be selected automatically.

param
keyEvent The KeyEvent to send.
param
needWakeLock True if a wake lock should be held while sending the key.
hide

        try {
            mService.dispatchMediaKeyEvent(keyEvent, needWakeLock);
        } catch (RemoteException e) {
            Log.e(TAG, "Failed to send key event.", e);
        }
public java.util.ListgetActiveSessions(android.content.ComponentName notificationListener)
Get a list of controllers for all ongoing sessions. The controllers will be provided in priority order with the most important controller at index 0.

This requires the android.Manifest.permission.MEDIA_CONTENT_CONTROL permission be held by the calling app. You may also retrieve this list if your app is an enabled notification listener using the {@link NotificationListenerService} APIs, in which case you must pass the {@link ComponentName} of your enabled listener.

param
notificationListener The enabled notification listener component. May be null.
return
A list of controllers for ongoing sessions.

        return getActiveSessionsForUser(notificationListener, UserHandle.myUserId());
public java.util.ListgetActiveSessionsForUser(android.content.ComponentName notificationListener, int userId)
Get active sessions for a specific user. To retrieve actions for a user other than your own you must hold the {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL} permission in addition to any other requirements. If you are an enabled notification listener you may only get sessions for the users you are enabled for.

param
notificationListener The enabled notification listener component. May be null.
param
userId The user id to fetch sessions for.
return
A list of controllers for ongoing sessions.
hide

        ArrayList<MediaController> controllers = new ArrayList<MediaController>();
        try {
            List<IBinder> binders = mService.getSessions(notificationListener, userId);
            int size = binders.size();
            for (int i = 0; i < size; i++) {
                MediaController controller = new MediaController(mContext, ISessionController.Stub
                        .asInterface(binders.get(i)));
                controllers.add(controller);
            }
        } catch (RemoteException e) {
            Log.e(TAG, "Failed to get active sessions: ", e);
        }
        return controllers;
public booleanisGlobalPriorityActive()
Check if the global priority session is currently active. This can be used to decide if media keys should be sent to the session or to the app.

hide

        try {
            return mService.isGlobalPriorityActive();
        } catch (RemoteException e) {
            Log.e(TAG, "Failed to check if the global priority is active.", e);
        }
        return false;
public voidremoveOnActiveSessionsChangedListener(android.media.session.MediaSessionManager$OnActiveSessionsChangedListener listener)
Stop receiving active sessions updates on the specified listener.

param
listener The listener to remove.

        if (listener == null) {
            throw new IllegalArgumentException("listener may not be null");
        }
        synchronized (mLock) {
            SessionsChangedWrapper wrapper = mListeners.remove(listener);
            if (wrapper != null) {
                try {
                    mService.removeSessionsListener(wrapper.mStub);
                } catch (RemoteException e) {
                    Log.e(TAG, "Error in removeOnActiveSessionsChangedListener.", e);
                }
            }
        }
public voidsetRemoteVolumeController(android.media.IRemoteVolumeController rvc)
Set the remote volume controller to receive volume updates on. Only for use by system UI.

param
rvc The volume controller to receive updates on.
hide

        try {
            mService.setRemoteVolumeController(rvc);
        } catch (RemoteException e) {
            Log.e(TAG, "Error in setRemoteVolumeController.", e);
        }