Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 504ee98a authored by Pavlin Radoslavov's avatar Pavlin Radoslavov
Browse files

Add support for Multi-A2DP state machines per device 

* Remove mStateMachine and use a single A2dpStateMachine instance per device
* Cleanup/simplify A2dpStateMachine internals - the BluetoothDevice per
  state machine doesn't change.
* Send the state changed broadcast message on enter() in a new state
  This fixes timing ordering issue exposed by some of the unit tests
* Remove a state machine when bonding for a device is removed
* Add a mechanism to set the active device
* Add a mechanism to track the maximum number of connected devices
* Updated the codec-related APIs to take a BluetoothDevice argument:
  - getCodecStatus()
  - setCodecConfigPrefereice()
  - enableOptionalCodecs()
  - disableOptionalCodecs()
* Add A2dpServiceTest unit tests for A2dpService
* Add ActiveDeviceManager that is responsible for keeping track of the
  connected devices and select which device is active.

Also:
* Updated the JNI codec-related calls to use const reference
  instead of a pointer
* Additional cleanup

Bug: 69269748
Test: Manual and unit tests
Change-Id: If379f0aa1403de09c485d4adb0dfdfe73190cbf9
Merged-In: If379f0aa1403de09c485d4adb0dfdfe73190cbf9
(cherry picked from commit bf9a5b64)
parent 44b38035

android/app/jni/com_android_bluetooth_a2dp.cpp

+71 −18
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ static std::shared_timed_mutex interface_mutex; 
static jobject mCallbacksObj = nullptr;

static std::shared_timed_mutex callbacks_mutex;



static void bta2dp_connection_state_callback(RawAddress* bd_addr,

static void bta2dp_connection_state_callback(const RawAddress& bd_addr,

                                             btav_connection_state_t state) {

  ALOGI("%s", __func__);
@@ -66,13 +66,14 @@ static void bta2dp_connection_state_callback(RawAddress* bd_addr, 
    return;

  }



  sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),

                                   (jbyte*)bd_addr);

  sCallbackEnv->SetByteArrayRegion(

      addr.get(), 0, sizeof(RawAddress),

      reinterpret_cast<const jbyte*>(bd_addr.address));

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged,

                               addr.get(), (jint)state);

}



static void bta2dp_audio_state_callback(RawAddress* bd_addr,

static void bta2dp_audio_state_callback(const RawAddress& bd_addr,

                                        btav_audio_state_t state) {

  ALOGI("%s", __func__);
@@ -87,14 +88,15 @@ static void bta2dp_audio_state_callback(RawAddress* bd_addr, 
    return;

  }



  sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),

                                   (jbyte*)bd_addr);

  sCallbackEnv->SetByteArrayRegion(

      addr.get(), 0, sizeof(RawAddress),

      reinterpret_cast<const jbyte*>(bd_addr.address));

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioStateChanged,

                               addr.get(), (jint)state);

}



static void bta2dp_audio_config_callback(

    RawAddress* bd_addr, btav_a2dp_codec_config_t codec_config,

    const RawAddress& bd_addr, btav_a2dp_codec_config_t codec_config,

    std::vector<btav_a2dp_codec_config_t> codecs_local_capabilities,

    std::vector<btav_a2dp_codec_config_t> codecs_selectable_capabilities) {

  ALOGI("%s", __func__);
@@ -152,8 +154,9 @@ static void bta2dp_audio_config_callback( 
    ALOGE("%s: Fail to new jbyteArray bd addr", __func__);

    return;

  }

  sCallbackEnv->SetByteArrayRegion(addr.get(), 0, RawAddress::kLength,

                                   (jbyte*)bd_addr->address);

  sCallbackEnv->SetByteArrayRegion(

      addr.get(), 0, RawAddress::kLength,

      reinterpret_cast<const jbyte*>(bd_addr.address));



  sCallbackEnv->CallVoidMethod(

      mCallbacksObj, method_onCodecConfigChanged, addr.get(), codecConfigObj,
@@ -340,7 +343,10 @@ static jboolean connectA2dpNative(JNIEnv* env, jobject object, 
                                  jbyteArray address) {

  ALOGI("%s: sBluetoothA2dpInterface: %p", __func__, sBluetoothA2dpInterface);

  std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);

  if (!sBluetoothA2dpInterface) return JNI_FALSE;

  if (!sBluetoothA2dpInterface) {

    ALOGE("%s: Failed to get the Bluetooth A2DP Interface", __func__);

    return JNI_FALSE;

  }



  jbyte* addr = env->GetByteArrayElements(address, nullptr);

  if (!addr) {
@@ -348,9 +354,11 @@ static jboolean connectA2dpNative(JNIEnv* env, jobject object, 
    return JNI_FALSE;

  }



  bt_status_t status = sBluetoothA2dpInterface->connect((RawAddress*)addr);

  RawAddress bd_addr;

  bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));

  bt_status_t status = sBluetoothA2dpInterface->connect(bd_addr);

  if (status != BT_STATUS_SUCCESS) {

    ALOGE("%s: Failed HF connection, status: %d", __func__, status);

    ALOGE("%s: Failed A2DP connection, status: %d", __func__, status);

  }

  env->ReleaseByteArrayElements(address, addr, 0);

  return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
@@ -360,7 +368,35 @@ static jboolean disconnectA2dpNative(JNIEnv* env, jobject object, 
                                     jbyteArray address) {

  ALOGI("%s: sBluetoothA2dpInterface: %p", __func__, sBluetoothA2dpInterface);

  std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);

  if (!sBluetoothA2dpInterface) return JNI_FALSE;

  if (!sBluetoothA2dpInterface) {

    ALOGE("%s: Failed to get the Bluetooth A2DP Interface", __func__);

    return JNI_FALSE;

  }



  jbyte* addr = env->GetByteArrayElements(address, nullptr);

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress bd_addr;

  bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));

  bt_status_t status = sBluetoothA2dpInterface->disconnect(bd_addr);

  if (status != BT_STATUS_SUCCESS) {

    ALOGE("%s: Failed A2DP disconnection, status: %d", __func__, status);

  }

  env->ReleaseByteArrayElements(address, addr, 0);

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

}



static jboolean setActiveDeviceNative(JNIEnv* env, jobject object,

                                      jbyteArray address) {

  ALOGI("%s: sBluetoothA2dpInterface: %p", __func__, sBluetoothA2dpInterface);

  std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);

  if (!sBluetoothA2dpInterface) {

    ALOGE("%s: Failed to get the Bluetooth A2DP Interface", __func__);

    return JNI_FALSE;

  }



  jbyte* addr = env->GetByteArrayElements(address, nullptr);

  if (!addr) {
@@ -368,27 +404,43 @@ static jboolean disconnectA2dpNative(JNIEnv* env, jobject object, 
    return JNI_FALSE;

  }



  bt_status_t status = sBluetoothA2dpInterface->disconnect((RawAddress*)addr);

  RawAddress bd_addr;

  bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));

  bt_status_t status = sBluetoothA2dpInterface->set_active_device(bd_addr);

  if (status != BT_STATUS_SUCCESS) {

    ALOGE("%s: Failed HF disconnection, status: %d", __func__, status);

    ALOGE("%s: Failed A2DP set_active_device, status: %d", __func__, status);

  }

  env->ReleaseByteArrayElements(address, addr, 0);

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

}



static jboolean setCodecConfigPreferenceNative(JNIEnv* env, jobject object,

                                               jbyteArray address,

                                               jobjectArray codecConfigArray) {

  ALOGI("%s: sBluetoothA2dpInterface: %p", __func__, sBluetoothA2dpInterface);

  std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);

  if (!sBluetoothA2dpInterface) return JNI_FALSE;

  if (!sBluetoothA2dpInterface) {

    ALOGE("%s: Failed to get the Bluetooth A2DP Interface", __func__);

    return JNI_FALSE;

  }



  jbyte* addr = env->GetByteArrayElements(address, nullptr);

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress bd_addr;

  bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));

  std::vector<btav_a2dp_codec_config_t> codec_preferences =

      prepareCodecPreferences(env, object, codecConfigArray);



  bt_status_t status = sBluetoothA2dpInterface->config_codec(codec_preferences);

  bt_status_t status =

      sBluetoothA2dpInterface->config_codec(bd_addr, codec_preferences);

  if (status != BT_STATUS_SUCCESS) {

    ALOGE("%s: Failed codec configuration, status: %d", __func__, status);

  }

  env->ReleaseByteArrayElements(address, addr, 0);

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

}
@@ -399,8 +451,9 @@ static JNINativeMethod sMethods[] = { 
    {"cleanupNative", "()V", (void*)cleanupNative},

    {"connectA2dpNative", "([B)Z", (void*)connectA2dpNative},

    {"disconnectA2dpNative", "([B)Z", (void*)disconnectA2dpNative},

    {"setActiveDeviceNative", "([B)Z", (void*)setActiveDeviceNative},

    {"setCodecConfigPreferenceNative",

     "([Landroid/bluetooth/BluetoothCodecConfig;)Z",

     "([B[Landroid/bluetooth/BluetoothCodecConfig;)Z",

     (void*)setCodecConfigPreferenceNative},

};

android/app/jni/com_android_bluetooth_a2dp_sink.cpp

+12 −8
Original line number Diff line number Diff line
@@ -33,7 +33,7 @@ static jmethodID method_onAudioConfigChanged; 
static const btav_sink_interface_t* sBluetoothA2dpInterface = NULL;

static jobject mCallbacksObj = NULL;



static void bta2dp_connection_state_callback(RawAddress* bd_addr,

static void bta2dp_connection_state_callback(const RawAddress& bd_addr,

                                             btav_connection_state_t state) {

  ALOGI("%s", __func__);

  CallbackEnv sCallbackEnv(__func__);
@@ -47,12 +47,12 @@ static void bta2dp_connection_state_callback(RawAddress* bd_addr, 
  }



  sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),

                                   (jbyte*)bd_addr);

                                   (const jbyte*)bd_addr.address);

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged,

                               addr.get(), (jint)state);

}



static void bta2dp_audio_state_callback(RawAddress* bd_addr,

static void bta2dp_audio_state_callback(const RawAddress& bd_addr,

                                        btav_audio_state_t state) {

  ALOGI("%s", __func__);

  CallbackEnv sCallbackEnv(__func__);
@@ -66,12 +66,12 @@ static void bta2dp_audio_state_callback(RawAddress* bd_addr, 
  }



  sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),

                                   (jbyte*)bd_addr);

                                   (const jbyte*)bd_addr.address);

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioStateChanged,

                               addr.get(), (jint)state);

}



static void bta2dp_audio_config_callback(RawAddress* bd_addr,

static void bta2dp_audio_config_callback(const RawAddress& bd_addr,

                                         uint32_t sample_rate,

                                         uint8_t channel_count) {

  ALOGI("%s", __func__);
@@ -86,7 +86,7 @@ static void bta2dp_audio_config_callback(RawAddress* bd_addr, 
  }



  sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),

                                   (jbyte*)bd_addr);

                                   (const jbyte*)bd_addr.address);

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioConfigChanged,

                               addr.get(), (jint)sample_rate,

                               (jint)channel_count);
@@ -177,7 +177,9 @@ static jboolean connectA2dpNative(JNIEnv* env, jobject object, 
    return JNI_FALSE;

  }



  bt_status_t status = sBluetoothA2dpInterface->connect((RawAddress*)addr);

  RawAddress bd_addr;

  bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));

  bt_status_t status = sBluetoothA2dpInterface->connect(bd_addr);

  if (status != BT_STATUS_SUCCESS) {

    ALOGE("Failed HF connection, status: %d", status);

  }
@@ -195,7 +197,9 @@ static jboolean disconnectA2dpNative(JNIEnv* env, jobject object, 
    return JNI_FALSE;

  }



  bt_status_t status = sBluetoothA2dpInterface->disconnect((RawAddress*)addr);

  RawAddress bd_addr;

  bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));

  bt_status_t status = sBluetoothA2dpInterface->disconnect(bd_addr);

  if (status != BT_STATUS_SUCCESS) {

    ALOGE("Failed HF disconnection, status: %d", status);

  }

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

0 → 100644
+190 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.bluetooth.a2dp;



import android.bluetooth.BluetoothCodecConfig;

import android.bluetooth.BluetoothDevice;

import android.content.Context;

import android.content.res.Resources;

import android.content.res.Resources.NotFoundException;



import com.android.bluetooth.R;



/*

 * A2DP Codec Configuration setup.

 */

class A2dpCodecConfig {

    private static final boolean DBG = true;

    private static final String TAG = "A2dpCodecConfig";



    private Context mContext;

    private A2dpNativeInterface mA2dpNativeInterface;



    private BluetoothCodecConfig[] mCodecConfigPriorities;

    private int mA2dpSourceCodecPrioritySbc = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

    private int mA2dpSourceCodecPriorityAac = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

    private int mA2dpSourceCodecPriorityAptx = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

    private int mA2dpSourceCodecPriorityAptxHd = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

    private int mA2dpSourceCodecPriorityLdac = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;



    A2dpCodecConfig(Context context, A2dpNativeInterface a2dpNativeInterface) {

        mContext = context;

        mA2dpNativeInterface = a2dpNativeInterface;

        mCodecConfigPriorities = assignCodecConfigPriorities();

    }



    BluetoothCodecConfig[] codecConfigPriorities() {

        return mCodecConfigPriorities;

    }



    void setCodecConfigPreference(BluetoothDevice device,

                                  BluetoothCodecConfig codecConfig) {

        BluetoothCodecConfig[] codecConfigArray = new BluetoothCodecConfig[1];

        codecConfigArray[0] = codecConfig;

        mA2dpNativeInterface.setCodecConfigPreference(device, codecConfigArray);

    }



    void enableOptionalCodecs(BluetoothDevice device) {

        BluetoothCodecConfig[] codecConfigArray = assignCodecConfigPriorities();

        if (codecConfigArray == null) {

            return;

        }



        // Set the mandatory codec's priority to default, and remove the rest

        for (int i = 0; i < codecConfigArray.length; i++) {

            BluetoothCodecConfig codecConfig = codecConfigArray[i];

            if (!codecConfig.isMandatoryCodec()) {

                codecConfigArray[i] = null;

            }

        }



        mA2dpNativeInterface.setCodecConfigPreference(device, codecConfigArray);

    }



    void disableOptionalCodecs(BluetoothDevice device) {

        BluetoothCodecConfig[] codecConfigArray = assignCodecConfigPriorities();

        if (codecConfigArray == null) {

            return;

        }

        // Set the mandatory codec's priority to highest, and remove the rest

        for (int i = 0; i < codecConfigArray.length; i++) {

            BluetoothCodecConfig codecConfig = codecConfigArray[i];

            if (codecConfig.isMandatoryCodec()) {

                codecConfig.setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST);

            } else {

                codecConfigArray[i] = null;

            }

        }

        mA2dpNativeInterface.setCodecConfigPreference(device, codecConfigArray);

    }



    // Assign the A2DP Source codec config priorities

    private BluetoothCodecConfig[] assignCodecConfigPriorities() {

        Resources resources = mContext.getResources();

        if (resources == null) {

            return null;

        }



        int value;

        try {

            value = resources.getInteger(R.integer.a2dp_source_codec_priority_sbc);

        } catch (NotFoundException e) {

            value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

        }

        if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value

                < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {

            mA2dpSourceCodecPrioritySbc = value;

        }



        try {

            value = resources.getInteger(R.integer.a2dp_source_codec_priority_aac);

        } catch (NotFoundException e) {

            value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

        }

        if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value

                < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {

            mA2dpSourceCodecPriorityAac = value;

        }



        try {

            value = resources.getInteger(R.integer.a2dp_source_codec_priority_aptx);

        } catch (NotFoundException e) {

            value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

        }

        if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value

                < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {

            mA2dpSourceCodecPriorityAptx = value;

        }



        try {

            value = resources.getInteger(R.integer.a2dp_source_codec_priority_aptx_hd);

        } catch (NotFoundException e) {

            value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

        }

        if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value

                < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {

            mA2dpSourceCodecPriorityAptxHd = value;

        }



        try {

            value = resources.getInteger(R.integer.a2dp_source_codec_priority_ldac);

        } catch (NotFoundException e) {

            value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

        }

        if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value

                < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {

            mA2dpSourceCodecPriorityLdac = value;

        }



        BluetoothCodecConfig codecConfig;

        BluetoothCodecConfig[] codecConfigArray =

                new BluetoothCodecConfig[BluetoothCodecConfig.SOURCE_CODEC_TYPE_MAX];

        codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC,

                mA2dpSourceCodecPrioritySbc, BluetoothCodecConfig.SAMPLE_RATE_NONE,

                BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig

                .CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,

                0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);

        codecConfigArray[0] = codecConfig;

        codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC,

                mA2dpSourceCodecPriorityAac, BluetoothCodecConfig.SAMPLE_RATE_NONE,

                BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig

                .CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,

                0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);

        codecConfigArray[1] = codecConfig;

        codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX,

                mA2dpSourceCodecPriorityAptx, BluetoothCodecConfig.SAMPLE_RATE_NONE,

                BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig

                .CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,

                0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);

        codecConfigArray[2] = codecConfig;

        codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD,

                mA2dpSourceCodecPriorityAptxHd, BluetoothCodecConfig.SAMPLE_RATE_NONE,

                BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig

                .CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,

                0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);

        codecConfigArray[3] = codecConfig;

        codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC,

                mA2dpSourceCodecPriorityLdac, BluetoothCodecConfig.SAMPLE_RATE_NONE,

                BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig

                .CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,

                0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);

        codecConfigArray[4] = codecConfig;



        return codecConfigArray;

    }

}

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

+19 −9
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ public class A2dpNativeInterface { 
    private A2dpNativeInterface() {

        mAdapter = BluetoothAdapter.getDefaultAdapter();

        if (mAdapter == null) {

            Log.wtf(TAG, "No Bluetooth Adapter Available");

            Log.wtfStack(TAG, "No Bluetooth Adapter Available");

        }

    }
@@ -104,15 +104,28 @@ public class A2dpNativeInterface { 
        return disconnectA2dpNative(getByteAddress(device));

    }



    /**

     * Sets a connected A2DP remote device as active.

     *

     * @param device the remote device

     * @return true on success, otherwise false.

     */

    public boolean setActiveDevice(BluetoothDevice device) {

        return setActiveDeviceNative(getByteAddress(device));

    }



    /**

     * Sets the codec configuration preferences.

     *

     * @param device the remote Bluetooth device

     * @param codecConfigArray an array with the codec configurations to

     * configure.

     * @return true on success, otherwise false.

     */

    public boolean setCodecConfigPreference(BluetoothCodecConfig[] codecConfigArray) {

        return setCodecConfigPreferenceNative(codecConfigArray);

    public boolean setCodecConfigPreference(BluetoothDevice device,

                                            BluetoothCodecConfig[] codecConfigArray) {

        return setCodecConfigPreferenceNative(getByteAddress(device),

                                              codecConfigArray);

    }



    private BluetoothDevice getDevice(byte[] address) {
@@ -176,14 +189,11 @@ public class A2dpNativeInterface { 


    // Native methods that call into the JNI interface

    private static native void classInitNative();



    private native void initNative(BluetoothCodecConfig[] codecConfigPriorities);



    private native void cleanupNative();



    private native boolean connectA2dpNative(byte[] address);



    private native boolean disconnectA2dpNative(byte[] address);



    private native boolean setCodecConfigPreferenceNative(BluetoothCodecConfig[] codecConfigArray);

    private native boolean setActiveDeviceNative(byte[] address);

    private native boolean setCodecConfigPreferenceNative(byte[] address,

                BluetoothCodecConfig[] codecConfigArray);

}

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

+497 −122

File changed.

Preview size limit exceeded, changes collapsed.