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

Commit 4a342193 authored by Jakub Pawłowski's avatar Jakub Pawłowski Committed by Gerrit Code Review
Browse files

Merge changes Ie524da6f,I37609e05,Ib1715e1f,I11dae3ed,Iacc680ce, ... 

* changes:
  broadcaster: Refactor handling broadcast ID
  broadcaster: Fix stopping audio session
  broadcaster: Fix suppressing noisy intent
  broadcaster: Remove redundant code
  broadcaster: Fix invalid HAL version log
  broadcaster: Improve dumpsys logs
  broadcaster: Enable and improve logging
  common/strings: Support classes with operator<<(std::ostream&, const T&)
parents 1001ec92 03c4b80e

android/app/jni/com_android_bluetooth_le_audio.cpp

+17 −53
Original line number Diff line number Diff line
@@ -493,7 +493,6 @@ static JNINativeMethod sMethods[] = { 
static jmethodID method_onBroadcastCreated;

static jmethodID method_onBroadcastDestroyed;

static jmethodID method_onBroadcastStateChanged;

static jmethodID method_onBroadcastId;



static LeAudioBroadcasterInterface* sLeAudioBroadcasterInterface = nullptr;

static std::shared_timed_mutex sBroadcasterInterfaceMutex;
@@ -505,7 +504,7 @@ class LeAudioBroadcasterCallbacksImpl : public LeAudioBroadcasterCallbacks { 
 public:

  ~LeAudioBroadcasterCallbacksImpl() = default;



  void OnBroadcastCreated(uint8_t instance_id, bool success) override {

  void OnBroadcastCreated(uint32_t broadcast_id, bool success) override {

    LOG(INFO) << __func__;



    std::shared_lock<std::shared_timed_mutex> lock(sBroadcasterCallbacksMutex);
@@ -513,11 +512,11 @@ class LeAudioBroadcasterCallbacksImpl : public LeAudioBroadcasterCallbacks { 


    if (!sCallbackEnv.valid() || sBroadcasterCallbacksObj == nullptr) return;

    sCallbackEnv->CallVoidMethod(sBroadcasterCallbacksObj,

                                 method_onBroadcastCreated, (jint)instance_id,

                                 method_onBroadcastCreated, (jint)broadcast_id,

                                 success ? JNI_TRUE : JNI_FALSE);

  }



  void OnBroadcastDestroyed(uint8_t instance_id) override {

  void OnBroadcastDestroyed(uint32_t broadcast_id) override {

    LOG(INFO) << __func__;



    std::shared_lock<std::shared_timed_mutex> lock(sBroadcasterCallbacksMutex);
@@ -526,10 +525,10 @@ class LeAudioBroadcasterCallbacksImpl : public LeAudioBroadcasterCallbacks { 
    if (!sCallbackEnv.valid() || sBroadcasterCallbacksObj == nullptr) return;

    sCallbackEnv->CallVoidMethod(sBroadcasterCallbacksObj,

                                 method_onBroadcastDestroyed,

                                 (jint)instance_id);

                                 (jint)broadcast_id);

  }



  void OnBroadcastStateChanged(uint8_t instance_id,

  void OnBroadcastStateChanged(uint32_t broadcast_id,

                               BroadcastState state) override {

    LOG(INFO) << __func__;
@@ -539,35 +538,9 @@ class LeAudioBroadcasterCallbacksImpl : public LeAudioBroadcasterCallbacks { 
    if (!sCallbackEnv.valid() || sBroadcasterCallbacksObj == nullptr) return;

    sCallbackEnv->CallVoidMethod(

        sBroadcasterCallbacksObj, method_onBroadcastStateChanged,

        (jint)instance_id,

        (jint)broadcast_id,

        (jint) static_cast<std::underlying_type<BroadcastState>::type>(state));

  }



  void OnBroadcastId(uint8_t instance_id,

                     const BroadcastId& broadcast_id) override {

    LOG(INFO) << __func__;



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

    CallbackEnv sCallbackEnv(__func__);



    // broadcast_id

    int field_size = broadcast_id.size();

    ScopedLocalRef<jbyteArray> serialized_broadcast_id(

        sCallbackEnv.get(), sCallbackEnv->NewByteArray(field_size));

    if (!serialized_broadcast_id.get()) {

      LOG(ERROR) << "Failed to allocate new jbyteArray broadcast_id for the "

                    "announcement";

      return;

    }



    sCallbackEnv->SetByteArrayRegion(serialized_broadcast_id.get(), 0,

                                     field_size, (jbyte*)broadcast_id.data());



    if (!sCallbackEnv.valid() || sBroadcasterCallbacksObj == nullptr) return;

    sCallbackEnv->CallVoidMethod(sBroadcasterCallbacksObj, method_onBroadcastId,

                                 (jint)instance_id,

                                 serialized_broadcast_id.get());

  }

};



static LeAudioBroadcasterCallbacksImpl sLeAudioBroadcasterCallbacks;
@@ -579,7 +552,6 @@ static void BroadcasterClassInitNative(JNIEnv* env, jclass clazz) { 
      env->GetMethodID(clazz, "onBroadcastDestroyed", "(I)V");

  method_onBroadcastStateChanged =

      env->GetMethodID(clazz, "onBroadcastStateChanged", "(II)V");

  method_onBroadcastId = env->GetMethodID(clazz, "onBroadcastId", "(I[B)V");

}



static void BroadcasterInitNative(JNIEnv* env, jobject object) {
@@ -674,52 +646,45 @@ static void CreateBroadcastNative(JNIEnv* env, jobject object, 
  env->ReleaseByteArrayElements(metadata, meta, 0);

}



static void UpdateMetadataNative(JNIEnv* env, jobject object, jint instance_id,

static void UpdateMetadataNative(JNIEnv* env, jobject object, jint broadcast_id,

                                 jbyteArray metadata) {

  jbyte* meta = env->GetByteArrayElements(metadata, nullptr);

  sLeAudioBroadcasterInterface->UpdateMetadata(

      instance_id,

      broadcast_id,

      std::vector<uint8_t>(meta, meta + env->GetArrayLength(metadata)));

  env->ReleaseByteArrayElements(metadata, meta, 0);

}



static void StartBroadcastNative(JNIEnv* env, jobject object,

                                 jint instance_id) {

                                 jint broadcast_id) {

  LOG(INFO) << __func__;

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

  if (!sLeAudioBroadcasterInterface) return;

  sLeAudioBroadcasterInterface->StartBroadcast(instance_id);

  sLeAudioBroadcasterInterface->StartBroadcast(broadcast_id);

}



static void StopBroadcastNative(JNIEnv* env, jobject object, jint instance_id) {

static void StopBroadcastNative(JNIEnv* env, jobject object,

                                jint broadcast_id) {

  LOG(INFO) << __func__;

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

  if (!sLeAudioBroadcasterInterface) return;

  sLeAudioBroadcasterInterface->StopBroadcast(instance_id);

  sLeAudioBroadcasterInterface->StopBroadcast(broadcast_id);

}



static void PauseBroadcastNative(JNIEnv* env, jobject object,

                                 jint instance_id) {

                                 jint broadcast_id) {

  LOG(INFO) << __func__;

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

  if (!sLeAudioBroadcasterInterface) return;

  sLeAudioBroadcasterInterface->PauseBroadcast(instance_id);

  sLeAudioBroadcasterInterface->PauseBroadcast(broadcast_id);

}



static void DestroyBroadcastNative(JNIEnv* env, jobject object,

                                   jint instance_id) {

  LOG(INFO) << __func__;

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

  if (!sLeAudioBroadcasterInterface) return;

  sLeAudioBroadcasterInterface->DestroyBroadcast(instance_id);

}



static void GetBroadcastIdNative(JNIEnv* env, jobject object,

                                 jint instance_id) {

                                   jint broadcast_id) {

  LOG(INFO) << __func__;

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

  if (!sLeAudioBroadcasterInterface) return;

  sLeAudioBroadcasterInterface->GetBroadcastId(instance_id);

  sLeAudioBroadcasterInterface->DestroyBroadcast(broadcast_id);

}



static void GetAllBroadcastStatesNative(JNIEnv* env, jobject object) {
@@ -740,7 +705,6 @@ static JNINativeMethod sBroadcasterMethods[] = { 
    {"stopBroadcastNative", "(I)V", (void*)StopBroadcastNative},

    {"pauseBroadcastNative", "(I)V", (void*)PauseBroadcastNative},

    {"destroyBroadcastNative", "(I)V", (void*)DestroyBroadcastNative},

    {"getBroadcastIdNative", "(I)V", (void*)GetBroadcastIdNative},

    {"getAllBroadcastStatesNative", "()V", (void*)GetAllBroadcastStatesNative},

};

android/app/src/com/android/bluetooth/le_audio/LeAudioBroadcasterNativeInterface.java

+29 −52
Original line number Diff line number Diff line
@@ -81,34 +81,34 @@ public class LeAudioBroadcasterNativeInterface { 


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

    @VisibleForTesting

    public void onBroadcastCreated(int instanceId, boolean success) {

    public void onBroadcastCreated(int broadcastId, boolean success) {

        if (DBG) {

            Log.d(TAG, "onBroadcastCreated: instanceId=" + instanceId);

            Log.d(TAG, "onBroadcastCreated: broadcastId=" + broadcastId);

        }

        LeAudioStackEvent event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_CREATED);



        event.valueInt1 = instanceId;

        event.valueInt1 = broadcastId;

        event.valueBool1 = success;

        sendMessageToService(event);

    }



    @VisibleForTesting

    public void onBroadcastDestroyed(int instanceId) {

    public void onBroadcastDestroyed(int broadcastId) {

        if (DBG) {

            Log.d(TAG, "onBroadcastDestroyed: instanceId=" + instanceId);

            Log.d(TAG, "onBroadcastDestroyed: broadcastId=" + broadcastId);

        }

        LeAudioStackEvent event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_DESTROYED);



        event.valueInt1 = instanceId;

        event.valueInt1 = broadcastId;

        sendMessageToService(event);

    }



    @VisibleForTesting

    public void onBroadcastStateChanged(int instanceId, int state) {

    public void onBroadcastStateChanged(int broadcastId, int state) {

        if (DBG) {

            Log.d(TAG, "onBroadcastStateChanged: instanceId=" + instanceId + " state=" + state);

            Log.d(TAG, "onBroadcastStateChanged: broadcastId=" + broadcastId + " state=" + state);

        }

        LeAudioStackEvent event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_STATE);
@@ -120,23 +120,11 @@ public class LeAudioBroadcasterNativeInterface { 
         * For now it's only important that this device is a Bluetooth device.

         */

        event.device = getDevice(Utils.getBytesFromAddress("FF:FF:FF:FF:FF:FF"));

        event.valueInt1 = instanceId;

        event.valueInt1 = broadcastId;

        event.valueInt2 = state;

        sendMessageToService(event);

    }



    @VisibleForTesting

    public void onBroadcastId(int instanceId, byte[] broadcastId) {

        LeAudioStackEvent event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_ID);

        event.valueInt1 = instanceId;

        event.valueByte1 = broadcastId;

        if (DBG) {

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

        }

        sendMessageToService(event);

    }



    /**

     * Initializes the native interface.

     *
@@ -178,62 +166,52 @@ public class LeAudioBroadcasterNativeInterface { 
    /**

     * Update LeAudio Broadcast instance metadata.

     *

     * @param instanceId broadcast instance identifier

     * @param broadcastId broadcast instance identifier

     * @param metadata metadata buffer with TLVs

     */

    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)

    public void updateMetadata(int instanceId, byte[] metadata) {

        updateMetadataNative(instanceId, metadata);

    public void updateMetadata(int broadcastId, byte[] metadata) {

        updateMetadataNative(broadcastId, metadata);

    }



    /**

     * Start LeAudio Broadcast instance.

     *

     * @param instanceId broadcast instance identifier

     * @param broadcastId broadcast instance identifier

     */

    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)

    public void startBroadcast(int instanceId) {

        startBroadcastNative(instanceId);

    public void startBroadcast(int broadcastId) {

        startBroadcastNative(broadcastId);

    }



    /**

     * Stop LeAudio Broadcast instance.

     *

     * @param instanceId broadcast instance identifier

     * @param broadcastId broadcast instance identifier

     */

    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)

    public void stopBroadcast(int instanceId) {

        stopBroadcastNative(instanceId);

    public void stopBroadcast(int broadcastId) {

        stopBroadcastNative(broadcastId);

    }



    /**

     * Pause LeAudio Broadcast instance.

     *

     * @param instanceId broadcast instance identifier

     * @param broadcastId broadcast instance identifier

     */

    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)

    public void pauseBroadcast(int instanceId) {

        pauseBroadcastNative(instanceId);

    public void pauseBroadcast(int broadcastId) {

        pauseBroadcastNative(broadcastId);

    }



    /**

     * Destroy LeAudio Broadcast instance.

     *

     * @param instanceId broadcast instance identifier

     */

    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)

    public void destroyBroadcast(int instanceId) {

        destroyBroadcastNative(instanceId);

    }



    /**

     * Get LeAudio Broadcast instance advertising address.

     *

     * @param instanceId broadcast instance identifier

     * @param broadcastId broadcast instance identifier

     */

    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)

    public void getBroadcastId(int instanceId) {

        getBroadcastIdNative(instanceId);

    public void destroyBroadcast(int broadcastId) {

        destroyBroadcastNative(broadcastId);

    }



    /**
@@ -250,11 +228,10 @@ public class LeAudioBroadcasterNativeInterface { 
    private native void stopNative();

    private native void cleanupNative();

    private native void createBroadcastNative(byte[] metadata, int profile, byte[] broadcastCode);

    private native void updateMetadataNative(int instanceId, byte[] metadata);

    private native void startBroadcastNative(int instanceId);

    private native void stopBroadcastNative(int instanceId);

    private native void pauseBroadcastNative(int instanceId);

    private native void destroyBroadcastNative(int instanceId);

    private native void getBroadcastIdNative(int instanceId);

    private native void updateMetadataNative(int broadcastId, byte[] metadata);

    private native void startBroadcastNative(int broadcastId);

    private native void stopBroadcastNative(int broadcastId);

    private native void pauseBroadcastNative(int broadcastId);

    private native void destroyBroadcastNative(int broadcastId);

    private native void getAllBroadcastStatesNative();

}

android/app/src/com/android/bluetooth/le_audio/LeAudioService.java

+61 −152

File changed.

Preview size limit exceeded, changes collapsed.

android/app/src/com/android/bluetooth/le_audio/LeAudioStackEvent.java

+3 −35
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ public class LeAudioStackEvent { 
    public static final int EVENT_TYPE_BROADCAST_CREATED = EVENT_TYPE_UNICAST_MAX + 1;

    public static final int EVENT_TYPE_BROADCAST_DESTROYED = EVENT_TYPE_UNICAST_MAX + 2;

    public static final int EVENT_TYPE_BROADCAST_STATE = EVENT_TYPE_UNICAST_MAX + 3;

    public static final int EVENT_TYPE_BROADCAST_ID = EVENT_TYPE_UNICAST_MAX + 4;



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

    // Match up with GroupStatus enum of bt_le_audio.h
@@ -73,7 +72,6 @@ public class LeAudioStackEvent { 
    public int valueInt4 = 0;

    public int valueInt5 = 0;

    public boolean valueBool1 = false;

    public byte[] valueByte1;

    public BluetoothLeAudioCodecConfig valueCodec1;

    public BluetoothLeAudioCodecConfig valueCodec2;

    public List<BluetoothLeAudioCodecConfig> valueCodecList1;
@@ -101,7 +99,6 @@ public class LeAudioStackEvent { 
                + eventTypeValueCodecList1ToString(type, valueCodecList1));

        result.append(", valueCodecList2:"

                + eventTypeValueCodecList2ToString(type, valueCodecList2));

        result.append(", " + eventTypeValueByte1ToString(type, valueByte1));

        result.append("}");

        return result.toString();

    }
@@ -126,8 +123,6 @@ public class LeAudioStackEvent { 
                return "EVENT_TYPE_BROADCAST_DESTROYED";

            case EVENT_TYPE_BROADCAST_STATE:

                return "EVENT_TYPE_BROADCAST_STATE";

            case EVENT_TYPE_BROADCAST_ID:

                return "EVENT_TYPE_BROADCAST_ID";

            case EVENT_TYPE_AUDIO_LOCAL_CODEC_CONFIG_CAPA_CHANGED:

                return "EVENT_TYPE_AUDIO_LOCAL_CODEC_CONFIG_CAPA_CHANGED";

            case EVENT_TYPE_AUDIO_GROUP_CODEC_CONFIG_CHANGED:
@@ -164,13 +159,11 @@ public class LeAudioStackEvent { 
            case EVENT_TYPE_SINK_AUDIO_LOCATION_AVAILABLE:

                return "{sink_audio_location:" + value + "}";

            case EVENT_TYPE_BROADCAST_CREATED:

                return "{instance_id:" + value + "}";

                return "{broadcastId:" + value + "}";

            case EVENT_TYPE_BROADCAST_DESTROYED:

                return "{instance_id:" + value + "}";

                return "{broadcastId:" + value + "}";

            case EVENT_TYPE_BROADCAST_STATE:

                return "{instance_id:" + value + "}";

            case EVENT_TYPE_BROADCAST_ID:

                return "{instance_id:" + value + "}";

                return "{broadcastId:" + value + "}";

            default:

                break;

        }
@@ -202,8 +195,6 @@ public class LeAudioStackEvent { 
                return "{group_id:" + Integer.toString(value) + "}";

            case EVENT_TYPE_BROADCAST_STATE:

                return "{state:" + broadcastStateToString(value) + "}";

            case EVENT_TYPE_BROADCAST_ID:

                return "{addr_type:" + addrTypeToString(value) + "}";

            default:

                break;

        }
@@ -242,18 +233,6 @@ public class LeAudioStackEvent { 
        return Integer.toString(value);

    }



    private static String eventTypeValueByte1ToString(int type, byte[] value) {

        switch (type) {

            case EVENT_TYPE_BROADCAST_ID:

                if (value == null) {

                    return "empty";

                }

                return "broadcast_id: [" + encodeHexString(value) + "]";

            default:

                return "<unused>";

        }

    }



    private static String eventTypeValueBool1ToString(int type, boolean value) {

        switch (type) {

            case EVENT_TYPE_BROADCAST_CREATED:
@@ -324,17 +303,6 @@ public class LeAudioStackEvent { 
        }

    }



    private static String addrTypeToString(int value) {

        switch (value) {

            case 0:

                return "Static";

            case 1:

                return "Random";

            default:

                return "Unknown {" + value + "}";

        }

    }



    protected static String encodeHexString(byte[] pduData) {

        StringBuilder out = new StringBuilder(pduData.length * 2);

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

system/bta/include/bta_le_audio_broadcaster_api.h

+7 −8
Original line number Diff line number Diff line
@@ -49,17 +49,16 @@ class LeAudioBroadcaster { 
      std::vector<uint8_t> metadata, AudioProfile profile,

      std::optional<bluetooth::le_audio::BroadcastCode> broadcast_code =

          std::nullopt) = 0;

  virtual void SuspendAudioBroadcast(uint8_t instance_id) = 0;

  virtual void StartAudioBroadcast(uint8_t instance_id) = 0;

  virtual void StopAudioBroadcast(uint8_t instance_id) = 0;

  virtual void DestroyAudioBroadcast(uint8_t instance_id) = 0;

  virtual void GetBroadcastId(uint8_t instance_id) = 0;

  virtual void SuspendAudioBroadcast(uint32_t broadcast_id) = 0;

  virtual void StartAudioBroadcast(uint32_t broadcast_id) = 0;

  virtual void StopAudioBroadcast(uint32_t broadcast_id) = 0;

  virtual void DestroyAudioBroadcast(uint32_t broadcast_id) = 0;

  virtual void GetAllBroadcastStates(void) = 0;

  virtual void UpdateMetadata(uint8_t instance_id,

  virtual void UpdateMetadata(uint32_t broadcast_id,

                              std::vector<uint8_t> metadata) = 0;

  virtual void IsValidBroadcast(

      uint8_t instance_id, uint8_t addr_type, RawAddress addr,

      base::Callback<void(uint8_t /* instance_id */, uint8_t /* addr_type */,

      uint32_t broadcast_id, uint8_t addr_type, RawAddress addr,

      base::Callback<void(uint8_t /* broadcast_id */, uint8_t /* addr_type */,

                          RawAddress /* addr */, bool /* is_valid */)>

          cb) = 0;