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

Commit 301ebe76 authored by Henri Chataing's avatar Henri Chataing Committed by Automerger Merge Worker
Browse files

Merge "jni/a2dp: Cleanup A2DP initialization" into main am: c6a22081 am: 46975962 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3368760



Change-Id: I2e5213dc63654bbeabb7791d9a8b37d5bf67e011
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 040d1582 46975962

android/app/jni/com_android_bluetooth_a2dp.cpp

+67 −35
Original line number Diff line number Diff line
@@ -36,15 +36,23 @@ 
#include "types/raw_address.h"



namespace android {

static jmethodID method_onConnectionStateChanged;

static jmethodID method_onAudioStateChanged;

static jmethodID method_onCodecConfigChanged;

static jmethodID method_isMandatoryCodecPreferred;



static struct {

  jfieldID mNativeCallback;

} android_bluetooth_A2dpNativeInterface;



static struct {

  jmethodID onConnectionStateChanged;

  jmethodID onAudioStateChanged;

  jmethodID onCodecConfigChanged;

  jmethodID isMandatoryCodecPreferred;

} android_bluetooth_A2dpNativeCallback;



static struct {

  jclass clazz;

  jmethodID constructor;

  jmethodID getCodecType;

  jmethodID getExtendedCodecType;

  jmethodID getCodecPriority;

  jmethodID getSampleRate;

  jmethodID getBitsPerSample;
@@ -55,6 +63,12 @@ static struct { 
  jmethodID getCodecSpecific4;

} android_bluetooth_BluetoothCodecConfig;



static struct {

  jclass clazz;

  jmethodID constructor;

  jmethodID getCodecId;

} android_bluetooth_BluetoothCodecType;



static std::vector<btav_a2dp_codec_info_t> supported_codecs;

static std::shared_timed_mutex interface_mutex;
@@ -81,8 +95,9 @@ static void bta2dp_connection_state_callback(const RawAddress& 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);

  sCallbackEnv->CallVoidMethod(mCallbacksObj,

                               android_bluetooth_A2dpNativeCallback.onConnectionStateChanged,

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

}



static void bta2dp_audio_state_callback(const RawAddress& bd_addr, btav_audio_state_t state) {
@@ -103,7 +118,9 @@ static void bta2dp_audio_state_callback(const RawAddress& bd_addr, btav_audio_st 


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

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

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioStateChanged, addr.get(), (jint)state);

  sCallbackEnv->CallVoidMethod(mCallbacksObj,

                               android_bluetooth_A2dpNativeCallback.onAudioStateChanged, addr.get(),

                               (jint)state);

}



static void bta2dp_audio_config_callback(
@@ -168,9 +185,9 @@ static void bta2dp_audio_config_callback( 
  sCallbackEnv->SetByteArrayRegion(addr.get(), 0, RawAddress::kLength,

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



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onCodecConfigChanged, addr.get(),

                               codecConfigObj, local_capabilities_array,

                               selectable_capabilities_array);

  sCallbackEnv->CallVoidMethod(

          mCallbacksObj, android_bluetooth_A2dpNativeCallback.onCodecConfigChanged, addr.get(),

          codecConfigObj, local_capabilities_array, selectable_capabilities_array);

}



static bool bta2dp_mandatory_codec_preferred_callback(const RawAddress& bd_addr) {
@@ -190,7 +207,8 @@ static bool bta2dp_mandatory_codec_preferred_callback(const RawAddress& bd_addr) 
  }

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

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

  return sCallbackEnv->CallBooleanMethod(mCallbacksObj, method_isMandatoryCodecPreferred,

  return sCallbackEnv->CallBooleanMethod(

          mCallbacksObj, android_bluetooth_A2dpNativeCallback.isMandatoryCodecPreferred,

          addr.get());

}
@@ -216,6 +234,7 @@ static std::vector<btav_a2dp_codec_config_t> prepareCodecPreferences( 
      log::error("Invalid BluetoothCodecConfig instance");

      continue;

    }



    jint codecType =

            env->CallIntMethod(jcodecConfig, android_bluetooth_BluetoothCodecConfig.getCodecType);

    jint codecPriority = env->CallIntMethod(
@@ -268,7 +287,8 @@ static void initNative(JNIEnv* env, jobject object, jint maxConnectedAudioDevice 
    mCallbacksObj = nullptr;

  }



  if ((mCallbacksObj = env->NewGlobalRef(object)) == nullptr) {

  if ((mCallbacksObj = env->NewGlobalRef(env->GetObjectField(

               object, android_bluetooth_A2dpNativeInterface.mNativeCallback))) == nullptr) {

    log::error("Failed to allocate Global Ref for A2DP Callbacks");

    return;

  }
@@ -280,6 +300,13 @@ static void initNative(JNIEnv* env, jobject object, jint maxConnectedAudioDevice 
    return;

  }



  android_bluetooth_BluetoothCodecType.clazz =

          (jclass)env->NewGlobalRef(env->FindClass("android/bluetooth/BluetoothCodecType"));

  if (android_bluetooth_BluetoothCodecType.clazz == nullptr) {

    log::error("Failed to allocate Global Ref for BluetoothCodecType class");

    return;

  }



  std::vector<btav_a2dp_codec_config_t> codec_priorities =

          prepareCodecPreferences(env, object, codecConfigArray);
@@ -316,23 +343,8 @@ static void cleanupNative(JNIEnv* env, jobject /* object */) { 
}



static jobjectArray getSupportedCodecTypesNative(JNIEnv* env) {

  jclass android_bluetooth_BluetoothCodecType_clazz =

          (jclass)env->NewGlobalRef(env->FindClass("android/bluetooth/BluetoothCodecType"));

  if (android_bluetooth_BluetoothCodecType_clazz == nullptr) {

    log::error("Failed to allocate Global Ref for BluetoothCodecType class");

    return nullptr;

  }



  jmethodID init = env->GetMethodID(android_bluetooth_BluetoothCodecType_clazz, "<init>",

                                    "(IJLjava/lang/String;)V");



  if (init == nullptr) {

    log::error("Failed to find method <init> of BluetoothCodecType class");

    return nullptr;

  }



  jobjectArray result = env->NewObjectArray(supported_codecs.size(),

                                            android_bluetooth_BluetoothCodecType_clazz, nullptr);

                                            android_bluetooth_BluetoothCodecType.clazz, nullptr);



  if (result == nullptr) {

    log::error("Failed to allocate result array of BluetoothCodecType");
@@ -341,7 +353,8 @@ static jobjectArray getSupportedCodecTypesNative(JNIEnv* env) { 


  for (size_t index = 0; index < supported_codecs.size(); index++) {

    jobject codec_type = env->NewObject(

            android_bluetooth_BluetoothCodecType_clazz, init,

            android_bluetooth_BluetoothCodecType.clazz,

            android_bluetooth_BluetoothCodecType.constructor,

            (jint)supported_codecs[index].codec_type, (jlong)supported_codecs[index].codec_id,

            env->NewStringUTF(supported_codecs[index].codec_name.c_str()));

    env->SetObjectArrayElement(result, index, codec_type);
@@ -443,6 +456,7 @@ static jboolean setCodecConfigPreferenceNative(JNIEnv* env, jobject object, jbyt 
  bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));

  std::vector<btav_a2dp_codec_config_t> codec_preferences =

          prepareCodecPreferences(env, object, codecConfigArray);



  log::info("{}: {}", bd_addr, btav_a2dp_codec_config_t::PrintCodecs(codec_preferences));

  bt_status_t status = btif_av_source_set_codec_config_preference(bd_addr, codec_preferences);

  if (status != BT_STATUS_SUCCESS) {
@@ -475,20 +489,32 @@ int register_com_android_bluetooth_a2dp(JNIEnv* env) { 
  }



  const JNIJavaMethod javaMethods[] = {

          {"onConnectionStateChanged", "([BI)V", &method_onConnectionStateChanged},

          {"onAudioStateChanged", "([BI)V", &method_onAudioStateChanged},

          {"onConnectionStateChanged", "([BI)V",

           &android_bluetooth_A2dpNativeCallback.onConnectionStateChanged},

          {"onAudioStateChanged", "([BI)V",

           &android_bluetooth_A2dpNativeCallback.onAudioStateChanged},

          {"onCodecConfigChanged",

           "([BLandroid/bluetooth/BluetoothCodecConfig;"

           "[Landroid/bluetooth/BluetoothCodecConfig;"

           "[Landroid/bluetooth/BluetoothCodecConfig;)V",

           &method_onCodecConfigChanged},

          {"isMandatoryCodecPreferred", "([B)Z", &method_isMandatoryCodecPreferred},

           &android_bluetooth_A2dpNativeCallback.onCodecConfigChanged},

          {"isMandatoryCodecPreferred", "([B)Z",

           &android_bluetooth_A2dpNativeCallback.isMandatoryCodecPreferred},

  };

  GET_JAVA_METHODS(env, "com/android/bluetooth/a2dp/A2dpNativeInterface", javaMethods);

  GET_JAVA_METHODS(env, "com/android/bluetooth/a2dp/A2dpNativeCallback", javaMethods);



  jclass jniA2dpNativeInterfaceClass =

          env->FindClass("com/android/bluetooth/a2dp/A2dpNativeInterface");

  android_bluetooth_A2dpNativeInterface.mNativeCallback =

          env->GetFieldID(jniA2dpNativeInterfaceClass, "mNativeCallback",

                          "Lcom/android/bluetooth/a2dp/A2dpNativeCallback;");

  env->DeleteLocalRef(jniA2dpNativeInterfaceClass);



  const JNIJavaMethod codecConfigCallbacksMethods[] = {

          {"<init>", "(IIIIIJJJJ)V", &android_bluetooth_BluetoothCodecConfig.constructor},

          {"getCodecType", "()I", &android_bluetooth_BluetoothCodecConfig.getCodecType},

          {"getExtendedCodecType", "()Landroid/bluetooth/BluetoothCodecType;",

           &android_bluetooth_BluetoothCodecConfig.getExtendedCodecType},

          {"getCodecPriority", "()I", &android_bluetooth_BluetoothCodecConfig.getCodecPriority},

          {"getSampleRate", "()I", &android_bluetooth_BluetoothCodecConfig.getSampleRate},

          {"getBitsPerSample", "()I", &android_bluetooth_BluetoothCodecConfig.getBitsPerSample},
@@ -500,6 +526,12 @@ int register_com_android_bluetooth_a2dp(JNIEnv* env) { 
  };

  GET_JAVA_METHODS(env, "android/bluetooth/BluetoothCodecConfig", codecConfigCallbacksMethods);



  const JNIJavaMethod bluetoothCodecTypeMethods[] = {

          {"<init>", "(IJLjava/lang/String;)V", &android_bluetooth_BluetoothCodecType.constructor},

          {"getCodecId", "()J", &android_bluetooth_BluetoothCodecType.getCodecId},

  };

  GET_JAVA_METHODS(env, "android/bluetooth/BluetoothCodecType", bluetoothCodecTypeMethods);



  return 0;

}

}  // namespace android

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

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

 * Copyright 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.a2dp;



import static java.util.Objects.requireNonNull;



import android.annotation.NonNull;

import android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothCodecConfig;

import android.bluetooth.BluetoothCodecStatus;

import android.bluetooth.BluetoothDevice;

import android.util.Log;



import com.android.bluetooth.btservice.AdapterService;

import com.android.internal.annotations.VisibleForTesting;



import java.util.Arrays;



class A2dpNativeCallback {

    static final String TAG = A2dpNativeCallback.class.getSimpleName();



    private final AdapterService mAdapterService;

    private final A2dpService mA2dpService;



    @VisibleForTesting

    A2dpNativeCallback(@NonNull AdapterService adapterService, @NonNull A2dpService a2dpService) {

        mAdapterService = requireNonNull(adapterService);

        mA2dpService = requireNonNull(a2dpService);

    }



    private BluetoothDevice getDevice(byte[] address) {

        return mAdapterService.getDeviceFromByte(address);

    }



    @VisibleForTesting

    void onConnectionStateChanged(byte[] address, int state) {

        A2dpStackEvent event =

                new A2dpStackEvent(A2dpStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED);

        event.device = getDevice(address);

        event.valueInt = state;



        Log.d(TAG, "onConnectionStateChanged: " + event);

        mA2dpService.messageFromNative(event);

    }



    @VisibleForTesting

    void onAudioStateChanged(byte[] address, int state) {

        A2dpStackEvent event = new A2dpStackEvent(A2dpStackEvent.EVENT_TYPE_AUDIO_STATE_CHANGED);

        event.device = getDevice(address);

        event.valueInt = state;



        Log.d(TAG, "onAudioStateChanged: " + event);

        mA2dpService.messageFromNative(event);

    }



    @VisibleForTesting

    void onCodecConfigChanged(

            byte[] address,

            BluetoothCodecConfig newCodecConfig,

            BluetoothCodecConfig[] codecsLocalCapabilities,

            BluetoothCodecConfig[] codecsSelectableCapabilities) {

        A2dpStackEvent event = new A2dpStackEvent(A2dpStackEvent.EVENT_TYPE_CODEC_CONFIG_CHANGED);

        event.device = getDevice(address);

        event.codecStatus =

                new BluetoothCodecStatus(

                        newCodecConfig,

                        Arrays.asList(codecsLocalCapabilities),

                        Arrays.asList(codecsSelectableCapabilities));



        Log.d(TAG, "onCodecConfigChanged: " + event);

        mA2dpService.messageFromNative(event);

    }



    @VisibleForTesting

    boolean isMandatoryCodecPreferred(byte[] address) {

        int enabled = mA2dpService.getOptionalCodecsEnabled(getDevice(address));



        Log.d(TAG, "isMandatoryCodecPreferred: optional preference " + enabled);

        return enabled == BluetoothA2dp.OPTIONAL_CODECS_PREF_DISABLED;

    }

}

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

+15 −109
Original line number Diff line number Diff line
@@ -21,65 +21,37 @@ 
 */

package com.android.bluetooth.a2dp;



import android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothAdapter;

import static java.util.Objects.requireNonNull;



import android.annotation.NonNull;

import android.bluetooth.BluetoothCodecConfig;

import android.bluetooth.BluetoothCodecStatus;

import android.bluetooth.BluetoothCodecType;

import android.bluetooth.BluetoothDevice;

import android.util.Log;



import com.android.bluetooth.Utils;

import com.android.bluetooth.btservice.AdapterService;

import com.android.bluetooth.flags.Flags;

import com.android.internal.annotations.GuardedBy;

import com.android.internal.annotations.VisibleForTesting;



import java.lang.annotation.Native;



import java.util.Arrays;

import java.util.List;

import java.util.Objects;



/** A2DP Native Interface to/from JNI. */

public class A2dpNativeInterface {

    private static final String TAG = A2dpNativeInterface.class.getSimpleName();

    private BluetoothAdapter mAdapter;

    private AdapterService mAdapterService;



    @GuardedBy("INSTANCE_LOCK")

    private static A2dpNativeInterface sInstance;



    private static BluetoothCodecType[] sSupportedCodecTypes;



    private static final Object INSTANCE_LOCK = new Object();



    @VisibleForTesting

    private A2dpNativeInterface() {

        mAdapter = BluetoothAdapter.getDefaultAdapter();

        if (mAdapter == null) {

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

        }

        mAdapterService =

                Objects.requireNonNull(

                        AdapterService.getAdapterService(),

                        "AdapterService cannot be null when A2dpNativeInterface init");

    }

    private final AdapterService mAdapterService;

    @Native private final A2dpNativeCallback mNativeCallback;



    /** Get singleton instance. */

    public static A2dpNativeInterface getInstance() {

        synchronized (INSTANCE_LOCK) {

            if (sInstance == null) {

                sInstance = new A2dpNativeInterface();

            }

            return sInstance;

        }

    }

    private BluetoothCodecType[] mSupportedCodecTypes;



    /** Set singleton instance. */

    @VisibleForTesting

    public static void setInstance(A2dpNativeInterface instance) {

        synchronized (INSTANCE_LOCK) {

            sInstance = instance;

        }

    A2dpNativeInterface(

            @NonNull AdapterService adapterService, @NonNull A2dpNativeCallback nativeCallback) {

        mAdapterService = requireNonNull(adapterService);

        mNativeCallback = requireNonNull(nativeCallback);

    }



    /**
@@ -103,10 +75,10 @@ public class A2dpNativeInterface { 


    /** Returns the list of locally supported codec types. */

    public List<BluetoothCodecType> getSupportedCodecTypes() {

        if (sSupportedCodecTypes == null) {

            sSupportedCodecTypes = getSupportedCodecTypesNative();

        if (mSupportedCodecTypes == null) {

            mSupportedCodecTypes = getSupportedCodecTypesNative();

        }

        return Arrays.asList(sSupportedCodecTypes);

        return Arrays.asList(mSupportedCodecTypes);

    }



    /**
@@ -161,10 +133,6 @@ public class A2dpNativeInterface { 
        return setCodecConfigPreferenceNative(getByteAddress(device), codecConfigArray);

    }



    private BluetoothDevice getDevice(byte[] address) {

        return mAdapterService.getDeviceFromByte(address);

    }



    private byte[] getByteAddress(BluetoothDevice device) {

        if (device == null) {

            return Utils.getBytesFromAddress("00:00:00:00:00:00");
@@ -176,68 +144,6 @@ public class A2dpNativeInterface { 
        }

    }



    private void sendMessageToService(A2dpStackEvent event) {

        A2dpService service = A2dpService.getA2dpService();

        if (service != null) {

            service.messageFromNative(event);

        } else {

            Log.w(TAG, "Event ignored, service not available: " + event);

        }

    }



    // Callbacks from the native stack back into the Java framework.

    // All callbacks are routed via the Service which will disambiguate which

    // state machine the message should be routed to.



    private void onConnectionStateChanged(byte[] address, int state) {

        A2dpStackEvent event =

                new A2dpStackEvent(A2dpStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED);

        event.device = getDevice(address);

        event.valueInt = state;



        Log.d(TAG, "onConnectionStateChanged: " + event);

        sendMessageToService(event);

    }



    private void onAudioStateChanged(byte[] address, int state) {

        A2dpStackEvent event = new A2dpStackEvent(A2dpStackEvent.EVENT_TYPE_AUDIO_STATE_CHANGED);

        event.device = getDevice(address);

        event.valueInt = state;



        Log.d(TAG, "onAudioStateChanged: " + event);

        sendMessageToService(event);

    }



    private void onCodecConfigChanged(

            byte[] address,

            BluetoothCodecConfig newCodecConfig,

            BluetoothCodecConfig[] codecsLocalCapabilities,

            BluetoothCodecConfig[] codecsSelectableCapabilities) {

        A2dpStackEvent event = new A2dpStackEvent(A2dpStackEvent.EVENT_TYPE_CODEC_CONFIG_CHANGED);

        event.device = getDevice(address);

        event.codecStatus =

                new BluetoothCodecStatus(

                        newCodecConfig,

                        Arrays.asList(codecsLocalCapabilities),

                        Arrays.asList(codecsSelectableCapabilities));

        Log.d(TAG, "onCodecConfigChanged: " + event);

        sendMessageToService(event);

    }



    private boolean isMandatoryCodecPreferred(byte[] address) {

        A2dpService service = A2dpService.getA2dpService();

        if (service != null) {

            int enabled = service.getOptionalCodecsEnabled(getDevice(address));

            Log.d(TAG, "isMandatoryCodecPreferred: optional preference " + enabled);

            // Optional codecs are more preferred if possible

            return enabled == BluetoothA2dp.OPTIONAL_CODECS_PREF_DISABLED;

        } else {

            Log.w(TAG, "isMandatoryCodecPreferred: service not available");

            return false;

        }

    }



    // Native methods that call into the JNI interface

    private native void initNative(

            int maxConnectedAudioDevices,

            BluetoothCodecConfig[] codecConfigPriorities,

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

+14 −4
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ import static android.bluetooth.BluetoothProfile.STATE_CONNECTING; 
import static com.android.bluetooth.Utils.checkCallerTargetSdk;



import static java.util.Objects.requireNonNull;

import static java.util.Objects.requireNonNullElseGet;



import android.annotation.NonNull;

import android.annotation.RequiresPermission;
@@ -116,14 +117,20 @@ public class A2dpService extends ProfileService { 
            new AudioManagerAudioDeviceCallback();



    public A2dpService(AdapterService adapterService) {

        this(adapterService, A2dpNativeInterface.getInstance(), Looper.getMainLooper());

        this(adapterService, null, Looper.getMainLooper());

    }



    @VisibleForTesting

    A2dpService(AdapterService adapterService, A2dpNativeInterface nativeInterface, Looper looper) {

        super(requireNonNull(adapterService));

        mAdapterService = adapterService;

        mNativeInterface = requireNonNull(nativeInterface);

        mNativeInterface =

                requireNonNullElseGet(

                        nativeInterface,

                        () ->

                                new A2dpNativeInterface(

                                        adapterService,

                                        new A2dpNativeCallback(adapterService, this)));

        mDatabaseManager = requireNonNull(mAdapterService.getDatabase());

        mAudioManager = requireNonNull(getSystemService(AudioManager.class));

        mCompanionDeviceManager = requireNonNull(getSystemService(CompanionDeviceManager.class));
@@ -879,9 +886,12 @@ public class A2dpService extends ProfileService { 


    // Handle messages from native (JNI) to Java

    void messageFromNative(A2dpStackEvent stackEvent) {

        requireNonNull(stackEvent.device);

        if (!isAvailable()) {

            Log.w(TAG, "messageFromNative(): service is not available");

            return;

        }

        BluetoothDevice device = requireNonNull(stackEvent.device);

        synchronized (mStateMachines) {

            BluetoothDevice device = stackEvent.device;

            A2dpStateMachine sm = mStateMachines.get(device);

            if (sm == null) {

                if (stackEvent.type == A2dpStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED) {

android/app/tests/unit/src/com/android/bluetooth/btservice/ProfileServiceTest.java

+2 −5
Original line number Diff line number Diff line
@@ -32,7 +32,6 @@ import androidx.test.filters.MediumTest; 
import androidx.test.runner.AndroidJUnit4;



import com.android.bluetooth.TestUtils;

import com.android.bluetooth.a2dp.A2dpNativeInterface;

import com.android.bluetooth.a2dpsink.A2dpSinkNativeInterface;

import com.android.bluetooth.avrcp.AvrcpNativeInterface;

import com.android.bluetooth.avrcpcontroller.AvrcpControllerNativeInterface;
@@ -80,7 +79,6 @@ public class ProfileServiceTest { 


    private int[] mProfiles;



    @Mock private A2dpNativeInterface mA2dpNativeInterface;

    @Mock private A2dpSinkNativeInterface mA2dpSinkNativeInterface;

    @Mock private AvrcpNativeInterface mAvrcpNativeInterface;

    @Mock private AvrcpControllerNativeInterface mAvrcpControllerNativeInterface;
@@ -155,13 +153,13 @@ public class ProfileServiceTest { 
                                        profile != BluetoothProfile.HAP_CLIENT

                                                && profile != BluetoothProfile.VOLUME_CONTROL

                                                && profile != BluetoothProfile.CSIP_SET_COORDINATOR

                                                && profile != BluetoothProfile.GATT)

                                                && profile != BluetoothProfile.GATT

                                                && profile != BluetoothProfile.A2DP)

                        .toArray();

        TestUtils.setAdapterService(mAdapterService);



        Assert.assertNotNull(AdapterService.getAdapterService());



        A2dpNativeInterface.setInstance(mA2dpNativeInterface);

        A2dpSinkNativeInterface.setInstance(mA2dpSinkNativeInterface);

        AvrcpNativeInterface.setInstance(mAvrcpNativeInterface);

        AvrcpControllerNativeInterface.setInstance(mAvrcpControllerNativeInterface);
@@ -180,7 +178,6 @@ public class ProfileServiceTest { 
        TestUtils.clearAdapterService(mAdapterService);

        mAdapterService = null;

        mProfiles = null;

        A2dpNativeInterface.setInstance(null);

        A2dpSinkNativeInterface.setInstance(null);

        AvrcpNativeInterface.setInstance(null);

        AvrcpControllerNativeInterface.setInstance(null);