src/controller/python/chip/ble/LinuxImpl.cpp

   1
   2 #include <platform/CHIPDeviceLayer.h>
   3 #include <platform/Linux/bluez/AdapterIterator.h>
   4 #include <platform/Linux/bluez/MainLoop.h>
   5 #include <platform/internal/BLEManager.h>
   6 #include <support/CHIPMem.h>
   7
   8 using namespace chip::DeviceLayer::Internal;
   9
  10 /////////// Listing adapters implementation //////////
  11
  12 extern "C" void * pychip_ble_adapter_list_new()
  13 {
  14     return static_cast<void *>(new AdapterIterator());
  15 }
  16
  17 extern "C" void pychip_ble_adapter_list_delete(void * adapterIterator)
  18 {
  19     delete static_cast<AdapterIterator *>(adapterIterator);
  20 }
  21
  22 extern "C" bool pychip_ble_adapter_list_next(void * adapterIterator)
  23 {
  24     return static_cast<AdapterIterator *>(adapterIterator)->Next();
  25 }
  26
  27 extern "C" uint32_t pychip_ble_adapter_list_get_index(void * adapterIterator)
  28 {
  29     return static_cast<AdapterIterator *>(adapterIterator)->GetIndex();
  30 }
  31
  32 extern "C" const char * pychip_ble_adapter_list_get_address(void * adapterIterator)
  33 {
  34     return static_cast<AdapterIterator *>(adapterIterator)->GetAddress();
  35 }
  36
  37 extern "C" const char * pychip_ble_adapter_list_get_alias(void * adapterIterator)
  38 {
  39     return static_cast<AdapterIterator *>(adapterIterator)->GetAlias();
  40 }
  41
  42 extern "C" const char * pychip_ble_adapter_list_get_name(void * adapterIterator)
  43 {
  44     return static_cast<AdapterIterator *>(adapterIterator)->GetName();
  45 }
  46
  47 extern "C" bool pychip_ble_adapter_list_is_powered(void * adapterIterator)
  48 {
  49     return static_cast<AdapterIterator *>(adapterIterator)->IsPowered();
  50 }
  51
  52 extern "C" void * pychip_ble_adapter_list_get_raw_adapter(void * adapterIterator)
  53 {
  54     return static_cast<AdapterIterator *>(adapterIterator)->GetAdapter();
  55 }
  56
  57 /////////// CHIP Device scanner implementation //////////
  58
  59 namespace {
  60
  61 // To avoid pythoon compatibility issues on inc/dec references,
  62 // code assumes an abstract type and leaves it up to python to keep track of
  63 // reference counts
  64 struct PyObject;
  65
  66 class ScannerDelegateImpl : public ChipDeviceScannerDelegate
  67 {
  68 public:
  69     using DeviceScannedCallback = void (*)(PyObject * context, const char * address, uint16_t discriminator, uint16_t vendorId,
  70                                            uint16_t productId);
  71     using ScanCompleteCallback  = void (*)(PyObject * context);
  72
  73     ScannerDelegateImpl(PyObject * context, DeviceScannedCallback scanCallback, ScanCompleteCallback completeCallback) :
  74         mContext(context), mScanCallback(scanCallback), mCompleteCallback(completeCallback)
  75     {}
  76
  77     void SetScanner(std::unique_ptr<ChipDeviceScanner> scanner) { mScanner = std::move(scanner); }
  78
  79     void OnDeviceScanned(BluezDevice1 * device, const chip::Ble::ChipBLEDeviceIdentificationInfo & info) override
  80     {
  81         if (mScanCallback)
  82         {
  83             mScanCallback(mContext, bluez_device1_get_address(device), info.GetDeviceDiscriminator(), info.GetProductId(),
  84                           info.GetVendorId());
  85         }
  86     }
  87
  88     void OnScanComplete() override
  89     {
  90         if (mCompleteCallback)
  91         {
  92             mCompleteCallback(mContext);
  93         }
  94
  95         delete this;
  96     }
  97
  98 private:
  99     std::unique_ptr<ChipDeviceScanner> mScanner;
 100     PyObject * const mContext;
 101     const DeviceScannedCallback mScanCallback;
 102     const ScanCompleteCallback mCompleteCallback;
 103 };
 104
 105 } // namespace
 106
 107 extern "C" void * pychip_ble_start_scanning(PyObject * context, void * adapter, uint32_t timeout,
 108                                             ScannerDelegateImpl::DeviceScannedCallback scanCallback,
 109                                             ScannerDelegateImpl::ScanCompleteCallback completeCallback)
 110 {
 111     std::unique_ptr<ScannerDelegateImpl> delegate = std::make_unique<ScannerDelegateImpl>(context, scanCallback, completeCallback);
 112
 113     std::unique_ptr<ChipDeviceScanner> scanner = ChipDeviceScanner::Create(static_cast<BluezAdapter1 *>(adapter), delegate.get());
 114
 115     if (!scanner)
 116     {
 117         return nullptr;
 118     }
 119
 120     if (scanner->StartScan(timeout) != CHIP_NO_ERROR)
 121     {
 122         return nullptr;
 123     }
 124
 125     delegate->SetScanner(std::move(scanner));
 126
 127     return delegate.release();
 128 }