Btukfyl

I tried to use the TBluetoothLE component in a multi-platform application. The code works fine on iOS. Needs some tweaking to work correctly on Android. But I am not able to make it work on Windows.

I looked during debugging at the source code on the Windows platform, and it seems to use the WinRT API. I know that writing (and testing) a generic component that works well on several platforms is not so easy. But I'm wondering if we can use the WinRT directly from the application without using the component provided by Embarcadero.

There are many working examples in C# that I tested on Windows. BluetoothLEExplorer is a very good application that show the use of WinRT to discover and communicate with BLE devices.

Delphi also provides interface files to use WinRT, but there is no sample application showing how to use it.

I would like to investigate a very simple example of calling a function inside a .NET assembly from C++Builder.

In C#, a simple example is to call FromBluetoothAddressAsync to find if a BLE device with a given address is connectable:

C# example in 3 lines of code:

1- create a Watcher to discover BLE devices

BluetoothLEAdvertisementWatcher advWatcher;

// then call its Received method 

advWatcher.Received(some_callback_function_to_be_called_when_the_watcher_detect_adevice);

//the discovered BLE device address is saved in variable uint_t64 deviceAddr by the callback_function

2- get a BluetoothLEDevice object for the device using FromBluetoothAddressAsync():

BluetoothLEDevice dev = BluetoothLEDevice::FromBluetoothAddressAsync(deviceAddr).get(); 

In the .NET assembly Windows.Device.Bluetooth, the signature of the FromBluetoothAddressAsync() function is:

inline Windows::Foundation::IAsyncOperation<Windows::Devices::Bluetooth::BluetoothLEDevice> BluetoothLEDevice::FromBluetoothAddressAsync(uint64_t bluetoothAddress)

Delphi provides interfaces to the BluetoothLEAdvertisementWatcher and BluetoothLEDevice classes, and the Received() and FromBluetoothAddressAsync() methods, inside WinAPI.Devices.Bluetooth.pas.

From the C++Builder side, we have the header files for the definitions. In Winapi.Devices.Bluetooth.Advertisement.hpp we have:

__interface DELPHIINTERFACE IBluetoothLEAdvertisementWatcher;

typedef System::DelphiInterface<IBluetoothLEAdvertisementWatcher> _di_IBluetoothLEAdvertisementWatcher;

and in WinAPI.Devices.Bluetooth.hpp we have:

  class PASCALIMPLEMENTATION TBluetoothDevice : public System::Win::Winrt::TWinRTGenericImportS2__2<_di_IBluetoothDeviceStatics,_di_IBluetoothDeviceStatics2>

{

    typedef System::Win::Winrt::TWinRTGenericImportS2__2<_di_IBluetoothDeviceStatics,_di_IBluetoothDeviceStatics2> inherited;



public:

    ...

    static _di_IAsyncOperation_1__IBluetoothDevice __fastcall FromBluetoothAddressAsync(unsigned __int64 address);



public:

    /* TObject.Create */ inline __fastcall TBluetoothDevice() : System::Win::Winrt::TWinRTGenericImportS2__2<_di_IBluetoothDeviceStatics,_di_IBluetoothDeviceStatics2>() { }

    /* TObject.Destroy */ inline __fastcall virtual ~TBluetoothDevice() { }



};

My question is : how to make instances of .NET objects in C++Builder?

I understand that a statement like:

_di_IBluetoothLEAdvertisementWatcher MyWatacher;

in C++Builder is just a declaration. This means that MyWatcher is a NULL pointer. But how to create an instance of a new (real) BluetoothLEAdvertisementWatcher object before calling its methods?

Update #1

My understanding is that for each invokable class _X in .NET assembly, delphi will generate two definitions: the interface I_X and the object T_X. We can "Create/Allocate" instances of T_X but not of I_X. In C++Builder we get another name for the interface _di_I_X.

Creating the object seems ok :

    TBluetoothLEAdvertisementWatcher *inst =

    new TBluetoothLEAdvertisementWatcher();

    _di_IBluetoothLEAdvertisementWatcher intf;

I tried several approaches to typecast the created T_X to _di_I_X :

//First method :

inst->GetInterface(__uuidof(IBluetoothLEAdvertisementWatcher), (void*)&intf);

//Second method :

intf = interface_cast<TBluetoothLEAdvertisementWatcher>(inst);

//Third method :

bool trans_ok = Supports(inst,__uuidof(IBluetoothLEAdvertisementWatcher),(void*)&intf);     

All of them return a NULL for intf.

I noticed that TBluetoothLEAdvertisementWatcher is declared by :

TBluetoothLEAdvertisementWatcher= class(TWinRTGenericImportFI<IBluetoothLEAdvertisementWatcherFactory, IBluetoothLEAdvertisementWatcher>)

Do you think that "the type casting issue" is related to multiple inheritance in TBluetoothLEAdvertisementWatcher ?

Update #2:

I used delphi to create an instance for me.
I created a unit2.pas with :

unit Unit2;



interface

uses

  System.SysUtils, System.Bluetooth,  Winapi.Devices.Bluetooth.Advertisement;



function CreateADelphiInstance() : IBluetoothLEAdvertisementWatcher;

implementation



  function CreateADelphiInstance() : IBluetoothLEAdvertisementWatcher;

begin

  Result := TBluetoothLEAdvertisementWatcher.Create;

end;

end.

Then in C++ Builder I call it by:

_di_IBluetoothLEAdvertisementWatcher intf = CreateADelphiInstance();

if (intf) 

    intf->ScanningMode = Winapi::Commontypes::BluetoothLEScanningMode::Active;

But I hope being able to do this directly in C++Builder.