diff --git a/system/bta/le_audio/broadcaster/broadcaster.cc b/system/bta/le_audio/broadcaster/broadcaster.cc
index 50269141eeca7afddf31a86191577fe3dd4e8869..b06fd2d6e028ebeecbadda96915b9c5daf90d9d4 100644
--- a/system/bta/le_audio/broadcaster/broadcaster.cc
+++ b/system/bta/le_audio/broadcaster/broadcaster.cc
@@ -363,6 +363,18 @@ class LeAudioBroadcasterImpl : public LeAudioBroadcaster, public BigCallbacks {
     LeAudioLtvMap public_ltv;
     std::vector<LeAudioLtvMap> subgroup_ltvs;
 
+    if (queued_broadcast_.IsQueuedBroadcast()) {
+      LOG_ERROR("Not processed yet queued broadcast");
+      return;
+    }
+
+    if (!queued_broadcast_.CanCreateBroadcast()) {
+      queued_broadcast_.SetQueuedBroadcast(is_public, broadcast_name,
+                                           broadcast_code, public_metadata,
+                                           subgroup_quality, subgroup_metadata);
+      return;
+    }
+
     if (is_public) {
       // Prepare public broadcast announcement format
       bool is_metadata_valid;
@@ -712,6 +724,18 @@ class LeAudioBroadcasterImpl : public LeAudioBroadcaster, public BigCallbacks {
     }
   }
 
+  void IsoTrafficEventCb(bool is_active) {
+    if (is_active) {
+      queued_broadcast_.SetIsoTrafficFlag();
+    } else {
+      queued_broadcast_.ResetIsoTrafficFlag();
+
+      if (!queued_broadcast_.IsQueuedBroadcast()) return;
+
+      queued_broadcast_.CreateAudioBroadcast();
+    }
+  }
+
   void Dump(int fd) {
     std::stringstream stream;
 
@@ -1084,6 +1108,81 @@ class LeAudioBroadcasterImpl : public LeAudioBroadcaster, public BigCallbacks {
     std::vector<std::vector<uint8_t>> enc_audio_buffers_;
   } audio_receiver_;
 
+  static class QueuedBroadcast {
+   public:
+    bool IsQueuedBroadcast() {
+      LOG_INFO("");
+
+      return is_queued_;
+    }
+
+    void SetQueuedBroadcast(
+        bool is_public, const std::string& broadcast_name,
+        const std::optional<bluetooth::le_audio::BroadcastCode>& broadcast_code,
+        const std::vector<uint8_t>& public_metadata,
+        const std::vector<uint8_t>& subgroup_quality,
+        const std::vector<std::vector<uint8_t>>& subgroup_metadata) {
+      LOG_INFO();
+
+      is_public_ = is_public;
+      broadcast_name_ = broadcast_name;
+      broadcast_code_ = broadcast_code;
+      public_metadata_ = public_metadata;
+      subgroup_quality_ = subgroup_quality;
+      subgroup_metadata_ = subgroup_metadata;
+
+      is_queued_ = true;
+    }
+
+    void CreateAudioBroadcast() {
+      if (!instance || !CanCreateBroadcast()) return;
+
+      LOG_INFO("Create queued broadcast");
+
+      is_queued_ = false;
+
+      instance->CreateAudioBroadcast(is_public_, broadcast_name_,
+                                     broadcast_code_, public_metadata_,
+                                     subgroup_quality_, subgroup_metadata_);
+    }
+
+    void ClearQueuedBroadcast() {
+      LOG_INFO();
+
+      is_queued_ = false;
+    }
+
+    void SetIsoTrafficFlag() {
+      LOG_INFO();
+
+      is_iso_running_ = true;
+    }
+
+    void ResetIsoTrafficFlag() {
+      LOG_INFO();
+
+      is_iso_running_ = false;
+    }
+
+    bool CanCreateBroadcast() {
+      LOG_INFO("%d", is_iso_running_ == false);
+
+      return is_iso_running_ == false;
+    }
+
+   private:
+    /* Queued broadcast data */
+    bool is_public_;
+    std::string broadcast_name_;
+    std::optional<bluetooth::le_audio::BroadcastCode> broadcast_code_;
+    std::vector<uint8_t> public_metadata_;
+    std::vector<uint8_t> subgroup_quality_;
+    std::vector<std::vector<uint8_t>> subgroup_metadata_;
+
+    bool is_iso_running_;
+    bool is_queued_;
+  } queued_broadcast_;
+
   bluetooth::le_audio::LeAudioBroadcasterCallbacks* callbacks_;
   std::map<uint32_t, std::unique_ptr<BroadcastStateMachine>> broadcasts_;
   std::vector<std::unique_ptr<BroadcastStateMachine>> pending_broadcasts_;
@@ -1102,6 +1201,8 @@ LeAudioBroadcasterImpl::LeAudioSourceCallbacksImpl
     LeAudioBroadcasterImpl::audio_receiver_;
 LeAudioBroadcasterImpl::BroadcastAdvertisingCallbacks
     LeAudioBroadcasterImpl::state_machine_adv_callbacks_;
+LeAudioBroadcasterImpl::QueuedBroadcast
+    LeAudioBroadcasterImpl::queued_broadcast_;
 } /* namespace */
 
 void LeAudioBroadcaster::Initialize(
@@ -1129,6 +1230,14 @@ void LeAudioBroadcaster::Initialize(
   instance = new LeAudioBroadcasterImpl(callbacks);
   /* Register HCI event handlers */
   IsoManager::GetInstance()->RegisterBigCallbacks(instance);
+  /* Register for active traffic */
+  IsoManager::GetInstance()->RegisterOnIsoTrafficActiveCallback(
+      [](bool is_active) {
+        if (!instance) {
+          return;
+        }
+        instance->IsoTrafficEventCb(is_active);
+      });
 }
 
 bool LeAudioBroadcaster::IsLeAudioBroadcasterRunning() { return instance; }