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

Commit 67f51aca authored by Chris Manton's avatar Chris Manton Committed by Android (Google) Code Review
Browse files

Merge "le_impl: Disarm connectability only when fully ARMED" into tm-qpr-dev

parents e521730c cc749d06

system/gd/hci/acl_manager/le_impl.h

+49 −23
Original line number Diff line number Diff line
@@ -668,28 +668,43 @@ struct le_impl : public bluetooth::hci::LeAddressManagerCallback { 
        address_with_type.ToPeerAddressType(), address_with_type.GetAddress());

  }



  void on_extended_create_connection(CommandStatusView status) {

    ASSERT(status.IsValid());

    ASSERT(status.GetCommandOpCode() == OpCode::LE_EXTENDED_CREATE_CONNECTION);

    if (connectability_state_ != ConnectabilityState::ARMING) {

  void update_connectability_state_after_armed(const ErrorCode& status) {

    switch (connectability_state_) {

      case ConnectabilityState::DISARMED:

      case ConnectabilityState::ARMED:

      case ConnectabilityState::DISARMING:

        LOG_ERROR(

          "Received connectability arm notification for unexpected state:%s",

          connectability_state_machine_text(connectability_state_).c_str());

            "Received connectability arm notification for unexpected state:%s status:%s",

            connectability_state_machine_text(connectability_state_).c_str(),

            ErrorCodeText(status).c_str());

        break;

      case ConnectabilityState::ARMING:

        if (status != ErrorCode::SUCCESS) {

          LOG_ERROR("Le connection state machine armed failed status:%s", ErrorCodeText(status).c_str());

        }

        connectability_state_ =

        (status.GetStatus() == ErrorCode::SUCCESS) ? ConnectabilityState::ARMED : ConnectabilityState::DISARMED;

            (status == ErrorCode::SUCCESS) ? ConnectabilityState::ARMED : ConnectabilityState::DISARMED;

        LOG_INFO(

            "Le connection state machine armed state:%s status:%s",

            connectability_state_machine_text(connectability_state_).c_str(),

            ErrorCodeText(status).c_str());

        if (disarmed_while_arming_) {

          disarmed_while_arming_ = false;

          disarm_connectability();

        }

    }

  }



  void on_extended_create_connection(CommandStatusView status) {

    ASSERT(status.IsValid());

    ASSERT(status.GetCommandOpCode() == OpCode::LE_EXTENDED_CREATE_CONNECTION);

    update_connectability_state_after_armed(status.GetStatus());

  }



  void on_create_connection(CommandStatusView status) {

    ASSERT(status.IsValid());

    ASSERT(status.GetCommandOpCode() == OpCode::LE_CREATE_CONNECTION);

    if (connectability_state_ != ConnectabilityState::ARMING) {

      LOG_ERROR(

          "Received connectability arm notification for unexpected state:%s",

          connectability_state_machine_text(connectability_state_).c_str());

    }

    connectability_state_ =

        (status.GetStatus() == ErrorCode::SUCCESS) ? ConnectabilityState::ARMED : ConnectabilityState::DISARMED;

    update_connectability_state_after_armed(status.GetStatus());

  }



  void arm_connectability() {
@@ -802,16 +817,26 @@ struct le_impl : public bluetooth::hci::LeAddressManagerCallback { 
  }



  void disarm_connectability() {

    if (connectability_state_ != ConnectabilityState::ARMED && connectability_state_ != ConnectabilityState::ARMING) {

      LOG_ERROR(

          "Attempting to disarm le connection state machine in unexpected state:%s",

          connectability_state_machine_text(connectability_state_).c_str());

      return;

    }

    switch (connectability_state_) {

      case ConnectabilityState::ARMED:

        LOG_INFO("Disarming LE connection state machine with create connection cancel");

        connectability_state_ = ConnectabilityState::DISARMING;

        le_acl_connection_interface_->EnqueueCommand(

            LeCreateConnectionCancelBuilder::Create(),

            handler_->BindOnce(&le_impl::on_create_connection_cancel_complete, common::Unretained(this)));

        break;



      case ConnectabilityState::ARMING:

        LOG_INFO("Queueing cancel connect until after connection state machine is armed");

        disarmed_while_arming_ = true;

        break;

      case ConnectabilityState::DISARMING:

      case ConnectabilityState::DISARMED:

        LOG_ERROR(

            "Attempting to disarm le connection state machine in unexpected state:%s",

            connectability_state_machine_text(connectability_state_).c_str());

        break;

    }

  }



  void create_le_connection(AddressWithType address_with_type, bool add_to_connect_list, bool is_direct) {
@@ -1075,6 +1100,7 @@ struct le_impl : public bluetooth::hci::LeAddressManagerCallback { 
  bool address_manager_registered = false;

  bool ready_to_unregister = false;

  bool pause_connection = false;

  bool disarmed_while_arming_ = false;

  ConnectabilityState connectability_state_{ConnectabilityState::DISARMED};

  std::map<AddressWithType, os::Alarm> create_connection_timeout_alarms_;

};

system/gd/hci/acl_manager/le_impl_test.cc

+115 −0
Original line number Diff line number Diff line
@@ -762,6 +762,121 @@ TEST_F(LeImplTest, register_with_address_manager__AddressPolicyNotSet) { 
      std::move(log_capture)));

}



TEST_F(LeImplTest, disarm_connectability_DISARMED) {

  bluetooth::common::InitFlags::SetAllForTesting();

  std::unique_ptr<LogCapture> log_capture = std::make_unique<LogCapture>();



  le_impl_->connectability_state_ = ConnectabilityState::DISARMED;

  le_impl_->disarm_connectability();

  ASSERT_FALSE(le_impl_->disarmed_while_arming_);



  le_impl_->on_create_connection(ReturnCommandStatus(OpCode::LE_CREATE_CONNECTION, ErrorCode::SUCCESS));



  ASSERT_TRUE(log_capture->Rewind()->Find("Attempting to disarm le connection"));

  ASSERT_TRUE(log_capture->Rewind()->Find("in unexpected state:ConnectabilityState::DISARMED"));

}



TEST_F(LeImplTest, disarm_connectability_DISARMED_extended) {

  bluetooth::common::InitFlags::SetAllForTesting();

  std::unique_ptr<LogCapture> log_capture = std::make_unique<LogCapture>();



  le_impl_->connectability_state_ = ConnectabilityState::DISARMED;

  le_impl_->disarm_connectability();

  ASSERT_FALSE(le_impl_->disarmed_while_arming_);



  le_impl_->on_extended_create_connection(

      ReturnCommandStatus(OpCode::LE_EXTENDED_CREATE_CONNECTION, ErrorCode::SUCCESS));



  ASSERT_TRUE(log_capture->Rewind()->Find("Attempting to disarm le connection"));

  ASSERT_TRUE(log_capture->Rewind()->Find("in unexpected state:ConnectabilityState::DISARMED"));

}



TEST_F(LeImplTest, disarm_connectability_ARMING) {

  bluetooth::common::InitFlags::SetAllForTesting();

  std::unique_ptr<LogCapture> log_capture = std::make_unique<LogCapture>();



  le_impl_->connectability_state_ = ConnectabilityState::ARMING;

  le_impl_->disarm_connectability();

  ASSERT_TRUE(le_impl_->disarmed_while_arming_);

  le_impl_->on_create_connection(ReturnCommandStatus(OpCode::LE_CREATE_CONNECTION, ErrorCode::SUCCESS));



  ASSERT_TRUE(log_capture->Rewind()->Find("Queueing cancel connect until"));

  ASSERT_TRUE(log_capture->Rewind()->Find("Le connection state machine armed state"));

}



TEST_F(LeImplTest, disarm_connectability_ARMING_extended) {

  bluetooth::common::InitFlags::SetAllForTesting();

  std::unique_ptr<LogCapture> log_capture = std::make_unique<LogCapture>();



  le_impl_->connectability_state_ = ConnectabilityState::ARMING;

  le_impl_->disarm_connectability();

  ASSERT_TRUE(le_impl_->disarmed_while_arming_);



  le_impl_->on_extended_create_connection(

      ReturnCommandStatus(OpCode::LE_EXTENDED_CREATE_CONNECTION, ErrorCode::SUCCESS));



  ASSERT_TRUE(log_capture->Rewind()->Find("Queueing cancel connect until"));

  ASSERT_TRUE(log_capture->Rewind()->Find("Le connection state machine armed state"));

}



TEST_F(LeImplTest, disarm_connectability_ARMED) {

  bluetooth::common::InitFlags::SetAllForTesting();

  std::unique_ptr<LogCapture> log_capture = std::make_unique<LogCapture>();



  le_impl_->connectability_state_ = ConnectabilityState::ARMED;

  le_impl_->disarm_connectability();

  ASSERT_FALSE(le_impl_->disarmed_while_arming_);



  le_impl_->on_create_connection(ReturnCommandStatus(OpCode::LE_CREATE_CONNECTION, ErrorCode::SUCCESS));



  ASSERT_TRUE(log_capture->Rewind()->Find("Disarming LE connection state machine"));

  ASSERT_TRUE(log_capture->Rewind()->Find("Disarming LE connection state machine with create connection"));

}



TEST_F(LeImplTest, disarm_connectability_ARMED_extended) {

  bluetooth::common::InitFlags::SetAllForTesting();

  std::unique_ptr<LogCapture> log_capture = std::make_unique<LogCapture>();



  le_impl_->connectability_state_ = ConnectabilityState::ARMED;

  le_impl_->disarm_connectability();

  ASSERT_FALSE(le_impl_->disarmed_while_arming_);



  le_impl_->on_extended_create_connection(

      ReturnCommandStatus(OpCode::LE_EXTENDED_CREATE_CONNECTION, ErrorCode::SUCCESS));



  ASSERT_TRUE(log_capture->Rewind()->Find("Disarming LE connection state machine"));

  ASSERT_TRUE(log_capture->Rewind()->Find("Disarming LE connection state machine with create connection"));

}



TEST_F(LeImplTest, disarm_connectability_DISARMING) {

  bluetooth::common::InitFlags::SetAllForTesting();

  std::unique_ptr<LogCapture> log_capture = std::make_unique<LogCapture>();



  le_impl_->connectability_state_ = ConnectabilityState::DISARMING;

  le_impl_->disarm_connectability();

  ASSERT_FALSE(le_impl_->disarmed_while_arming_);



  le_impl_->on_create_connection(ReturnCommandStatus(OpCode::LE_CREATE_CONNECTION, ErrorCode::SUCCESS));



  ASSERT_TRUE(log_capture->Rewind()->Find("Attempting to disarm le connection"));

  ASSERT_TRUE(log_capture->Rewind()->Find("in unexpected state:ConnectabilityState::DISARMING"));

}



TEST_F(LeImplTest, disarm_connectability_DISARMING_extended) {

  bluetooth::common::InitFlags::SetAllForTesting();

  std::unique_ptr<LogCapture> log_capture = std::make_unique<LogCapture>();



  le_impl_->connectability_state_ = ConnectabilityState::DISARMING;

  le_impl_->disarm_connectability();

  ASSERT_FALSE(le_impl_->disarmed_while_arming_);



  le_impl_->on_extended_create_connection(

      ReturnCommandStatus(OpCode::LE_EXTENDED_CREATE_CONNECTION, ErrorCode::SUCCESS));



  ASSERT_TRUE(log_capture->Rewind()->Find("Attempting to disarm le connection"));

  ASSERT_TRUE(log_capture->Rewind()->Find("in unexpected state:ConnectabilityState::DISARMING"));

}



}  // namespace acl_manager

}  // namespace hci

}  // namespace bluetooth