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

Commit 5a602069 authored by Rongxuan Liu's avatar Rongxuan Liu Committed by Automerger Merge Worker
Browse files

Merge "broadcast: Remove redundant broadcast start" into main am: 67092584 

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



Change-Id: Ic659b89113708ddf7dfc619a1a0a9a2312cc4ef2
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 26bfc616 67092584

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

+125 −72
Original line number Diff line number Diff line
@@ -117,6 +117,9 @@ public class LeAudioService extends ProfileService { 
    // Timeout for state machine thread join, to prevent potential ANR.

    private static final int SM_THREAD_JOIN_TIMEOUT_MS = 1000;



    /* 5 seconds timeout for Broadcast streaming state transition */

    private static final int CREATE_BROADCAST_TIMEOUT_MS = 5000;



    private static LeAudioService sLeAudioService;



    /** Indicates group audio support for none direction */
@@ -151,9 +154,6 @@ public class LeAudioService extends ProfileService { 
                    .setSampleRate(BluetoothLeAudioCodecConfig.SAMPLE_RATE_48000)

                    .build();



    /* 5 seconds timeout for Broadcast streaming state transition */

    private static final int DIALING_OUT_TIMEOUT_MS = 5000;



    private AdapterService mAdapterService;

    private DatabaseManager mDatabaseManager;

    private HandlerThread mStateMachinesThread;
@@ -165,6 +165,8 @@ public class LeAudioService extends ProfileService { 
    private final ReentrantReadWriteLock mGroupReadWriteLock = new ReentrantReadWriteLock();

    private final Lock mGroupReadLock = mGroupReadWriteLock.readLock();

    private final Lock mGroupWriteLock = mGroupReadWriteLock.writeLock();

    private CreateBroadcastTimeoutEvent mCreateBroadcastTimeoutEvent;



    ServiceFactory mServiceFactory = new ServiceFactory();



    private final LeAudioNativeInterface mNativeInterface;
@@ -182,7 +184,6 @@ public class LeAudioService extends ProfileService { 
    BluetoothDevice mLeAudioDeviceInactivatedForHfpHandover = null;



    LeAudioBroadcasterNativeInterface mLeAudioBroadcasterNativeInterface = null;

    private DialingOutTimeoutEvent mDialingOutTimeoutEvent = null;

    @VisibleForTesting AudioManager mAudioManager;

    LeAudioTmapGattServer mTmapGattServer;

    int mTmapRoleMask;
@@ -653,7 +654,7 @@ public class LeAudioService extends ProfileService { 
        mIsSinkStreamMonitorModeEnabled = false;

        mIsBroadcastPausedFromOutside = false;



        clearBroadcastTimeoutCallback();

        clearCreateBroadcastTimeoutCallback();



        if (!Flags.leaudioSynchronizeStart()) {

            mHandler.removeCallbacks(this::init);
@@ -1148,29 +1149,48 @@ public class LeAudioService extends ProfileService { 
        return LE_AUDIO_GROUP_ID_INVALID;

    }



    /**

     * Creates LeAudio Broadcast instance with BluetoothLeBroadcastSettings.

     *

     * @param broadcastSettings broadcast settings for this broadcast source

     */

    public void createBroadcast(BluetoothLeBroadcastSettings broadcastSettings) {

    private int canBroadcastBeCreated(BluetoothLeBroadcastSettings broadcastSettings) {

        if (mBroadcastDescriptors.size() >= getMaximumNumberOfBroadcasts()) {

            Log.w(

                    TAG,

                    "createBroadcast reached maximum allowed broadcasts number: "

                            + getMaximumNumberOfBroadcasts());

            mHandler.post(

                    () ->

                            notifyBroadcastStartFailed(

                                    BluetoothStatusCodes.ERROR_LOCAL_NOT_ENOUGH_RESOURCES));

            return;

            return BluetoothStatusCodes.ERROR_LOCAL_NOT_ENOUGH_RESOURCES;

        }



        byte[] broadcastCode = broadcastSettings.getBroadcastCode();

        if (broadcastCode != null && ((broadcastCode.length > 16) || (broadcastCode.length < 4))) {

            Log.e(TAG, "Invalid broadcast code length. Should be from 4 to 16 octets long.");

            return BluetoothStatusCodes.ERROR_LE_BROADCAST_INVALID_CODE;

        }



        List<BluetoothLeBroadcastSubgroupSettings> settingsList =

                broadcastSettings.getSubgroupSettings();

        if (settingsList == null || settingsList.size() < 1) {

            Log.d(TAG, "subgroup settings is not valid value");

            return BluetoothStatusCodes.ERROR_BAD_PARAMETERS;

        }



        return BluetoothStatusCodes.SUCCESS;

    }



    /**

     * Creates LeAudio Broadcast instance with BluetoothLeBroadcastSettings.

     *

     * @param broadcastSettings broadcast settings for this broadcast source

     */

    public void createBroadcast(BluetoothLeBroadcastSettings broadcastSettings) {

        if (mLeAudioBroadcasterNativeInterface == null) {

            Log.w(TAG, "Native interface not available.");

            return;

        }



        int canBroadcastBeCreatedReturnCode = canBroadcastBeCreated(broadcastSettings);

        if (canBroadcastBeCreatedReturnCode != BluetoothStatusCodes.SUCCESS) {

            mHandler.post(() -> notifyBroadcastStartFailed(canBroadcastBeCreatedReturnCode));

            return;

        }



        if (mAwaitingBroadcastCreateResponse) {

            mCreateBroadcastQueue.add(broadcastSettings);

            Log.i(TAG, "Broadcast creation queued due to waiting for a previous request response.");
@@ -1192,21 +1212,6 @@ public class LeAudioService extends ProfileService { 
            }

        }



        byte[] broadcastCode = broadcastSettings.getBroadcastCode();

        boolean isEncrypted = (broadcastCode != null) && (broadcastCode.length != 0);

        if (isEncrypted) {

            if ((broadcastCode.length > 16) || (broadcastCode.length < 4)) {

                Log.e(TAG, "Invalid broadcast code length. Should be from 4 to 16 octets long.");

                return;

            }

        }



        List<BluetoothLeBroadcastSubgroupSettings> settingsList =

                broadcastSettings.getSubgroupSettings();

        if (settingsList == null || settingsList.size() < 1) {

            Log.d(TAG, "subgroup settings is not valid value");

            return;

        }

        mBroadcastSessionStats.put(

                INVALID_BROADCAST_ID,

                new LeAudioBroadcastSessionStats(broadcastSettings, SystemClock.elapsedRealtime()));
@@ -1214,19 +1219,37 @@ public class LeAudioService extends ProfileService { 
        BluetoothLeAudioContentMetadata publicMetadata =

                broadcastSettings.getPublicBroadcastMetadata();



        Log.i(TAG, "createBroadcast: isEncrypted=" + (isEncrypted ? "true" : "false"));

        byte[] broadcastCode = broadcastSettings.getBroadcastCode();

        Log.i(

                TAG,

                "createBroadcast: isEncrypted="

                        + (((broadcastCode != null) && (broadcastCode.length != 0))

                                ? "true"

                                : "false"));



        mAwaitingBroadcastCreateResponse = true;

        if (leaudioBigDependsOnAudioState()) {

            mCreateBroadcastQueue.add(broadcastSettings);

        }



        if (leaudioBigDependsOnAudioState()) {

            /* Start timeout to recover from stucked/error create Broadcast operation */

            if (mCreateBroadcastTimeoutEvent != null) {

                Log.w(TAG, "CreateBroadcastTimeoutEvent already scheduled");

            } else {

                mCreateBroadcastTimeoutEvent = new CreateBroadcastTimeoutEvent();

                mHandler.postDelayed(mCreateBroadcastTimeoutEvent, CREATE_BROADCAST_TIMEOUT_MS);

            }

        }



        mLeAudioBroadcasterNativeInterface.createBroadcast(

                broadcastSettings.isPublicBroadcast(),

                broadcastSettings.getBroadcastName(),

                broadcastCode,

                publicMetadata == null ? null : publicMetadata.getRawMetadata(),

                getBroadcastAudioQualityPerSinkCapabilities(settingsList),

                settingsList.stream()

                getBroadcastAudioQualityPerSinkCapabilities(

                        broadcastSettings.getSubgroupSettings()),

                broadcastSettings.getSubgroupSettings().stream()

                        .map(s -> s.getContentMetadata().getRawMetadata())

                        .toArray(byte[][]::new));

    }
@@ -1280,8 +1303,8 @@ public class LeAudioService extends ProfileService { 
        Log.d(TAG, "startBroadcast");



        /* Start timeout to recover from stucked/error start Broadcast operation */

        mDialingOutTimeoutEvent = new DialingOutTimeoutEvent(broadcastId);

        mHandler.postDelayed(mDialingOutTimeoutEvent, DIALING_OUT_TIMEOUT_MS);

        mCreateBroadcastTimeoutEvent = new CreateBroadcastTimeoutEvent(broadcastId);

        mHandler.postDelayed(mCreateBroadcastTimeoutEvent, CREATE_BROADCAST_TIMEOUT_MS);



        mLeAudioBroadcasterNativeInterface.startBroadcast(broadcastId);

    }
@@ -3181,19 +3204,19 @@ public class LeAudioService extends ProfileService { 
        setActiveDevice(unicastDevice);

    }



    void clearBroadcastTimeoutCallback() {

    private void clearCreateBroadcastTimeoutCallback() {

        if (mHandler == null) {

            Log.e(TAG, "No callback handler");

            return;

        }



        /* Timeout callback already cleared */

        if (mDialingOutTimeoutEvent == null) {

        if (mCreateBroadcastTimeoutEvent == null) {

            return;

        }



        mHandler.removeCallbacks(mDialingOutTimeoutEvent);

        mDialingOutTimeoutEvent = null;

        mHandler.removeCallbacks(mCreateBroadcastTimeoutEvent);

        mCreateBroadcastTimeoutEvent = null;

    }



    void notifyAudioFrameworkForCodecConfigUpdate(
@@ -3669,7 +3692,10 @@ public class LeAudioService extends ProfileService { 
                                if (!leaudioUseAudioModeListener()) {

                                    mQueuedInCallValue = Optional.empty();

                                }

                                startBroadcast(mBroadcastIdDeactivatedForUnicastTransition.get());

                                if (!leaudioBigDependsOnAudioState()) {

                                    startBroadcast(

                                            mBroadcastIdDeactivatedForUnicastTransition.get());

                                }

                                mBroadcastIdDeactivatedForUnicastTransition = Optional.empty();

                            }
@@ -3729,9 +3755,10 @@ public class LeAudioService extends ProfileService { 
                    mBroadcastSessionStats.put(broadcastId, sessionStats);

                }



                if (!leaudioBigDependsOnAudioState()) {

                    // Start sending the actual stream

                    startBroadcast(broadcastId);



                }

            } else {

                // TODO: Improve reason reporting or extend the native stack event with reason code

                Log.e(
@@ -3744,7 +3771,9 @@ public class LeAudioService extends ProfileService { 
                if ((mUnicastGroupIdDeactivatedForBroadcastTransition != LE_AUDIO_GROUP_ID_INVALID)

                        && mCreateBroadcastQueue.isEmpty()

                        && (!Objects.equals(device, mActiveBroadcastAudioDevice))) {

                    clearBroadcastTimeoutCallback();

                    if (!leaudioBigDependsOnAudioState()) {

                        clearCreateBroadcastTimeoutCallback();

                    }

                    updateBroadcastActiveDevice(null, mActiveBroadcastAudioDevice, false);

                }
@@ -3755,6 +3784,9 @@ public class LeAudioService extends ProfileService { 
                                .BROADCAST_AUDIO_SESSION_REPORTED__SESSION_SETUP_STATUS__SETUP_STATUS_CREATE_FAILED);

            }



            if (leaudioBigDependsOnAudioState()) {

                clearCreateBroadcastTimeoutCallback();

            }

            mAwaitingBroadcastCreateResponse = false;



            // In case if there were additional calls to create broadcast
@@ -3883,7 +3915,9 @@ public class LeAudioService extends ProfileService { 
                        sessionStats.updateSessionStreamingTime(SystemClock.elapsedRealtime());

                    }



                    clearBroadcastTimeoutCallback();

                    if (!leaudioBigDependsOnAudioState()) {

                        clearCreateBroadcastTimeoutCallback();

                    }



                    if (previousState == LeAudioStackEvent.BROADCAST_STATE_PAUSED) {

                        if (bassClientService != null) {
@@ -5279,21 +5313,38 @@ public class LeAudioService extends ProfileService { 
        return audioFrameworkCalls;

    }



    class DialingOutTimeoutEvent implements Runnable {

    private class CreateBroadcastTimeoutEvent implements Runnable {

        Integer mBroadcastId;



        DialingOutTimeoutEvent(Integer broadcastId) {

        CreateBroadcastTimeoutEvent() {}



        CreateBroadcastTimeoutEvent(Integer broadcastId) {

            mBroadcastId = broadcastId;

        }



        @Override

        public void run() {

            if (leaudioBigDependsOnAudioState()) {

                Log.w(TAG, "Failed to start Broadcast in time");



                if (getLeAudioService() == null) {

                    Log.e(TAG, "CreateBroadcastTimeoutEvent: No LE Audio service");

                    return;

                }



                if (sLeAudioService.mHandler == null) {

                    Log.w(TAG, "CreateBroadcastTimeoutEvent: No handler");

                    return;

                }



                mHandler.post(() -> notifyBroadcastStartFailed(BluetoothStatusCodes.ERROR_TIMEOUT));

            } else {

                Log.w(TAG, "Failed to start Broadcast in time: " + mBroadcastId);



            mDialingOutTimeoutEvent = null;

                mCreateBroadcastTimeoutEvent = null;



                if (getLeAudioService() == null) {

                Log.e(TAG, "DialingOutTimeoutEvent: No LE Audio service");

                    Log.e(TAG, "CreateBroadcastTimeoutEvent: No LE Audio service");

                    return;

                }
@@ -5313,7 +5364,8 @@ public class LeAudioService extends ProfileService { 
                        updateBroadcastActiveDevice(null, mActiveBroadcastAudioDevice, false);

                    }



                mHandler.post(() -> notifyBroadcastStartFailed(BluetoothStatusCodes.ERROR_TIMEOUT));

                    mHandler.post(

                            () -> notifyBroadcastStartFailed(BluetoothStatusCodes.ERROR_TIMEOUT));

                    logBroadcastSessionStatsWithStatus(

                            mBroadcastId,

                            BluetoothStatsLog
@@ -5321,6 +5373,7 @@ public class LeAudioService extends ProfileService { 
                }

            }

        }

    }



    class AudioModeChangeListener implements AudioManager.OnModeChangedListener {

        @Override

android/app/tests/unit/src/com/android/bluetooth/le_audio/LeAudioBroadcastServiceTest.java

+164 −140

File changed.

Preview size limit exceeded, changes collapsed.

system/bta/le_audio/broadcaster/broadcaster.cc

+8 −5
Original line number Diff line number Diff line
@@ -913,6 +913,7 @@ public: 
    is_iso_running_ = is_active;

    log::info("is_iso_running: {}", is_iso_running_);

    if (!is_iso_running_) {

      if (!com::android::bluetooth::flags::leaudio_big_depends_on_audio_state()) {

        if (queued_start_broadcast_request_) {

          auto broadcast_id = *queued_start_broadcast_request_;

          queued_start_broadcast_request_ = std::nullopt;
@@ -920,6 +921,8 @@ public: 
          log::info("Start queued broadcast.");

          StartAudioBroadcast(broadcast_id);

        }

      }



      if (queued_create_broadcast_request_) {

        auto broadcast_msg = std::move(*queued_create_broadcast_request_);

        queued_create_broadcast_request_ = std::nullopt;

system/bta/le_audio/broadcaster/broadcaster_test.cc

+36 −63
Original line number Diff line number Diff line
@@ -533,8 +533,19 @@ TEST_F(BroadcasterTest, CreateAudioBroadcastMultiGroups) { 
TEST_F(BroadcasterTest, SuspendAudioBroadcast) {

  EXPECT_CALL(*mock_codec_manager_, UpdateActiveBroadcastAudioHalClient(mock_audio_source_, true))

          .Times(1);

  LeAudioSourceAudioHalClient::Callbacks* audio_receiver;

  EXPECT_CALL(*mock_audio_source_, Start)

          .WillOnce(DoAll(SaveArg<1>(&audio_receiver), Return(true)))

          .WillRepeatedly(Return(false));

  auto broadcast_id = InstantiateBroadcast();



  if (com::android::bluetooth::flags::leaudio_big_depends_on_audio_state()) {

    ASSERT_NE(audio_receiver, nullptr);

    audio_receiver->OnAudioResume();

  } else {

    LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  }



  Mock::VerifyAndClearExpectations(mock_codec_manager_);



  EXPECT_CALL(mock_broadcaster_callbacks_,
@@ -559,7 +570,9 @@ TEST_F(BroadcasterTest, StartAudioBroadcast) { 


  EXPECT_CALL(*mock_codec_manager_, UpdateActiveBroadcastAudioHalClient(mock_audio_source_, true))

          .Times(1);



  auto broadcast_id = InstantiateBroadcast();

  ASSERT_NE(audio_receiver, nullptr);

  Mock::VerifyAndClearExpectations(mock_codec_manager_);



  EXPECT_CALL(*mock_codec_manager_, UpdateActiveBroadcastAudioHalClient(mock_audio_source_, true))
@@ -575,8 +588,7 @@ TEST_F(BroadcasterTest, StartAudioBroadcast) { 
  ASSERT_TRUE(big_terminate_timer_->cb == nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb == nullptr);



  LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  ASSERT_NE(audio_receiver, nullptr);

  audio_receiver->OnAudioResume();



  // NOTICE: This is really an implementation specific part, we fake the BIG

  //         config as the mocked state machine does not even call the
@@ -609,6 +621,7 @@ TEST_F(BroadcasterTest, StartAudioBroadcastMedia) { 
          .Times(1);

  auto broadcast_id =

          InstantiateBroadcast(media_metadata, default_code, {bluetooth::le_audio::QUALITY_HIGH});

  ASSERT_NE(audio_receiver, nullptr);

  Mock::VerifyAndClearExpectations(mock_codec_manager_);



  LeAudioBroadcaster::Get()->StopAudioBroadcast(broadcast_id);
@@ -626,8 +639,7 @@ TEST_F(BroadcasterTest, StartAudioBroadcastMedia) { 
  EXPECT_CALL(*mock_codec_manager_, UpdateActiveBroadcastAudioHalClient(mock_audio_source_, false))

          .Times(0);



  LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  ASSERT_NE(audio_receiver, nullptr);

  audio_receiver->OnAudioResume();



  // NOTICE: This is really an implementation specific part, we fake the BIG

  //         config as the mocked state machine does not even call the
@@ -651,8 +663,18 @@ TEST_F(BroadcasterTest, StartAudioBroadcastMedia) { 
TEST_F(BroadcasterTest, StopAudioBroadcast) {

  EXPECT_CALL(*mock_codec_manager_, UpdateActiveBroadcastAudioHalClient(mock_audio_source_, true))

          .Times(1);

  LeAudioSourceAudioHalClient::Callbacks* audio_receiver;

  EXPECT_CALL(*mock_audio_source_, Start)

          .WillOnce(DoAll(SaveArg<1>(&audio_receiver), Return(true)))

          .WillRepeatedly(Return(false));

  auto broadcast_id = InstantiateBroadcast();



  if (com::android::bluetooth::flags::leaudio_big_depends_on_audio_state()) {

    ASSERT_NE(audio_receiver, nullptr);

    audio_receiver->OnAudioResume();

  } else {

    LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  }



  // NOTICE: This is really an implementation specific part, we fake the BIG

  //         config as the mocked state machine does not even call the
@@ -712,7 +734,6 @@ TEST_F(BroadcasterTest, DestroyAudioBroadcast) { 
  LeAudioBroadcaster::Get()->StopAudioBroadcast(broadcast_id);



  EXPECT_CALL(*mock_audio_source_, Start).Times(0);

  LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);



  EXPECT_CALL(*mock_audio_source_, Stop).Times(0);

  LeAudioBroadcaster::Get()->SuspendAudioBroadcast(broadcast_id);
@@ -846,8 +867,8 @@ TEST_F(BroadcasterTest, UpdateMetadataFromAudioTrackMetadata) { 
  ContentControlIdKeeper::GetInstance()->SetCcid(LeAudioContextType::MEDIA, media_ccid);

  auto broadcast_id = InstantiateBroadcast();



  LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  ASSERT_NE(audio_receiver, nullptr);

  audio_receiver->OnAudioResume();



  auto sm = MockBroadcastStateMachine::GetLastInstance();

  std::vector<uint8_t> ccid_list;
@@ -1204,6 +1225,7 @@ TEST_F(BroadcasterTest, AudioActiveState) { 
          .WillRepeatedly(Return(false));



  auto broadcast_id = InstantiateBroadcast();

  ASSERT_NE(audio_receiver, nullptr);

  auto sm = MockBroadcastStateMachine::GetLastInstance();

  pb_announcement = sm->GetPublicBroadcastAnnouncement();

  auto created_public_meta = types::LeAudioLtvMap(pb_announcement.metadata).RawPacket();
@@ -1218,9 +1240,6 @@ TEST_F(BroadcasterTest, AudioActiveState) { 
                  });

  ON_CALL(*sm, GetPublicBroadcastAnnouncement()).WillByDefault(ReturnRef(pb_announcement));



  LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  ASSERT_NE(audio_receiver, nullptr);



  // Update to true Audio Active State while audio resumed

  EXPECT_CALL(*sm, UpdatePublicBroadcastAnnouncement);

  audio_receiver->OnAudioResume();
@@ -1278,32 +1297,12 @@ TEST_F(BroadcasterTest, BigTerminationAndBroadcastStopWhenNoSoundFromTheBeginnin 
  auto broadcast_id = InstantiateBroadcast();

  EXPECT_CALL(mock_broadcaster_callbacks_,

              OnBroadcastStateChanged(broadcast_id, BroadcastState::STREAMING))

          .Times(1);

          .Times(0);

  // Timers not started

  ASSERT_TRUE(big_terminate_timer_->cb == nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb == nullptr);



  // Start Broadcast

  LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  // Timers started

  ASSERT_EQ(2, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_TRUE(big_terminate_timer_->cb != nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb != nullptr);

  ASSERT_EQ(0, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_NE(audio_receiver, nullptr);



  // BIG termination timer execution, state machine go to CONFIGURED state so BIG terminated

  EXPECT_CALL(mock_broadcaster_callbacks_,

              OnBroadcastStateChanged(broadcast_id, BroadcastState::CONFIGURED))

          .Times(1);

  // Imitate execution of BIG termination timer

  big_terminate_timer_->cb(big_terminate_timer_->data);



  // Broadcast stop timer execution, state machine go to STOPPED state

  EXPECT_CALL(mock_broadcaster_callbacks_,

              OnBroadcastStateChanged(broadcast_id, BroadcastState::STOPPED))

          .Times(1);

  // Imitate execution of BIG termination timer

  broadcast_stop_timer_->cb(broadcast_stop_timer_->data);

}



TEST_F(BroadcasterTest, BigTerminationAndBroadcastStopWhenNoSoundAfterSuspend) {
@@ -1326,24 +1325,11 @@ TEST_F(BroadcasterTest, BigTerminationAndBroadcastStopWhenNoSoundAfterSuspend) { 
  ASSERT_TRUE(broadcast_stop_timer_->cb == nullptr);



  // Start Broadcast

  LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  // Timers started

  ASSERT_EQ(2, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_TRUE(big_terminate_timer_->cb != nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb != nullptr);

  ASSERT_NE(audio_receiver, nullptr);



  // First onAudioResume when BIG already created, not cause any state change

  EXPECT_CALL(mock_broadcaster_callbacks_, OnBroadcastStateChanged(broadcast_id, _)).Times(0);

  audio_receiver->OnAudioResume();

  // Timers cancelled

  ASSERT_EQ(2, get_func_call_count("alarm_cancel"));

  ASSERT_TRUE(big_terminate_timer_->cb == nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb == nullptr);



  // OnAudioSuspend cause starting the BIG termination timer

  audio_receiver->OnAudioSuspend();

  ASSERT_EQ(4, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_EQ(2, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_TRUE(big_terminate_timer_->cb != nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb != nullptr);
@@ -1357,7 +1343,7 @@ TEST_F(BroadcasterTest, BigTerminationAndBroadcastStopWhenNoSoundAfterSuspend) { 


  // OnAudioSuspend cause starting the BIG termination timer

  audio_receiver->OnAudioSuspend();

  ASSERT_EQ(6, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_EQ(4, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_TRUE(big_terminate_timer_->cb != nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb != nullptr);
@@ -1396,24 +1382,11 @@ TEST_F(BroadcasterTest, BigCreationTerminationDependsOnAudioResumeSuspend) { 
  ASSERT_TRUE(broadcast_stop_timer_->cb == nullptr);



  // Start Broadcast

  LeAudioBroadcaster::Get()->StartAudioBroadcast(broadcast_id);

  // Timers started

  ASSERT_EQ(2, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_TRUE(big_terminate_timer_->cb != nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb != nullptr);

  ASSERT_NE(audio_receiver, nullptr);



  // First onAudioResume when BIG already created, not cause any state change

  EXPECT_CALL(mock_broadcaster_callbacks_, OnBroadcastStateChanged(broadcast_id, _)).Times(0);

  audio_receiver->OnAudioResume();

  // Timers cancelled

  ASSERT_EQ(2, get_func_call_count("alarm_cancel"));

  ASSERT_TRUE(big_terminate_timer_->cb == nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb == nullptr);



  // OnAudioSuspend cause starting the BIG termination timer

  audio_receiver->OnAudioSuspend();

  ASSERT_EQ(4, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_EQ(2, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_TRUE(big_terminate_timer_->cb != nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb != nullptr);
@@ -1427,7 +1400,7 @@ TEST_F(BroadcasterTest, BigCreationTerminationDependsOnAudioResumeSuspend) { 


  // OnAudioSuspend cause starting the BIG termination timer

  audio_receiver->OnAudioSuspend();

  ASSERT_EQ(6, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_EQ(4, get_func_call_count("alarm_set_on_mloop"));

  ASSERT_TRUE(big_terminate_timer_->cb != nullptr);

  ASSERT_TRUE(broadcast_stop_timer_->cb != nullptr);

system/bta/le_audio/broadcaster/mock_state_machine.h

+1 −0
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ public: 
    advertising_sid_ = ++instance_counter_;



    ON_CALL(*this, Initialize).WillByDefault([this]() {

      SetState(State::CONFIGURED);

      this->cb->OnStateMachineCreateStatus(this->cfg.broadcast_id, result_);

      return result_;

    });