Merge changes I28f9c9b8,I68dd438c,I9a0e1fb3 into main (3525c228) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_vc.cpp

+336 −3

Original line number	Diff line number	Diff line
		@@ -36,6 +36,11 @@ static jmethodID method_onDeviceAvailable;
		static jmethodID method_onExtAudioOutVolumeOffsetChanged;
		static jmethodID method_onExtAudioOutLocationChanged;
		static jmethodID method_onExtAudioOutDescriptionChanged;
		static jmethodID method_onExtAudioInStateChanged;
		static jmethodID method_onExtAudioInStatusChanged;
		static jmethodID method_onExtAudioInTypeChanged;
		static jmethodID method_onExtAudioInGainPropsChanged;
		static jmethodID method_onExtAudioInDescriptionChanged;

		static VolumeControlInterface* sVolumeControlInterface = nullptr;
		static std::shared_timed_mutex interface_mutex;
		@@ -105,7 +110,8 @@ public:
		(jboolean)mute, group_id, (jboolean)isAutonomous);
		}

		void OnDeviceAvailable(const RawAddress& bd_addr, uint8_t num_offsets) override {
		void OnDeviceAvailable(const RawAddress& bd_addr, uint8_t num_offsets,
		uint8_t num_inputs) override {
		log::info("");

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		@@ -124,7 +130,7 @@ public:
		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		reinterpret_cast<const jbyte*>(&bd_addr));
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onDeviceAvailable, (jint)num_offsets,
		addr.get());
		(jint)num_inputs, addr.get());
		}

		void OnExtAudioOutVolumeOffsetChanged(const RawAddress& bd_addr, uint8_t ext_output_id,
		@@ -200,6 +206,122 @@ public:
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioOutDescriptionChanged,
		(jint)ext_output_id, description, addr.get());
		}

		void OnExtAudioInStateChanged(const RawAddress& bd_addr, uint8_t ext_input_id, int8_t gain_val,
		uint8_t gain_mode, bool mute) override {
		log::info("");

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) {
		return;
		}

		ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(),
		sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		log::error("Failed to get addr for {}", bd_addr);
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		reinterpret_cast<const jbyte*>(&bd_addr));
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInStateChanged, (jint)ext_input_id,
		(jint)gain_val, (jint)gain_mode, (jboolean)mute, addr.get());
		}

		void OnExtAudioInStatusChanged(const RawAddress& bd_addr, uint8_t ext_input_id,
		bluetooth::vc::VolumeInputStatus status) override {
		log::info("");

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) {
		return;
		}

		ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(),
		sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		log::error("Failed to get addr for {}", bd_addr);
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		reinterpret_cast<const jbyte*>(&bd_addr));
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInStatusChanged,
		(jint)ext_input_id, (jint)status, addr.get());
		}

		void OnExtAudioInTypeChanged(const RawAddress& bd_addr, uint8_t ext_input_id,
		bluetooth::vc::VolumeInputType type) override {
		log::info("");

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) {
		return;
		}

		ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(),
		sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		log::error("Failed to get addr for {}", bd_addr);
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		reinterpret_cast<const jbyte*>(&bd_addr));
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInTypeChanged, (jint)ext_input_id,
		(jint)type, addr.get());
		}

		void OnExtAudioInGainPropsChanged(const RawAddress& bd_addr, uint8_t ext_input_id, uint8_t unit,
		int8_t min, int8_t max) override {
		log::info("");

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) {
		return;
		}

		ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(),
		sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		log::error("Failed to get addr for {}", bd_addr);
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		reinterpret_cast<const jbyte*>(&bd_addr));
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInGainPropsChanged,
		(jint)ext_input_id, (jint)unit, (jint)min, (jint)max, addr.get());
		}

		void OnExtAudioInDescriptionChanged(const RawAddress& bd_addr, uint8_t ext_input_id,
		std::string descr) override {
		log::info("");

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) {
		return;
		}

		ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(),
		sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		log::error("Failed to get addr for {}", bd_addr);
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		reinterpret_cast<const jbyte*>(&bd_addr));
		jstring description = sCallbackEnv->NewStringUTF(descr.c_str());
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInDescriptionChanged,
		(jint)ext_input_id, description, addr.get());
		}
		};

		static VolumeControlCallbacksImpl sVolumeControlCallbacks;
		@@ -514,6 +636,195 @@ static jboolean setExtAudioOutDescriptionNative(JNIEnv* env, jobject /* object *
		return JNI_TRUE;
		}

		/* Native methods for external audio inputs */
		static jboolean getExtAudioInStateNative(JNIEnv* env, jobject /* object */, jbyteArray address,
		jint ext_input_id) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->GetExtAudioInState(*tmpraw, ext_input_id);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean getExtAudioInStatusNative(JNIEnv* env, jobject /* object */, jbyteArray address,
		jint ext_input_id) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->GetExtAudioInStatus(*tmpraw, ext_input_id);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean getExtAudioInTypeNative(JNIEnv* env, jobject /* object */, jbyteArray address,
		jint ext_input_id) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->GetExtAudioInType(*tmpraw, ext_input_id);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean getExtAudioInGainPropsNative(JNIEnv* env, jobject /* object */, jbyteArray address,
		jint ext_input_id) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->GetExtAudioInGainProps(*tmpraw, ext_input_id);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean getExtAudioInDescriptionNative(JNIEnv* env, jobject /* object */,
		jbyteArray address, jint ext_input_id) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->GetExtAudioInDescription(*tmpraw, ext_input_id);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean setExtAudioInDescriptionNative(JNIEnv* env, jobject /* object */,
		jbyteArray address, jint ext_input_id,
		jstring descr) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		std::string description;
		if (descr != nullptr) {
		const char* value = env->GetStringUTFChars(descr, nullptr);
		description = std::string(value);
		env->ReleaseStringUTFChars(descr, value);
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->SetExtAudioInDescription(*tmpraw, ext_input_id, description);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean setExtAudioInGainValueNative(JNIEnv* env, jobject /* object */, jbyteArray address,
		jint ext_input_id, jint gain_val) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->SetExtAudioInGainValue(*tmpraw, ext_input_id, gain_val);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean setExtAudioInGainModeNative(JNIEnv* env, jobject /* object */, jbyteArray address,
		jint ext_input_id, jboolean mode_auto) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->SetExtAudioInGainMode(*tmpraw, ext_input_id, mode_auto);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean setExtAudioInGainMuteNative(JNIEnv* env, jobject /* object */, jbyteArray address,
		jint ext_input_id, jboolean mute) {
		log::info("");
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sVolumeControlInterface) {
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		return JNI_FALSE;
		}

		RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);
		sVolumeControlInterface->SetExtAudioInGainMute(*tmpraw, ext_input_id, mute);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		int register_com_android_bluetooth_vc(JNIEnv* env) {
		const JNINativeMethod methods[] = {
		{"initNative", "()V", reinterpret_cast<void*>(initNative)},
		@@ -540,6 +851,22 @@ int register_com_android_bluetooth_vc(JNIEnv* env) {
		reinterpret_cast<void*>(getExtAudioOutDescriptionNative)},
		{"setExtAudioOutDescriptionNative", "([BILjava/lang/String;)Z",
		reinterpret_cast<void*>(setExtAudioOutDescriptionNative)},
		{"getExtAudioInStateNative", "([BI)Z", reinterpret_cast<void*>(getExtAudioInStateNative)},
		{"getExtAudioInStatusNative", "([BI)Z",
		reinterpret_cast<void*>(getExtAudioInStatusNative)},
		{"getExtAudioInTypeNative", "([BI)Z", reinterpret_cast<void*>(getExtAudioInTypeNative)},
		{"getExtAudioInGainPropsNative", "([BI)Z",
		reinterpret_cast<void*>(getExtAudioInGainPropsNative)},
		{"getExtAudioInDescriptionNative", "([BI)Z",
		reinterpret_cast<void*>(getExtAudioInDescriptionNative)},
		{"setExtAudioInDescriptionNative", "([BILjava/lang/String;)Z",
		reinterpret_cast<void*>(setExtAudioInDescriptionNative)},
		{"setExtAudioInGainValueNative", "([BII)Z",
		reinterpret_cast<void*>(setExtAudioInGainValueNative)},
		{"setExtAudioInGainModeNative", "([BIZ)Z",
		reinterpret_cast<void*>(setExtAudioInGainModeNative)},
		{"setExtAudioInGainMuteNative", "([BIZ)Z",
		reinterpret_cast<void*>(setExtAudioInGainMuteNative)},
		};
		const int result = REGISTER_NATIVE_METHODS(
		env, "com/android/bluetooth/vc/VolumeControlNativeInterface", methods);
		@@ -551,11 +878,17 @@ int register_com_android_bluetooth_vc(JNIEnv* env) {
		{"onConnectionStateChanged", "(I[B)V", &method_onConnectionStateChanged},
		{"onVolumeStateChanged", "(IZI[BZ)V", &method_onVolumeStateChanged},
		{"onGroupVolumeStateChanged", "(IZIZ)V", &method_onGroupVolumeStateChanged},
		{"onDeviceAvailable", "(I[B)V", &method_onDeviceAvailable},
		{"onDeviceAvailable", "(II[B)V", &method_onDeviceAvailable},
		{"onExtAudioOutVolumeOffsetChanged", "(II[B)V", &method_onExtAudioOutVolumeOffsetChanged},
		{"onExtAudioOutLocationChanged", "(II[B)V", &method_onExtAudioOutLocationChanged},
		{"onExtAudioOutDescriptionChanged", "(ILjava/lang/String;[B)V",
		&method_onExtAudioOutDescriptionChanged},
		{"onExtAudioInStateChanged", "(IIIZ[B)V", &method_onExtAudioInStateChanged},
		{"onExtAudioInStatusChanged", "(II[B)V", &method_onExtAudioInStatusChanged},
		{"onExtAudioInTypeChanged", "(II[B)V", &method_onExtAudioInTypeChanged},
		{"onExtAudioInGainPropsChanged", "(IIII[B)V", &method_onExtAudioInGainPropsChanged},
		{"onExtAudioInDescriptionChanged", "(ILjava/lang/String;[B)V",
		&method_onExtAudioInDescriptionChanged},
		};
		GET_JAVA_METHODS(env, "com/android/bluetooth/vc/VolumeControlNativeInterface", javaMethods);

android/app/src/com/android/bluetooth/vc/VolumeControlInputDescriptor.java

0 → 100644

+228 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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.vc;

		import android.bluetooth.BluetoothVolumeControl;
		import android.util.Log;

		import com.android.bluetooth.btservice.ProfileService;

		import java.util.HashMap;
		import java.util.Map;

		class VolumeControlInputDescriptor {
		private static final String TAG = "VolumeControlInputDescriptor";
		final Map<Integer, Descriptor> mVolumeInputs = new HashMap<>();

		public static final int AUDIO_INPUT_TYPE_UNSPECIFIED = 0x00;
		public static final int AUDIO_INPUT_TYPE_BLUETOOTH = 0x01;
		public static final int AUDIO_INPUT_TYPE_MICROPHONE = 0x02;
		public static final int AUDIO_INPUT_TYPE_ANALOG = 0x03;
		public static final int AUDIO_INPUT_TYPE_DIGITAL = 0x04;
		public static final int AUDIO_INPUT_TYPE_RADIO = 0x05;
		public static final int AUDIO_INPUT_TYPE_STREAMING = 0x06;
		public static final int AUDIO_INPUT_TYPE_AMBIENT = 0x07;

		private static class Descriptor {
		/* True when input is active, false otherwise */
		boolean mIsActive = false;

		/* Defined as in Assigned Numbers in the BluetoothVolumeControl.AUDIO_INPUT_TYPE_ */
		int mType = AUDIO_INPUT_TYPE_UNSPECIFIED;

		int mGainValue = 0;

		/* As per AICS 1.0
		* 3.1.3. Gain_Mode field
		* The Gain_Mode field shall be set to a value that reflects whether gain modes are
		* manual or automatic.
		*
		* If the Gain_Mode field value is Manual Only, the server allows only manual gain.
		* If the Gain_Mode field is Automatic Only, the server allows only automatic gain.
		*
		* For all other Gain_Mode field values, the server allows switchable
		* automatic/manual gain.
		*/
		int mGainMode = 0;

		boolean mIsMute = false;

		/* As per AICS 1.0
		* The Gain_Setting (mGainValue) field is a signed value for which a single increment
		* or decrement should result in a corresponding increase or decrease of the input
		* amplitude by the value of the Gain_Setting_Units (mGainSettingsUnits)
		* field of the Gain Setting Properties characteristic value.
		*/
		int mGainSettingsUnits = 0;

		int mGainSettingsMaxSetting = 0;
		int mGainSettingsMinSetting = 0;

		String mDescription = "";
		}

		int size() {
		return mVolumeInputs.size();
		}

		void add(int id) {
		if (!mVolumeInputs.containsKey(id)) {
		mVolumeInputs.put(id, new Descriptor());
		}
		}

		boolean setActive(int id, boolean active) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "setActive, Id " + id + " is unknown");
		return false;
		}
		desc.mIsActive = active;
		return true;
		}

		boolean isActive(int id) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "isActive, Id " + id + " is unknown");
		return false;
		}
		return desc.mIsActive;
		}

		boolean setDescription(int id, String description) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "setDescription, Id " + id + " is unknown");
		return false;
		}
		desc.mDescription = description;
		return true;
		}

		String getDescription(int id) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "getDescription, Id " + id + " is unknown");
		return null;
		}
		return desc.mDescription;
		}

		boolean setType(int id, int type) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "setType, Id " + id + " is unknown");
		return false;
		}

		if (type > AUDIO_INPUT_TYPE_AMBIENT) {
		Log.e(TAG, "setType, Type " + type + "for id " + id + " is invalid");
		return false;
		}

		desc.mType = type;
		return true;
		}

		int getType(int id) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "getType, Id " + id + " is unknown");
		return AUDIO_INPUT_TYPE_UNSPECIFIED;
		}
		return desc.mType;
		}

		int getGain(int id) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "getGain, Id " + id + " is unknown");
		return 0;
		}
		return desc.mGainValue;
		}

		boolean isMuted(int id) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "isMuted, Id " + id + " is unknown");
		return false;
		}
		return desc.mIsMute;
		}

		boolean setPropSettings(int id, int gainUnit, int gainMin, int gainMax) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "setPropSettings, Id " + id + " is unknown");
		return false;
		}

		desc.mGainSettingsUnits = gainUnit;
		desc.mGainSettingsMinSetting = gainMin;
		desc.mGainSettingsMaxSetting = gainMax;

		return true;
		}

		boolean setState(int id, int gainValue, int gainMode, boolean mute) {
		Descriptor desc = mVolumeInputs.get(id);
		if (desc == null) {
		Log.e(TAG, "Id " + id + " is unknown");
		return false;
		}

		if (gainValue > desc.mGainSettingsMaxSetting \|\| gainValue < desc.mGainSettingsMinSetting) {
		Log.e(TAG, "Invalid gainValue " + gainValue);
		return false;
		}

		desc.mGainValue = gainValue;
		desc.mGainMode = gainMode;
		desc.mIsMute = mute;

		return true;
		}

		void remove(int id) {
		Log.d(TAG, "remove, id: " + id);
		mVolumeInputs.remove(id);
		}

		void clear() {
		Log.d(TAG, "clear all inputs");
		mVolumeInputs.clear();
		}

		void dump(StringBuilder sb) {
		for (Map.Entry<Integer, Descriptor> entry : mVolumeInputs.entrySet()) {
		Descriptor desc = entry.getValue();
		Integer id = entry.getKey();
		ProfileService.println(sb, " id: " + id);
		ProfileService.println(sb, " description: " + desc.mDescription);
		ProfileService.println(sb, " type: " + desc.mType);
		ProfileService.println(sb, " isActive: " + desc.mIsActive);
		ProfileService.println(sb, " gainValue: " + desc.mGainValue);
		ProfileService.println(sb, " gainMode: " + desc.mGainMode);
		ProfileService.println(sb, " mute: " + desc.mIsMute);
		ProfileService.println(sb, " units:" + desc.mGainSettingsUnits);
		ProfileService.println(sb, " minGain:" + desc.mGainSettingsMinSetting);
		ProfileService.println(sb, " maxGain:" + desc.mGainSettingsMaxSetting);
		}
		}
		}

android/app/src/com/android/bluetooth/vc/VolumeControlNativeInterface.java

+215 −1

File changed.

Preview size limit exceeded, changes collapsed.

android/app/src/com/android/bluetooth/vc/VolumeControlService.java

+209 −2

File changed.

Preview size limit exceeded, changes collapsed.

android/app/src/com/android/bluetooth/vc/VolumeControlStackEvent.java

+45 −0

File changed.

Preview size limit exceeded, changes collapsed.