| /* |
| * 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.bluetooth.avrcp; |
| |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothAvrcpController; |
| import android.bluetooth.BluetoothAvrcpPlayerSettings; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.IBluetoothAvrcpController; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.media.MediaMetadata; |
| import android.media.session.PlaybackState; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.util.Log; |
| import android.media.AudioManager; |
| import com.android.bluetooth.a2dpsink.A2dpSinkService; |
| import com.android.bluetooth.btservice.ProfileService; |
| import com.android.bluetooth.Utils; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.HashMap; |
| import java.nio.charset.Charset; |
| import java.nio.ByteBuffer; |
| /** |
| * Provides Bluetooth AVRCP Controller profile, as a service in the Bluetooth application. |
| * @hide |
| */ |
| public class AvrcpControllerService extends ProfileService { |
| private static final boolean DBG = AvrcpControllerConstants.DBG; |
| private static final boolean VDBG = AvrcpControllerConstants.VDBG; |
| private static final String TAG = "AvrcpControllerService"; |
| |
| /* |
| * Messages handled by mHandler |
| */ |
| |
| RemoteDevice mAvrcpRemoteDevice; |
| RemoteMediaPlayers mRemoteMediaPlayers; |
| NowPlaying mRemoteNowPlayingList; |
| |
| private AvrcpMessageHandler mHandler; |
| private static AvrcpControllerService sAvrcpControllerService; |
| private static AudioManager mAudioManager; |
| |
| private final ArrayList<BluetoothDevice> mConnectedDevices |
| = new ArrayList<BluetoothDevice>(); |
| |
| 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(); |
| Looper looper = thread.getLooper(); |
| mHandler = new AvrcpMessageHandler(looper); |
| |
| setAvrcpControllerService(this); |
| mAudioManager = (AudioManager)sAvrcpControllerService. |
| getSystemService(Context.AUDIO_SERVICE); |
| return true; |
| } |
| |
| protected void resetRemoteData() { |
| try { |
| unregisterReceiver(mBroadcastReceiver); |
| } |
| catch (IllegalArgumentException e) { |
| Log.e(TAG,"Receiver not registered"); |
| } |
| if(mAvrcpRemoteDevice != null) { |
| mAvrcpRemoteDevice.cleanup(); |
| mAvrcpRemoteDevice = null; |
| } |
| if(mRemoteMediaPlayers != null) { |
| mRemoteMediaPlayers.cleanup(); |
| mRemoteMediaPlayers = null; |
| } |
| if(mRemoteNowPlayingList != null) { |
| mRemoteNowPlayingList.cleanup(); |
| mRemoteNowPlayingList = null; |
| } |
| } |
| protected boolean stop() { |
| if (mHandler != null) { |
| mHandler.removeCallbacksAndMessages(null); |
| Looper looper = mHandler.getLooper(); |
| if (looper != null) { |
| looper.quit(); |
| } |
| } |
| resetRemoteData(); |
| return true; |
| } |
| |
| protected boolean cleanup() { |
| if (mHandler != null) { |
| mHandler.removeCallbacksAndMessages(null); |
| Looper looper = mHandler.getLooper(); |
| if (looper != null) looper.quit(); |
| } |
| resetRemoteData(); |
| clearAvrcpControllerService(); |
| cleanupNative(); |
| |
| 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 (sAvrcpControllerService == null) { |
| Log.d(TAG, "setAvrcpControllerService(): service not available"); |
| } else if (!sAvrcpControllerService.isAvailable()) { |
| Log.d(TAG,"setAvrcpControllerService(): service is cleaning up"); |
| } |
| } |
| } |
| } |
| |
| private static synchronized void clearAvrcpControllerService() { |
| sAvrcpControllerService = null; |
| } |
| |
| public List<BluetoothDevice> getConnectedDevices() { |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| return mConnectedDevices; |
| } |
| |
| List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) { |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| for (int i = 0; i < states.length; i++) { |
| if (states[i] == BluetoothProfile.STATE_CONNECTED) { |
| return mConnectedDevices; |
| } |
| } |
| return new ArrayList<BluetoothDevice>(); |
| } |
| |
| int getConnectionState(BluetoothDevice device) { |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| return (mConnectedDevices.contains(device) ? BluetoothProfile.STATE_CONNECTED |
| : BluetoothProfile.STATE_DISCONNECTED); |
| } |
| |
| public void sendGroupNavigationCmd(BluetoothDevice device, int keyCode, int keyState) { |
| Log.v(TAG, "sendGroupNavigationCmd keyCode: " + keyCode + " keyState: " + keyState); |
| if (device == null) { |
| throw new NullPointerException("device == null"); |
| } |
| if (!(mConnectedDevices.contains(device))) { |
| for (BluetoothDevice cdevice : mConnectedDevices) { |
| Log.e(TAG, "Device: " + cdevice); |
| } |
| Log.e(TAG," Device does not match " + device); |
| return; |
| } |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants. |
| MESSAGE_SEND_GROUP_NAVIGATION_CMD,keyCode, keyState, device); |
| mHandler.sendMessage(msg); |
| } |
| |
| public void sendPassThroughCmd(BluetoothDevice device, int keyCode, int keyState) { |
| Log.v(TAG, "sendPassThroughCmd keyCode: " + keyCode + " keyState: " + keyState); |
| if (device == null) { |
| throw new NullPointerException("device == null"); |
| } |
| if (!(mConnectedDevices.contains(device))) { |
| Log.d(TAG," Device does not match"); |
| return; |
| } |
| if ((mAvrcpRemoteDevice == null)|| |
| (mAvrcpRemoteDevice.mRemoteFeatures == AvrcpControllerConstants.BTRC_FEAT_NONE)|| |
| (mRemoteMediaPlayers == null) || |
| (mRemoteMediaPlayers.getAddressedPlayer() == null)){ |
| Log.d(TAG," Device connected but PlayState not present "); |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants.MESSAGE_SEND_PASS_THROUGH_CMD, |
| keyCode, keyState, device); |
| mHandler.sendMessage(msg); |
| return; |
| } |
| boolean sendCommand = false; |
| switch(keyCode) { |
| case BluetoothAvrcpController.PASS_THRU_CMD_ID_PLAY: |
| sendCommand = (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_STOPPED)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_PAUSED) || |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_PLAYING); |
| break; |
| case BluetoothAvrcpController.PASS_THRU_CMD_ID_PAUSE: |
| /* |
| * allowing pause command in pause state to handle A2DP Sink Concurrency |
| * If call is ongoing and Start is initiated from remote, we will send pause again |
| * If acquireFocus fails, we will send Pause again |
| * To Stop sending multiple Pause, check in application. |
| */ |
| sendCommand = (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_PLAYING)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_FWD_SEEK)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_STOPPED)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_PAUSED)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_REV_SEEK); |
| break; |
| case BluetoothAvrcpController.PASS_THRU_CMD_ID_STOP: |
| sendCommand = (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_PLAYING)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_FWD_SEEK)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_REV_SEEK)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_STOPPED)|| |
| (mRemoteMediaPlayers.getPlayStatus() == |
| AvrcpControllerConstants.PLAY_STATUS_PAUSED); |
| break; |
| case BluetoothAvrcpController.PASS_THRU_CMD_ID_BACKWARD: |
| case BluetoothAvrcpController.PASS_THRU_CMD_ID_FORWARD: |
| case BluetoothAvrcpController.PASS_THRU_CMD_ID_FF: |
| case BluetoothAvrcpController.PASS_THRU_CMD_ID_REWIND: |
| sendCommand = true; // we can send this command in all states |
| break; |
| } |
| if (sendCommand) { |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants.MESSAGE_SEND_PASS_THROUGH_CMD, |
| keyCode, keyState, device); |
| mHandler.sendMessage(msg); |
| } |
| else { |
| Log.e(TAG," Not in right state, don't send Pass Thru cmd "); |
| } |
| } |
| |
| public void startAvrcpUpdates() { |
| mHandler.obtainMessage( |
| AvrcpControllerConstants.MESSAGE_START_METADATA_BROADCASTS).sendToTarget(); |
| } |
| |
| public void stopAvrcpUpdates() { |
| mHandler.obtainMessage( |
| AvrcpControllerConstants.MESSAGE_STOP_METADATA_BROADCASTS).sendToTarget(); |
| } |
| |
| public MediaMetadata getMetaData(BluetoothDevice device) { |
| Log.d(TAG, "getMetaData = "); |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| if((mRemoteNowPlayingList != null) && (mRemoteNowPlayingList.getCurrentTrack() != null)) { |
| return getCurrentMetaData(AvrcpControllerConstants.AVRCP_SCOPE_NOW_PLAYING, 0); |
| } |
| else |
| return null; |
| } |
| public PlaybackState getPlaybackState(BluetoothDevice device) { |
| if (DBG) Log.d(TAG, "getPlayBackState device = "+ device); |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| return getCurrentPlayBackState(); |
| } |
| public BluetoothAvrcpPlayerSettings getPlayerSettings(BluetoothDevice device) { |
| if (DBG) Log.d(TAG, "getPlayerApplicationSetting "); |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| return getCurrentPlayerAppSetting(); |
| } |
| public boolean setPlayerApplicationSetting(BluetoothAvrcpPlayerSettings plAppSetting) { |
| if ((mAvrcpRemoteDevice == null)||(mRemoteMediaPlayers == null)) { |
| return false; |
| } |
| enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); |
| /* |
| * We have to extract values from BluetoothAvrcpPlayerSettings |
| */ |
| int mSettings = plAppSetting.getSettings(); |
| int numAttributes = 0; |
| /* calculate number of attributes in request */ |
| while(mSettings > 0) { |
| numAttributes += ((mSettings & 0x01)!= 0)?1: 0; |
| mSettings = mSettings >> 1; |
| } |
| byte[] attribArray = new byte [2*numAttributes]; |
| mSettings = plAppSetting.getSettings(); |
| /* |
| * Now we will flatten it <id, val> |
| */ |
| int i = 0; |
| if((mSettings & BluetoothAvrcpPlayerSettings.SETTING_EQUALIZER) != 0) { |
| attribArray[i++] = AvrcpControllerConstants.ATTRIB_EQUALIZER_STATUS; |
| attribArray[i++] = (byte)AvrcpUtils.mapAvrcpPlayerSettingstoBTAttribVal( |
| BluetoothAvrcpPlayerSettings.SETTING_EQUALIZER, plAppSetting. |
| getSettingValue(BluetoothAvrcpPlayerSettings.SETTING_EQUALIZER)); |
| } |
| if((mSettings & BluetoothAvrcpPlayerSettings.SETTING_REPEAT) != 0) { |
| attribArray[i++] = AvrcpControllerConstants.ATTRIB_REPEAT_STATUS; |
| attribArray[i++] = (byte)AvrcpUtils.mapAvrcpPlayerSettingstoBTAttribVal( |
| BluetoothAvrcpPlayerSettings.SETTING_REPEAT, plAppSetting. |
| getSettingValue(BluetoothAvrcpPlayerSettings.SETTING_REPEAT)); |
| } |
| if((mSettings & BluetoothAvrcpPlayerSettings.SETTING_SHUFFLE) != 0) { |
| attribArray[i++] = AvrcpControllerConstants.ATTRIB_SHUFFLE_STATUS; |
| attribArray[i++] = (byte)AvrcpUtils.mapAvrcpPlayerSettingstoBTAttribVal( |
| BluetoothAvrcpPlayerSettings.SETTING_SHUFFLE, plAppSetting. |
| getSettingValue(BluetoothAvrcpPlayerSettings.SETTING_SHUFFLE)); |
| } |
| if((mSettings & BluetoothAvrcpPlayerSettings.SETTING_SCAN) != 0) { |
| attribArray[i++] = AvrcpControllerConstants.ATTRIB_SCAN_STATUS; |
| attribArray[i++] = (byte)AvrcpUtils.mapAvrcpPlayerSettingstoBTAttribVal( |
| BluetoothAvrcpPlayerSettings.SETTING_SCAN, plAppSetting. |
| getSettingValue(BluetoothAvrcpPlayerSettings.SETTING_SCAN)); |
| } |
| boolean isSettingSupported = mRemoteMediaPlayers.getAddressedPlayer(). |
| isPlayerAppSettingSupported((byte)numAttributes, attribArray); |
| if(isSettingSupported) { |
| ByteBuffer bb = ByteBuffer.wrap(attribArray, 0, (2*numAttributes)); |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants. |
| MESSAGE_SEND_SET_CURRENT_PLAYER_APPLICATION_SETTINGS, numAttributes, 0, bb); |
| mHandler.sendMessage(msg); |
| } |
| return isSettingSupported; |
| } |
| |
| //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; |
| } |
| |
| public List<BluetoothDevice> getConnectedDevices() { |
| AvrcpControllerService service = getService(); |
| if (service == null) return new ArrayList<BluetoothDevice>(0); |
| return service.getConnectedDevices(); |
| } |
| |
| public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) { |
| AvrcpControllerService service = getService(); |
| if (service == null) return new ArrayList<BluetoothDevice>(0); |
| return service.getDevicesMatchingConnectionStates(states); |
| } |
| |
| public int getConnectionState(BluetoothDevice device) { |
| AvrcpControllerService service = getService(); |
| if (service == null) return BluetoothProfile.STATE_DISCONNECTED; |
| return service.getConnectionState(device); |
| } |
| |
| public void sendPassThroughCmd(BluetoothDevice device, int keyCode, int keyState) { |
| Log.v(TAG,"Binder Call: sendPassThroughCmd"); |
| AvrcpControllerService service = getService(); |
| if (service == null) return; |
| service.sendPassThroughCmd(device, keyCode, keyState); |
| } |
| |
| @Override |
| public void sendGroupNavigationCmd(BluetoothDevice device, int keyCode, int keyState) { |
| Log.v(TAG,"Binder Call: sendGroupNavigationCmd"); |
| AvrcpControllerService service = getService(); |
| if (service == null) return; |
| 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; |
| return service.getPlayerSettings(device); |
| } |
| |
| @Override |
| public MediaMetadata getMetadata(BluetoothDevice device) { |
| Log.v(TAG,"Binder Call: getMetaData "); |
| AvrcpControllerService service = getService(); |
| if (service == null) return null; |
| return service.getMetaData(device); |
| } |
| |
| @Override |
| public PlaybackState getPlaybackState(BluetoothDevice device) { |
| Log.v(TAG,"Binder Call: getPlaybackState"); |
| AvrcpControllerService service = getService(); |
| if (service == null) return null; |
| return service.getPlaybackState(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); |
| } |
| }; |
| |
| private String utf8ToString(byte[] input) |
| { |
| Charset UTF8_CHARSET = Charset.forName("UTF-8"); |
| return new String(input,UTF8_CHARSET); |
| } |
| private int asciiToInt(int len, byte[] array) |
| { |
| return Integer.parseInt(utf8ToString(array)); |
| } |
| private BluetoothAvrcpPlayerSettings getCurrentPlayerAppSetting() { |
| if((mRemoteMediaPlayers == null) || (mRemoteMediaPlayers.getAddressedPlayer() == null)) |
| return null; |
| return mRemoteMediaPlayers.getAddressedPlayer().getSupportedPlayerAppSetting(); |
| } |
| private PlaybackState getCurrentPlayBackState() { |
| if ((mRemoteMediaPlayers == null) || (mRemoteMediaPlayers.getAddressedPlayer() == null)) { |
| return new PlaybackState.Builder().setState(PlaybackState.STATE_ERROR, |
| PlaybackState.PLAYBACK_POSITION_UNKNOWN, |
| 0).build(); |
| } |
| return AvrcpUtils.mapBtPlayStatustoPlayBackState( |
| mRemoteMediaPlayers.getAddressedPlayer().mPlayStatus, |
| mRemoteMediaPlayers.getAddressedPlayer().mPlayTime); |
| } |
| private MediaMetadata getCurrentMetaData(int scope, int trackId) { |
| /* if scope is now playing */ |
| if(scope == AvrcpControllerConstants.AVRCP_SCOPE_NOW_PLAYING) { |
| if((mRemoteNowPlayingList == null) || (mRemoteNowPlayingList. |
| getTrackFromId(trackId) == null)) |
| return null; |
| TrackInfo mNowPlayingTrack = mRemoteNowPlayingList.getTrackFromId(trackId); |
| return AvrcpUtils.getMediaMetaData(mNowPlayingTrack); |
| } |
| /* if scope is now playing */ |
| else if(scope == AvrcpControllerConstants.AVRCP_SCOPE_VFS) { |
| /* TODO for browsing */ |
| } |
| return null; |
| } |
| private void broadcastMetaDataChanged(MediaMetadata mMetaData) { |
| Intent intent = new Intent(BluetoothAvrcpController.ACTION_TRACK_EVENT); |
| intent.putExtra(BluetoothAvrcpController.EXTRA_METADATA, mMetaData); |
| if(DBG) Log.d(TAG," broadcastMetaDataChanged = " + |
| AvrcpUtils.displayMetaData(mMetaData)); |
| sendBroadcast(intent, ProfileService.BLUETOOTH_PERM); |
| } |
| private void broadcastPlayBackStateChanged(PlaybackState state) { |
| Intent intent = new Intent(BluetoothAvrcpController.ACTION_TRACK_EVENT); |
| intent.putExtra(BluetoothAvrcpController.EXTRA_PLAYBACK, state); |
| if(DBG) Log.d(TAG," broadcastPlayBackStateChanged = " + state.toString()); |
| sendBroadcast(intent, ProfileService.BLUETOOTH_PERM); |
| } |
| private void broadcastPlayerAppSettingChanged(BluetoothAvrcpPlayerSettings mPlAppSetting) { |
| Intent intent = new Intent(BluetoothAvrcpController.ACTION_PLAYER_SETTING); |
| intent.putExtra(BluetoothAvrcpController.EXTRA_PLAYER_SETTING, mPlAppSetting); |
| if(DBG) Log.d(TAG," broadcastPlayerAppSettingChanged = " + |
| AvrcpUtils.displayBluetoothAvrcpSettings(mPlAppSetting)); |
| sendBroadcast(intent, ProfileService.BLUETOOTH_PERM); |
| } |
| /** Handles Avrcp messages. */ |
| private final class AvrcpMessageHandler extends Handler { |
| private boolean mBroadcastMetadata = false; |
| |
| private AvrcpMessageHandler(Looper looper) { |
| super(looper); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| Log.d(TAG," HandleMessage: "+ AvrcpControllerConstants.dumpMessageString(msg.what) + |
| " Remote Connected " + !mConnectedDevices.isEmpty()); |
| A2dpSinkService a2dpSinkService = A2dpSinkService.getA2dpSinkService(); |
| switch (msg.what) { |
| case AvrcpControllerConstants.MESSAGE_STOP_METADATA_BROADCASTS: |
| // Any messages hence forth about play pos/play status/song info will be ignored. |
| if(mRemoteMediaPlayers != null) { |
| // Mock the current state to *look like* it is paused. The remote play state is |
| // still cached in mRemoteMediaPlayers and will be restored when the |
| // startAvrcpUpdates is called again. |
| broadcastPlayBackStateChanged(AvrcpUtils.mapBtPlayStatustoPlayBackState |
| ((byte) AvrcpControllerConstants.PLAY_STATUS_PAUSED, |
| mRemoteMediaPlayers.getAddressedPlayer().mPlayTime)); |
| } |
| mBroadcastMetadata = false; |
| break; |
| case AvrcpControllerConstants.MESSAGE_START_METADATA_BROADCASTS: |
| // Any messages hence forth about play pos/play status/song info will be sent. |
| if(mRemoteMediaPlayers != null) { |
| broadcastPlayBackStateChanged(getCurrentPlayBackState()); |
| broadcastMetaDataChanged( |
| getCurrentMetaData(AvrcpControllerConstants.AVRCP_SCOPE_NOW_PLAYING, 0)); |
| } |
| mBroadcastMetadata = true; |
| break; |
| case AvrcpControllerConstants.MESSAGE_SEND_PASS_THROUGH_CMD: |
| BluetoothDevice device = (BluetoothDevice)msg.obj; |
| sendPassThroughCommandNative(getByteAddress(device), msg.arg1, msg.arg2); |
| if((a2dpSinkService != null)&&(!mConnectedDevices.isEmpty())) { |
| Log.d(TAG," inform AVRCP Commands to A2DP Sink "); |
| a2dpSinkService.informAvrcpPassThroughCmd(device, msg.arg1, msg.arg2); |
| } |
| break; |
| case AvrcpControllerConstants.MESSAGE_SEND_GROUP_NAVIGATION_CMD: |
| BluetoothDevice peerDevice = (BluetoothDevice)msg.obj; |
| sendGroupNavigationCommandNative(getByteAddress(peerDevice), msg.arg1, msg.arg2); |
| break; |
| case AvrcpControllerConstants.MESSAGE_SEND_SET_CURRENT_PLAYER_APPLICATION_SETTINGS: |
| byte numAttributes = (byte)msg.arg1; |
| ByteBuffer bbRsp = (ByteBuffer)msg.obj; |
| byte[] attributeIds = new byte [numAttributes]; |
| byte[] attributeVals = new byte [numAttributes]; |
| for(int i = 0; (bbRsp.hasRemaining())&&(i < numAttributes); i++) { |
| attributeIds[i] = bbRsp.get(); |
| attributeVals[i] = bbRsp.get(); |
| } |
| setPlayerApplicationSettingValuesNative(getByteAddress(mAvrcpRemoteDevice.mBTDevice), |
| numAttributes, attributeIds, attributeVals); |
| break; |
| |
| case AvrcpControllerConstants.MESSAGE_PROCESS_CONNECTION_CHANGE: |
| int newState = msg.arg1; |
| int oldState = msg.arg2; |
| BluetoothDevice rtDevice = (BluetoothDevice)msg.obj; |
| if ((newState == BluetoothProfile.STATE_CONNECTED) && |
| (oldState == BluetoothProfile.STATE_DISCONNECTED)) { |
| /* We create RemoteDevice and MediaPlayerList here |
| * Now playing list after RC features |
| */ |
| if(mAvrcpRemoteDevice == null){ |
| mAvrcpRemoteDevice = new RemoteDevice(rtDevice); |
| /* Remote will have a player irrespective of AVRCP Version |
| * Create a Default player, we will add entries in case Browsing |
| * is supported by remote |
| */ |
| if(mRemoteMediaPlayers == null) { |
| mRemoteMediaPlayers = new RemoteMediaPlayers(mAvrcpRemoteDevice); |
| PlayerInfo mPlayer = new PlayerInfo(); |
| mPlayer.mPlayerId = 0; |
| mRemoteMediaPlayers.addPlayer(mPlayer); |
| mRemoteMediaPlayers.setAddressedPlayer(mPlayer); |
| } |
| } |
| } |
| else if ((newState == BluetoothProfile.STATE_DISCONNECTED) && |
| (oldState == BluetoothProfile.STATE_CONNECTED)) /* connection down */ |
| { |
| resetRemoteData(); |
| mHandler.removeCallbacksAndMessages(null); |
| } |
| /* |
| * Send intent now |
| */ |
| Intent intent = new Intent(BluetoothAvrcpController.ACTION_CONNECTION_STATE_CHANGED); |
| intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, oldState); |
| intent.putExtra(BluetoothProfile.EXTRA_STATE, newState); |
| intent.putExtra(BluetoothDevice.EXTRA_DEVICE, rtDevice); |
| // intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); |
| sendBroadcast(intent, ProfileService.BLUETOOTH_PERM); |
| break; |
| case AvrcpControllerConstants.MESSAGE_PROCESS_RC_FEATURES: |
| if(mAvrcpRemoteDevice == null) |
| break; |
| mAvrcpRemoteDevice.mRemoteFeatures = msg.arg1; |
| /* in case of AVRCP version < 1.3, no need to add track info */ |
| if(mAvrcpRemoteDevice.isMetaDataSupported()) { |
| if(mRemoteNowPlayingList == null) |
| mRemoteNowPlayingList = new NowPlaying(mAvrcpRemoteDevice); |
| TrackInfo mTrack = new TrackInfo(); |
| /* First element of NowPlayingList will be current Track |
| * for 1.3 this will be the only song |
| * for >= 1.4, others songs will have non-zero UID |
| */ |
| mTrack.mItemUid = 0; |
| mRemoteNowPlayingList.addTrack(mTrack); |
| mRemoteNowPlayingList.setCurrTrack(mTrack); |
| } |
| break; |
| case AvrcpControllerConstants.MESSAGE_PROCESS_SET_ABS_VOL_CMD: |
| mAvrcpRemoteDevice.mAbsVolNotificationState = |
| AvrcpControllerConstants.DEFER_VOLUME_CHANGE_RSP; |
| setAbsVolume(msg.arg1, msg.arg2); |
| break; |
| case AvrcpControllerConstants.MESSAGE_PROCESS_REGISTER_ABS_VOL_NOTIFICATION: |
| /* start BroadcastReceiver now */ |
| IntentFilter filter = new IntentFilter(AudioManager.VOLUME_CHANGED_ACTION); |
| mAvrcpRemoteDevice.mNotificationLabel = msg.arg1; |
| mAvrcpRemoteDevice.mAbsVolNotificationState = |
| AvrcpControllerConstants.SEND_VOLUME_CHANGE_RSP; |
| registerReceiver(mBroadcastReceiver, filter); |
| int maxVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC); |
| int currIndex = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC); |
| int percentageVol = ((currIndex* AvrcpControllerConstants.ABS_VOL_BASE)/maxVolume); |
| Log.d(TAG," Sending Interim Response = "+ percentageVol + " label " + msg.arg1); |
| sendRegisterAbsVolRspNative(getByteAddress(mAvrcpRemoteDevice.mBTDevice), |
| (byte)AvrcpControllerConstants.NOTIFICATION_RSP_TYPE_INTERIM, percentageVol, |
| mAvrcpRemoteDevice.mNotificationLabel); |
| break; |
| case AvrcpControllerConstants.MESSAGE_PROCESS_TRACK_CHANGED: |
| if(mRemoteNowPlayingList != null) { |
| mRemoteNowPlayingList.updateCurrentTrack((TrackInfo)msg.obj); |
| |
| if (!mBroadcastMetadata) { |
| Log.d(TAG, "Metadata is not broadcasted, ignoring."); |
| return; |
| } |
| |
| broadcastMetaDataChanged(AvrcpUtils.getMediaMetaData |
| (mRemoteNowPlayingList.getCurrentTrack())); |
| } |
| break; |
| case AvrcpControllerConstants.MESSAGE_PROCESS_PLAY_POS_CHANGED: |
| if(mRemoteMediaPlayers != null) { |
| mRemoteMediaPlayers.getAddressedPlayer().mPlayTime = msg.arg2; |
| |
| if (!mBroadcastMetadata) { |
| Log.d(TAG, "Metadata is not broadcasted, ignoring."); |
| return; |
| } |
| |
| broadcastPlayBackStateChanged(AvrcpUtils.mapBtPlayStatustoPlayBackState |
| (mRemoteMediaPlayers.getAddressedPlayer().mPlayStatus, |
| mRemoteMediaPlayers.getAddressedPlayer().mPlayTime)); |
| } |
| if(mRemoteNowPlayingList != null) { |
| mRemoteNowPlayingList.getCurrentTrack().mTrackLen = msg.arg1; |
| } |
| break; |
| case AvrcpControllerConstants.MESSAGE_PROCESS_PLAY_STATUS_CHANGED: |
| if(mRemoteMediaPlayers != null) { |
| int status = msg.arg1; |
| mRemoteMediaPlayers.getAddressedPlayer().mPlayStatus = (byte) status; |
| if (status == AvrcpControllerConstants.PLAY_STATUS_PLAYING) { |
| a2dpSinkService.informTGStatePlaying(mConnectedDevices.get(0), true); |
| } else if (status == AvrcpControllerConstants.PLAY_STATUS_PAUSED || |
| status == AvrcpControllerConstants.PLAY_STATUS_STOPPED) { |
| a2dpSinkService.informTGStatePlaying(mConnectedDevices.get(0), false); |
| } |
| |
| if (mBroadcastMetadata) { |
| broadcastPlayBackStateChanged(AvrcpUtils.mapBtPlayStatustoPlayBackState |
| (mRemoteMediaPlayers.getAddressedPlayer().mPlayStatus, |
| mRemoteMediaPlayers.getAddressedPlayer().mPlayTime)); |
| } else { |
| Log.d(TAG, "Metadata is not broadcasted, ignoring."); |
| return; |
| } |
| } |
| break; |
| case AvrcpControllerConstants.MESSAGE_PROCESS_SUPPORTED_PLAYER_APP_SETTING: |
| if(mRemoteMediaPlayers != null) |
| mRemoteMediaPlayers.getAddressedPlayer(). |
| setSupportedPlayerAppSetting((ByteBuffer)msg.obj); |
| break; |
| case AvrcpControllerConstants.MESSAGE_PROCESS_PLAYER_APP_SETTING_CHANGED: |
| if(mRemoteMediaPlayers != null) { |
| mRemoteMediaPlayers.getAddressedPlayer(). |
| updatePlayerAppSetting((ByteBuffer)msg.obj); |
| broadcastPlayerAppSettingChanged(getCurrentPlayerAppSetting()); |
| } |
| break; |
| } |
| } |
| } |
| |
| private void setAbsVolume(int absVol, int label) |
| { |
| int maxVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC); |
| int currIndex = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC); |
| if (mAvrcpRemoteDevice.mFirstAbsVolCmdRecvd) { |
| int newIndex = (maxVolume*absVol)/AvrcpControllerConstants.ABS_VOL_BASE; |
| Log.d(TAG," setAbsVolume ="+absVol + " maxVol = " + maxVolume + " cur = " + currIndex + |
| " new = "+newIndex); |
| /* |
| * In some cases change in percentage is not sufficient enough to warrant |
| * change in index values which are in range of 0-15. For such cases |
| * no action is required |
| */ |
| if (newIndex != currIndex) { |
| mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, newIndex, |
| AudioManager.FLAG_SHOW_UI); |
| } |
| } |
| else { |
| mAvrcpRemoteDevice.mFirstAbsVolCmdRecvd = true; |
| absVol = (currIndex*AvrcpControllerConstants.ABS_VOL_BASE)/maxVolume; |
| Log.d(TAG," SetAbsVol recvd for first time, respond with " + absVol); |
| } |
| sendAbsVolRspNative(getByteAddress(mAvrcpRemoteDevice.mBTDevice), absVol, label); |
| } |
| |
| private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(AudioManager.VOLUME_CHANGED_ACTION)) { |
| int streamType = intent.getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_TYPE, -1); |
| if (streamType == AudioManager.STREAM_MUSIC) { |
| int streamValue = intent |
| .getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_VALUE, -1); |
| int streamPrevValue = intent.getIntExtra( |
| AudioManager.EXTRA_PREV_VOLUME_STREAM_VALUE, -1); |
| if (streamValue != -1 && streamValue != streamPrevValue) { |
| if ((mAvrcpRemoteDevice == null) |
| ||((mAvrcpRemoteDevice.mRemoteFeatures & |
| AvrcpControllerConstants.BTRC_FEAT_ABSOLUTE_VOLUME) == 0) |
| ||(mConnectedDevices.isEmpty())) |
| return; |
| if(mAvrcpRemoteDevice.mAbsVolNotificationState == |
| AvrcpControllerConstants.SEND_VOLUME_CHANGE_RSP) { |
| int maxVol = mAudioManager. |
| getStreamMaxVolume(AudioManager.STREAM_MUSIC); |
| int currIndex = mAudioManager. |
| getStreamVolume(AudioManager.STREAM_MUSIC); |
| int percentageVol = ((currIndex* |
| AvrcpControllerConstants.ABS_VOL_BASE)/maxVol); |
| Log.d(TAG," Abs Vol Notify Rsp Changed vol = "+ percentageVol); |
| sendRegisterAbsVolRspNative(getByteAddress(mAvrcpRemoteDevice.mBTDevice), |
| (byte)AvrcpControllerConstants.NOTIFICATION_RSP_TYPE_CHANGED, |
| percentageVol, mAvrcpRemoteDevice.mNotificationLabel); |
| } |
| else if (mAvrcpRemoteDevice.mAbsVolNotificationState == |
| AvrcpControllerConstants.DEFER_VOLUME_CHANGE_RSP) { |
| Log.d(TAG," Don't Complete Notification Rsp. "); |
| mAvrcpRemoteDevice.mAbsVolNotificationState = |
| AvrcpControllerConstants.SEND_VOLUME_CHANGE_RSP; |
| } |
| } |
| } |
| } |
| } |
| }; |
| |
| private void handlePassthroughRsp(int id, int keyState) { |
| Log.d(TAG, "passthrough response received as: key: " + id + " state: " + keyState); |
| } |
| |
| private void onConnectionStateChanged(boolean connected, byte[] address) { |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| Log.d(TAG, "onConnectionStateChanged " + connected + " " + device+ " size "+ |
| mConnectedDevices.size()); |
| if (device == null) |
| return; |
| int oldState = (mConnectedDevices.contains(device) ? BluetoothProfile.STATE_CONNECTED |
| : BluetoothProfile.STATE_DISCONNECTED); |
| int newState = (connected ? BluetoothProfile.STATE_CONNECTED |
| : BluetoothProfile.STATE_DISCONNECTED); |
| |
| if (connected && oldState == BluetoothProfile.STATE_DISCONNECTED) { |
| /* AVRCPControllerService supports single connection */ |
| if(mConnectedDevices.size() > 0) { |
| Log.d(TAG,"A Connection already exists, returning"); |
| return; |
| } |
| mConnectedDevices.add(device); |
| Message msg = mHandler.obtainMessage( |
| AvrcpControllerConstants.MESSAGE_PROCESS_CONNECTION_CHANGE, newState, |
| oldState, device); |
| mHandler.sendMessage(msg); |
| } else if (!connected && oldState == BluetoothProfile.STATE_CONNECTED) { |
| mConnectedDevices.remove(device); |
| Message msg = mHandler.obtainMessage( |
| AvrcpControllerConstants.MESSAGE_PROCESS_CONNECTION_CHANGE, newState, |
| oldState, device); |
| mHandler.sendMessage(msg); |
| } |
| } |
| |
| private void getRcFeatures(byte[] address, int features) { |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| Message msg = mHandler.obtainMessage( |
| AvrcpControllerConstants.MESSAGE_PROCESS_RC_FEATURES, features, 0, device); |
| mHandler.sendMessage(msg); |
| } |
| private void setPlayerAppSettingRsp(byte[] address, byte accepted) { |
| /* TODO do we need to do anything here */ |
| } |
| private void handleRegisterNotificationAbsVol(byte[] address, byte label) |
| { |
| Log.d(TAG,"handleRegisterNotificationAbsVol "); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| if (!mConnectedDevices.contains(device)) |
| return; |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants. |
| MESSAGE_PROCESS_REGISTER_ABS_VOL_NOTIFICATION, label, 0); |
| mHandler.sendMessage(msg); |
| } |
| |
| private void handleSetAbsVolume(byte[] address, byte absVol, byte label) |
| { |
| Log.d(TAG,"handleSetAbsVolume "); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| if (!mConnectedDevices.contains(device)) |
| return; |
| Message msg = mHandler.obtainMessage( |
| AvrcpControllerConstants.MESSAGE_PROCESS_SET_ABS_VOL_CMD, absVol, label); |
| mHandler.sendMessage(msg); |
| } |
| |
| private void onTrackChanged(byte[] address, byte numAttributes, int[] attributes, |
| String[] attribVals) |
| { |
| Log.d(TAG,"onTrackChanged "); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| if (!mConnectedDevices.contains(device)) |
| return; |
| TrackInfo mTrack = new TrackInfo(0, numAttributes, attributes, attribVals); |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants. |
| MESSAGE_PROCESS_TRACK_CHANGED, numAttributes, 0, mTrack); |
| mHandler.sendMessage(msg); |
| } |
| |
| private void onPlayPositionChanged(byte[] address, int songLen, int currSongPosition) { |
| Log.d(TAG,"onPlayPositionChanged "); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| if (!mConnectedDevices.contains(device)) |
| return; |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants. |
| MESSAGE_PROCESS_PLAY_POS_CHANGED, songLen, currSongPosition); |
| mHandler.sendMessage(msg); |
| } |
| |
| private void onPlayStatusChanged(byte[] address, byte playStatus) { |
| if(DBG) Log.d(TAG,"onPlayStatusChanged " + playStatus); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| if (!mConnectedDevices.contains(device)) |
| return; |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants. |
| MESSAGE_PROCESS_PLAY_STATUS_CHANGED, playStatus, 0); |
| mHandler.sendMessage(msg); |
| } |
| |
| private void handlePlayerAppSetting(byte[] address, byte[] playerAttribRsp, int rspLen) { |
| Log.d(TAG,"handlePlayerAppSetting rspLen = " + rspLen); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| if (!mConnectedDevices.contains(device)) |
| return; |
| ByteBuffer bb = ByteBuffer.wrap(playerAttribRsp, 0, rspLen); |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants. |
| MESSAGE_PROCESS_SUPPORTED_PLAYER_APP_SETTING, 0, 0, bb); |
| mHandler.sendMessage(msg); |
| } |
| |
| private void onPlayerAppSettingChanged(byte[] address, byte[] playerAttribRsp, int rspLen) { |
| Log.d(TAG,"onPlayerAppSettingChanged "); |
| BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice |
| (Utils.getAddressStringFromByte(address)); |
| if (!mConnectedDevices.contains(device)) |
| return; |
| ByteBuffer bb = ByteBuffer.wrap(playerAttribRsp, 0, rspLen); |
| Message msg = mHandler.obtainMessage(AvrcpControllerConstants. |
| MESSAGE_PROCESS_PLAYER_APP_SETTING_CHANGED, 0, 0, bb); |
| mHandler.sendMessage(msg); |
| } |
| |
| private void handleGroupNavigationRsp(int id, int keyState) { |
| Log.d(TAG, "group navigation response received as: key: " |
| + id + " state: " + keyState); |
| } |
| |
| private byte[] getByteAddress(BluetoothDevice device) { |
| return Utils.getBytesFromAddress(device.getAddress()); |
| } |
| |
| @Override |
| public void dump(StringBuilder sb) { |
| super.dump(sb); |
| } |
| |
| private native static void classInitNative(); |
| private native void initNative(); |
| private native void cleanupNative(); |
| private native boolean sendPassThroughCommandNative(byte[] address, int keyCode, int keyState); |
| private native boolean sendGroupNavigationCommandNative(byte[] address, int keyCode, |
| int keyState); |
| private native void setPlayerApplicationSettingValuesNative(byte[] address, byte numAttrib, |
| byte[] atttibIds, byte[]attribVal); |
| /* This api is used to send response to SET_ABS_VOL_CMD */ |
| private native void sendAbsVolRspNative(byte[] address, int absVol, int label); |
| /* This api is used to inform remote for any volume level changes */ |
| private native void sendRegisterAbsVolRspNative(byte[] address, byte rspType, int absVol, |
| int label); |
| } |
