| /* |
| * Copyright (C) 2016 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.avrcpcontroller; |
| |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothAvrcpPlayerSettings; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.IBluetoothAvrcpController; |
| import android.content.Context; |
| import android.media.AudioManager; |
| import android.media.browse.MediaBrowser; |
| import android.media.browse.MediaBrowser.MediaItem; |
| import android.media.MediaDescription; |
| import android.media.MediaMetadata; |
| import android.media.session.PlaybackState; |
| import android.os.Bundle; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.util.Log; |
| |
| import com.android.bluetooth.Utils; |
| import com.android.bluetooth.btservice.ProfileService; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.UUID; |
| |
| /** |
| * Provides Bluetooth AVRCP Controller profile, as a service in the Bluetooth application. |
| */ |
| public class AvrcpControllerService extends ProfileService { |
| static final String TAG = "AvrcpControllerService"; |
| static final boolean DBG = true; |
| static final boolean VDBG = Log.isLoggable(TAG, Log.VERBOSE); |
| /* |
| * Play State Values from JNI |
| */ |
| private static final byte JNI_PLAY_STATUS_STOPPED = 0x00; |
| private static final byte JNI_PLAY_STATUS_PLAYING = 0x01; |
| private static final byte JNI_PLAY_STATUS_PAUSED = 0x02; |
| private static final byte JNI_PLAY_STATUS_FWD_SEEK = 0x03; |
| private static final byte JNI_PLAY_STATUS_REV_SEEK = 0x04; |
| private static final byte JNI_PLAY_STATUS_ERROR = -1; |
| |
| /* |
| * Browsing Media Item Attribute IDs |
| * This should be kept in sync with BTRC_MEDIA_ATTR_ID_* in bt_rc.h |
| */ |
| private static final int JNI_MEDIA_ATTR_ID_INVALID = -1; |
| private static final int JNI_MEDIA_ATTR_ID_TITLE = 0x00000001; |
| private static final int JNI_MEDIA_ATTR_ID_ARTIST = 0x00000002; |
| private static final int JNI_MEDIA_ATTR_ID_ALBUM = 0x00000003; |
| private static final int JNI_MEDIA_ATTR_ID_TRACK_NUM = 0x00000004; |
| private static final int JNI_MEDIA_ATTR_ID_NUM_TRACKS = 0x00000005; |
| private static final int JNI_MEDIA_ATTR_ID_GENRE = 0x00000006; |
| private static final int JNI_MEDIA_ATTR_ID_PLAYING_TIME = 0x00000007; |
| |
| /* |
| * Browsing folder types |
| * This should be kept in sync with BTRC_FOLDER_TYPE_* in bt_rc.h |
| */ |
| private static final int JNI_FOLDER_TYPE_TITLES = 0x01; |
| private static final int JNI_FOLDER_TYPE_ALBUMS = 0x02; |
| private static final int JNI_FOLDER_TYPE_ARTISTS = 0x03; |
| private static final int JNI_FOLDER_TYPE_GENRES = 0x04; |
| private static final int JNI_FOLDER_TYPE_PLAYLISTS = 0x05; |
| private static final int JNI_FOLDER_TYPE_YEARS = 0x06; |
| |
| /* |
| * AVRCP Error types as defined in spec. Also they should be in sync with btrc_status_t. |
| * NOTE: Not all may be defined. |
| */ |
| private static final int JNI_AVRC_STS_NO_ERROR = 0x04; |
| private static final int JNI_AVRC_INV_RANGE = 0x0b; |
| |
| /** |
| * Intent used to broadcast the change in browse connection state of the AVRCP Controller |
| * profile. |
| * |
| * <p>This intent will have 2 extras: |
| * <ul> |
| * <li> {@link BluetoothProfile#EXTRA_STATE} - The current state of the profile. </li> |
| * <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote device. </li> |
| * </ul> |
| * |
| * <p>{@link #EXTRA_STATE} can be any of |
| * {@link #STATE_DISCONNECTED}, {@link #STATE_CONNECTING}, |
| * {@link #STATE_CONNECTED}, {@link #STATE_DISCONNECTING}. |
| * |
| * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission to |
| * receive. |
| */ |
| public static final String ACTION_BROWSE_CONNECTION_STATE_CHANGED = |
| "android.bluetooth.avrcp-controller.profile.action.BROWSE_CONNECTION_STATE_CHANGED"; |
| |
| /** |
| * intent used to broadcast the change in metadata state of playing track on the avrcp |
| * ag. |
| * |
| * <p>this intent will have the two extras: |
| * <ul> |
| * <li> {@link #extra_metadata} - {@link mediametadata} containing the current metadata.</li> |
| * <li> {@link #extra_playback} - {@link playbackstate} containing the current playback |
| * state. </li> |
| * </ul> |
| */ |
| public static final String ACTION_TRACK_EVENT = |
| "android.bluetooth.avrcp-controller.profile.action.TRACK_EVENT"; |
| |
| /** |
| * Intent used to broadcast the change of folder list. |
| * |
| * <p>This intent will have the one extra: |
| * <ul> |
| * <li> {@link #EXTRA_FOLDER_LIST} - array of {@link MediaBrowser#MediaItem} |
| * containing the folder listing of currently selected folder. |
| * </ul> |
| */ |
| public static final String ACTION_FOLDER_LIST = |
| "android.bluetooth.avrcp-controller.profile.action.FOLDER_LIST"; |
| |
| public static final String EXTRA_FOLDER_LIST = |
| "android.bluetooth.avrcp-controller.profile.extra.FOLDER_LIST"; |
| |
| public static final String EXTRA_FOLDER_ID = "com.android.bluetooth.avrcp.EXTRA_FOLDER_ID"; |
| public static final String EXTRA_FOLDER_BT_ID = |
| "com.android.bluetooth.avrcp-controller.EXTRA_FOLDER_BT_ID"; |
| |
| public static final String EXTRA_METADATA = |
| "android.bluetooth.avrcp-controller.profile.extra.METADATA"; |
| |
| public static final String EXTRA_PLAYBACK = |
| "android.bluetooth.avrcp-controller.profile.extra.PLAYBACK"; |
| |
| public static final String MEDIA_ITEM_UID_KEY = "media-item-uid-key"; |
| |
| /* |
| * KeyCoded for Pass Through Commands |
| */ |
| public static final int PASS_THRU_CMD_ID_PLAY = 0x44; |
| public static final int PASS_THRU_CMD_ID_PAUSE = 0x46; |
| public static final int PASS_THRU_CMD_ID_VOL_UP = 0x41; |
| public static final int PASS_THRU_CMD_ID_VOL_DOWN = 0x42; |
| public static final int PASS_THRU_CMD_ID_STOP = 0x45; |
| public static final int PASS_THRU_CMD_ID_FF = 0x49; |
| public static final int PASS_THRU_CMD_ID_REWIND = 0x48; |
| public static final int PASS_THRU_CMD_ID_FORWARD = 0x4B; |
| public static final int PASS_THRU_CMD_ID_BACKWARD = 0x4C; |
| |
| /* Key State Variables */ |
| public static final int KEY_STATE_PRESSED = 0; |
| public static final int KEY_STATE_RELEASED = 1; |
| |
| /* Group Navigation Key Codes */ |
| public static final int PASS_THRU_CMD_ID_NEXT_GRP = 0x00; |
| public static final int PASS_THRU_CMD_ID_PREV_GRP = 0x01; |
| |
| /* Folder navigation directions |
| * This is borrowed from AVRCP 1.6 spec and must be kept with same values |
| */ |
| public static final int FOLDER_NAVIGATION_DIRECTION_UP = 0x00; |
| public static final int FOLDER_NAVIGATION_DIRECTION_DOWN = 0x01; |
| |
| /* Folder/Media Item scopes. |
| * Keep in sync with AVRCP 1.6 sec. 6.10.1 |
| */ |
| public static final int BROWSE_SCOPE_PLAYER_LIST = 0x00; |
| public static final int BROWSE_SCOPE_VFS = 0x01; |
| public static final int BROWSE_SCOPE_SEARCH = 0x02; |
| public static final int BROWSE_SCOPE_NOW_PLAYING = 0x03; |
| |
| private AvrcpControllerStateMachine mAvrcpCtSm; |
| private static AvrcpControllerService sAvrcpControllerService; |
| // UID size is 8 bytes (AVRCP 1.6 spec) |
| private static final byte[] EMPTY_UID = {0, 0, 0, 0, 0, 0, 0, 0}; |
| |
| // We only support one device. |
| private BluetoothDevice mConnectedDevice = null; |
| // If browse is supported (only valid if mConnectedDevice != null). |
| private boolean mBrowseConnected = false; |
| // Caches the current browse folder. If this is null then root is the currently browsed folder |
| // (which also has no UID). |
| private String mCurrentBrowseFolderUID = null; |
| |
| static { |
| classInitNative(); |
| } |
| |
| public AvrcpControllerService() { |
| initNative(); |
| } |
| |
| protected String getName() { |
| return TAG; |
| } |
| |
| protected IProfileServiceBinder initBinder() { |
| return new BluetoothAvrcpControllerBinder(this); |
| } |
| |
| protected boolean start() { |
| HandlerThread thread = new HandlerThread("BluetoothAvrcpHandler"); |
| thread.start(); |
| mAvrcpCtSm = new AvrcpControllerStateMachine(this); |
| mAvrcpCtSm.start(); |
| |
| setAvrcpControllerService(this); |
| return true; |
| } |
| |
| protected boolean stop() { |
| if (mAvrcpCtSm != null) { |
| mAvrcpCtSm.doQuit(); |
| } |
| return true; |
| } |
| |
| //API Methods |
| |
| public static synchronized AvrcpControllerService getAvrcpControllerService() { |
| if (sAvrcpControllerService != null && sAvrcpControllerService.isAvailable()) { |
| if (DBG) { |
| Log.d(TAG, "getAvrcpControllerService(): returning " |
| + sAvrcpControllerService); |
| } |
| return sAvrcpControllerService; |
| } |
| if (DBG) { |
| if (sAvrcpControllerService == null) { |
| Log.d(TAG, "getAvrcpControllerService(): service is NULL"); |
| } else if (!(sAvrcpControllerService.isAvailable())) { |
| Log.d(TAG, "getAvrcpControllerService(): service is not available"); |
| } |
| } |
| return null; |
| } |
| |
| private static synchronized void setAvrcpControllerService(AvrcpControllerService instance) { |
| if (instance != null && instance.isAvailable()) { |
| if (DBG) { |
| Log.d(TAG, "setAvrcpControllerService(): set to: " + sAvrcpControllerService); |
| } |
| sAvrcpControllerService = instance; |
| } else { |
| if (DBG) { |
| if (instance == null) { |
| Log.d(TAG, "setAvrcpControllerService(): service not available"); |
| } else if (!instance.isAvailable()) { |
| Log.d(TAG, "setAvrcpControllerService(): service is cleaning up"); |
| } |
| } |
| } |
| } |
| |
| private static synchronized void clearAvrcpControllerService() { |
| sAvrcpControllerService = null; |
| } |
| |
| public synchronized List<BluetoothDevice> getConnectedDevices() { |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| List<BluetoothDevice> devices = new ArrayList<BluetoothDevice>(); |
| if (mConnectedDevice != null) { |
| devices.add(mConnectedDevice); |
| } |
| return devices; |
| } |
| |
| /** |
| * This function only supports STATE_CONNECTED |
| */ |
| public synchronized List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) { |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| List<BluetoothDevice> devices = new ArrayList<BluetoothDevice>(); |
| for (int i = 0; i < states.length; i++) { |
| if (states[i] == BluetoothProfile.STATE_CONNECTED && mConnectedDevice != null) { |
| devices.add(mConnectedDevice); |
| } |
| } |
| return devices; |
| } |
| |
| public synchronized int getConnectionState(BluetoothDevice device) { |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| return (mConnectedDevice != null ? BluetoothProfile.STATE_CONNECTED : |
| BluetoothProfile.STATE_DISCONNECTED); |
| } |
| |
| public synchronized void sendGroupNavigationCmd(BluetoothDevice device, int keyCode, int keyState) { |
| Log.v(TAG, "sendGroupNavigationCmd keyCode: " + keyCode + " keyState: " + keyState); |
| if (device == null) { |
| Log.e(TAG, "sendGroupNavigationCmd device is null"); |
| } |
| |
| if (!(device.equals(mConnectedDevice))) { |
| Log.e(TAG, " Device does not match " + device + " connected " + mConnectedDevice); |
| return; |
| } |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| Message msg = mAvrcpCtSm.obtainMessage(AvrcpControllerStateMachine. |
| MESSAGE_SEND_GROUP_NAVIGATION_CMD, keyCode, keyState, device); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| public synchronized void sendPassThroughCmd(BluetoothDevice device, int keyCode, int keyState) { |
| Log.v(TAG, "sendPassThroughCmd keyCode: " + keyCode + " keyState: " + keyState); |
| if (device == null) { |
| Log.e(TAG, "sendPassThroughCmd Device is null"); |
| return; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.w(TAG, " Device does not match device " + device + " conn " + mConnectedDevice); |
| return; |
| } |
| |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| Message msg = mAvrcpCtSm |
| .obtainMessage(AvrcpControllerStateMachine.MESSAGE_SEND_PASS_THROUGH_CMD, |
| keyCode, keyState, device); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| public void startAvrcpUpdates() { |
| mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_START_METADATA_BROADCASTS).sendToTarget(); |
| } |
| |
| public void stopAvrcpUpdates() { |
| mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_STOP_METADATA_BROADCASTS).sendToTarget(); |
| } |
| |
| public synchronized MediaMetadata getMetaData(BluetoothDevice device) { |
| if (DBG) { |
| Log.d(TAG, "getMetaData"); |
| } |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| if (device == null) { |
| Log.e(TAG, "getMetadata device is null"); |
| return null; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| return null; |
| } |
| return mAvrcpCtSm.getCurrentMetaData(); |
| } |
| |
| public PlaybackState getPlaybackState(BluetoothDevice device) { |
| // Get the cached state by default. |
| return getPlaybackState(device, true); |
| } |
| |
| // cached can be used to force a getPlaybackState command. Useful for PTS testing. |
| public synchronized PlaybackState getPlaybackState(BluetoothDevice device, boolean cached) { |
| if (DBG) { |
| Log.d(TAG, "getPlayBackState device = " + device); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "getPlaybackState device is null"); |
| return null; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "Device " + device + " does not match connected deivce " + mConnectedDevice); |
| return null; |
| |
| } |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| return mAvrcpCtSm.getCurrentPlayBackState(cached); |
| } |
| |
| public synchronized BluetoothAvrcpPlayerSettings getPlayerSettings(BluetoothDevice device) { |
| if (DBG) { |
| Log.d(TAG, "getPlayerApplicationSetting "); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "getPlayerSettings device is null"); |
| return null; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "device " + device + " does not match connected device " + mConnectedDevice); |
| return null; |
| } |
| |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| |
| /* Do nothing */ |
| return null; |
| } |
| |
| public boolean setPlayerApplicationSetting(BluetoothAvrcpPlayerSettings plAppSetting) { |
| if (DBG) { |
| Log.d(TAG, "getPlayerApplicationSetting"); |
| } |
| |
| /* Do nothing */ |
| return false; |
| } |
| |
| /** |
| * Fetches the list of children for the parentID node. |
| * |
| * This function manages the overall tree for browsing structure. |
| * |
| * Arguments: |
| * device - Device to browse content for. |
| * parentMediaId - ID of the parent that we need to browse content for. Since most |
| * of the players are database unware, fetching a root invalidates all the children. |
| * start - number of item to start scanning from |
| * items - number of items to fetch |
| */ |
| public synchronized boolean getChildren( |
| BluetoothDevice device, String parentMediaId, int start, int items) { |
| if (DBG) { |
| Log.d(TAG, "getChildren device = " + device + " parent " + parentMediaId); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "getChildren device is null"); |
| return false; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "getChildren device " + device + " does not match " + |
| mConnectedDevice); |
| return false; |
| } |
| |
| if (!mBrowseConnected) { |
| Log.e(TAG, "getChildren browse not yet connected"); |
| return false; |
| } |
| |
| if (!mAvrcpCtSm.isConnected()) { |
| return false; |
| } |
| mAvrcpCtSm.getChildren(parentMediaId, start, items); |
| return true; |
| } |
| |
| public synchronized boolean getNowPlayingList( |
| BluetoothDevice device, String id, int start, int items) { |
| if (DBG) { |
| Log.d(TAG, "getNowPlayingList device = " + device + " start = " + start + |
| "items = " + items); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "getNowPlayingList device is null"); |
| return false; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "getNowPlayingList device " + device + " does not match " + |
| mConnectedDevice); |
| return false; |
| } |
| |
| if (!mBrowseConnected) { |
| Log.e(TAG, "getNowPlayingList browse not yet connected"); |
| return false; |
| } |
| |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_GET_NOW_PLAYING_LIST, start, items, id); |
| mAvrcpCtSm.sendMessage(msg); |
| return true; |
| } |
| |
| public synchronized boolean getFolderList( |
| BluetoothDevice device, String id, int start, int items) { |
| if (DBG) { |
| Log.d(TAG, "getFolderListing device = " + device + " start = " + start + |
| "items = " + items); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "getFolderListing device is null"); |
| return false; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "getFolderListing device " + device + " does not match " + mConnectedDevice); |
| return false; |
| } |
| |
| if (!mBrowseConnected) { |
| Log.e(TAG, "getFolderListing browse not yet connected"); |
| return false; |
| } |
| |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_GET_FOLDER_LIST, start, items, id); |
| mAvrcpCtSm.sendMessage(msg); |
| return true; |
| } |
| |
| public synchronized boolean getPlayerList(BluetoothDevice device, int start, int items) { |
| if (DBG) { |
| Log.d(TAG, "getPlayerList device = " + device + " start = " + start + |
| "items = " + items); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "getPlayerList device is null"); |
| return false; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "getPlayerList device " + device + " does not match " + mConnectedDevice); |
| return false; |
| } |
| |
| if (!mBrowseConnected) { |
| Log.e(TAG, "getPlayerList browse not yet connected"); |
| return false; |
| } |
| |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_GET_PLAYER_LIST, start, items); |
| mAvrcpCtSm.sendMessage(msg); |
| return true; |
| } |
| |
| public synchronized boolean changeFolderPath( |
| BluetoothDevice device, int direction, String uid, String fid) { |
| if (DBG) { |
| Log.d(TAG, "changeFolderPath device = " + device + " direction " + |
| direction + " uid " + uid); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "changeFolderPath device is null"); |
| return false; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "changeFolderPath device " + device + " does not match " + |
| mConnectedDevice); |
| return false; |
| } |
| |
| if (!mBrowseConnected) { |
| Log.e(TAG, "changeFolderPath browse not yet connected"); |
| return false; |
| } |
| |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| |
| Bundle b = new Bundle(); |
| b.putString(EXTRA_FOLDER_ID, fid); |
| b.putString(EXTRA_FOLDER_BT_ID, uid); |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_CHANGE_FOLDER_PATH, direction, 0, b); |
| mAvrcpCtSm.sendMessage(msg); |
| return true; |
| } |
| |
| public synchronized boolean setBrowsedPlayer(BluetoothDevice device, int id, String fid) { |
| if (DBG) { |
| Log.d(TAG, "setBrowsedPlayer device = " + device + " id" + id + " fid " + fid); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "setBrowsedPlayer device is null"); |
| return false; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "changeFolderPath device " + device + " does not match " + |
| mConnectedDevice); |
| return false; |
| } |
| |
| if (!mBrowseConnected) { |
| Log.e(TAG, "setBrowsedPlayer browse not yet connected"); |
| return false; |
| } |
| |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_SET_BROWSED_PLAYER, id, 0, fid); |
| mAvrcpCtSm.sendMessage(msg); |
| return true; |
| } |
| |
| public synchronized void fetchAttrAndPlayItem(BluetoothDevice device, String uid) { |
| if (DBG) { |
| Log.d(TAG, "fetchAttrAndPlayItem device = " + device + " uid " + uid); |
| } |
| |
| if (device == null) { |
| Log.e(TAG, "fetchAttrAndPlayItem device is null"); |
| return; |
| } |
| |
| if (!device.equals(mConnectedDevice)) { |
| Log.e(TAG, "fetchAttrAndPlayItem device " + device + " does not match " + |
| mConnectedDevice); |
| return; |
| } |
| |
| if (!mBrowseConnected) { |
| Log.e(TAG, "fetchAttrAndPlayItem browse not yet connected"); |
| return; |
| } |
| mAvrcpCtSm.fetchAttrAndPlayItem(uid); |
| } |
| |
| //Binder object: Must be static class or memory leak may occur |
| private static class BluetoothAvrcpControllerBinder extends IBluetoothAvrcpController.Stub |
| implements IProfileServiceBinder { |
| |
| private AvrcpControllerService mService; |
| |
| private AvrcpControllerService getService() { |
| if (!Utils.checkCaller()) { |
| Log.w(TAG, "AVRCP call not allowed for non-active user"); |
| return null; |
| } |
| |
| if (mService != null && mService.isAvailable()) { |
| return mService; |
| } |
| return null; |
| } |
| |
| BluetoothAvrcpControllerBinder(AvrcpControllerService svc) { |
| mService = svc; |
| } |
| |
| public boolean cleanup() { |
| mService = null; |
| return true; |
| } |
| |
| @Override |
| public List<BluetoothDevice> getConnectedDevices() { |
| AvrcpControllerService service = getService(); |
| if (service == null) { |
| return new ArrayList<BluetoothDevice>(0); |
| } |
| return service.getConnectedDevices(); |
| } |
| |
| @Override |
| public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) { |
| AvrcpControllerService service = getService(); |
| if (service == null) { |
| return new ArrayList<BluetoothDevice>(0); |
| } |
| return service.getDevicesMatchingConnectionStates(states); |
| } |
| |
| @Override |
| public int getConnectionState(BluetoothDevice device) { |
| AvrcpControllerService service = getService(); |
| if (service == null) { |
| return BluetoothProfile.STATE_DISCONNECTED; |
| } |
| |
| if (device == null) { |
| throw new IllegalStateException("Device cannot be null!"); |
| } |
| |
| return service.getConnectionState(device); |
| } |
| |
| @Override |
| public void sendGroupNavigationCmd(BluetoothDevice device, int keyCode, int keyState) { |
| Log.v(TAG, "Binder Call: sendGroupNavigationCmd"); |
| AvrcpControllerService service = getService(); |
| if (service == null) { |
| return; |
| } |
| |
| if (device == null) { |
| throw new IllegalStateException("Device cannot be null!"); |
| } |
| |
| service.sendGroupNavigationCmd(device, keyCode, keyState); |
| } |
| |
| @Override |
| public BluetoothAvrcpPlayerSettings getPlayerSettings(BluetoothDevice device) { |
| Log.v(TAG, "Binder Call: getPlayerApplicationSetting "); |
| AvrcpControllerService service = getService(); |
| if (service == null) { |
| return null; |
| } |
| |
| if (device == null) { |
| throw new IllegalStateException("Device cannot be null!"); |
| } |
| |
| return service.getPlayerSettings(device); |
| } |
| |
| @Override |
| public boolean setPlayerApplicationSetting(BluetoothAvrcpPlayerSettings plAppSetting) { |
| Log.v(TAG, "Binder Call: setPlayerApplicationSetting "); |
| AvrcpControllerService service = getService(); |
| if (service == null) { |
| return false; |
| } |
| return service.setPlayerApplicationSetting(plAppSetting); |
| } |
| } |
| |
| // Called by JNI when a passthrough key was received. |
| private void handlePassthroughRsp(int id, int keyState, byte[] address) { |
| Log.d(TAG, "passthrough response received as: key: " + id + " state: " + keyState + |
| "address:" + address); |
| } |
| |
| private void handleGroupNavigationRsp(int id, int keyState) { |
| Log.d(TAG, "group navigation response received as: key: " + id + " state: " + keyState); |
| } |
| |
| // Called by JNI when a device has connected or disconnected. |
| private synchronized void onConnectionStateChanged( |
| boolean rc_connected, boolean br_connected, byte[] address) { |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| Log.d(TAG, "onConnectionStateChanged " + rc_connected + " " + br_connected + |
| device + " conn device " + mConnectedDevice); |
| if (device == null) { |
| Log.e(TAG, "onConnectionStateChanged Device is null"); |
| return; |
| } |
| |
| // Adjust the AVRCP connection state. |
| int oldState = (device.equals(mConnectedDevice) ? BluetoothProfile.STATE_CONNECTED : |
| BluetoothProfile.STATE_DISCONNECTED); |
| int newState = (rc_connected ? BluetoothProfile.STATE_CONNECTED : |
| BluetoothProfile.STATE_DISCONNECTED); |
| |
| if (rc_connected && oldState == BluetoothProfile.STATE_DISCONNECTED) { |
| /* AVRCPControllerService supports single connection */ |
| if (mConnectedDevice != null) { |
| Log.d(TAG, "A Connection already exists, returning"); |
| return; |
| } |
| mConnectedDevice = device; |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_PROCESS_CONNECTION_CHANGE, newState, |
| oldState, device); |
| mAvrcpCtSm.sendMessage(msg); |
| } else if (!rc_connected && oldState == BluetoothProfile.STATE_CONNECTED) { |
| mConnectedDevice = null; |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_PROCESS_CONNECTION_CHANGE, newState, |
| oldState, device); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| // Adjust the browse connection state. If RC is connected we should have already sent the |
| // connection status out. |
| if (rc_connected && br_connected) { |
| mBrowseConnected = true; |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_PROCESS_BROWSE_CONNECTION_CHANGE); |
| msg.arg1 = 1; |
| msg.obj = device; |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| } |
| |
| // Called by JNI to notify Avrcp of features supported by the Remote device. |
| private void getRcFeatures(byte[] address, int features) { |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_PROCESS_RC_FEATURES, features, 0, device); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| // Called by JNI |
| private void setPlayerAppSettingRsp(byte[] address, byte accepted) { |
| /* Do Nothing. */ |
| } |
| |
| // Called by JNI when remote wants to receive absolute volume notifications. |
| private synchronized void handleRegisterNotificationAbsVol(byte[] address, byte label) { |
| Log.d(TAG, "handleRegisterNotificationAbsVol "); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| if (device != null && !device.equals(mConnectedDevice)) { |
| Log.e(TAG, "handleRegisterNotificationAbsVol device not found " + address); |
| return; |
| } |
| Message msg = mAvrcpCtSm.obtainMessage(AvrcpControllerStateMachine. |
| MESSAGE_PROCESS_REGISTER_ABS_VOL_NOTIFICATION, (int) label, 0); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| // Called by JNI when remote wants to set absolute volume. |
| private synchronized void handleSetAbsVolume(byte[] address, byte absVol, byte label) { |
| Log.d(TAG, "handleSetAbsVolume "); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| if (device != null && !device.equals(mConnectedDevice)) { |
| Log.e(TAG, "handleSetAbsVolume device not found " + address); |
| return; |
| } |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_PROCESS_SET_ABS_VOL_CMD, absVol, label); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| // Called by JNI when a track changes and local AvrcpController is registered for updates. |
| private synchronized void onTrackChanged(byte[] address, byte numAttributes, int[] attributes, |
| String[] attribVals) { |
| if (DBG) { |
| Log.d(TAG, "onTrackChanged"); |
| } |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| if (device != null && !device.equals(mConnectedDevice)) { |
| Log.e(TAG, "onTrackChanged device not found " + address); |
| return; |
| } |
| |
| List<Integer> attrList = new ArrayList<>(); |
| for (int attr : attributes) { |
| attrList.add(attr); |
| } |
| List<String> attrValList = Arrays.asList(attribVals); |
| TrackInfo trackInfo = new TrackInfo(attrList, attrValList); |
| if (DBG) { |
| Log.d(TAG, "onTrackChanged " + trackInfo); |
| } |
| Message msg = mAvrcpCtSm.obtainMessage(AvrcpControllerStateMachine. |
| MESSAGE_PROCESS_TRACK_CHANGED, trackInfo); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| // Called by JNI periodically based upon timer to update play position |
| private synchronized void onPlayPositionChanged(byte[] address, int songLen, int currSongPosition) { |
| if (DBG) { |
| Log.d(TAG, "onPlayPositionChanged pos " + currSongPosition); |
| } |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| if (device != null && !device.equals(mConnectedDevice)) { |
| Log.e(TAG, "onPlayPositionChanged not found device not found " + address); |
| return; |
| } |
| Message msg = mAvrcpCtSm.obtainMessage(AvrcpControllerStateMachine. |
| MESSAGE_PROCESS_PLAY_POS_CHANGED, songLen, currSongPosition); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| // Called by JNI on changes of play status |
| private synchronized void onPlayStatusChanged(byte[] address, byte playStatus) { |
| if (DBG) { |
| Log.d(TAG, "onPlayStatusChanged " + playStatus); |
| } |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| if (device != null && !device.equals(mConnectedDevice)) { |
| Log.e(TAG, "onPlayStatusChanged not found device not found " + address); |
| return; |
| } |
| int playbackState = PlaybackState.STATE_NONE; |
| switch (playStatus) { |
| case JNI_PLAY_STATUS_STOPPED: |
| playbackState = PlaybackState.STATE_STOPPED; |
| break; |
| case JNI_PLAY_STATUS_PLAYING: |
| playbackState = PlaybackState.STATE_PLAYING; |
| break; |
| case JNI_PLAY_STATUS_PAUSED: |
| playbackState = PlaybackState.STATE_PAUSED; |
| break; |
| case JNI_PLAY_STATUS_FWD_SEEK: |
| playbackState = PlaybackState.STATE_FAST_FORWARDING; |
| break; |
| case JNI_PLAY_STATUS_REV_SEEK: |
| playbackState = PlaybackState.STATE_FAST_FORWARDING; |
| break; |
| default: |
| playbackState = PlaybackState.STATE_NONE; |
| } |
| Message msg = mAvrcpCtSm.obtainMessage(AvrcpControllerStateMachine. |
| MESSAGE_PROCESS_PLAY_STATUS_CHANGED, playbackState); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| // Called by JNI to report remote Player's capabilities |
| private synchronized void handlePlayerAppSetting(byte[] address, byte[] playerAttribRsp, int rspLen) { |
| if (DBG) { |
| Log.d(TAG, "handlePlayerAppSetting rspLen = " + rspLen); |
| } |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| if (device != null && !device.equals(mConnectedDevice)) { |
| Log.e(TAG, "handlePlayerAppSetting not found device not found " + address); |
| return; |
| } |
| PlayerApplicationSettings supportedSettings = PlayerApplicationSettings. |
| makeSupportedSettings(playerAttribRsp); |
| /* Do nothing */ |
| } |
| |
| private synchronized void onPlayerAppSettingChanged(byte[] address, byte[] playerAttribRsp, int rspLen) { |
| if (DBG) { |
| Log.d(TAG, "onPlayerAppSettingChanged "); |
| } |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| if (device != null && !device.equals(mConnectedDevice)) { |
| Log.e(TAG, "onPlayerAppSettingChanged not found device not found " + address); |
| return; |
| } |
| PlayerApplicationSettings desiredSettings = PlayerApplicationSettings. |
| makeSettings(playerAttribRsp); |
| /* Do nothing */ |
| } |
| |
| // Browsing related JNI callbacks. |
| void handleGetFolderItemsRsp(int status, MediaItem[] items) { |
| if (DBG) { |
| Log.d(TAG, "handleGetFolderItemsRsp called with status " + status + |
| " items " + items.length + " items."); |
| } |
| |
| if (status == JNI_AVRC_INV_RANGE) { |
| Log.w(TAG, "Sending out of range message."); |
| // Send a special message since this could be used by state machine |
| // to take as a signal that fetch is finished. |
| Message msg = mAvrcpCtSm.obtainMessage(AvrcpControllerStateMachine. |
| MESSAGE_PROCESS_GET_FOLDER_ITEMS_OUT_OF_RANGE); |
| mAvrcpCtSm.sendMessage(msg); |
| return; |
| } |
| |
| for (MediaItem item : items) { |
| if (DBG) { |
| Log.d(TAG, "media item: " + item + " uid: " + item.getDescription().getMediaId()); |
| } |
| } |
| ArrayList<MediaItem> itemsList = new ArrayList<>(); |
| for (MediaItem item : items) { |
| itemsList.add(item); |
| } |
| Message msg = mAvrcpCtSm.obtainMessage(AvrcpControllerStateMachine. |
| MESSAGE_PROCESS_GET_FOLDER_ITEMS, itemsList); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| void handleGetPlayerItemsRsp(AvrcpPlayer[] items) { |
| if (DBG) { |
| Log.d(TAG, "handleGetFolderItemsRsp called with " + items.length + " items."); |
| } |
| for (AvrcpPlayer item : items) { |
| if (DBG) { |
| Log.d(TAG, "bt player item: " + item); |
| } |
| } |
| List<AvrcpPlayer> itemsList = new ArrayList<>(); |
| for (AvrcpPlayer p : items) { |
| itemsList.add(p); |
| } |
| |
| Message msg = mAvrcpCtSm.obtainMessage(AvrcpControllerStateMachine. |
| MESSAGE_PROCESS_GET_PLAYER_ITEMS, itemsList); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| // JNI Helper functions to convert native objects to java. |
| MediaItem createFromNativeMediaItem( |
| byte[] uid, int type, String name, int[] attrIds, String[] attrVals) { |
| if (DBG) { |
| Log.d(TAG, "createFromNativeMediaItem uid: " + uid + " type " + type + " name " + |
| name + " attrids " + attrIds + " attrVals " + attrVals); |
| } |
| MediaDescription.Builder mdb = new MediaDescription.Builder(); |
| |
| Bundle mdExtra = new Bundle(); |
| mdExtra.putString(MEDIA_ITEM_UID_KEY, byteUIDToHexString(uid)); |
| mdb.setExtras(mdExtra); |
| |
| // Generate a random UUID. We do this since database unaware TGs can send multiple |
| // items with same MEDIA_ITEM_UID_KEY. |
| mdb.setMediaId(UUID.randomUUID().toString()); |
| |
| // Concise readable name. |
| mdb.setTitle(name); |
| |
| // We skip the attributes since we can query them using UID for the item above |
| // Also MediaDescription does not give an easy way to provide this unless we pass |
| // it as an MediaMetadata which is put inside the extras. |
| return new MediaItem(mdb.build(), MediaItem.FLAG_PLAYABLE); |
| } |
| |
| MediaItem createFromNativeFolderItem( |
| byte[] uid, int type, String name, int playable) { |
| if (DBG) { |
| Log.d(TAG, "createFromNativeFolderItem uid: " + uid + " type " + type + |
| " name " + name + " playable " + playable); |
| } |
| MediaDescription.Builder mdb = new MediaDescription.Builder(); |
| |
| // Covert the byte to a hex string. The coversion can be done back here to a |
| // byte array when needed. |
| Bundle mdExtra = new Bundle(); |
| mdExtra.putString(MEDIA_ITEM_UID_KEY, byteUIDToHexString(uid)); |
| mdb.setExtras(mdExtra); |
| |
| // Generate a random UUID. We do this since database unaware TGs can send multiple |
| // items with same MEDIA_ITEM_UID_KEY. |
| mdb.setMediaId(UUID.randomUUID().toString()); |
| |
| // Concise readable name. |
| mdb.setTitle(name); |
| |
| return new MediaItem(mdb.build(), MediaItem.FLAG_BROWSABLE); |
| } |
| |
| AvrcpPlayer createFromNativePlayerItem( |
| int id, String name, byte[] transportFlags, int playStatus, int playerType) { |
| if (DBG) { |
| Log.d(TAG, "createFromNativePlayerItem name: " + name + " transportFlags " + |
| transportFlags + " play status " + playStatus + " player type " + |
| playerType); |
| } |
| AvrcpPlayer player = new AvrcpPlayer(id, name, 0, playStatus, playerType); |
| return player; |
| } |
| |
| private void handleChangeFolderRsp(int count) { |
| if (DBG) { |
| Log.d(TAG, "handleChangeFolderRsp count: " + count); |
| } |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_PROCESS_FOLDER_PATH, count); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| private void handleSetBrowsedPlayerRsp(int items, int depth) { |
| if (DBG) { |
| Log.d(TAG, "handleSetBrowsedPlayerRsp depth: " + depth); |
| } |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_PROCESS_SET_BROWSED_PLAYER, items, depth); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| private void handleSetAddressedPlayerRsp(int status) { |
| if (DBG) { |
| Log.d(TAG, "handleSetAddressedPlayerRsp status: " + status); |
| } |
| Message msg = mAvrcpCtSm.obtainMessage( |
| AvrcpControllerStateMachine.MESSAGE_PROCESS_SET_ADDRESSED_PLAYER); |
| mAvrcpCtSm.sendMessage(msg); |
| } |
| |
| @Override |
| public void dump(StringBuilder sb) { |
| super.dump(sb); |
| mAvrcpCtSm.dump(sb); |
| } |
| |
| public static String byteUIDToHexString(byte[] uid) { |
| StringBuilder sb = new StringBuilder(); |
| for (byte b : uid) { |
| sb.append(String.format("%02X", b)); |
| } |
| return sb.toString(); |
| } |
| |
| public static byte[] hexStringToByteUID(String uidStr) { |
| if (uidStr == null) { |
| Log.e(TAG, "Null hex string."); |
| return EMPTY_UID; |
| } else if (uidStr.length() % 2 == 1) { |
| // Odd length strings should not be possible. |
| Log.e(TAG, "Odd length hex string " + uidStr); |
| return EMPTY_UID; |
| } |
| int len = uidStr.length(); |
| byte[] data = new byte[len / 2]; |
| for (int i = 0; i < len; i += 2) { |
| data[i / 2] = (byte) ((Character.digit(uidStr.charAt(i), 16) << 4) |
| + Character.digit(uidStr.charAt(i + 1), 16)); |
| } |
| return data; |
| } |
| |
| private native static void classInitNative(); |
| |
| private native void initNative(); |
| |
| private native void cleanupNative(); |
| |
| native static boolean sendPassThroughCommandNative(byte[] address, int keyCode, int keyState); |
| |
| native static boolean sendGroupNavigationCommandNative(byte[] address, int keyCode, |
| int keyState); |
| |
| native static void setPlayerApplicationSettingValuesNative(byte[] address, byte numAttrib, |
| byte[] atttibIds, byte[] attribVal); |
| |
| /* This api is used to send response to SET_ABS_VOL_CMD */ |
| native static void sendAbsVolRspNative(byte[] address, int absVol, int label); |
| |
| /* This api is used to inform remote for any volume level changes */ |
| native static void sendRegisterAbsVolRspNative(byte[] address, byte rspType, int absVol, |
| int label); |
| |
| /* API used to fetch the playback state */ |
| native static void getPlaybackStateNative(byte[] address); |
| /* API used to fetch the current now playing list */ |
| native static void getNowPlayingListNative(byte[] address, byte start, byte end); |
| /* API used to fetch the current folder's listing */ |
| native static void getFolderListNative(byte[] address, byte start, byte end); |
| /* API used to fetch the listing of players */ |
| native static void getPlayerListNative(byte[] address, byte start, byte end); |
| /* API used to change the folder */ |
| native static void changeFolderPathNative(byte[] address, byte direction, byte[] uid); |
| native static void playItemNative( |
| byte[] address, byte scope, byte[] uid, int uidCounter); |
| native static void setBrowsedPlayerNative(byte[] address, int playerId); |
| native static void setAddressedPlayerNative(byte[] address, int playerId); |
| } |
