Adding support for Absolute Volume (bb008f1b) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_avrcp.cpp

+60 −0

Original line number	Diff line number	Diff line
		@@ -26,9 +26,11 @@
		#include <string.h>

		namespace android {
		static jmethodID method_getRcFeatures;
		static jmethodID method_getPlayStatus;
		static jmethodID method_getElementAttr;
		static jmethodID method_registerNotification;
		static jmethodID method_volumeChangeCallback;
		static jmethodID method_handlePassthroughCmd;

		static const btrc_interface_t *sBluetoothAvrcpInterface = NULL;
		@@ -47,6 +49,26 @@ static bool checkCallbackThread() {
		return true;
		}

		static void btavrcp_remote_features_callback(bt_bdaddr_t* bd_addr, btrc_remote_features_t features) {
		ALOGI("%s", __FUNCTION__);
		jbyteArray addr;

		if (!checkCallbackThread()) {
		ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__);
		return;
		}
		addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));
		if (!addr) {
		ALOGE("Fail to new jbyteArray bd addr for connection state");
		checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr);
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getRcFeatures, addr, (jint)features);
		checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
		}

		static void btavrcp_get_play_status_callback() {
		ALOGI("%s", __FUNCTION__);

		@@ -93,6 +115,19 @@ static void btavrcp_register_notification_callback(btrc_event_id_t event_id, uin
		checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
		}

		static void btavrcp_volume_change_callback(uint8_t volume, uint8_t ctype) {
		ALOGI("%s", __FUNCTION__);

		if (!checkCallbackThread()) {
		ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__);
		return;
		}

		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_volumeChangeCallback, (jint)volume,
		(jint)ctype);
		checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
		}

		static void btavrcp_passthrough_command_callback(int id, int pressed) {
		ALOGI("%s", __FUNCTION__);

		@@ -108,6 +143,7 @@ static void btavrcp_passthrough_command_callback(int id, int pressed) {

		static btrc_callbacks_t sBluetoothAvrcpCallbacks = {
		sizeof(sBluetoothAvrcpCallbacks),
		btavrcp_remote_features_callback,
		btavrcp_get_play_status_callback,
		NULL,
		NULL,
		@@ -117,10 +153,13 @@ static btrc_callbacks_t sBluetoothAvrcpCallbacks = {
		NULL,
		btavrcp_get_element_attr_callback,
		btavrcp_register_notification_callback,
		btavrcp_volume_change_callback,
		btavrcp_passthrough_command_callback
		};

		static void classInitNative(JNIEnv* env, jclass clazz) {
		method_getRcFeatures =
		env->GetMethodID(clazz, "getRcFeatures", "([BI)V");
		method_getPlayStatus =
		env->GetMethodID(clazz, "getPlayStatus", "()V");

		@@ -130,6 +169,9 @@ static void classInitNative(JNIEnv* env, jclass clazz) {
		method_registerNotification =
		env->GetMethodID(clazz, "registerNotification", "(II)V");

		method_volumeChangeCallback =
		env->GetMethodID(clazz, "volumeChangeCallback", "(II)V");

		method_handlePassthroughCmd =
		env->GetMethodID(clazz, "handlePassthroughCmd", "(II)V");

		@@ -336,6 +378,22 @@ static jboolean registerNotificationRspPlayPosNative(JNIEnv *env, jobject object
		return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
		}

		static jboolean setVolumeNative(JNIEnv *env, jobject object, jint volume) {
		bt_status_t status;

		//TODO: delete test code
		ALOGI("%s: jint: %d, uint8_t: %u", __FUNCTION__, volume, (uint8_t) volume);

		ALOGI("%s: sBluetoothAvrcpInterface: %p", __FUNCTION__, sBluetoothAvrcpInterface);
		if (!sBluetoothAvrcpInterface) return JNI_FALSE;

		if ((status = sBluetoothAvrcpInterface->set_volume((uint8_t)volume)) != BT_STATUS_SUCCESS) {
		ALOGE("Failed set_volume, status: %d", status);
		}

		return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
		}

		static JNINativeMethod sMethods[] = {
		{"classInitNative", "()V", (void *) classInitNative},
		{"initNative", "()V", (void *) initNative},
		@@ -348,6 +406,8 @@ static JNINativeMethod sMethods[] = {
		(void *) registerNotificationRspTrackChangeNative},
		{"registerNotificationRspPlayPosNative", "(II)Z",
		(void *) registerNotificationRspPlayPosNative},
		{"setVolumeNative", "(I)Z",
		(void *) setVolumeNative}
		};

		int register_com_android_bluetooth_avrcp(JNIEnv* env)

android/app/src/com/android/bluetooth/a2dp/A2dpService.java

+31 −0

Original line number	Diff line number	Diff line
		@@ -176,6 +176,19 @@ public class A2dpService extends ProfileService {
		return priority;
		}

		/* Absolute volume implementation */
		public boolean isAvrcpAbsoluteVolumeSupported() {
		return mAvrcp.isAbsoluteVolumeSupported();
		}

		public void adjustAvrcpAbsoluteVolume(int direction) {
		mAvrcp.adjustVolume(direction);
		}

		public void setAvrcpAbsoluteVolume(int volume) {
		mAvrcp.setAbsoluteVolume(volume);
		}

		synchronized boolean isA2dpPlaying(BluetoothDevice device) {
		enforceCallingOrSelfPermission(BLUETOOTH_PERM,
		"Need BLUETOOTH permission");
		@@ -251,6 +264,24 @@ public class A2dpService extends ProfileService {
		return service.getPriority(device);
		}

		public boolean isAvrcpAbsoluteVolumeSupported() {
		A2dpService service = getService();
		if (service == null) return false;
		return service.isAvrcpAbsoluteVolumeSupported();
		}

		public void adjustAvrcpAbsoluteVolume(int direction) {
		A2dpService service = getService();
		if (service == null) return;
		service.adjustAvrcpAbsoluteVolume(direction);
		}

		public void setAvrcpAbsoluteVolume(int volume) {
		A2dpService service = getService();
		if (service == null) return;
		service.setAvrcpAbsoluteVolume(volume);
		}

		public boolean isA2dpPlaying(BluetoothDevice device) {
		A2dpService service = getService();
		if (service == null) return false;

android/app/src/com/android/bluetooth/a2dp/Avrcp.java

+200 −8

Original line number	Diff line number	Diff line
		@@ -55,7 +55,7 @@ import java.util.Set;
		* support metadata, play status and event notification
		*/
		final class Avrcp {
		private static final boolean DEBUG = false;
		private static final boolean DEBUG = true;
		private static final String TAG = "Avrcp";

		private Context mContext;
		@@ -78,18 +78,44 @@ final class Avrcp {
		private long mPrevPosMs;
		private long mSkipStartTime;
		private Timer mTimer;
		private int mFeatures;
		private int mAbsoluteVolume;
		private int mLastSetVolume;
		private int mLastDirection;
		private int mVolumeStep;
		private boolean mVolCmdInProgress;
		private int mAbsVolRetryTimes;

		/* AVRC IDs from avrc_defs.h */
		private static final int AVRC_ID_REWIND = 0x48;
		private static final int AVRC_ID_FAST_FOR = 0x49;

		private static final int MESSAGE_GET_PLAY_STATUS = 1;
		private static final int MESSAGE_GET_ELEM_ATTRS = 2;
		private static final int MESSAGE_REGISTER_NOTIFICATION = 3;
		private static final int MESSAGE_PLAY_INTERVAL_TIMEOUT = 4;
		private static final int MESSAGE_FAST_FORWARD = 5;
		private static final int MESSAGE_REWIND = 6;
		private static final int MESSAGE_FF_REW_TIMEOUT = 7;
		/* BTRC features */
		public static final int BTRC_FEAT_METADATA = 0x01;
		public static final int BTRC_FEAT_ABSOLUTE_VOLUME = 0x02;
		public static final int BTRC_FEAT_BROWSE = 0x04;

		/* AVRC response codes, from avrc_defs */
		private static final int AVRC_RSP_NOT_IMPL = 8;
		private static final int AVRC_RSP_ACCEPT = 9;
		private static final int AVRC_RSP_REJ = 10;
		private static final int AVRC_RSP_IN_TRANS = 11;
		private static final int AVRC_RSP_IMPL_STBL = 12;
		private static final int AVRC_RSP_CHANGED = 13;
		private static final int AVRC_RSP_INTERIM = 15;

		private static final int MESSAGE_GET_RC_FEATURES = 1;
		private static final int MESSAGE_GET_PLAY_STATUS = 2;
		private static final int MESSAGE_GET_ELEM_ATTRS = 3;
		private static final int MESSAGE_REGISTER_NOTIFICATION = 4;
		private static final int MESSAGE_PLAY_INTERVAL_TIMEOUT = 5;
		private static final int MESSAGE_VOLUME_CHANGED = 6;
		private static final int MESSAGE_ADJUST_VOLUME = 7;
		private static final int MESSAGE_SET_ABSOLUTE_VOLUME = 8;
		private static final int MESSAGE_ABS_VOL_TIMEOUT = 9;
		private static final int MESSAGE_FAST_FORWARD = 10;
		private static final int MESSAGE_REWIND = 11;
		private static final int MESSAGE_FF_REW_TIMEOUT = 12;
		private static final int MSG_UPDATE_STATE = 100;
		private static final int MSG_SET_METADATA = 101;
		private static final int MSG_SET_TRANSPORT_CONTROLS = 102;
		@@ -102,6 +128,11 @@ final class Avrcp {
		private static final int KEY_STATE_RELEASE = 0;
		private static final int SKIP_PERIOD = 400;
		private static final int SKIP_DOUBLE_INTERVAL = 3000;
		private static final int CMD_TIMEOUT_DELAY = 2000;
		private static final int MAX_ERROR_RETRY_TIMES = 3;
		private static final int AUDIO_STREAM_MAX_VOL = 150;
		private static final int AVRCP_MAX_VOL = 127;
		private static final int AVRCP_BASE_VOLUME_STEP = 1;

		static {
		classInitNative();
		@@ -119,6 +150,13 @@ final class Avrcp {
		mPlaybackIntervalMs = 0L;
		mPlayPosChangedNT = NOTIFICATION_TYPE_CHANGED;
		mTimer = null;
		mFeatures = 0;
		mAbsoluteVolume = -1;
		mLastSetVolume = -1;
		mLastDirection = 0;
		mVolumeStep = AVRCP_BASE_VOLUME_STEP;
		mVolCmdInProgress = false;
		mAbsVolRetryTimes = 0;

		mContext = context;

		@@ -248,6 +286,14 @@ final class Avrcp {
		mClientGeneration = msg.arg1;
		break;

		case MESSAGE_GET_RC_FEATURES:
		String address = (String) msg.obj;
		if (DEBUG) Log.v(TAG, "MESSAGE_GET_RC_FEATURES: address="+address+
		", features="+msg.arg1);
		mFeatures = msg.arg1;
		mAudioManager.avrcpSupportsAbsoluteVolume(address, isAbsoluteVolumeSupported());
		break;

		case MESSAGE_GET_PLAY_STATUS:
		if (DEBUG) Log.v(TAG, "MESSAGE_GET_PLAY_STATUS");
		getPlayStatusRspNative(convertPlayStateToPlayStatus(mCurrentPlayState),
		@@ -282,6 +328,87 @@ final class Avrcp {
		registerNotificationRspPlayPosNative(mPlayPosChangedNT, (int)getPlayPosition());
		break;

		case MESSAGE_VOLUME_CHANGED:
		if (DEBUG) Log.v(TAG, "MESSAGE_VOLUME_CHANGED: volume=" + msg.arg1 +
		" ctype=" + msg.arg2);

		if (msg.arg2 == AVRC_RSP_ACCEPT \|\| msg.arg2 == AVRC_RSP_REJ) {
		if (mVolCmdInProgress == false) {
		Log.e(TAG, "Unsolicited response, ignored");
		break;
		}
		removeMessages(MESSAGE_ABS_VOL_TIMEOUT);
		mVolCmdInProgress = false;
		mAbsVolRetryTimes = 0;
		}
		// to deal with granularity in the TG
		if (msg.arg2 == AVRC_RSP_ACCEPT && mAbsoluteVolume == msg.arg1) {
		if ((mAbsoluteVolume == AVRCP_MAX_VOL && mLastDirection == -1)
		\|\| (mAbsoluteVolume == 0 && mLastDirection == 1)
		\|\| (mAbsoluteVolume != AVRCP_MAX_VOL && mAbsoluteVolume != 0)) {
		mVolumeStep += 1;
		adjustVolumeImmediate(mLastDirection);
		}
		} else if (mAbsoluteVolume != msg.arg1 && (msg.arg2 == AVRC_RSP_ACCEPT \|\|
		msg.arg2 == AVRC_RSP_CHANGED \|\|
		msg.arg2 == AVRC_RSP_INTERIM)) {
		notifyVolumeChanged(mAbsoluteVolume, msg.arg1);
		mAbsoluteVolume = msg.arg1;
		} else if (msg.arg2 == AVRC_RSP_REJ) {
		Log.e(TAG, "setAbsoluteVolume call rejected");
		}
		break;

		case MESSAGE_ADJUST_VOLUME:
		if (DEBUG) Log.d(TAG, "MESSAGE_ADJUST_VOLUME: direction=" + msg.arg1);
		if (mVolCmdInProgress) {
		if (DEBUG) Log.w(TAG, "There is already a volume command in progress.");
		break;
		}
		// Wait on verification on volume from device, before changing the volume.
		if (mAbsoluteVolume != -1 && (msg.arg1 == -1 \|\| msg.arg1 == 1)) {
		int setVol = Math.min(AVRCP_MAX_VOL,
		Math.max(0, mAbsoluteVolume + msg.arg1*mVolumeStep));
		if (setVolumeNative(setVol)) {
		sendMessageDelayed(obtainMessage(MESSAGE_ABS_VOL_TIMEOUT),
		CMD_TIMEOUT_DELAY);
		mVolCmdInProgress = true;
		mLastDirection = msg.arg1;
		mLastSetVolume = setVol;
		}
		} else {
		Log.e(TAG, "Unknown direction in MESSAGE_ADJUST_VOLUME");
		}
		break;

		case MESSAGE_SET_ABSOLUTE_VOLUME:
		if (DEBUG) Log.v(TAG, "MESSAGE_SET_ABSOLUTE_VOLUME");
		if (mVolCmdInProgress) {
		if (DEBUG) Log.w(TAG, "There is already a volume command in progress.");
		break;
		}
		if (setVolumeNative(msg.arg1)) {
		sendMessageDelayed(obtainMessage(MESSAGE_ABS_VOL_TIMEOUT), CMD_TIMEOUT_DELAY);
		mVolCmdInProgress = true;
		mLastSetVolume = msg.arg1;
		}
		break;

		case MESSAGE_ABS_VOL_TIMEOUT:
		if (DEBUG) Log.v(TAG, "MESSAGE_ABS_VOL_TIMEOUT: Volume change cmd timed out.");
		mVolCmdInProgress = false;
		if (mAbsVolRetryTimes >= MAX_ERROR_RETRY_TIMES) {
		mAbsVolRetryTimes = 0;
		} else {
		mAbsVolRetryTimes += 1;
		if (setVolumeNative(mLastSetVolume)) {
		sendMessageDelayed(obtainMessage(MESSAGE_ABS_VOL_TIMEOUT),
		CMD_TIMEOUT_DELAY);
		mVolCmdInProgress = true;
		}
		}
		break;

		case MESSAGE_FAST_FORWARD:
		case MESSAGE_REWIND:
		final int skipAmount;
		@@ -430,6 +557,12 @@ final class Avrcp {
		if (DEBUG) Log.v(TAG, "duration=" + mSongLengthMs);
		}

		private void getRcFeatures(byte[] address, int features) {
		Message msg = mHandler.obtainMessage(MESSAGE_GET_RC_FEATURES, features, 0,
		Utils.getAddressStringFromByte(address));
		mHandler.sendMessage(msg);
		}

		private void getPlayStatus() {
		Message msg = mHandler.obtainMessage(MESSAGE_GET_PLAY_STATUS);
		mHandler.sendMessage(msg);
		@@ -602,6 +735,64 @@ final class Avrcp {
		return playStatus;
		}

		/**
		* This is called from AudioService. It will return whether this device supports abs volume.
		* NOT USED AT THE MOMENT.
		*/
		public boolean isAbsoluteVolumeSupported() {
		return ((mFeatures & BTRC_FEAT_ABSOLUTE_VOLUME) != 0);
		}

		/**
		* We get this call from AudioService. This will send a message to our handler object,
		* requesting our handler to call setVolumeNative()
		*/
		public void adjustVolume(int direction) {
		Message msg = mHandler.obtainMessage(MESSAGE_ADJUST_VOLUME, direction, 0);
		mHandler.sendMessage(msg);
		}

		private void adjustVolumeImmediate(int direction) {
		Message msg = mHandler.obtainMessage(MESSAGE_ADJUST_VOLUME, direction, 0);
		mHandler.sendMessageAtFrontOfQueue(msg);
		}

		public void setAbsoluteVolume(int volume) {
		int avrcpVolume = convertToAvrcpVolume(volume);
		avrcpVolume = Math.min(AVRCP_MAX_VOL, Math.max(0, avrcpVolume));
		mHandler.removeMessages(MESSAGE_ADJUST_VOLUME);
		Message msg = mHandler.obtainMessage(MESSAGE_SET_ABSOLUTE_VOLUME, avrcpVolume, 0);
		mHandler.sendMessage(msg);

		}

		/* Called in the native layer as a btrc_callback to return the volume set on the carkit in the
		* case when the volume is change locally on the carkit. This notification is not called when
		* the volume is changed from the phone.
		*
		* This method will send a message to our handler to change the local stored volume and notify
		* AudioService to update the UI
		*/
		private void volumeChangeCallback(int volume, int ctype) {
		Message msg = mHandler.obtainMessage(MESSAGE_VOLUME_CHANGED, volume, ctype);
		mHandler.sendMessage(msg);
		}

		private void notifyVolumeChanged(int oldVolume, int volume) {
		oldVolume = convertToAudioStreamVolume(oldVolume);
		volume = convertToAudioStreamVolume(volume);
		mAudioManager.avrcpUpdateVolume(oldVolume, volume);
		}

		private int convertToAudioStreamVolume(int volume) {
		// Rescale volume to match AudioSystem's volume
		return (int) Math.ceil((double) volume*AUDIO_STREAM_MAX_VOL/AVRCP_MAX_VOL);
		}

		private int convertToAvrcpVolume(int volume) {
		return (int) Math.ceil((double) volume*AVRCP_MAX_VOL/AUDIO_STREAM_MAX_VOL);
		}

		// Do not modify without updating the HAL bt_rc.h files.

		// match up with btrc_play_status_t enum of bt_rc.h
		@@ -646,4 +837,5 @@ final class Avrcp {
		private native boolean registerNotificationRspPlayStatusNative(int type, int playStatus);
		private native boolean registerNotificationRspTrackChangeNative(int type, byte[] track);
		private native boolean registerNotificationRspPlayPosNative(int type, int playPos);
		private native boolean setVolumeNative(int volume);
		}