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();

}