astarte_device.h

Go to the documentation of this file.

/*
 * (C) Copyright 2018-2023, SECO Mind Srl
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later OR Apache-2.0
 */
 
#ifndef _ASTARTE_DEVICE_H_
#define _ASTARTE_DEVICE_H_
 
#include "astarte.h"
 
#include "astarte_bson_deserializer.h"
#include "astarte_interface.h"
 
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
 
#define ASTARTE_INVALID_TIMESTAMP 0
 
typedef struct astarte_device *astarte_device_handle_t;
 
typedef struct
{
    astarte_device_handle_t device;
    const char *interface_name;
    const char *path;
    const void *bson_value __attribute__((
        deprecated("Please use bson_element with the functions from astarte_bson_deserializer.h")));
    int bson_value_type __attribute__((
        deprecated("Please use bson_element with the functions from astarte_bson_deserializer.h")));
    astarte_bson_element_t bson_element;
} astarte_device_data_event_t;
 
typedef struct
{
    astarte_device_handle_t device;
    const char *interface_name;
    const char *path;
} astarte_device_unset_event_t;
 
typedef void (*astarte_device_data_event_callback_t)(astarte_device_data_event_t *event);
 
typedef struct
{
    astarte_device_handle_t device;
    int session_present;
} astarte_device_connection_event_t;
 
typedef void (*astarte_device_connection_event_callback_t)(
    astarte_device_connection_event_t *event);
 
typedef struct
{
    astarte_device_handle_t device;
    int session_present;
} astarte_device_disconnection_event_t;
 
typedef void (*astarte_device_disconnection_event_callback_t)(
    astarte_device_disconnection_event_t *event);
 
typedef void (*astarte_device_unset_event_callback_t)(astarte_device_unset_event_t *event);
 
typedef struct
{
    astarte_device_data_event_callback_t data_event_callback;
    astarte_device_unset_event_callback_t unset_event_callback;
    astarte_device_connection_event_callback_t connection_event_callback;
    astarte_device_disconnection_event_callback_t disconnection_event_callback;
    const char *hwid;
    const char *credentials_secret;
    const char *realm;
} astarte_device_config_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
astarte_device_handle_t astarte_device_init(astarte_device_config_t *cfg);
 
void astarte_device_destroy(astarte_device_handle_t device);
 
astarte_err_t astarte_device_add_interface(
    astarte_device_handle_t device, const astarte_interface_t *interface);
 
astarte_err_t astarte_device_start(astarte_device_handle_t device);
 
astarte_err_t astarte_device_stop(astarte_device_handle_t device);
 
astarte_err_t astarte_device_stream_double(astarte_device_handle_t device,
    const char *interface_name, const char *path, double value, int qos);
 
astarte_err_t astarte_device_stream_double_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, double value, uint64_t ts_epoch_millis, int qos);
 
astarte_err_t astarte_device_stream_integer(astarte_device_handle_t device,
    const char *interface_name, const char *path, int32_t value, int qos);
 
astarte_err_t astarte_device_stream_integer_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, int32_t value, uint64_t ts_epoch_millis, int qos);
 
astarte_err_t astarte_device_stream_longinteger(astarte_device_handle_t device,
    const char *interface_name, const char *path, int64_t value, int qos);
 
astarte_err_t astarte_device_stream_longinteger_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, int64_t value, uint64_t ts_epoch_millis, int qos);
 
astarte_err_t astarte_device_stream_boolean(astarte_device_handle_t device,
    const char *interface_name, const char *path, bool value, int qos);
 
astarte_err_t astarte_device_stream_boolean_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, bool value, uint64_t ts_epoch_millis, int qos);
 
astarte_err_t astarte_device_stream_string(astarte_device_handle_t device,
    const char *interface_name, const char *path, const char *value, int qos);
 
astarte_err_t astarte_device_stream_string_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, const char *value, uint64_t ts_epoch_millis,
    int qos);
 
astarte_err_t astarte_device_stream_binaryblob(astarte_device_handle_t device,
    const char *interface_name, const char *path, void *value, size_t size, int qos);
 
astarte_err_t astarte_device_stream_binaryblob_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, void *value, size_t size,
    uint64_t ts_epoch_millis, int qos);
 
astarte_err_t astarte_device_stream_datetime(astarte_device_handle_t device,
    const char *interface_name, const char *path, int64_t value, int qos);
 
astarte_err_t astarte_device_stream_datetime_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, int64_t value, uint64_t ts_epoch_millis, int qos);
 
astarte_err_t astarte_device_stream_double_array_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, const double *values, int count,
    uint64_t ts_epoch_millis, int qos);
 
static inline astarte_err_t astarte_device_stream_double_array(astarte_device_handle_t device,
    const char *interface_name, const char *path, const double *values, int count,
    uint64_t ts_epoch_millis, int qos)
{
    return astarte_device_stream_double_array_with_timestamp(
        device, interface_name, path, values, count, ASTARTE_INVALID_TIMESTAMP, qos);
}
 
astarte_err_t astarte_device_stream_integer_array_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, const int32_t *values, int count,
    uint64_t ts_epoch_millis, int qos);
 
static inline astarte_err_t astarte_device_stream_integer_array(astarte_device_handle_t device,
    const char *interface_name, const char *path, const int32_t *values, int count, int qos)
{
    return astarte_device_stream_integer_array_with_timestamp(
        device, interface_name, path, values, count, ASTARTE_INVALID_TIMESTAMP, qos);
}
 
astarte_err_t astarte_device_stream_longinteger_array_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, const int64_t *values, int count,
    uint64_t ts_epoch_millis, int qos);
 
static inline astarte_err_t astarte_device_stream_longinteger_array(astarte_device_handle_t device,
    const char *interface_name, const char *path, const int64_t *values, int count, int qos)
{
    return astarte_device_stream_longinteger_array_with_timestamp(
        device, interface_name, path, values, count, ASTARTE_INVALID_TIMESTAMP, qos);
}
 
astarte_err_t astarte_device_stream_boolean_array_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, const bool *values, int count,
    uint64_t ts_epoch_millis, int qos);
 
static inline astarte_err_t astarte_device_stream_boolean_array(astarte_device_handle_t device,
    const char *interface_name, const char *path, const bool *values, int count, int qos)
{
    return astarte_device_stream_boolean_array_with_timestamp(
        device, interface_name, path, values, count, ASTARTE_INVALID_TIMESTAMP, qos);
}
 
astarte_err_t astarte_device_stream_string_array_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, const char *const *values, int count,
    uint64_t ts_epoch_millis, int qos);
 
static inline astarte_err_t astarte_device_stream_string_array(astarte_device_handle_t device,
    const char *interface_name, const char *path, const char *const *values, int count, int qos)
{
    return astarte_device_stream_string_array_with_timestamp(
        device, interface_name, path, values, count, ASTARTE_INVALID_TIMESTAMP, qos);
}
 
astarte_err_t astarte_device_stream_binaryblob_array_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, const void *const *values, const int *sizes,
    int count, uint64_t ts_epoch_millis, int qos);
 
static inline astarte_err_t astarte_device_stream_binaryblob_array(astarte_device_handle_t device,
    const char *interface_name, const char *path, const void *const *values, const int *sizes,
    int count, int qos)
{
    return astarte_device_stream_binaryblob_array_with_timestamp(
        device, interface_name, path, values, sizes, count, ASTARTE_INVALID_TIMESTAMP, qos);
}
 
astarte_err_t astarte_device_stream_datetime_array_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path, const int64_t *values, int count,
    uint64_t ts_epoch_millis, int qos);
 
static inline astarte_err_t astarte_device_stream_datetime_array(astarte_device_handle_t device,
    const char *interface_name, const char *path, const int64_t *values, int count, int qos)
{
    return astarte_device_stream_datetime_array_with_timestamp(
        device, interface_name, path, values, count, ASTARTE_INVALID_TIMESTAMP, qos);
}
 
astarte_err_t astarte_device_stream_aggregate(astarte_device_handle_t device,
    const char *interface_name, const char *path_prefix, const void *bson_document, int qos);
 
astarte_err_t astarte_device_stream_aggregate_with_timestamp(astarte_device_handle_t device,
    const char *interface_name, const char *path_prefix, const void *bson_document,
    uint64_t ts_epoch_millis, int qos);
 
astarte_err_t astarte_device_set_double_property(
    astarte_device_handle_t device, const char *interface_name, const char *path, double value);
 
astarte_err_t astarte_device_set_integer_property(
    astarte_device_handle_t device, const char *interface_name, const char *path, int32_t value);
 
astarte_err_t astarte_device_set_longinteger_property(
    astarte_device_handle_t device, const char *interface_name, const char *path, int64_t value);
 
astarte_err_t astarte_device_set_boolean_property(
    astarte_device_handle_t device, const char *interface_name, const char *path, bool value);
 
astarte_err_t astarte_device_set_string_property(astarte_device_handle_t device,
    const char *interface_name, const char *path, const char *value);
 
astarte_err_t astarte_device_set_binaryblob_property(astarte_device_handle_t device,
    const char *interface_name, const char *path, void *value, size_t size);
 
astarte_err_t astarte_device_set_datetime_property(
    astarte_device_handle_t device, const char *interface_name, const char *path, int64_t value);
 
astarte_err_t astarte_device_unset_path(
    astarte_device_handle_t device, const char *interface_name, const char *path);
 
bool astarte_device_is_connected(astarte_device_handle_t device);
 
char *astarte_device_get_encoded_id(astarte_device_handle_t device);
#ifdef __cplusplus
}
#endif
 
#endif