/*
|
* Copyright (C) 2014 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 com.android.server.media;
|
|
import android.media.session.MediaController.PlaybackInfo;
|
import android.media.session.MediaSession;
|
import android.media.session.PlaybackState;
|
import android.os.Debug;
|
import android.os.UserHandle;
|
import android.util.IntArray;
|
import android.util.Log;
|
import android.util.SparseArray;
|
|
import java.io.PrintWriter;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Objects;
|
|
/**
|
* Keeps track of media sessions and their priority for notifications, media
|
* button dispatch, etc.
|
* <p>This class isn't thread-safe. The caller should take care of the synchronization.
|
*/
|
class MediaSessionStack {
|
private static final boolean DEBUG = MediaSessionService.DEBUG;
|
private static final String TAG = "MediaSessionStack";
|
|
/**
|
* Listen the change in the media button session.
|
*/
|
interface OnMediaButtonSessionChangedListener {
|
/**
|
* Called when the media button session is changed.
|
*/
|
void onMediaButtonSessionChanged(MediaSessionRecord oldMediaButtonSession,
|
MediaSessionRecord newMediaButtonSession);
|
}
|
|
/**
|
* These are states that usually indicate the user took an action and should
|
* bump priority regardless of the old state.
|
*/
|
private static final int[] ALWAYS_PRIORITY_STATES = {
|
PlaybackState.STATE_FAST_FORWARDING,
|
PlaybackState.STATE_REWINDING,
|
PlaybackState.STATE_SKIPPING_TO_PREVIOUS,
|
PlaybackState.STATE_SKIPPING_TO_NEXT };
|
/**
|
* These are states that usually indicate the user took an action if they
|
* were entered from a non-priority state.
|
*/
|
private static final int[] TRANSITION_PRIORITY_STATES = {
|
PlaybackState.STATE_BUFFERING,
|
PlaybackState.STATE_CONNECTING,
|
PlaybackState.STATE_PLAYING };
|
|
/**
|
* Sorted list of the media sessions.
|
* The session of which PlaybackState is changed to ALWAYS_PRIORITY_STATES or
|
* TRANSITION_PRIORITY_STATES comes first.
|
* @see #shouldUpdatePriority
|
*/
|
private final List<MediaSessionRecord> mSessions = new ArrayList<MediaSessionRecord>();
|
|
private final AudioPlayerStateMonitor mAudioPlayerStateMonitor;
|
private final OnMediaButtonSessionChangedListener mOnMediaButtonSessionChangedListener;
|
|
/**
|
* The media button session which receives media key events.
|
* It could be null if the previous media buttion session is released.
|
*/
|
private MediaSessionRecord mMediaButtonSession;
|
|
private MediaSessionRecord mCachedVolumeDefault;
|
|
/**
|
* Cache the result of the {@link #getActiveSessions} per user.
|
*/
|
private final SparseArray<ArrayList<MediaSessionRecord>> mCachedActiveLists =
|
new SparseArray<>();
|
|
MediaSessionStack(AudioPlayerStateMonitor monitor, OnMediaButtonSessionChangedListener listener) {
|
mAudioPlayerStateMonitor = monitor;
|
mOnMediaButtonSessionChangedListener = listener;
|
}
|
|
/**
|
* Add a record to the priority tracker.
|
*
|
* @param record The record to add.
|
*/
|
public void addSession(MediaSessionRecord record) {
|
mSessions.add(record);
|
clearCache(record.getUserId());
|
|
// Update the media button session.
|
// The added session could be the session from the package with the audio playback.
|
// This can happen if an app starts audio playback before creating media session.
|
updateMediaButtonSessionIfNeeded();
|
}
|
|
/**
|
* Remove a record from the priority tracker.
|
*
|
* @param record The record to remove.
|
*/
|
public void removeSession(MediaSessionRecord record) {
|
mSessions.remove(record);
|
if (mMediaButtonSession == record) {
|
// When the media button session is removed, nullify the media button session and do not
|
// search for the alternative media session within the app. It's because the alternative
|
// media session might be a dummy which isn't able to handle the media key events.
|
updateMediaButtonSession(null);
|
}
|
clearCache(record.getUserId());
|
}
|
|
/**
|
* Return if the record exists in the priority tracker.
|
*/
|
public boolean contains(MediaSessionRecord record) {
|
return mSessions.contains(record);
|
}
|
|
/**
|
* Gets the {@link MediaSessionRecord} with the {@link MediaSession.Token}.
|
*
|
* @param sessionToken session token
|
* @return the MediaSessionRecord. Can be {@code null} if the session is gone meanwhile.
|
*/
|
public MediaSessionRecord getMediaSessionRecord(MediaSession.Token sessionToken) {
|
for (MediaSessionRecord record : mSessions) {
|
if (Objects.equals(record.getControllerBinder(), sessionToken.getBinder())) {
|
return record;
|
}
|
}
|
return null;
|
}
|
|
/**
|
* Notify the priority tracker that a session's playback state changed.
|
*
|
* @param record The record that changed.
|
* @param oldState Its old playback state.
|
* @param newState Its new playback state.
|
*/
|
public void onPlaystateChanged(MediaSessionRecord record, int oldState, int newState) {
|
if (shouldUpdatePriority(oldState, newState)) {
|
mSessions.remove(record);
|
mSessions.add(0, record);
|
clearCache(record.getUserId());
|
} else if (!MediaSession.isActiveState(newState)) {
|
// Just clear the volume cache when a state goes inactive
|
mCachedVolumeDefault = null;
|
}
|
|
// In most cases, playback state isn't needed for finding media button session,
|
// but we only use it as a hint if an app has multiple local media sessions.
|
// In that case, we pick the media session whose PlaybackState matches
|
// the audio playback configuration.
|
if (mMediaButtonSession != null && mMediaButtonSession.getUid() == record.getUid()) {
|
MediaSessionRecord newMediaButtonSession =
|
findMediaButtonSession(mMediaButtonSession.getUid());
|
if (newMediaButtonSession != mMediaButtonSession) {
|
updateMediaButtonSession(newMediaButtonSession);
|
}
|
}
|
}
|
|
/**
|
* Handle the change in activeness for a session.
|
*
|
* @param record The record that changed.
|
*/
|
public void onSessionStateChange(MediaSessionRecord record) {
|
// For now just clear the cache. Eventually we'll selectively clear
|
// depending on what changed.
|
clearCache(record.getUserId());
|
}
|
|
/**
|
* Update the media button session if needed.
|
* <p>The media button session is the session that will receive the media button events.
|
* <p>We send the media button events to the lastly played app. If the app has the media
|
* session, the session will receive the media button events.
|
*/
|
public void updateMediaButtonSessionIfNeeded() {
|
if (DEBUG) {
|
Log.d(TAG, "updateMediaButtonSessionIfNeeded, callers=" + Debug.getCallers(2));
|
}
|
IntArray audioPlaybackUids = mAudioPlayerStateMonitor.getSortedAudioPlaybackClientUids();
|
for (int i = 0; i < audioPlaybackUids.size(); i++) {
|
MediaSessionRecord mediaButtonSession =
|
findMediaButtonSession(audioPlaybackUids.get(i));
|
if (mediaButtonSession != null) {
|
// Found the media button session.
|
mAudioPlayerStateMonitor.cleanUpAudioPlaybackUids(mediaButtonSession.getUid());
|
if (mMediaButtonSession != mediaButtonSession) {
|
updateMediaButtonSession(mediaButtonSession);
|
}
|
return;
|
}
|
}
|
}
|
|
/**
|
* Find the media button session with the given {@param uid}.
|
* If the app has multiple media sessions, the media session whose playback state is not null
|
* and matches the audio playback state becomes the media button session. Otherwise the top
|
* priority session becomes the media button session.
|
*
|
* @return The media button session. Returns {@code null} if the app doesn't have a media
|
* session.
|
*/
|
private MediaSessionRecord findMediaButtonSession(int uid) {
|
MediaSessionRecord mediaButtonSession = null;
|
for (MediaSessionRecord session : mSessions) {
|
if (uid == session.getUid()) {
|
if (session.getPlaybackState() != null && session.isPlaybackActive() ==
|
mAudioPlayerStateMonitor.isPlaybackActive(session.getUid())) {
|
// If there's a media session whose PlaybackState matches
|
// the audio playback state, return it immediately.
|
return session;
|
}
|
if (mediaButtonSession == null) {
|
// Among the media sessions whose PlaybackState doesn't match
|
// the audio playback state, pick the top priority.
|
mediaButtonSession = session;
|
}
|
}
|
}
|
return mediaButtonSession;
|
}
|
|
/**
|
* Get the current priority sorted list of active sessions. The most
|
* important session is at index 0 and the least important at size - 1.
|
*
|
* @param userId The user to check. It can be {@link UserHandle#USER_ALL} to get all sessions
|
* for all users in this {@link MediaSessionStack}.
|
* @return All the active sessions in priority order.
|
*/
|
public ArrayList<MediaSessionRecord> getActiveSessions(int userId) {
|
ArrayList<MediaSessionRecord> cachedActiveList = mCachedActiveLists.get(userId);
|
if (cachedActiveList == null) {
|
cachedActiveList = getPriorityList(true, userId);
|
mCachedActiveLists.put(userId, cachedActiveList);
|
}
|
return cachedActiveList;
|
}
|
|
/**
|
* Get the media button session which receives the media button events.
|
*
|
* @return The media button session or null.
|
*/
|
public MediaSessionRecord getMediaButtonSession() {
|
return mMediaButtonSession;
|
}
|
|
private void updateMediaButtonSession(MediaSessionRecord newMediaButtonSession) {
|
MediaSessionRecord oldMediaButtonSession = mMediaButtonSession;
|
mMediaButtonSession = newMediaButtonSession;
|
mOnMediaButtonSessionChangedListener.onMediaButtonSessionChanged(
|
oldMediaButtonSession, newMediaButtonSession);
|
}
|
|
public MediaSessionRecord getDefaultVolumeSession() {
|
if (mCachedVolumeDefault != null) {
|
return mCachedVolumeDefault;
|
}
|
ArrayList<MediaSessionRecord> records = getPriorityList(true, UserHandle.USER_ALL);
|
int size = records.size();
|
for (int i = 0; i < size; i++) {
|
MediaSessionRecord record = records.get(i);
|
if (record.isPlaybackActive()) {
|
mCachedVolumeDefault = record;
|
return record;
|
}
|
}
|
return null;
|
}
|
|
public MediaSessionRecord getDefaultRemoteSession(int userId) {
|
ArrayList<MediaSessionRecord> records = getPriorityList(true, userId);
|
|
int size = records.size();
|
for (int i = 0; i < size; i++) {
|
MediaSessionRecord record = records.get(i);
|
if (record.getPlaybackType() == PlaybackInfo.PLAYBACK_TYPE_REMOTE) {
|
return record;
|
}
|
}
|
return null;
|
}
|
|
public void dump(PrintWriter pw, String prefix) {
|
ArrayList<MediaSessionRecord> sortedSessions = getPriorityList(false,
|
UserHandle.USER_ALL);
|
int count = sortedSessions.size();
|
pw.println(prefix + "Media button session is " + mMediaButtonSession);
|
pw.println(prefix + "Sessions Stack - have " + count + " sessions:");
|
String indent = prefix + " ";
|
for (int i = 0; i < count; i++) {
|
MediaSessionRecord record = sortedSessions.get(i);
|
record.dump(pw, indent);
|
pw.println();
|
}
|
}
|
|
/**
|
* Get a priority sorted list of sessions. Can filter to only return active
|
* sessions or sessions.
|
* <p>Here's the priority order.
|
* <li>Active sessions whose PlaybackState is active</li>
|
* <li>Active sessions whose PlaybackState is inactive</li>
|
* <li>Inactive sessions</li>
|
*
|
* @param activeOnly True to only return active sessions, false to return
|
* all sessions.
|
* @param userId The user to get sessions for. {@link UserHandle#USER_ALL}
|
* will return sessions for all users.
|
* @return The priority sorted list of sessions.
|
*/
|
public ArrayList<MediaSessionRecord> getPriorityList(boolean activeOnly, int userId) {
|
ArrayList<MediaSessionRecord> result = new ArrayList<MediaSessionRecord>();
|
int lastPlaybackActiveIndex = 0;
|
int lastActiveIndex = 0;
|
|
int size = mSessions.size();
|
for (int i = 0; i < size; i++) {
|
final MediaSessionRecord session = mSessions.get(i);
|
|
if (userId != UserHandle.USER_ALL && userId != session.getUserId()) {
|
// Filter out sessions for the wrong user
|
continue;
|
}
|
|
if (!session.isActive()) {
|
if (!activeOnly) {
|
// If we're getting unpublished as well always put them at
|
// the end
|
result.add(session);
|
}
|
continue;
|
}
|
|
if (session.isPlaybackActive()) {
|
result.add(lastPlaybackActiveIndex++, session);
|
lastActiveIndex++;
|
} else {
|
result.add(lastActiveIndex++, session);
|
}
|
}
|
|
return result;
|
}
|
|
private boolean shouldUpdatePriority(int oldState, int newState) {
|
if (containsState(newState, ALWAYS_PRIORITY_STATES)) {
|
return true;
|
}
|
if (!containsState(oldState, TRANSITION_PRIORITY_STATES)
|
&& containsState(newState, TRANSITION_PRIORITY_STATES)) {
|
return true;
|
}
|
return false;
|
}
|
|
private boolean containsState(int state, int[] states) {
|
for (int i = 0; i < states.length; i++) {
|
if (states[i] == state) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private void clearCache(int userId) {
|
mCachedVolumeDefault = null;
|
mCachedActiveLists.remove(userId);
|
// mCachedActiveLists may also include the list of sessions for UserHandle.USER_ALL,
|
// so they also need to be cleared.
|
mCachedActiveLists.remove(UserHandle.USER_ALL);
|
}
|
}
|
