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

Commit 2cabb2dd authored by Chris Manton's avatar Chris Manton
Browse files

Integrate name module into legacy stack 

Bug: 142570089
Test: Start pairing in Gd mode

Change-Id: Iebbab317ce194e833006a24ce512f671e3e15066
parent f688134e

system/main/shim/btm.cc

+89 −2
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#define LOG_TAG "bt_shim_btm"



#include <algorithm>

#include <cstring>



#include "main/shim/btm.h"

#include "main/shim/entry.h"
@@ -34,12 +35,16 @@ static constexpr uint8_t kInquiryResultMode = 0; 
static constexpr uint8_t kInquiryResultWithRssiMode = 1;

static constexpr uint8_t kExtendedInquiryResultMode = 2;



static constexpr size_t kRemoteDeviceNameLength = 248;



extern void btm_process_cancel_complete(uint8_t status, uint8_t mode);

extern void btm_process_inq_complete(uint8_t status, uint8_t result_type);

extern void btm_process_inq_results(uint8_t* p, uint8_t result_mode);



using BtmRemoteDeviceName = tBTM_REMOTE_DEV_NAME;



/**

 * Inquiry

 *

 */

void bluetooth::shim::Btm::OnInquiryResult(std::vector<const uint8_t> result) {

  CHECK(result.size() < kMaxInquiryResultSize);
@@ -194,7 +199,7 @@ bool bluetooth::shim::Btm::IsLimitedInquiryActive() const { 
}



/**

 * Periodic Inquiry

 * Periodic

 */

bool bluetooth::shim::Btm::StartPeriodicInquiry(

    uint8_t mode, uint8_t duration, uint8_t max_responses, uint16_t max_delay,
@@ -343,3 +348,85 @@ ConnectabilityState bluetooth::shim::Btm::GetLeConnectabilityState() const { 
  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

  return state;

}



bool bluetooth::shim::Btm::IsLeAclConnected(

    const RawAddress& raw_address) const {

  // TODO(cmanton) Check current acl's for this address and indicate if there is

  // an LE option.  For now ignore and default to classic.

  LOG_INFO(LOG_TAG, "%s Le acl connection check is temporarily unsupported",

           __func__);

  return false;

}



bluetooth::shim::BtmStatus bluetooth::shim::Btm::ReadClassicRemoteDeviceName(

    const RawAddress& raw_address, tBTM_CMPL_CB* callback) {

  if (!CheckClassicAclLink(raw_address)) {

    return bluetooth::shim::BTM_UNKNOWN_ADDR;

  }



  if (!classic_read_remote_name_.Start(raw_address)) {

    LOG_INFO(LOG_TAG, "%s Read remote name is currently busy address:%s",

             __func__, raw_address.ToString().c_str());

    return bluetooth::shim::BTM_BUSY;

  }



  LOG_DEBUG(LOG_TAG, "%s Start read name from address:%s", __func__,

            raw_address.ToString().c_str());

  bluetooth::shim::GetName()->ReadRemoteNameRequest(

      classic_read_remote_name_.AddressString(),

      [this, callback](

          std::string address_string, uint8_t hci_status,

          std::array<uint8_t, kRemoteDeviceNameLength> remote_name) {

        RawAddress raw_address;

        RawAddress::FromString(address_string, raw_address);



        BtmRemoteDeviceName name{

            .status = (hci_status == 0) ? (BTM_SUCCESS) : (BTM_BAD_VALUE_RET),

            .bd_addr = raw_address,

            .length = kRemoteDeviceNameLength,

        };

        std::copy(remote_name.begin(), remote_name.end(), name.remote_bd_name);

        LOG_DEBUG(LOG_TAG, "%s Finish read name from address:%s name:%s",

                  __func__, address_string.c_str(), name.remote_bd_name);

        callback(&name);

        classic_read_remote_name_.Stop();

      });

  return bluetooth::shim::BTM_CMD_STARTED;

}



bluetooth::shim::BtmStatus bluetooth::shim::Btm::ReadLeRemoteDeviceName(

    const RawAddress& raw_address, tBTM_CMPL_CB* callback) {

  if (!CheckLeAclLink(raw_address)) {

    return bluetooth::shim::BTM_UNKNOWN_ADDR;

  }



  if (!le_read_remote_name_.Start(raw_address)) {

    return bluetooth::shim::BTM_BUSY;

  }



  LOG_INFO(LOG_TAG, "UNIMPLEMENTED %s need access to GATT module", __func__);

  return bluetooth::shim::BTM_UNKNOWN_ADDR;

}



bluetooth::shim::BtmStatus

bluetooth::shim::Btm::CancelAllReadRemoteDeviceName() {

  if (classic_read_remote_name_.IsInProgress() ||

      le_read_remote_name_.IsInProgress()) {

    if (classic_read_remote_name_.IsInProgress()) {

      bluetooth::shim::GetName()->CancelRemoteNameRequest(

          classic_read_remote_name_.AddressString(),

          [this](std::string address_string, uint8_t status) {

            classic_read_remote_name_.Stop();

          });

    }

    if (le_read_remote_name_.IsInProgress()) {

      LOG_INFO(LOG_TAG, "UNIMPLEMENTED %s need access to GATT module",

               __func__);

    }

    return bluetooth::shim::BTM_UNKNOWN_ADDR;

  }

  LOG_INFO(LOG_TAG,

           "%s Cancelling classic remote device name without one in progress",

           __func__);

  return bluetooth::shim::BTM_WRONG_MODE;

}

system/main/shim/btm.h

+70 −8
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#pragma once



#include <cstdint>

#include <mutex>

#include <unordered_map>

#include <vector>
@@ -62,6 +63,62 @@ using ConnectabilityState = DiscoverabilityState; 
namespace bluetooth {

namespace shim {



using BtmStatus = enum : uint16_t {

  BTM_SUCCESS = 0,         /* 0  Command succeeded                 */

  BTM_CMD_STARTED,         /* 1  Command started OK.               */

  BTM_BUSY,                /* 2  Device busy with another command  */

  BTM_NO_RESOURCES,        /* 3  No resources to issue command     */

  BTM_MODE_UNSUPPORTED,    /* 4  Request for 1 or more unsupported modes */

  BTM_ILLEGAL_VALUE,       /* 5  Illegal parameter value           */

  BTM_WRONG_MODE,          /* 6  Device in wrong mode for request  */

  BTM_UNKNOWN_ADDR,        /* 7  Unknown remote BD address         */

  BTM_DEVICE_TIMEOUT,      /* 8  Device timeout                    */

  BTM_BAD_VALUE_RET,       /* 9  A bad value was received from HCI */

  BTM_ERR_PROCESSING,      /* 10 Generic error                     */

  BTM_NOT_AUTHORIZED,      /* 11 Authorization failed              */

  BTM_DEV_RESET,           /* 12 Device has been reset             */

  BTM_CMD_STORED,          /* 13 request is stored in control block */

  BTM_ILLEGAL_ACTION,      /* 14 state machine gets illegal command */

  BTM_DELAY_CHECK,         /* 15 delay the check on encryption */

  BTM_SCO_BAD_LENGTH,      /* 16 Bad SCO over HCI data length */

  BTM_SUCCESS_NO_SECURITY, /* 17 security passed, no security set  */

  BTM_FAILED_ON_SECURITY,  /* 18 security failed                   */

  BTM_REPEATED_ATTEMPTS,   /* 19 repeated attempts for LE security requests */

  BTM_MODE4_LEVEL4_NOT_SUPPORTED, /* 20 Secure Connections Only Mode can't be

                                     supported */

  BTM_DEV_BLACKLISTED             /* 21 The device is Blacklisted */

};



class ReadRemoteName {

 public:

  bool Start(RawAddress raw_address) {

    std::unique_lock<std::mutex> lock(mutex_);

    if (in_progress_) {

      return false;

    }

    raw_address_ = raw_address;

    in_progress_ = true;

    return true;

  }



  void Stop() {

    std::unique_lock<std::mutex> lock(mutex_);

    raw_address_ = RawAddress::kEmpty;

    in_progress_ = false;

  }



  bool IsInProgress() const { return in_progress_; }



  std::string AddressString() const { return raw_address_.ToString(); }



  ReadRemoteName() : in_progress_{false}, raw_address_(RawAddress::kEmpty) {}



 private:

  bool in_progress_;

  RawAddress raw_address_;

  std::mutex mutex_;

};



class Btm {

 public:

  Btm();
@@ -120,16 +177,21 @@ class Btm { 
  void SetLeConnectibleOff();

  ConnectabilityState GetLeConnectabilityState() const;



 private:

  //  DiscoverabilityState classic_;

  //  DiscoverabilityState le_;

  bool IsLeAclConnected(const RawAddress& raw_address) const;



  //  ConnectabilityState classic_connectibility_state_;

  //  ConnectabilityState le_connectibility_state_;

  // Remote device name

  BtmStatus ReadClassicRemoteDeviceName(const RawAddress& raw_address,

                                        tBTM_CMPL_CB* callback);

  BtmStatus ReadLeRemoteDeviceName(const RawAddress& raw_address,

                                   tBTM_CMPL_CB* callback);

  BtmStatus CancelAllReadRemoteDeviceName();



  //  bool DoSetEventFilter();

  //  void DoSetDiscoverability();

  //  bool DoSetInquiryMode();

 private:

  ReadRemoteName le_read_remote_name_;

  ReadRemoteName classic_read_remote_name_;

  // TODO(cmanton) abort if there is no classic acl link up

  bool CheckClassicAclLink(const RawAddress& raw_address) { return true; }

  bool CheckLeAclLink(const RawAddress& raw_address) { return true; }

};



}  // namespace shim

system/main/shim/btm_api.cc

+19 −13
Original line number Diff line number Diff line
@@ -493,15 +493,23 @@ tBTM_STATUS bluetooth::shim::BTM_CancelInquiry(void) { 
 *

 ******************************************************************************/

tBTM_STATUS bluetooth::shim::BTM_ReadRemoteDeviceName(

    const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb, tBT_TRANSPORT transport) {

  if (transport == BT_TRANSPORT_LE) {

    LOG_INFO(LOG_TAG, "UNIMPLEMENTED %s", __func__);

    return BTM_NO_RESOURCES;

    const RawAddress& raw_address, tBTM_CMPL_CB* callback,

    tBT_TRANSPORT transport) {

  CHECK(callback != nullptr);

  tBTM_STATUS status = BTM_NO_RESOURCES;



  switch (transport) {

    case BT_TRANSPORT_LE:

      status = shim_btm.ReadLeRemoteDeviceName(raw_address, callback);

      break;

    case BT_TRANSPORT_BR_EDR:

      status = shim_btm.ReadClassicRemoteDeviceName(raw_address, callback);

      break;

    default:

      LOG_WARN(LOG_TAG, "%s Unspecified transport:%d", __func__, transport);

      break;

  }



  LOG_INFO(LOG_TAG, "UNIMPLEMENTED %s", __func__);

  return BTM_NO_RESOURCES;

  CHECK(p_cb != nullptr);

  return status;

}



/*******************************************************************************
@@ -523,8 +531,7 @@ tBTM_STATUS bluetooth::shim::BTM_ReadRemoteDeviceName( 
 *

 ******************************************************************************/

tBTM_STATUS bluetooth::shim::BTM_CancelRemoteDeviceName(void) {

  LOG_INFO(LOG_TAG, "UNIMPLEMENTED %s", __func__);

  return BTM_NO_RESOURCES;

  return shim_btm.CancelAllReadRemoteDeviceName();

}



/*******************************************************************************
@@ -1155,9 +1162,8 @@ void bluetooth::shim::BTM_BleTestEnd(tBTM_CMPL_CB* p_cmd_cmpl_cback) { 
 * Returns          true to use LE, false use BR/EDR.

 *

 ******************************************************************************/

bool bluetooth::shim::BTM_UseLeLink(const RawAddress& bd_addr) {

  LOG_INFO(LOG_TAG, "UNIMPLEMENTED %s", __func__);

  return false;

bool bluetooth::shim::BTM_UseLeLink(const RawAddress& raw_address) {

  return shim_btm.IsLeAclConnected(raw_address);

}



/*******************************************************************************

system/main/shim/entry.cc

+4 −0
Original line number Diff line number Diff line
@@ -54,6 +54,10 @@ bluetooth::shim::IL2cap* bluetooth::shim::GetL2cap() { 
  return GetGabeldorscheStack()->GetL2cap();

}



bluetooth::shim::IName* bluetooth::shim::GetName() {

  return GetGabeldorscheStack()->GetName();

}



bluetooth::shim::IPage* bluetooth::shim::GetPage() {

  return GetGabeldorscheStack()->GetPage();

}

system/main/shim/entry.h

+1 −0
Original line number Diff line number Diff line
@@ -44,6 +44,7 @@ bluetooth::shim::IConnectability* GetConnectability(); 
bluetooth::shim::IInquiry* GetInquiry();

bluetooth::shim::IHciLayer* GetHciLayer();

bluetooth::shim::IL2cap* GetL2cap();

bluetooth::shim::IName* GetName();

bluetooth::shim::IPage* GetPage();



}  // namespace shim