| /* |
| * Copyright 2018 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.bluetooth.avrcp; |
| |
| import android.annotation.NonNull; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ResolveInfo; |
| import android.media.session.MediaSession; |
| import android.media.session.MediaSessionManager; |
| import android.media.session.PlaybackState; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| |
| import com.android.bluetooth.Utils; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| /** |
| * This class is directly responsible of maintaining the list of Browsable Players as well as |
| * the list of Addressable Players. This variation of the list doesn't actually list all the |
| * available players for a getAvailableMediaPlayers request. Instead it only reports one media |
| * player with ID=0 and all the other browsable players are folders in the root of that player. |
| * |
| * Changing the directory to a browsable player will allow you to traverse that player as normal. |
| * By only having one root player, we never have to send Addressed Player Changed notifications, |
| * UIDs Changed notifications, or Available Players Changed notifications. |
| * |
| * TODO (apanicke): Add non-browsable players as song items to the root folder. Selecting that |
| * player would effectively cause player switch by sending a play command to that player. |
| */ |
| public class MediaPlayerList { |
| private static final String TAG = "AvrcpMediaPlayerList"; |
| private static final boolean DEBUG = true; |
| static boolean sTesting = false; |
| |
| private static final String PACKAGE_SCHEME = "package"; |
| private static final int NO_ACTIVE_PLAYER = 0; |
| private static final int BLUETOOTH_PLAYER_ID = 0; |
| private static final String BLUETOOTH_PLAYER_NAME = "Bluetooth Player"; |
| |
| // mediaId's for the now playing list will be in the form of "NowPlayingId[XX]" where [XX] |
| // is the Queue ID for the requested item. |
| private static final String NOW_PLAYING_ID_PATTERN = Util.NOW_PLAYING_PREFIX + "([0-9]*)"; |
| |
| // mediaId's for folder browsing will be in the form of [XX][mediaid], where [XX] is a |
| // two digit representation of the player id and [mediaid] is the original media id as a |
| // string. |
| private static final String BROWSE_ID_PATTERN = "\\d\\d.*"; |
| |
| private Context mContext; |
| private Looper mLooper; // Thread all media player callbacks and timeouts happen on |
| private PackageManager mPackageManager; |
| private MediaSessionManager mMediaSessionManager; |
| |
| private Map<Integer, MediaPlayerWrapper> mMediaPlayers = |
| Collections.synchronizedMap(new HashMap<Integer, MediaPlayerWrapper>()); |
| private Map<String, Integer> mMediaPlayerIds = |
| Collections.synchronizedMap(new HashMap<String, Integer>()); |
| private Map<Integer, BrowsedPlayerWrapper> mBrowsablePlayers = |
| Collections.synchronizedMap(new HashMap<Integer, BrowsedPlayerWrapper>()); |
| private int mActivePlayerId = NO_ACTIVE_PLAYER; |
| |
| private AvrcpTargetService.ListCallback mCallback; |
| private BrowsablePlayerConnector mBrowsablePlayerConnector; |
| |
| interface MediaUpdateCallback { |
| void run(MediaData data); |
| } |
| |
| interface GetPlayerRootCallback { |
| void run(int playerId, boolean success, String rootId, int numItems); |
| } |
| |
| interface GetFolderItemsCallback { |
| void run(String parentId, List<ListItem> items); |
| } |
| |
| interface FolderUpdateCallback { |
| void run(boolean availablePlayers, boolean addressedPlayers, boolean uids); |
| } |
| |
| MediaPlayerList(Looper looper, Context context) { |
| Log.v(TAG, "Creating MediaPlayerList"); |
| |
| mLooper = looper; |
| mContext = context; |
| |
| // Register for intents where available players might have changed |
| IntentFilter pkgFilter = new IntentFilter(); |
| pkgFilter.addAction(Intent.ACTION_PACKAGE_REMOVED); |
| pkgFilter.addAction(Intent.ACTION_PACKAGE_DATA_CLEARED); |
| pkgFilter.addAction(Intent.ACTION_PACKAGE_ADDED); |
| pkgFilter.addAction(Intent.ACTION_PACKAGE_CHANGED); |
| pkgFilter.addDataScheme(PACKAGE_SCHEME); |
| context.registerReceiver(mPackageChangedBroadcastReceiver, pkgFilter); |
| |
| mMediaSessionManager = |
| (MediaSessionManager) context.getSystemService(Context.MEDIA_SESSION_SERVICE); |
| mMediaSessionManager.addOnActiveSessionsChangedListener( |
| mActiveSessionsChangedListener, null, new Handler(looper)); |
| mMediaSessionManager.setCallback(mButtonDispatchCallback, null); |
| } |
| |
| void init(AvrcpTargetService.ListCallback callback) { |
| Log.v(TAG, "Initializing MediaPlayerList"); |
| mCallback = callback; |
| |
| // Build the list of browsable players and afterwards, build the list of media players |
| Intent intent = new Intent(android.service.media.MediaBrowserService.SERVICE_INTERFACE); |
| List<ResolveInfo> playerList = |
| mContext |
| .getApplicationContext() |
| .getPackageManager() |
| .queryIntentServices(intent, PackageManager.MATCH_ALL); |
| |
| mBrowsablePlayerConnector = BrowsablePlayerConnector.connectToPlayers(mContext, mLooper, |
| playerList, (List<BrowsedPlayerWrapper> players) -> { |
| Log.i(TAG, "init: Browsable Player list size is " + players.size()); |
| |
| // Check to see if the list has been cleaned up before this completed |
| if (mMediaSessionManager == null) { |
| return; |
| } |
| |
| for (BrowsedPlayerWrapper wrapper : players) { |
| // Generate new id and add the browsable player |
| if (!mMediaPlayerIds.containsKey(wrapper.getPackageName())) { |
| mMediaPlayerIds.put(wrapper.getPackageName(), getFreeMediaPlayerId()); |
| } |
| |
| d("Adding Browser Wrapper for " + wrapper.getPackageName() + " with id " |
| + mMediaPlayerIds.get(wrapper.getPackageName())); |
| |
| mBrowsablePlayers.put(mMediaPlayerIds.get(wrapper.getPackageName()), wrapper); |
| |
| wrapper.getFolderItems(wrapper.getRootId(), |
| (int status, String mediaId, List<ListItem> results) -> { |
| d("Got the contents for: " + mediaId + " : num results=" |
| + results.size()); |
| }); |
| } |
| |
| // Construct the list of current players |
| d("Initializing list of current media players"); |
| List<android.media.session.MediaController> controllers = |
| mMediaSessionManager.getActiveSessions(null); |
| |
| for (android.media.session.MediaController controller : controllers) { |
| addMediaPlayer(controller); |
| } |
| |
| // If there were any active players and we don't already have one due to the Media |
| // Framework Callbacks then set the highest priority one to active |
| if (mActivePlayerId == 0 && mMediaPlayers.size() > 0) setActivePlayer(1); |
| }); |
| } |
| |
| void cleanup() { |
| mContext.unregisterReceiver(mPackageChangedBroadcastReceiver); |
| |
| mMediaSessionManager.removeOnActiveSessionsChangedListener(mActiveSessionsChangedListener); |
| mMediaSessionManager.setCallback(null, null); |
| mMediaSessionManager = null; |
| |
| mMediaPlayerIds.clear(); |
| |
| for (MediaPlayerWrapper player : mMediaPlayers.values()) { |
| player.cleanup(); |
| } |
| mMediaPlayers.clear(); |
| |
| if (mBrowsablePlayerConnector != null) { |
| mBrowsablePlayerConnector.cleanup(); |
| } |
| for (BrowsedPlayerWrapper player : mBrowsablePlayers.values()) { |
| player.disconnect(); |
| } |
| mBrowsablePlayers.clear(); |
| } |
| |
| int getCurrentPlayerId() { |
| return BLUETOOTH_PLAYER_ID; |
| } |
| |
| int getFreeMediaPlayerId() { |
| int id = 1; |
| while (mMediaPlayerIds.containsValue(id)) { |
| id++; |
| } |
| return id; |
| } |
| |
| MediaPlayerWrapper getActivePlayer() { |
| return mMediaPlayers.get(mActivePlayerId); |
| } |
| |
| |
| |
| // In this case the displayed player is the Bluetooth Player, the number of items is equal |
| // to the number of players. The root ID will always be empty string in this case as well. |
| void getPlayerRoot(int playerId, GetPlayerRootCallback cb) { |
| cb.run(playerId, playerId == BLUETOOTH_PLAYER_ID, "", mBrowsablePlayers.size()); |
| } |
| |
| // Return the "Bluetooth Player" as the only player always |
| List<PlayerInfo> getMediaPlayerList() { |
| PlayerInfo info = new PlayerInfo(); |
| info.id = BLUETOOTH_PLAYER_ID; |
| info.name = BLUETOOTH_PLAYER_NAME; |
| info.browsable = true; |
| List<PlayerInfo> ret = new ArrayList<PlayerInfo>(); |
| ret.add(info); |
| |
| return ret; |
| } |
| |
| @NonNull |
| String getCurrentMediaId() { |
| final MediaPlayerWrapper player = getActivePlayer(); |
| if (player == null) return ""; |
| |
| final PlaybackState state = player.getPlaybackState(); |
| final List<Metadata> queue = player.getCurrentQueue(); |
| |
| // Disable the now playing list if the player doesn't have a queue or provide an active |
| // queue ID that can be used to determine the active song in the queue. |
| if (state == null |
| || state.getActiveQueueItemId() == MediaSession.QueueItem.UNKNOWN_ID |
| || queue.size() == 0) { |
| d("getCurrentMediaId: No active queue item Id sending empty mediaId: PlaybackState=" |
| + state); |
| return ""; |
| } |
| |
| return Util.NOW_PLAYING_PREFIX + state.getActiveQueueItemId(); |
| } |
| |
| @NonNull |
| Metadata getCurrentSongInfo() { |
| final MediaPlayerWrapper player = getActivePlayer(); |
| if (player == null) return Util.empty_data(); |
| |
| return player.getCurrentMetadata(); |
| } |
| |
| PlaybackState getCurrentPlayStatus() { |
| final MediaPlayerWrapper player = getActivePlayer(); |
| if (player == null) return null; |
| |
| return player.getPlaybackState(); |
| } |
| |
| @NonNull |
| List<Metadata> getNowPlayingList() { |
| // Only send the current song for the now playing if there is no active song. See |
| // |getCurrentMediaId()| for reasons why there might be no active song. |
| if (getCurrentMediaId().equals("")) { |
| List<Metadata> ret = new ArrayList<Metadata>(); |
| Metadata data = getCurrentSongInfo(); |
| data.mediaId = ""; |
| ret.add(data); |
| return ret; |
| } |
| |
| return getActivePlayer().getCurrentQueue(); |
| } |
| |
| void playItem(int playerId, boolean nowPlaying, String mediaId) { |
| if (nowPlaying) { |
| playNowPlayingItem(mediaId); |
| } else { |
| playFolderItem(mediaId); |
| } |
| } |
| |
| private void playNowPlayingItem(String mediaId) { |
| d("playNowPlayingItem: mediaId=" + mediaId); |
| |
| Pattern regex = Pattern.compile(NOW_PLAYING_ID_PATTERN); |
| Matcher m = regex.matcher(mediaId); |
| if (!m.find()) { |
| // This should never happen since we control the media ID's reported |
| Log.wtf(TAG, "playNowPlayingItem: Couldn't match mediaId to pattern: mediaId=" |
| + mediaId); |
| } |
| |
| long queueItemId = Long.parseLong(m.group(1)); |
| if (getActivePlayer() != null) { |
| getActivePlayer().playItemFromQueue(queueItemId); |
| } |
| } |
| |
| private void playFolderItem(String mediaId) { |
| d("playFolderItem: mediaId=" + mediaId); |
| |
| if (!mediaId.matches(BROWSE_ID_PATTERN)) { |
| // This should never happen since we control the media ID's reported |
| Log.wtf(TAG, "playFolderItem: mediaId didn't match pattern: mediaId=" + mediaId); |
| } |
| |
| int playerIndex = Integer.parseInt(mediaId.substring(0, 2)); |
| String itemId = mediaId.substring(2); |
| |
| if (!mBrowsablePlayers.containsKey(playerIndex)) { |
| e("playFolderItem: Do not have the a browsable player with ID " + playerIndex); |
| return; |
| } |
| |
| mBrowsablePlayers.get(playerIndex).playItem(itemId); |
| } |
| |
| void getFolderItemsMediaPlayerList(GetFolderItemsCallback cb) { |
| d("getFolderItemsMediaPlayerList: Sending Media Player list for root directory"); |
| |
| ArrayList<ListItem> playerList = new ArrayList<ListItem>(); |
| for (BrowsedPlayerWrapper player : mBrowsablePlayers.values()) { |
| |
| String displayName = Util.getDisplayName(mContext, player.getPackageName()); |
| int id = mMediaPlayerIds.get(player.getPackageName()); |
| |
| d("getFolderItemsMediaPlayerList: Adding player " + displayName); |
| Folder playerFolder = new Folder(String.format("%02d", id), false, displayName); |
| playerList.add(new ListItem(playerFolder)); |
| } |
| cb.run("", playerList); |
| return; |
| } |
| |
| void getFolderItems(int playerId, String mediaId, GetFolderItemsCallback cb) { |
| // The playerId is unused since we always assume the remote device is using the |
| // Bluetooth Player. |
| d("getFolderItems(): playerId=" + playerId + ", mediaId=" + mediaId); |
| |
| // The device is requesting the content of the root folder. This folder contains a list of |
| // Browsable Media Players displayed as folders with their contents contained within. |
| if (mediaId.equals("")) { |
| getFolderItemsMediaPlayerList(cb); |
| return; |
| } |
| |
| if (!mediaId.matches(BROWSE_ID_PATTERN)) { |
| // This should never happen since we control the media ID's reported |
| Log.wtf(TAG, "getFolderItems: mediaId didn't match pattern: mediaId=" + mediaId); |
| } |
| |
| int playerIndex = Integer.parseInt(mediaId.substring(0, 2)); |
| String itemId = mediaId.substring(2); |
| |
| // TODO (apanicke): Add timeouts for looking up folder items since media browsers don't |
| // have to respond. |
| if (mBrowsablePlayers.containsKey(playerIndex)) { |
| BrowsedPlayerWrapper wrapper = mBrowsablePlayers.get(playerIndex); |
| if (itemId.equals("")) { |
| Log.i(TAG, "Empty media id, getting the root for " |
| + wrapper.getPackageName()); |
| itemId = wrapper.getRootId(); |
| } |
| |
| wrapper.getFolderItems(itemId, (status, id, results) -> { |
| if (status != BrowsedPlayerWrapper.STATUS_SUCCESS) { |
| cb.run(mediaId, new ArrayList<ListItem>()); |
| return; |
| } |
| |
| String playerPrefix = String.format("%02d", playerIndex); |
| for (ListItem item : results) { |
| if (item.isFolder) { |
| item.folder.mediaId = playerPrefix.concat(item.folder.mediaId); |
| } else { |
| item.song.mediaId = playerPrefix.concat(item.song.mediaId); |
| } |
| } |
| cb.run(mediaId, results); |
| }); |
| return; |
| } else { |
| cb.run(mediaId, new ArrayList<ListItem>()); |
| } |
| } |
| |
| // Adds the controller to the MediaPlayerList or updates the controller if we already had |
| // a controller for a package. Returns the new ID of the controller where its added or its |
| // previous value if it already existed. Returns -1 if the controller passed in is invalid |
| int addMediaPlayer(android.media.session.MediaController controller) { |
| if (controller == null) return -1; |
| |
| // Each new player has an ID of 1 plus the highest ID. The ID 0 is reserved to signify that |
| // there is no active player. If we already have a browsable player for the package, reuse |
| // that key. |
| String packageName = controller.getPackageName(); |
| if (!mMediaPlayerIds.containsKey(packageName)) { |
| mMediaPlayerIds.put(packageName, getFreeMediaPlayerId()); |
| } |
| |
| int playerId = mMediaPlayerIds.get(packageName); |
| |
| // If we already have a controller for the package, then update it with this new controller |
| // as the old controller has probably gone stale. |
| if (mMediaPlayers.containsKey(playerId)) { |
| d("Already have a controller for the player: " + packageName + ", updating instead"); |
| MediaPlayerWrapper player = mMediaPlayers.get(playerId); |
| player.updateMediaController(MediaControllerFactory.wrap(controller)); |
| |
| // If the media controller we updated was the active player check if the media updated |
| if (playerId == mActivePlayerId) { |
| sendMediaUpdate(getActivePlayer().getCurrentMediaData()); |
| } |
| |
| return playerId; |
| } |
| |
| MediaPlayerWrapper newPlayer = MediaPlayerWrapper.wrap( |
| MediaControllerFactory.wrap(controller), |
| mLooper); |
| |
| Log.i(TAG, "Adding wrapped media player: " + packageName + " at key: " |
| + mMediaPlayerIds.get(controller.getPackageName())); |
| |
| mMediaPlayers.put(playerId, newPlayer); |
| return playerId; |
| } |
| |
| void removeMediaPlayer(int playerId) { |
| if (!mMediaPlayers.containsKey(playerId)) { |
| e("Trying to remove nonexistent media player: " + playerId); |
| return; |
| } |
| |
| // If we removed the active player, set no player as active until the Media Framework |
| // tells us otherwise |
| if (playerId == mActivePlayerId && playerId != NO_ACTIVE_PLAYER) { |
| getActivePlayer().unregisterCallback(); |
| mActivePlayerId = NO_ACTIVE_PLAYER; |
| sendMediaUpdate(new MediaData(Util.empty_data(), null, null)); |
| } |
| |
| final MediaPlayerWrapper wrapper = mMediaPlayers.get(playerId); |
| d("Removing media player " + wrapper.getPackageName()); |
| mMediaPlayerIds.remove(wrapper.getPackageName()); |
| mMediaPlayers.remove(playerId); |
| wrapper.cleanup(); |
| } |
| |
| void setActivePlayer(int playerId) { |
| if (!mMediaPlayers.containsKey(playerId)) { |
| e("Player doesn't exist in list(): " + playerId); |
| return; |
| } |
| |
| if (playerId == mActivePlayerId) { |
| Log.w(TAG, getActivePlayer().getPackageName() + " is already the active player"); |
| return; |
| } |
| |
| if (mActivePlayerId != NO_ACTIVE_PLAYER) getActivePlayer().unregisterCallback(); |
| |
| mActivePlayerId = playerId; |
| getActivePlayer().registerCallback(mMediaPlayerCallback); |
| Log.i(TAG, "setActivePlayer(): setting player to " + getActivePlayer().getPackageName()); |
| |
| // Ensure that metadata is synced on the new player |
| if (!getActivePlayer().isMetadataSynced()) { |
| Log.w(TAG, "setActivePlayer(): Metadata not synced on new player"); |
| return; |
| } |
| |
| if (Utils.isPtsTestMode()) { |
| sendFolderUpdate(true, true, false); |
| } |
| |
| sendMediaUpdate(getActivePlayer().getCurrentMediaData()); |
| } |
| |
| // TODO (apanicke): Add logging for media key events in dumpsys |
| void sendMediaKeyEvent(int key, boolean pushed) { |
| d("sendMediaKeyEvent: key=" + key + " pushed=" + pushed); |
| int action = pushed ? KeyEvent.ACTION_DOWN : KeyEvent.ACTION_UP; |
| KeyEvent event = new KeyEvent(action, AvrcpPassthrough.toKeyCode(key)); |
| mMediaSessionManager.dispatchMediaKeyEvent(event); |
| } |
| |
| private void sendFolderUpdate(boolean availablePlayers, boolean addressedPlayers, |
| boolean uids) { |
| d("sendFolderUpdate"); |
| if (mCallback == null) { |
| return; |
| } |
| |
| mCallback.run(availablePlayers, addressedPlayers, uids); |
| } |
| |
| private void sendMediaUpdate(MediaData data) { |
| d("sendMediaUpdate"); |
| if (mCallback == null) { |
| return; |
| } |
| |
| // Always have items in the queue |
| if (data.queue.size() == 0) { |
| Log.i(TAG, "sendMediaUpdate: Creating a one item queue for a player with no queue"); |
| data.queue.add(data.metadata); |
| } |
| |
| mCallback.run(data); |
| } |
| |
| private final MediaSessionManager.OnActiveSessionsChangedListener |
| mActiveSessionsChangedListener = |
| new MediaSessionManager.OnActiveSessionsChangedListener() { |
| @Override |
| public void onActiveSessionsChanged( |
| List<android.media.session.MediaController> controllers) { |
| synchronized (MediaPlayerList.this) { |
| Log.v(TAG, "onActiveSessionsChanged: number of controllers: " |
| + controllers.size()); |
| if (controllers.size() == 0) return; |
| |
| // Apps are allowed to have multiple MediaControllers. If an app does have |
| // multiple controllers then controllers contains them in highest |
| // priority order. Since we only want to keep the highest priority one, |
| // we keep track of which controllers we updated and skip over ones |
| // we've already looked at. |
| HashSet<String> addedPackages = new HashSet<String>(); |
| |
| for (int i = 0; i < controllers.size(); i++) { |
| Log.d(TAG, "onActiveSessionsChanged: controller: " |
| + controllers.get(i).getPackageName()); |
| if (addedPackages.contains(controllers.get(i).getPackageName())) { |
| continue; |
| } |
| |
| addedPackages.add(controllers.get(i).getPackageName()); |
| addMediaPlayer(controllers.get(i)); |
| } |
| |
| // Remove all players that weren't added. |
| for (String packageName : mMediaPlayerIds.keySet()) { |
| if (!addedPackages.contains(packageName)) { |
| removeMediaPlayer(mMediaPlayerIds.get(packageName)); |
| } |
| } |
| } |
| } |
| }; |
| |
| // TODO (apanicke): Write a test that tests uninstalling the active session |
| private final BroadcastReceiver mPackageChangedBroadcastReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| Log.v(TAG, "mPackageChangedBroadcastReceiver: action: " + action); |
| |
| if (action.equals(Intent.ACTION_PACKAGE_REMOVED) |
| || action.equals(Intent.ACTION_PACKAGE_DATA_CLEARED)) { |
| if (intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) return; |
| |
| String packageName = intent.getData().getSchemeSpecificPart(); |
| if (packageName != null && mMediaPlayerIds.containsKey(packageName)) { |
| removeMediaPlayer(mMediaPlayerIds.get(packageName)); |
| } |
| } else if (action.equals(Intent.ACTION_PACKAGE_ADDED) |
| || action.equals(Intent.ACTION_PACKAGE_CHANGED)) { |
| String packageName = intent.getData().getSchemeSpecificPart(); |
| if (packageName != null) { |
| if (DEBUG) Log.d(TAG, "Name of package changed: " + packageName); |
| // TODO (apanicke): Handle either updating or adding the new package. |
| // Check if its browsable and send the UIDS changed to update the |
| // root folder |
| } |
| } |
| } |
| }; |
| |
| private final MediaPlayerWrapper.Callback mMediaPlayerCallback = |
| new MediaPlayerWrapper.Callback() { |
| @Override |
| public void mediaUpdatedCallback(MediaData data) { |
| if (data.metadata == null) { |
| Log.d(TAG, "mediaUpdatedCallback(): metadata is null"); |
| return; |
| } |
| |
| if (data.state == null) { |
| Log.w(TAG, "mediaUpdatedCallback(): Tried to update with null state"); |
| return; |
| } |
| |
| sendMediaUpdate(data); |
| } |
| }; |
| |
| private final MediaSessionManager.Callback mButtonDispatchCallback = |
| new MediaSessionManager.Callback() { |
| @Override |
| public void onMediaKeyEventDispatched(KeyEvent event, MediaSession.Token token) { |
| // TODO (apanicke): Add logging for these |
| } |
| |
| @Override |
| public void onMediaKeyEventDispatched(KeyEvent event, ComponentName receiver) { |
| // TODO (apanicke): Add logging for these |
| } |
| |
| @Override |
| public void onAddressedPlayerChanged(MediaSession.Token token) { |
| android.media.session.MediaController controller = |
| new android.media.session.MediaController(mContext, token); |
| |
| if (!mMediaPlayerIds.containsKey(controller.getPackageName())) { |
| // Since we have a controller, we can try to to recover by adding the |
| // player and then setting it as active. |
| Log.w(TAG, "onAddressedPlayerChanged(Token): Addressed Player " |
| + "changed to a player we didn't have a session for"); |
| addMediaPlayer(controller); |
| } |
| |
| Log.i(TAG, "onAddressedPlayerChanged: token=" + controller.getPackageName()); |
| setActivePlayer(mMediaPlayerIds.get(controller.getPackageName())); |
| } |
| |
| @Override |
| public void onAddressedPlayerChanged(ComponentName receiver) { |
| if (receiver == null) { |
| return; |
| } |
| |
| if (!mMediaPlayerIds.containsKey(receiver.getPackageName())) { |
| e("onAddressedPlayerChanged(Component): Addressed Player " |
| + "changed to a player we don't have a session for"); |
| return; |
| } |
| |
| Log.i(TAG, "onAddressedPlayerChanged: component=" + receiver.getPackageName()); |
| setActivePlayer(mMediaPlayerIds.get(receiver.getPackageName())); |
| } |
| }; |
| |
| |
| void dump(StringBuilder sb) { |
| sb.append("List of MediaControllers: size=" + mMediaPlayers.size() + "\n"); |
| for (int id : mMediaPlayers.keySet()) { |
| if (id == mActivePlayerId) { |
| sb.append("<Active> "); |
| } |
| MediaPlayerWrapper player = mMediaPlayers.get(id); |
| sb.append(" Media Player " + id + ": " + player.getPackageName() + "\n"); |
| sb.append(player.toString().replaceAll("(?m)^", " ")); |
| sb.append("\n"); |
| } |
| |
| sb.append("List of Browsers: size=" + mBrowsablePlayers.size() + "\n"); |
| for (BrowsedPlayerWrapper player : mBrowsablePlayers.values()) { |
| sb.append(player.toString().replaceAll("(?m)^", " ")); |
| sb.append("\n"); |
| } |
| // TODO (apanicke): Add media key events |
| // TODO (apanicke): Add last sent data |
| // TODO (apanicke): Add addressed player history |
| } |
| |
| private static void e(String message) { |
| if (sTesting) { |
| Log.wtfStack(TAG, message); |
| } else { |
| Log.e(TAG, message); |
| } |
| } |
| |
| private static void d(String message) { |
| if (DEBUG) { |
| Log.d(TAG, message); |
| } |
| } |
| } |
