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

Commit 13493a49 authored by Henri Chataing's avatar Henri Chataing
Browse files

system/gd: Remove unused RPC endpoints from neighbor facade 

Bug: 333555245
Test: m com.android.btservices
Flag: EXEMPT, dead code removal
Change-Id: I71623f708b41034493425bdec114c14219ca802c
parent a36742b8

system/blueberry/facade/neighbor/facade.proto

+0 −48
Original line number Diff line number Diff line
@@ -5,57 +5,9 @@ package blueberry.facade.neighbor; 
import "google/protobuf/empty.proto";



service NeighborFacade {

  rpc SetConnectability(EnableMsg) returns (google.protobuf.Empty) {}

  rpc SetDiscoverability(DiscoverabilitiyMsg) returns (google.protobuf.Empty) {}

  rpc SetInquiryMode(InquiryMsg) returns (stream InquiryResultMsg) {

    // Sets inquiry mode and fetches inquiry result HCI packet

  }

  rpc ReadRemoteName(RemoteNameRequestMsg) returns (google.protobuf.Empty) {}

  rpc GetRemoteNameEvents(google.protobuf.Empty) returns (stream RemoteNameResponseMsg) {}

  // TODO: Should we use a blocking call for ReadRemoteName instead? (Note: blocking model may not work for GD stack)

  rpc EnableInquiryScan(EnableMsg) returns (google.protobuf.Empty) {}

  rpc EnablePageScan(EnableMsg) returns (google.protobuf.Empty) {}

}



message EnableMsg {

  bool enabled = 1;

}
 


enum DiscoverabilityMode {

  OFF = 0;

  LIMITED = 1;

  GENERAL = 2;

}



message DiscoverabilitiyMsg {

  DiscoverabilityMode mode = 1;

}



enum ResultMode {

  STANDARD = 0;

  RSSI = 1;

  EXTENDED = 2;

}



message InquiryMsg {

  DiscoverabilityMode inquiry_mode = 1;

  ResultMode result_mode = 2;

  uint32 length_1_28s = 3;

  uint32 max_results = 4;  // 0 is unlimited

}



message InquiryResultMsg {

  bytes packet = 1;

}



message RemoteNameRequestMsg {

  bytes address = 1;

  uint32 page_scan_repetition_mode = 2;  // r0, r1, r2

  uint32 clock_offset = 3;

}



message RemoteNameResponseMsg {

  uint32 status = 1;

  bytes address = 2;

  bytes name = 3;

}

system/gd/neighbor/facade/facade.cc

+5 −165
Original line number Diff line number Diff line
@@ -39,141 +39,13 @@ using namespace blueberry::facade::neighbor; 
class NeighborFacadeService : public NeighborFacade::Service {

 public:

  NeighborFacadeService(

      DiscoverabilityModule* discoverability_module,

      InquiryModule* inquiry_module,

      hci::RemoteNameRequestModule* name_module,

      DiscoverabilityModule*,

      InquiryModule*,

      hci::RemoteNameRequestModule*,

      PageModule*,

      ScanModule* scan_module,

      ::bluetooth::os::Handler* facade_handler)

      : discoverability_module_(discoverability_module),

        inquiry_module_(inquiry_module),

        name_module_(name_module),

        scan_module_(scan_module),

        facade_handler_(facade_handler) {}



  ::grpc::Status SetConnectability(

      ::grpc::ServerContext* /* context */,

      const EnableMsg* request,

      ::google::protobuf::Empty* /* response */) override {

    if (request->enabled()) {

      scan_module_->SetPageScan();

    } else {

      scan_module_->ClearPageScan();

    }

    return ::grpc::Status::OK;

  }



  ::grpc::Status SetDiscoverability(

      ::grpc::ServerContext* /* context */,

      const DiscoverabilitiyMsg* request,

      ::google::protobuf::Empty* /* response */) override {

    switch (request->mode()) {

      case DiscoverabilityMode::OFF:

        discoverability_module_->StopDiscoverability();

        break;

      case DiscoverabilityMode::LIMITED:

        discoverability_module_->StartLimitedDiscoverability();

        break;

      case DiscoverabilityMode::GENERAL:

        discoverability_module_->StartGeneralDiscoverability();

        break;

      default:

        log::fatal("Unknown discoverability mode {}", static_cast<int>(request->mode()));

    }

    return ::grpc::Status::OK;

  }



  ::grpc::Status SetInquiryMode(

      ::grpc::ServerContext* context,

      const InquiryMsg* request,

      ::grpc::ServerWriter<InquiryResultMsg>* writer) override {

    inquiry_module_->RegisterCallbacks(inquiry_callbacks_);

    switch (request->result_mode()) {

      case ResultMode::STANDARD:

        inquiry_module_->SetStandardInquiryResultMode();

        break;

      case ResultMode::RSSI:

        inquiry_module_->SetInquiryWithRssiResultMode();

        break;

      case ResultMode::EXTENDED:

        inquiry_module_->SetExtendedInquiryResultMode();

        break;

      default:

        log::fatal("Unknown result mode {}", static_cast<int>(request->result_mode()));

    }

    switch (request->inquiry_mode()) {

      case DiscoverabilityMode::OFF:

        inquiry_module_->StopInquiry();

        break;

      case DiscoverabilityMode::LIMITED:

        inquiry_module_->StartLimitedInquiry(request->length_1_28s(), request->max_results());

        break;

      case DiscoverabilityMode::GENERAL:

        inquiry_module_->StartGeneralInquiry(request->length_1_28s(), request->max_results());

        break;

      default:

        log::fatal("Unknown discoverability mode {}", static_cast<int>(request->inquiry_mode()));

    }

    return pending_events_.RunLoop(context, writer);

  }



  ::grpc::Status ReadRemoteName(

      ::grpc::ServerContext* /* context */,

      const RemoteNameRequestMsg* request,

      ::google::protobuf::Empty* /* response */) override {

    hci::Address remote;

    log::assert_that(

        hci::Address::FromString(request->address(), remote),

        "assert failed: hci::Address::FromString(request->address(), remote)");

    hci::PageScanRepetitionMode mode;

    switch (request->page_scan_repetition_mode()) {

      case 0:

        mode = hci::PageScanRepetitionMode::R0;

        break;

      case 1:

        mode = hci::PageScanRepetitionMode::R1;

        break;

      case 2:

        mode = hci::PageScanRepetitionMode::R2;

        break;

      default:

        log::fatal(

            "Unknown PageScanRepetition mode {}",

            static_cast<int>(request->page_scan_repetition_mode()));

        std::abort();

    }

    name_module_->StartRemoteNameRequest(

        remote,

        hci::RemoteNameRequestBuilder::Create(

            remote,

            mode,

            request->clock_offset(),

            request->clock_offset() != 0 ? hci::ClockOffsetValid::VALID

                                         : hci::ClockOffsetValid::INVALID),

        facade_handler_->BindOnce([](hci::ErrorCode /* status */) { /* ignore */ }),

        facade_handler_->BindOnce([](uint64_t /* features */) { /* ignore */ }),

        facade_handler_->BindOnceOn(this, &NeighborFacadeService::on_remote_name, remote));

    return ::grpc::Status::OK;

  }



  ::grpc::Status GetRemoteNameEvents(

      ::grpc::ServerContext* context,

      const ::google::protobuf::Empty* /* request */,

      ::grpc::ServerWriter<RemoteNameResponseMsg>* writer) override {

    return pending_remote_names_.RunLoop(context, writer);

  }



  ::grpc::Status EnableInquiryScan(

      ::grpc::ServerContext* /* context */,

      const EnableMsg* request,

      ::google::protobuf::Empty* /* response */) override {

    if (request->enabled()) {

      scan_module_->SetInquiryScan();

    } else {

      scan_module_->ClearInquiryScan();

    }

    return ::grpc::Status::OK;

  }

      ::bluetooth::os::Handler*)

      : scan_module_(scan_module) {}



  ::grpc::Status EnablePageScan(

      ::grpc::ServerContext* /* context */,
@@ -188,39 +60,7 @@ class NeighborFacadeService : public NeighborFacade::Service { 
  }



 private:

  void on_incoming_inquiry_result(hci::EventView view) {

    InquiryResultMsg inquiry_result_msg;

    inquiry_result_msg.set_packet(std::string(view.begin(), view.end()));

    pending_events_.OnIncomingEvent(std::move(inquiry_result_msg));

  }



  void on_incoming_inquiry_complete(hci::ErrorCode status) {

    InquiryResultMsg inquiry_result_msg;

    inquiry_result_msg.set_packet(hci::ErrorCodeText(status));

    pending_events_.OnIncomingEvent(std::move(inquiry_result_msg));

  }



  InquiryCallbacks inquiry_callbacks_{

      .result = [this](hci::InquiryResultView view) { on_incoming_inquiry_result(view); },

      .result_with_rssi = [this](hci::InquiryResultWithRssiView view) { on_incoming_inquiry_result(view); },

      .extended_result = [this](hci::ExtendedInquiryResultView view) { on_incoming_inquiry_result(view); },

      .complete = [this](hci::ErrorCode status) { on_incoming_inquiry_complete(status); }};



  void on_remote_name(hci::Address address, hci::ErrorCode status, std::array<uint8_t, 248> name) {

    RemoteNameResponseMsg response;

    response.set_status(static_cast<int>(status));

    response.set_address(address.ToString());

    response.set_name(name.begin(), name.size());

    pending_remote_names_.OnIncomingEvent(response);

  }



  DiscoverabilityModule* discoverability_module_;

  InquiryModule* inquiry_module_;

  hci::RemoteNameRequestModule* name_module_;

  ScanModule* scan_module_;

  ::bluetooth::os::Handler* facade_handler_;

  ::bluetooth::grpc::GrpcEventQueue<InquiryResultMsg> pending_events_{"InquiryResponses"};

  ::bluetooth::grpc::GrpcEventQueue<RemoteNameResponseMsg> pending_remote_names_{"RemoteNameResponses"};

};



void NeighborFacadeModule::ListDependencies(ModuleList* list) const {