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

Commit fc3cde45 authored by Chienyuan Huang's avatar Chienyuan Huang
Browse files

Ignore OnPause/OnResume after unregistered 

Bug: 259185355
Test: gd/cert/run
Tag: #refactor
BYPASS_LONG_LINES_REASON: Bluetooth likes 120 lines

Change-Id: Ib5e05bcaceec5870e4a6fdd55843cbd2ec72aa78
parent b2a8f076

system/gd/hci/acl_manager/le_impl.h

+8 −0
Original line number Diff line number Diff line
@@ -1068,6 +1068,10 @@ struct le_impl : public bluetooth::hci::LeAddressManagerCallback { 
  }



  void OnPause() override {  // bluetooth::hci::LeAddressManagerCallback

    if (!address_manager_registered) {

      LOG_WARN("Unregistered!");

      return;

    }

    pause_connection = true;

    if (connectability_state_ == ConnectabilityState::DISARMED) {

      le_address_manager_->AckPause(this);
@@ -1078,6 +1082,10 @@ struct le_impl : public bluetooth::hci::LeAddressManagerCallback { 
  }



  void OnResume() override {  // bluetooth::hci::LeAddressManagerCallback

    if (!address_manager_registered) {

      LOG_WARN("Unregistered!");

      return;

    }

    pause_connection = false;

    if (arm_on_resume_) {

      arm_connectability();

system/gd/hci/acl_manager/le_impl_test.cc

+12 −0
Original line number Diff line number Diff line
@@ -1403,6 +1403,18 @@ TEST_F(LeImplRegisteredWithAddressManagerTest, clear_resolving_list) { 
  ASSERT_TRUE(hci_layer_->IsPacketQueueEmpty());

}



TEST_F(LeImplRegisteredWithAddressManagerTest, ignore_on_pause_on_resume_after_unregistered) {

  le_impl_->ready_to_unregister = true;

  le_impl_->check_for_unregister();

  // OnPause should be ignored

  le_impl_->OnPause();

  ASSERT_FALSE(le_impl_->pause_connection);

  // OnResume should be ignored

  le_impl_->pause_connection = true;

  le_impl_->OnResume();

  ASSERT_TRUE(le_impl_->pause_connection);

}



TEST_F(LeImplWithConnectionTest, HACK_get_handle) {

  sync_handler();

system/gd/hci/le_address_manager.h

+2 −2
Original line number Diff line number Diff line
@@ -70,8 +70,8 @@ class LeAddressManager { 
      std::chrono::milliseconds minimum_rotation_time,

      std::chrono::milliseconds maximum_rotation_time);

  virtual AddressPolicy GetAddressPolicy();

  void AckPause(LeAddressManagerCallback* callback);

  void AckResume(LeAddressManagerCallback* callback);

  virtual void AckPause(LeAddressManagerCallback* callback);

  virtual void AckResume(LeAddressManagerCallback* callback);

  virtual AddressPolicy Register(LeAddressManagerCallback* callback);

  virtual void Unregister(LeAddressManagerCallback* callback);

  virtual bool UnregisterSync(

system/gd/hci/le_advertising_manager.cc

+8 −0
Original line number Diff line number Diff line
@@ -1034,6 +1034,10 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
  }



  void OnPause() override {

    if (!address_manager_registered) {

      LOG_WARN("Unregistered!");

      return;

    }

    paused = true;

    if (!advertising_sets_.empty()) {

      std::vector<EnabledSet> enabled_sets = {};
@@ -1073,6 +1077,10 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
  }



  void OnResume() override {

    if (!address_manager_registered) {

      LOG_WARN("Unregistered!");

      return;

    }

    paused = false;

    if (!advertising_sets_.empty()) {

      std::vector<EnabledSet> enabled_sets = {};

system/gd/hci/le_advertising_manager_test.cc

+88 −1
Original line number Diff line number Diff line
@@ -240,10 +240,25 @@ class TestLeAddressManager : public LeAddressManager { 
      : LeAddressManager(enqueue_command, handler, public_address, connect_list_size, resolving_list_size) {}



  AddressPolicy Register(LeAddressManagerCallback* callback) override {

    client_ = callback;

    test_client_state_ = RESUMED;

    return AddressPolicy::USE_STATIC_ADDRESS;

  }



  void Unregister(LeAddressManagerCallback* callback) override {}

  void Unregister(LeAddressManagerCallback* callback) override {

    if (!ignore_unregister_for_testing) {

      client_ = nullptr;

    }

    test_client_state_ = UNREGISTERED;

  }



  void AckPause(LeAddressManagerCallback* callback) override {

    test_client_state_ = PAUSED;

  }



  void AckResume(LeAddressManagerCallback* callback) override {

    test_client_state_ = RESUMED;

  }



  AddressPolicy GetAddressPolicy() override {

    return address_policy_;
@@ -268,6 +283,14 @@ class TestLeAddressManager : public LeAddressManager { 
  }



  AddressPolicy address_policy_ = AddressPolicy::USE_STATIC_ADDRESS;

  LeAddressManagerCallback* client_;

  bool ignore_unregister_for_testing = false;

  enum TestClientState {

    UNREGISTERED,

    PAUSED,

    RESUMED,

  };

  TestClientState test_client_state_ = UNREGISTERED;

};



class TestAclManager : public AclManager {
@@ -736,6 +759,70 @@ TEST_F(LeExtendedAdvertisingManagerTest, create_advertiser_test) { 
  ASSERT_EQ(OpCode::LE_REMOVE_ADVERTISING_SET, test_hci_layer_->GetCommand().GetOpCode());

}



TEST_F(LeExtendedAdvertisingManagerTest, ignore_on_pause_on_resume_after_unregistered) {

  TestLeAddressManager* test_le_address_manager = (TestLeAddressManager*)test_acl_manager_->GetLeAddressManager();

  test_le_address_manager->ignore_unregister_for_testing = true;



  // Register LeAddressManager vai ExtendedCreateAdvertiser

  ExtendedAdvertisingConfig advertising_config{};

  advertising_config.advertising_type = AdvertisingType::ADV_IND;

  advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

  std::vector<GapData> gap_data{};

  GapData data_item{};

  data_item.data_type_ = GapDataType::FLAGS;

  data_item.data_ = {0x34};

  gap_data.push_back(data_item);

  data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;

  data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};

  gap_data.push_back(data_item);

  advertising_config.advertisement = gap_data;

  advertising_config.scan_response = gap_data;

  advertising_config.channel_map = 1;

  advertising_config.sid = 0x01;



  test_hci_layer_->SetCommandFuture(4);

  auto id = le_advertising_manager_->ExtendedCreateAdvertiser(

      0x00, advertising_config, scan_callback, set_terminated_callback, 0, 0, client_handler_);

  ASSERT_NE(LeAdvertisingManager::kInvalidId, id);

  EXPECT_CALL(

      mock_advertising_callback_,

      OnAdvertisingSetStarted(0x00, id, -23, AdvertisingCallback::AdvertisingStatus::SUCCESS));

  std::vector<OpCode> adv_opcodes = {

      OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS,

      OpCode::LE_SET_EXTENDED_SCAN_RESPONSE_DATA,

      OpCode::LE_SET_EXTENDED_ADVERTISING_DATA,

      OpCode::LE_SET_EXTENDED_ADVERTISING_ENABLE,

  };

  std::vector<uint8_t> success_vector{static_cast<uint8_t>(ErrorCode::SUCCESS)};

  for (size_t i = 0; i < adv_opcodes.size(); i++) {

    ASSERT_EQ(adv_opcodes[i], test_hci_layer_->GetCommand().GetOpCode());

    if (adv_opcodes[i] == OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS) {

      test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingParametersCompleteBuilder::Create(

          uint8_t{1}, ErrorCode::SUCCESS, static_cast<uint8_t>(-23)));

    } else {

      test_hci_layer_->IncomingEvent(

          CommandCompleteBuilder::Create(uint8_t{1}, adv_opcodes[i], std::make_unique<RawBuilder>(success_vector)));

    }

  }

  sync_client_handler();



  // Unregister LeAddressManager vai RemoveAdvertiser

  test_hci_layer_->SetCommandFuture(3);

  le_advertising_manager_->RemoveAdvertiser(id);

  ASSERT_EQ(OpCode::LE_SET_EXTENDED_ADVERTISING_ENABLE, test_hci_layer_->GetCommand().GetOpCode());

  ASSERT_EQ(OpCode::LE_SET_PERIODIC_ADVERTISING_ENABLE, test_hci_layer_->GetCommand().GetOpCode());

  ASSERT_EQ(OpCode::LE_REMOVE_ADVERTISING_SET, test_hci_layer_->GetCommand().GetOpCode());

  sync_client_handler();



  // Unregistered client should ignore OnPause/OnResume

  ASSERT_NE(test_le_address_manager->client_, nullptr);

  ASSERT_EQ(test_le_address_manager->test_client_state_, TestLeAddressManager::TestClientState::UNREGISTERED);

  test_le_address_manager->client_->OnPause();

  ASSERT_EQ(test_le_address_manager->test_client_state_, TestLeAddressManager::TestClientState::UNREGISTERED);

  test_le_address_manager->client_->OnResume();

  ASSERT_EQ(test_le_address_manager->test_client_state_, TestLeAddressManager::TestClientState::UNREGISTERED);

}



TEST_F(LeAdvertisingAPITest, startup_teardown) {}



TEST_F(LeAndroidHciAdvertisingAPITest, startup_teardown) {}