dbus.h

Go to the documentation of this file.

 
#ifndef __TBOX_DBUS_H__
#define __TBOX_DBUS_H__
 
#include <dbus/dbus.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
 
#include <tbox/error.h>
#include <tbox/log.h>
 
#ifdef __cplusplus
extern "C"
{
#endif


#define TBOX_DBUS_METHOD_RETURN_TIMEOUT_SEC 2U

typedef enum
{
    TBOX_DBUS_TYPE_STRING  = DBUS_TYPE_STRING,  
    TBOX_DBUS_TYPE_UINT32  = DBUS_TYPE_UINT32,  
    TBOX_DBUS_TYPE_INT32   = DBUS_TYPE_INT32,   
    TBOX_DBUS_TYPE_UINT16  = DBUS_TYPE_UINT16,  
    TBOX_DBUS_TYPE_INT16   = DBUS_TYPE_INT16,   
    TBOX_DBUS_TYPE_UINT8   = DBUS_TYPE_BYTE,    
    TBOX_DBUS_TYPE_BOOL    = DBUS_TYPE_BOOLEAN, 
    TBOX_DBUS_TYPE_ARRAY   = DBUS_TYPE_ARRAY,   
    TBOX_DBUS_TYPE_INVALID = DBUS_TYPE_INVALID, 
} tbox_dbus_type_t;

typedef struct
{
    tbox_dbus_type_t type;       
    tbox_dbus_type_t array_type; 
    uint32_t         array_len;  
    union
    {
        uint32_t u32;   
        int32_t  i32;   
        uint16_t u16;   
        int16_t  i16;   
        uint8_t  u8;    
        bool     b;     
        char*    str;   
        void*    array; 
    } type_info;
} tbox_dbus_param_t;

typedef void (*tbox_dbus_handler_t)(tbox_dbus_param_t* msg_param, tbox_dbus_param_t* return_param);

typedef struct
{
    const char*         module;  
    const char*         action;  
    tbox_dbus_handler_t handler; 
} tbox_dbus_handle_map_t;

typedef struct
{
    bool               is_signal; 
    const char*        dest;      
    const char*        module;    
    const char*        action;    
    tbox_dbus_param_t* param;     
} tbox_dbus_send_info_t;

typedef struct
{
    const char*       module; 
    const char*       action; 
    tbox_dbus_param_t param;  
} tbox_dbus_recv_info_t;

int tbox_dbus_connect(const char* app_name);

void tbox_dbus_disconnect(void);

const char* tbox_dbus_get_connection_name(void);

int tbox_dbus_set_message(DBusMessageIter* iter, const tbox_dbus_param_t* param);

int tbox_dbus_send_message_begin(const tbox_dbus_send_info_t* send_info, DBusMessage** msg, DBusMessageIter* iter);

int tbox_dbus_send_message_end(bool is_signal, DBusMessage* msg, tbox_dbus_param_t* return_param, int32_t timeout);

int tbox_dbus_get_message_begin(DBusMessageIter* iter, DBusMessage** msg, tbox_dbus_recv_info_t* recv_info,
                                int32_t timeout);

bool tbox_dbus_check_next_message(DBusMessageIter* iter);

int tbox_dbus_get_message(DBusMessageIter* iter, tbox_dbus_param_t* param);

int tbox_dbus_get_message_end(DBusMessage* msg, tbox_dbus_param_t* return_param);

int tbox_dbus_send_message(const tbox_dbus_send_info_t* send_info, tbox_dbus_param_t* return_param, int32_t timeout);

int tbox_dbus_set_receive_match(const char* filter);

int tbox_dbus_delete_receive_match(const char* filter);

void tbox_dbus_free_param(tbox_dbus_param_t* param);

void tbox_dbus_free_message(DBusMessage* msg);

bool tbox_dbus_check_message_match(DBusMessage* msg, bool is_signal, const char* module, const char* action);

int tbox_dbus_send_signal(const char* module, const char* action, tbox_dbus_param_t* param);

int tbox_dbus_call_set(const char* dest, const char* module, const char* action, tbox_dbus_param_t* param,
                       uint32_t timeout);

int tbox_dbus_call_get(const char* dest, const char* module, const char* action, tbox_dbus_param_t* return_param,
                       uint32_t timeout);

void tbox_dbus_send_no_reply(const char* dest, const char* module, const char* action, tbox_dbus_param_t* param);

int tbox_dbus_recv_no_reply(const char* need_module, int32_t timeout, bool need_signal, tbox_dbus_param_t* msg_param,
                            char* recv_action, uint32_t recv_action_len);

void tbox_dbus_handle_message(const tbox_dbus_handle_map_t* handle_map, const char* need_module, int32_t timeout);

#define DBUS_CHECK_OR_RESULT_WITH_ERROR(tag, expr, result, message, error)                                             \
    do                                                                                                                 \
    {                                                                                                                  \
        if (!(expr))                                                                                                   \
        {                                                                                                              \
            TBOX_LOGE(tag, message ", check failed: %s in %s at %d", #expr, __FILE__, __LINE__);                       \
            (result)->type          = TBOX_DBUS_TYPE_INT32;                                                            \
            (result)->type_info.i32 = (error);                                                                         \
            return;                                                                                                    \
        }                                                                                                              \
    } while (0)

#define DBUS_CHECK_RET_OR_RESULT_WITH_MESSAGE(tag, ret, result, message)                                               \
    DBUS_CHECK_OR_RESULT_WITH_ERROR(tag, TBOX_OK == (ret), result, message, (ret))

#define DBUS_CHECK_TYPE_OR_RESULT_WITH_MESSAGE(tag, etype, param, result, message)                                     \
    do                                                                                                                 \
    {                                                                                                                  \
        if ((etype) != (param)->type)                                                                                  \
        {                                                                                                              \
            TBOX_LOGE(tag, message ", wrong type(%c), expected(%c)", (param)->type, (etype));                          \
            (result)->type          = TBOX_DBUS_TYPE_INT32;                                                            \
            (result)->type_info.i32 = DBUS_ERROR_REMOTE_WRONG_TYPE;                                                    \
            return;                                                                                                    \
        }                                                                                                              \
    } while (0)

#define DBUS_CHECK_TYPE_OR_RETURN_WITH_ERROR(tag, etype, param, message, error)                                        \
    do                                                                                                                 \
    {                                                                                                                  \
        if ((etype) != (param)->type)                                                                                  \
        {                                                                                                              \
            TBOX_LOGE(tag, message ", wrong type(%c), expected(%c)", (param)->type, (etype));                          \
            if (TBOX_DBUS_TYPE_STRING == (param)->type)                                                                \
            {                                                                                                          \
                TBOX_LOGE(tag, "error message: %s", (param)->type_info.str);                                           \
                tbox_dbus_free_param(param);                                                                           \
            }                                                                                                          \
            if (TBOX_DBUS_TYPE_ARRAY == (param)->type)                                                                 \
            {                                                                                                          \
                tbox_dbus_free_param(param);                                                                           \
            }                                                                                                          \
            return (error);                                                                                            \
        }                                                                                                              \
    } while (0)

 
#ifdef __cplusplus
}
#endif
 
#endif /* __TBOX_DBUS_H__ */