How to send a GATT indicate to a connected central device?

[lynnbgm]

I have a question about sending a GATT Indicate Characteristic from a peripheral device to a connected central device. I have programmed the peripheral device using Bluez 5.63 and sdbus-cpp, and I am able to successfully advertise and connect to the central device. However, I need to send different values back to the central device based on the values it writes to us. I have reviewed the documentation, but I am unsure how to implement this functionality. I believe I need to connect to the D-Bus, create a D-Bus message to send the signal, and make API calls to set the GATT Indicate Characteristic value and send it. Can you help me identify the appropriate functions to achieve this?

Here is the pseudocode of how I defined the GATT Service GATT Characteristics and LEADvertiser in case it helps:

constexpr char BLUEZ_SERVICE[] = "org.bluez";
// GATT interface
constexpr char GATT_MANAGER_IFACE[] = "org.bluez.GattManager1";
// adapter control
constexpr char ADAPTER_IFACE[] = "org.bluez.Adapter1";
// device control
constexpr char DEVICE_IFACE[] = "org.bluez.Device1";

class LEAdvertiser : public sdbus::Adaptor_Interfaces<org::bluez::LEAdvertisement1_adaptor>
{
    public:
        // sdbus::IConnection create system bus connection
        LEAdvertiser(sdbus::IConnection &connection, std::string objPath, const std::string &name)
            : Adaptor_Interfaces(connection, std::move(objPath)), lName(name)
        {
            registerAdaptor();
        }

        ~LEAdvertiser()
        {
            unregisterAdaptor();
        }
        virtual void LocalName(const std::string& value) { lName = value; }

    private:
        // TODO: find out if we need to do anything for release
        virtual void Release() {}

        // Getter's for peripheral properties
        virtual std::string Type() { return "peripheral"; }
        virtual std::vector<std::string> ServiceUUIDs() 
        { 
            return 
            {
                //Provision Characteristics
                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXxx",
            };
        }

        virtual std::map<uint16_t, sdbus::Variant> ManufacturerData()
        {
            std::vector<uint8_t> id = {'i', 'i', 'i'};
            return 
            {
                {BLUETOOTH_IDENTIFIER, id}
            };
        }

        virtual std::vector<std::string> SolicitUUIDs() { return {}; }
        virtual std::map<std::string, sdbus::Variant> ServiceData(){}
        virtual std::map<std::string, sdbus::Variant> Data() { return {}; }
        virtual bool Discoverable() { return true; }
        virtual uint16_t DiscoverableTimeout() { return 0; }
        virtual std::vector<std::string> Includes() { return {}; }
        virtual std::string LocalName() { return lName; }
        virtual uint16_t Appearance() { return 0xFFFF; }
        virtual uint16_t Duration() { return 0; }
        virtual uint16_t Timeout() { return 0; }

        virtual uint32_t MinInterval() { return MIN_INTERVAL; }
        virtual uint32_t MaxInterval() { return MAX_INTERVAL; }

        std::string lName = "Cumberlands";
};

class GATT_Application : public sdbus::Adaptor_Interfaces<sdbus::ObjectManager_adaptor> {
public:
    GATT_Application(sdbus::IConnection &connection, std::string objPath)
        : Adaptor_Interfaces(connection, std::move(objPath)) {
        registerAdaptor();
    }

    ~GATT_Application() {
        unregisterAdaptor();
    }
    sdbus::IConnection &getConnection() const { return getObject().getConnection(); };

private:
};

class GATT_Service : public sdbus::Adaptor_Interfaces<org::bluez::GattService1_adaptor> {
private:
    std::string uuid;
    bool primary;

    virtual std::string UUID() { return uuid; }
    virtual bool Primary() { return primary; }

public:
    GATT_Service(const GATT_Application &app, unsigned index, std::string uuid, bool primary = true)
        : Adaptor_Interfaces(app.getConnection(), app.getObjectPath() + "/service" + std::to_string(index)),
          uuid(std::move(uuid)),
          primary(primary) {
        registerAdaptor();
    }

    ~GATT_Service() {
        unregisterAdaptor();
    }
    sdbus::IConnection &getConnection() const { return getObject().getConnection(); };
};

class GATT_Characteristic_RW : public sdbus::Adaptor_Interfaces<org::bluez::Gatt_Characteristic_Uint8, sdbus::Properties_adaptor> {
public:
    GATT_Characteristic_Write(const GATT_Service &service, unsigned index, std::string uuid, std::vector<uint8_t> value)
        : Adaptor_Interfaces(service.getConnection(), service.getObjectPath() + "/char" + std::to_string(index)),
          service(std::move(service.getObjectPath())),
          uuid(std::move(uuid)),
          value(std::move(value)) {
        registerAdaptor();
    }

    ~GATT_Characteristic_Write() {
        unregisterAdaptor();
    }

    std::string vec_to_string(std::vector<uint8_t> v){
        std::string s;
        for(uint8_t c:v){
                s += static_cast<char>(c);
        }

        return s;
    }

private:
    std::string service;
    std::string uuid;
    virtual std::vector<uint8_t> ReadValue(const std::map<std::string, sdbus::Variant> &options) { 
        std::cout << "GATT RW read value: " << vec_to_string(value) << std::endl;
    };
    virtual void WriteValue(const std::vector<uint8_t> &value, const std::map<std::string, sdbus::Variant> &options){
        std::cout << "GATT RW write value: " << vec_to_string(value) << std::endl;
    };

    virtual void StartNotify(){};
    virtual void StopNotify(){};

    virtual sdbus::ObjectPath Service() { return service; }
    virtual std::string UUID() { return uuid; }
    virtual std::vector<uint8_t> Value() { return value; }
    virtual std::vector<std::string> Flags() { return std::vector<std::string>{"read", "write"}; }

protected:
    std::vector<uint8_t> value;
};

class GATT_Characteristic_RI_Uint8 : public sdbus::Adaptor_Interfaces<org::bluez::Gatt_Characteristic_Uint8, sdbus::Properties_adaptor> {
public:
    GATT_Characteristic_RI_Uint8(const GATT_Service &service, unsigned index, std::string uuid, std::vector<uint8_t> value)
        : Adaptor_Interfaces(service.getConnection(), service.getObjectPath() + "/char" + std::to_string(index)),
          service(std::move(service.getObjectPath())),
          uuid(std::move(uuid)),
          value(std::move(value)) {
        registerAdaptor();
    }

    ~GATT_Characteristic_RI_Uint8() {
        unregisterAdaptor();
    }

    std::string vec_to_string(std::vector<uint8_t> v){
        std::string s;
        for(uint8_t c:v){
                s += static_cast<char>(c);
        }

        return s;
    }


private:
    std::string service;
    std::string uuid;
    virtual std::vector<uint8_t> ReadValue(const std::map<std::string, sdbus::Variant> &options) { 
        std::cout << "GATT RI Uint8 read value: " << vec_to_string(value) << std::endl;    
    };
    virtual void WriteValue(const std::vector<uint8_t> &value, const std::map<std::string, sdbus::Variant> &options){};

    virtual void StartNotify(){};
    virtual void StopNotify(){};

    virtual sdbus::ObjectPath Service() { return service; }
    virtual std::string UUID() { return uuid; }
    virtual std::vector<uint8_t> Value() { return value; }
    virtual std::vector<std::string> Flags() { return std::vector<std::string>{"indicate", "read"}; }

protected:
    std::vector<uint8_t> value;
};

int main() {
    std::vector<uint8_t> ssid_char;
    std::vector<uint8_t> bssid_char;
    std::vector<uint8_t> password;
    std::vector<uint8_t> wifi_status;

    //Initializing D-Bus connection
    auto connection = sdbus::createSystemBusConnection();
    connection->enterEventLoopAsync();

    // Create an unnamed D-Bus connection to the system bus
    sdbus::ObjectPath adapter = find_adapter(*connection);

    // Get adapter
    auto adapterProxy = BluezProxy(*connection, adapter);

    // Power up adapter
    adapterProxy.Set(ADAPTER_IFACE, "Powered", (bool)true);

    // Set advertising application object, services, and service characteristics
    const char *applicationPath = "/com/blue/Cumberlands";
    GATT_Application application(*connection, applicationPath);
    GATT_Service provisioningService(application, 0, "XXXXXXXXXXXXXXXXXXX");
    GATT_Characteristic_RW ssid(provisioningService, 0, "XXXXXXXXXXXXXXXXXXX", ssid_char);
    GATT_Characteristic_RW bssid(provisioningService, 1, "XXXXXXXXXXXXXXXXXXX", bssid_char);
    GATT_Characteristic_RI_Uint8 wifi_status(provisioningService, 2, "XXXXXXXXXXXXXXXXXXX", wifi_status);

    // Register application object
    adapterProxy.RegisterApplication(applicationPath, {});

    char name[] = "peripheral";

    // Initialize advertisement but do not register it
    const char *advertisementPath = "/com/blue/Cumberlands/advertisement";
    LEAdvertiser advertisement(*connection, advertisementPath, name);

    // Register advertisement
    adapterProxy.RegisterAdvertisement(advertisementPath, {});

    // Here is where I plan to check for the GATT Writes from the central and send the indicate value
}
` 

[snailmail777]

Hello @lynnbgm did you figure out how to get this working?

your implementation above, does it successfully advertise packets?