From bda426ee9e3507f01d4d1657885d537f456d8267 Mon Sep 17 00:00:00 2001 From: Suresh Kumar N Date: Wed, 21 Dec 2016 21:21:18 +0530 Subject: [PATCH] Request ID (skeleton) Change-Id: I3154b2f955e09dee7368c5b5c94de3fc79e4daaa Signed-off-by: Suresh Kumar N --- zigbee-daemon/CMakeLists.txt | 1 + zigbee-daemon/zigbee-lib/include/zblib.h | 45 + zigbee-daemon/zigbee-lib/include/zblib_driver.h | 31 +- .../zigbee-lib/include/zblib_driver_alarm.h | 28 +- .../zigbee-lib/include/zblib_driver_custom.h | 19 +- .../zigbee-lib/include/zblib_driver_door_lock.h | 22 +- .../zigbee-lib/include/zblib_driver_fan_control.h | 22 +- .../include/zblib_driver_level_control.h | 31 +- .../include/zblib_driver_mfglib_control.h | 61 +- .../zigbee-lib/include/zblib_driver_on_off.h | 16 +- .../zigbee-lib/include/zblib_driver_service.h | 44 +- .../zigbee-lib/include/zblib_driver_thermostat.h | 25 +- .../zigbee-lib/include/zblib_driver_zcl_color.h | 43 +- .../zigbee-lib/include/zblib_driver_zcl_group.h | 28 +- .../include/zblib_driver_zcl_poll_control.h | 22 +- .../zigbee-lib/include/zblib_driver_zcl_scene.h | 31 +- .../include/zblib_driver_zclbasic_control.h | 13 +- .../include/zblib_driver_zclglobal_control.h | 46 +- .../include/zblib_driver_zclias_control.h | 14 +- .../include/zblib_driver_zclidentify_control.h | 16 +- .../zigbee-lib/include/zblib_driver_zdo_bind.h | 16 +- .../include/zblib_driver_zdodev_control.h | 61 +- zigbee-daemon/zigbee-lib/include/zblib_plugin.h | 2 + zigbee-daemon/zigbee-lib/include/zblib_request.h | 44 + zigbee-daemon/zigbee-lib/include/zblib_service.h | 3 + .../zigbee-lib/src/drivers/zblib_driver_alarm.c | 47 +- .../zigbee-lib/src/drivers/zblib_driver_custom.c | 35 +- .../src/drivers/zblib_driver_door_lock.c | 39 +- .../src/drivers/zblib_driver_fan_control.c | 39 +- .../src/drivers/zblib_driver_level_control.c | 51 +- .../src/drivers/zblib_driver_mfglib_control.c | 91 +- .../zigbee-lib/src/drivers/zblib_driver_on_off.c | 31 +- .../zigbee-lib/src/drivers/zblib_driver_service.c | 87 +- .../src/drivers/zblib_driver_thermostat.c | 43 +- .../src/drivers/zblib_driver_zcl_color.c | 67 +- .../src/drivers/zblib_driver_zcl_group.c | 47 +- .../src/drivers/zblib_driver_zcl_poll_control.c | 39 +- .../src/drivers/zblib_driver_zcl_scene.c | 51 +- .../src/drivers/zblib_driver_zclbasic_control.c | 27 +- .../src/drivers/zblib_driver_zclglobal_control.c | 71 +- .../src/drivers/zblib_driver_zclias_control.c | 28 +- .../src/drivers/zblib_driver_zclidentify_control.c | 31 +- .../zigbee-lib/src/drivers/zblib_driver_zdo_bind.c | 31 +- .../src/drivers/zblib_driver_zdodev_control.c | 91 +- zigbee-daemon/zigbee-lib/src/zblib_driver.c | 38 +- zigbee-daemon/zigbee-lib/src/zblib_plugin.c | 36 +- zigbee-daemon/zigbee-lib/src/zblib_request.c | 1259 ++++++++++++++++++++ zigbee-daemon/zigbee-lib/src/zblib_service.c | 79 +- 48 files changed, 2798 insertions(+), 244 deletions(-) create mode 100644 zigbee-daemon/zigbee-lib/include/zblib_request.h create mode 100644 zigbee-daemon/zigbee-lib/src/zblib_request.c diff --git a/zigbee-daemon/CMakeLists.txt b/zigbee-daemon/CMakeLists.txt index f5ae890..3c7a69f 100644 --- a/zigbee-daemon/CMakeLists.txt +++ b/zigbee-daemon/CMakeLists.txt @@ -59,6 +59,7 @@ SET(ZIGBEE_LIB_SRCS ${ZIGBEE_LIB_SRC_PATH}/zblib_service_interface.c ${ZIGBEE_LIB_SRC_PATH}/zblib_plugin.c ${ZIGBEE_LIB_SRC_PATH}/zblib_driver.c + ${ZIGBEE_LIB_SRC_PATH}/zblib_request.c ${ZIGBEE_LIB_SRC_PATH}/zblib_log.c ${ZIGBEE_LIB_SRC_PATH}/zblib_util.c ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_alarm.c diff --git a/zigbee-daemon/zigbee-lib/include/zblib.h b/zigbee-daemon/zigbee-lib/include/zblib.h index d4ea973..e180cc3 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib.h +++ b/zigbee-daemon/zigbee-lib/include/zblib.h @@ -27,6 +27,26 @@ #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + #define NOT_USED(var) ((var) = (var)) /**< ZigBee module typedefs */ @@ -34,5 +54,30 @@ typedef struct zblib_service_type ZigBeeService; typedef struct zblib_plugin_type ZigBeePlugin; typedef struct zblib_driver_type ZigBeeDriver; typedef struct zblib_service_interface_type ZigBeeServiceInterface; +typedef struct zblib_request_type ZigBeeRequest; + +/**< ZigBee driver types */ +typedef enum { + ZBLIB_DRIVER_TYPE_NONE, /**< None */ + ZBLIB_DRIVER_TYPE_ALARM, /**< Alarm */ + ZBLIB_DRIVER_TYPE_CUSTOM, /**< Custom */ + ZBLIB_DRIVER_TYPE_DOOR_LOCK, /**< Door lock */ + ZBLIB_DRIVER_TYPE_FAN_CONTROL, /**< Fan control */ + ZBLIB_DRIVER_TYPE_LEVEL_CONTROL, /**< Level control */ + ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL, /**< Mfglib control */ + ZBLIB_DRIVER_TYPE_ON_OFF, /**< On Off */ + ZBLIB_DRIVER_TYPE_SERVICE, /**< Service */ + ZBLIB_DRIVER_TYPE_THERMOSTAT, /**< Thermostat */ + ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL, /**< Zclbasic control */ + ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL, /**< Zclglobal control */ + ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL, /**< Zclias control */ + ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL, /**< Zclidentify control */ + ZBLIB_DRIVER_TYPE_ZCL_COLOR, /**< Zcl color */ + ZBLIB_DRIVER_TYPE_ZCL_GROUP, /**< Zcl group */ + ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL, /**< Zcl poll control */ + ZBLIB_DRIVER_TYPE_ZCL_SCENE, /**< Zcl scene */ + ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL, /**< Zdodev control */ + ZBLIB_DRIVER_TYPE_ZDO_BIND, /**< Zdo bind */ +} ZblibDriverType_e; #endif /* __ZIGBEE_LIB_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver.h b/zigbee-daemon/zigbee-lib/include/zblib_driver.h index e492c96..715c7d4 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver.h @@ -20,41 +20,20 @@ #define __ZIGBEE_LIB_DRIVER_H__ /**< ZigBee driver dispatcher function pointer */ -typedef gboolean (*ZblibDriverDispatcher_t)(ZigBeeDriver *driver); +typedef gboolean (*ZblibDriverDispatcher_t)(ZigBeeDriver *driver, guint request_id); /**< ZigBee driver free hook function pointer */ typedef void (*ZblibDriverFreeHook_t)(ZigBeeDriver *driver); -/**< ZigBee driver types */ -typedef enum { - ZBLIB_DRIVER_TYPE_NONE, /**< None */ - ZBLIB_DRIVER_TYPE_ALARM, /**< Alarm */ - ZBLIB_DRIVER_TYPE_CUSTOM, /**< Custom */ - ZBLIB_DRIVER_TYPE_DOOR_LOCK, /**< Door lock */ - ZBLIB_DRIVER_TYPE_FAN_CONTROL, /**< Fan control */ - ZBLIB_DRIVER_TYPE_LEVEL_CONTROL, /**< Level control */ - ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL, /**< Mfglib control */ - ZBLIB_DRIVER_TYPE_ON_OFF, /**< On Off */ - ZBLIB_DRIVER_TYPE_SERVICE, /**< Service */ - ZBLIB_DRIVER_TYPE_THERMOSTAT, /**< Thermostat */ - ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL, /**< Zclbasic control */ - ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL, /**< Zclglobal control */ - ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL, /**< Zclias control */ - ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL, /**< Zclidentify control */ - ZBLIB_DRIVER_TYPE_ZCL_COLOR, /**< Zcl color */ - ZBLIB_DRIVER_TYPE_ZCL_GROUP, /**< Zcl group */ - ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL, /**< Zcl poll control */ - ZBLIB_DRIVER_TYPE_ZCL_SCENE, /**< Zcl scene */ - ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL, /**< Zdodev control */ - ZBLIB_DRIVER_TYPE_ZDO_BIND, /**< Zdo bind */ -} ZblibDriverType_e; - /**< Driver APIs */ ZigBeeDriver *zblib_driver_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverType_e driver_type); void zblib_driver_free(ZigBeeDriver *driver); +ZigBeeService *zblib_driver_ref_service(ZigBeeDriver *driver); +ZigBeePlugin *zblib_driver_ref_plugin(ZigBeeDriver *driver); + gboolean zblib_driver_link_object(ZigBeeDriver *driver, gpointer object); gpointer zblib_driver_ref_object(ZigBeeDriver *driver); @@ -63,4 +42,6 @@ gboolean zblib_driver_set_free_hook(ZigBeeDriver *driver, ZblibDriverFreeHook_t ZblibDriverType_e zblib_driver_ref_driver_type(ZigBeeDriver *driver); +gboolean zblib_driver_dispatch_request(ZigBeeDriver *driver, guint request_id); + #endif /* __ZIGBEE_LIB_DRIVER_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_alarm.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_alarm.h index 71b5de1..57dce1b 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_alarm.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_alarm.h @@ -16,23 +16,33 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ALARM_H__ -#define __ZIGBEE_LIB_ALARM_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ALARM_H__ +#define __ZIGBEE_LIB_DRIVER_ALARM_H__ /**< ZigBee 'alarm' driver operations */ typedef struct { - gboolean (*get_alarm_count)(ZigBeeDriver *driver); - gboolean (*reset_alarm)(ZigBeeDriver *driver); - gboolean (*reset_all_alarm)(ZigBeeDriver *driver); - gboolean (*alarm)(ZigBeeDriver *driver); - gboolean (*reset_alarm_log)(ZigBeeDriver *driver); - gboolean (*get_alarm)(ZigBeeDriver *driver); + gboolean (*get_alarm_count)(ZigBeeDriver *driver, guint request_id); + gboolean (*reset_alarm)(ZigBeeDriver *driver, guint request_id); + gboolean (*reset_all_alarm)(ZigBeeDriver *driver, guint request_id); + gboolean (*alarm)(ZigBeeDriver *driver, guint request_id); + gboolean (*reset_alarm_log)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_alarm)(ZigBeeDriver *driver, guint request_id); } ZblibDriverAlarmOps_t; +/**< ZigBee 'alarm' ops IDs */ +typedef enum { + ZBLIB_ALARM_OPS_GET_ALARM_COUNT = 1, /**< Get alarm count */ + ZBLIB_ALARM_OPS_RESET_ALARM, /**< Reset alarm */ + ZBLIB_ALARM_OPS_RESET_ALL_ALARM, /**< Reset all alarm */ + ZBLIB_ALARM_OPS_ALARM, /**< Alarm */ + ZBLIB_ALARM_OPS_RESET_ALARM_LOG, /**< Reset alarm log */ + ZBLIB_ALARM_OPS_GET_ALARM, /**< Get alarm */ +} ZblibAlarmOps_e; + /* ZigBee 'alarm' driver APIs */ ZigBeeDriver *zblib_driver_alarm_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverAlarmOps_t *ops); void zblib_driver_alarm_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ALARM_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ALARM_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_custom.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_custom.h index dd7e964..6f172f6 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_custom.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_custom.h @@ -16,20 +16,27 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_CUSTOM_H__ -#define __ZIGBEE_LIB_CUSTOM_H__ +#ifndef __ZIGBEE_LIB_DRIVER_CUSTOM_H__ +#define __ZIGBEE_LIB_DRIVER_CUSTOM_H__ /**< ZigBee 'custom' driver operations */ typedef struct { - gboolean (*aps_send)(ZigBeeDriver *driver); - gboolean (*zcl_send)(ZigBeeDriver *driver); - gboolean (*send_to_local)(ZigBeeDriver *driver); + gboolean (*aps_send)(ZigBeeDriver *driver, guint request_id); + gboolean (*zcl_send)(ZigBeeDriver *driver, guint request_id); + gboolean (*send_to_local)(ZigBeeDriver *driver, guint request_id); } ZblibDriverCustomOps_t; +/**< ZigBee 'custom' ops IDs */ +typedef enum { + ZBLIB_CUSTOM_OPS_APS_SEND = 1, /**< Aps send */ + ZBLIB_CUSTOM_OPS_ZCL_SEND, /**< Zcl send */ + ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL, /**< Send to local */ +} ZblibCustomOps_e; + /* ZigBee 'custom' driver APIs */ ZigBeeDriver *zblib_driver_custom_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverCustomOps_t *ops); void zblib_driver_custom_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_CUSTOM_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_CUSTOM_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_door_lock.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_door_lock.h index 2fa4e81..6a9f234 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_door_lock.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_door_lock.h @@ -16,21 +16,29 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_DOOR_LOCK_H__ -#define __ZIGBEE_LIB_DOOR_LOCK_H__ +#ifndef __ZIGBEE_LIB_DRIVER_DOOR_LOCK_H__ +#define __ZIGBEE_LIB_DRIVER_DOOR_LOCK_H__ /**< ZigBee 'door lock' driver operations */ typedef struct { - gboolean (*subscribe_lock_event)(ZigBeeDriver *driver); - gboolean (*set_door_lock_pin)(ZigBeeDriver *driver); - gboolean (*set_door_lock)(ZigBeeDriver *driver); - gboolean (*get_lock_state)(ZigBeeDriver *driver); + gboolean (*subscribe_lock_event)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_door_lock_pin)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_door_lock)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_lock_state)(ZigBeeDriver *driver, guint request_id); } ZblibDriverDoorLockOps_t; +/**< ZigBee 'door lock' ops IDs */ +typedef enum { + ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT = 1, /**< Subscribe lock event */ + ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN, /**< Set door lock pin */ + ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK, /**< Set door lock */ + ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE, /**< Get lock state */ +} ZblibDoorLockOps_e; + /* ZigBee 'door lock' driver APIs */ ZigBeeDriver *zblib_driver_door_lock_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverDoorLockOps_t *ops); void zblib_driver_door_lock_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_DOOR_LOCK_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_DOOR_LOCK_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_fan_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_fan_control.h index 0d26a42..7515441 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_fan_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_fan_control.h @@ -16,17 +16,25 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_FAN_CONTROL_H__ -#define __ZIGBEE_LIB_FAN_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_FAN_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_FAN_CONTROL_H__ /**< ZigBee 'fan control' driver operations */ typedef struct { - gboolean (*set_fan_mode)(ZigBeeDriver *driver); - gboolean (*get_fan_mode)(ZigBeeDriver *driver); - gboolean (*set_fan_mode_sequence)(ZigBeeDriver *driver); - gboolean (*get_fan_mode_sequence)(ZigBeeDriver *driver); + gboolean (*set_fan_mode)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_fan_mode)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_fan_mode_sequence)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_fan_mode_sequence)(ZigBeeDriver *driver, guint request_id); } ZblibDriverFanControlOps_t; +/**< ZigBee 'fan control' ops IDs */ +typedef enum { + ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE = 1, /**< Set fan mode */ + ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE, /**< Get fan mode */ + ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE, /**< Set fan mode sequence */ + ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE, /**< Get fan mode sequence */ +} ZblibFanControlOps_e; + /* ZigBee 'fan control' driver APIs */ ZigBeeDriver *zblib_driver_fan_control_new(ZigBeePlugin *plugin, const gchar *driver_name, @@ -34,4 +42,4 @@ ZigBeeDriver *zblib_driver_fan_control_new(ZigBeePlugin *plugin, void zblib_driver_fan_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_FAN_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_FAN_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_level_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_level_control.h index 0d75684..91fb727 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_level_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_level_control.h @@ -16,24 +16,35 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_LEVEL_CONTROL_H__ -#define __ZIGBEE_LIB_LEVEL_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_LEVEL_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_LEVEL_CONTROL_H__ /**< ZigBee 'level control' driver operations */ typedef struct { - gboolean (*move_to_level)(ZigBeeDriver *driver); - gboolean (*move)(ZigBeeDriver *driver); - gboolean (*step)(ZigBeeDriver *driver); - gboolean (*move_to_level_with_on_off)(ZigBeeDriver *driver); - gboolean (*move_with_on_off)(ZigBeeDriver *driver); - gboolean (*step_with_on_off)(ZigBeeDriver *driver); - gboolean (*stop)(ZigBeeDriver *driver); + gboolean (*move_to_level)(ZigBeeDriver *driver, guint request_id); + gboolean (*move)(ZigBeeDriver *driver, guint request_id); + gboolean (*step)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_to_level_with_on_off)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_with_on_off)(ZigBeeDriver *driver, guint request_id); + gboolean (*step_with_on_off)(ZigBeeDriver *driver, guint request_id); + gboolean (*stop)(ZigBeeDriver *driver, guint request_id); } ZblibDriverLevelControlOps_t; +/**< ZigBee 'level control' ops IDs */ +typedef enum { + ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL = 1, /**< Move to level */ + ZBLIB_LEVEL_CONTROL_OPS_MOVE, /**< Move */ + ZBLIB_LEVEL_CONTROL_OPS_STEP, /**< Step */ + ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF, /**< Move to level with on off */ + ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF, /**< Move with on off */ + ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF, /**< Step with on off */ + ZBLIB_LEVEL_CONTROL_OPS_STOP, /**< Stop */ +} ZblibLevelControlOps_e; + /* ZigBee 'level control' driver APIs */ ZigBeeDriver *zblib_driver_level_control_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverLevelControlOps_t *ops); void zblib_driver_level_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_LEVEL_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_LEVEL_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_mfglib_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_mfglib_control.h index d527792..251bfe4 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_mfglib_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_mfglib_control.h @@ -16,34 +16,55 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_MFGLIB_CONTROL_H__ -#define __ZIGBEE_LIB_MFGLIB_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_MFGLIB_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_MFGLIB_CONTROL_H__ /**< ZigBee 'mfglib control' driver operations */ typedef struct { - gboolean (*start)(ZigBeeDriver *driver); - gboolean (*end)(ZigBeeDriver *driver); - gboolean (*start_tone)(ZigBeeDriver *driver); - gboolean (*stop_tone)(ZigBeeDriver *driver); - gboolean (*start_stream)(ZigBeeDriver *driver); - gboolean (*stop_stream)(ZigBeeDriver *driver); - gboolean (*send_packet)(ZigBeeDriver *driver); - gboolean (*set_channel)(ZigBeeDriver *driver); - gboolean (*get_channel)(ZigBeeDriver *driver); - gboolean (*set_power)(ZigBeeDriver *driver); - gboolean (*get_power)(ZigBeeDriver *driver); - gboolean (*set_synoffset)(ZigBeeDriver *driver); - gboolean (*get_synoffset)(ZigBeeDriver *driver); - gboolean (*rx_start)(ZigBeeDriver *driver); - gboolean (*rx_stop)(ZigBeeDriver *driver); - gboolean (*rx_verify)(ZigBeeDriver *driver); - gboolean (*get_rssi)(ZigBeeDriver *driver); + gboolean (*start)(ZigBeeDriver *driver, guint request_id); + gboolean (*end)(ZigBeeDriver *driver, guint request_id); + gboolean (*start_tone)(ZigBeeDriver *driver, guint request_id); + gboolean (*stop_tone)(ZigBeeDriver *driver, guint request_id); + gboolean (*start_stream)(ZigBeeDriver *driver, guint request_id); + gboolean (*stop_stream)(ZigBeeDriver *driver, guint request_id); + gboolean (*send_packet)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_channel)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_channel)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_power)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_power)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_synoffset)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_synoffset)(ZigBeeDriver *driver, guint request_id); + gboolean (*rx_start)(ZigBeeDriver *driver, guint request_id); + gboolean (*rx_stop)(ZigBeeDriver *driver, guint request_id); + gboolean (*rx_verify)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_rssi)(ZigBeeDriver *driver, guint request_id); } ZblibDriverMfglibControlOps_t; +/**< ZigBee 'mfglib control' ops IDs */ +typedef enum { + ZBLIB_MFGLIB_CONTROL_OPS_START = 1, /**< Start */ + ZBLIB_MFGLIB_CONTROL_OPS_END, /**< End */ + ZBLIB_MFGLIB_CONTROL_OPS_START_TONE, /**< Start tone */ + ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE, /**< Stop tone */ + ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM, /**< Start stream */ + ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM, /**< Stop stream */ + ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET, /**< Send packet */ + ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL, /**< Set channel */ + ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL, /**< Get channel */ + ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER, /**< Set power */ + ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER, /**< Get power */ + ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET, /**< Set synoffset */ + ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET, /**< Get synoffset */ + ZBLIB_MFGLIB_CONTROL_OPS_RX_START, /**< RX start */ + ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP, /**< RX stop */ + ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY, /**< RX verify */ + ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI, /**< Get rssi */ +} ZblibMfglibControlOps_e; + /* ZigBee 'mfglib control' driver APIs */ ZigBeeDriver *zblib_driver_mfglib_control_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverMfglibControlOps_t *ops); void zblib_driver_mfglib_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_MFGLIB_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_MFGLIB_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_on_off.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_on_off.h index 848f8bb..2d74b8a 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_on_off.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_on_off.h @@ -16,19 +16,25 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ON_OFF_H__ -#define __ZIGBEE_LIB_ON_OFF_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ON_OFF_H__ +#define __ZIGBEE_LIB_DRIVER_ON_OFF_H__ /**< ZigBee 'on off' driver operations */ typedef struct { - gboolean (*set_on_off)(ZigBeeDriver *driver); - gboolean (*get_on_off_state)(ZigBeeDriver *driver); + gboolean (*set_on_off)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_on_off_state)(ZigBeeDriver *driver, guint request_id); } ZblibDriverOnOffOps_t; +/**< ZigBee 'on off' ops IDs */ +typedef enum { + ZBLIB_ON_OFF_OPS_SET_ON_OFF = 1, /**< Set ON OFF */ + ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE, /**< Get ON OFF state */ +} ZblibOnOffOps_e; + /* ZigBee 'on off' driver APIs */ ZigBeeDriver *zblib_driver_on_off_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverOnOffOps_t *ops); void zblib_driver_on_off_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ON_OFF_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ON_OFF_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_service.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_service.h index 7f9cdfe..3a24594 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_service.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_service.h @@ -16,19 +16,53 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_SERVICE_H__ -#define __ZIGBEE_LIB_SERVICE_H__ +#ifndef __ZIGBEE_LIB_DRIVER_SERVICE_H__ +#define __ZIGBEE_LIB_DRIVER_SERVICE_H__ /**< ZigBee 'service' driver operations */ typedef struct { - gboolean (*set_on_off)(ZigBeeDriver *driver); - gboolean (*get_on_off_state)(ZigBeeDriver *driver); + gboolean (*enable)(ZigBeeDriver *driver, guint request_id); + gboolean (*disable)(ZigBeeDriver *driver, guint request_id); + gboolean (*zb_hw_reset)(ZigBeeDriver *driver, guint request_id); + gboolean (*form_network)(ZigBeeDriver *driver, guint request_id); + gboolean (*coex_start)(ZigBeeDriver *driver, guint request_id); + gboolean (*coex_stop)(ZigBeeDriver *driver, guint request_id); + gboolean (*leave_network)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_network_info)(ZigBeeDriver *driver, guint request_id); + gboolean (*permit_join)(ZigBeeDriver *driver, guint request_id); + gboolean (*leave_request)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_device_list)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_mac)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_device_info)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_endpoint_list)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_cluster_list)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_node_type)(ZigBeeDriver *driver, guint request_id); } ZblibDriverServiceOps_t; +/**< ZigBee 'service' ops IDs */ +typedef enum { + ZBLIB_SERVICE_OPS_ENABLE = 1, /**< Enable */ + ZBLIB_SERVICE_OPS_DISABLE, /**< Disable */ + ZBLIB_SERVICE_OPS_ZB_HW_RESET, /**< Zb hw reset */ + ZBLIB_SERVICE_OPS_FORM_NETWORK, /**< Form network */ + ZBLIB_SERVICE_OPS_COEX_START, /**< Coex start */ + ZBLIB_SERVICE_OPS_COEX_STOP, /**< Coex stop */ + ZBLIB_SERVICE_OPS_LEAVE_NETWORK, /**< Leave network */ + ZBLIB_SERVICE_OPS_GET_NETWORK_INFO, /**< get network info */ + ZBLIB_SERVICE_OPS_PERMIT_JOIN, /**< Permit join */ + ZBLIB_SERVICE_OPS_LEAVE_REQUEST, /**< Leave request */ + ZBLIB_SERVICE_OPS_GET_DEVICE_LIST, /**< Get device list */ + ZBLIB_SERVICE_OPS_GET_MAC, /**< Get mac */ + ZBLIB_SERVICE_OPS_GET_DEVICE_INFO, /**< Det device info */ + ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST, /**< Get endpoint list */ + ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST, /**< Get cluster list */ + ZBLIB_SERVICE_OPS_GET_NODE_TYPE, /**< Get node type */ +} ZblibServiceOps_e; + /* ZigBee 'service' driver APIs */ ZigBeeDriver *zblib_driver_service_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverServiceOps_t *ops); void zblib_driver_service_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_SERVICE_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_SERVICE_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_thermostat.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_thermostat.h index 95b452a..14f4389 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_thermostat.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_thermostat.h @@ -16,22 +16,31 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_THERMOSTAT_H__ -#define __ZIGBEE_LIB_THERMOSTAT_H__ +#ifndef __ZIGBEE_LIB_DRIVER_THERMOSTAT_H__ +#define __ZIGBEE_LIB_DRIVER_THERMOSTAT_H__ /**< ZigBee 'thermostat' driver operations */ typedef struct { - gboolean (*get_local_temp)(ZigBeeDriver *driver); - gboolean (*get_weekly_schedule)(ZigBeeDriver *driver); - gboolean (*set_weekly_schedule)(ZigBeeDriver *driver); - gboolean (*clear_weekly_schedule)(ZigBeeDriver *driver); - gboolean (*setpoint_raise_lower)(ZigBeeDriver *driver); + gboolean (*get_local_temp)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_weekly_schedule)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_weekly_schedule)(ZigBeeDriver *driver, guint request_id); + gboolean (*clear_weekly_schedule)(ZigBeeDriver *driver, guint request_id); + gboolean (*setpoint_raise_lower)(ZigBeeDriver *driver, guint request_id); } ZblibDriverThermostatOps_t; +/**< ZigBee 'thermostat' ops IDs */ +typedef enum { + ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP = 1, /**< Get local temp */ + ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE, /**< Get weekly schedule */ + ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE, /**< Set weekly schedule */ + ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE, /**< Clear weekly schedule */ + ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER, /**< Setpoint raise lower */ +} ZblibThermostatOps_e; + /* ZigBee 'thermostat' driver APIs */ ZigBeeDriver *zblib_driver_thermostat_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverThermostatOps_t *ops); void zblib_driver_thermostat_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_THERMOSTAT_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_THERMOSTAT_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_color.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_color.h index 05fbfb9..e71e3f2 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_color.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_color.h @@ -16,28 +16,43 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZCL_COLOR_H__ -#define __ZIGBEE_LIB_ZCL_COLOR_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZCL_COLOR_H__ +#define __ZIGBEE_LIB_DRIVER_ZCL_COLOR_H__ /**< ZigBee 'Zcl color' driver operations */ typedef struct { - gboolean (*move_to_hue)(ZigBeeDriver *driver); - gboolean (*move_hue)(ZigBeeDriver *driver); - gboolean (*step_hue)(ZigBeeDriver *driver); - gboolean (*move_to_saturation)(ZigBeeDriver *driver); - gboolean (*move_saturation)(ZigBeeDriver *driver); - gboolean (*step_saturation)(ZigBeeDriver *driver); - gboolean (*move_to_hue_and_saturation)(ZigBeeDriver *driver); - gboolean (*move_to_color)(ZigBeeDriver *driver); - gboolean (*move_color)(ZigBeeDriver *driver); - gboolean (*step_color)(ZigBeeDriver *driver); - gboolean (*move_color_temperature)(ZigBeeDriver *driver); + gboolean (*move_to_hue)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_hue)(ZigBeeDriver *driver, guint request_id); + gboolean (*step_hue)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_to_saturation)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_saturation)(ZigBeeDriver *driver, guint request_id); + gboolean (*step_saturation)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_to_hue_and_saturation)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_to_color)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_color)(ZigBeeDriver *driver, guint request_id); + gboolean (*step_color)(ZigBeeDriver *driver, guint request_id); + gboolean (*move_color_temperature)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZclColorOps_t; +/**< ZigBee 'Zcl color' ops IDs */ +typedef enum { + ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE = 1, /**< Move to hue */ + ZBLIB_ZCL_COLOR_OPS_MOVE_HUE, /**< Move hue */ + ZBLIB_ZCL_COLOR_OPS_STEP_HUE, /**< Step hue */ + ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION, /**< Move to saturation */ + ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION, /**< Move saturation */ + ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION, /**< Step saturation */ + ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION, /**< Move to hue and saturation */ + ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR, /**< Move to color */ + ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR, /**< Move color */ + ZBLIB_ZCL_COLOR_OPS_STEP_COLOR, /**< Step color */ + ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE, /**< Move color temperature */ +} ZblibZclColorOps_e; + /* ZigBee 'Zcl color' driver APIs */ ZigBeeDriver *zblib_driver_zcl_color_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZclColorOps_t *ops); void zblib_driver_zcl_color_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZCL_COLOR_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZCL_COLOR_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_group.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_group.h index b8c9a1f..e143cb7 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_group.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_group.h @@ -16,23 +16,33 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZCL_GROUP_H__ -#define __ZIGBEE_LIB_ZCL_GROUP_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZCL_GROUP_H__ +#define __ZIGBEE_LIB_DRIVER_ZCL_GROUP_H__ /**< ZigBee 'Zcl group' driver operations */ typedef struct { - gboolean (*add_group)(ZigBeeDriver *driver); - gboolean (*view_group)(ZigBeeDriver *driver); - gboolean (*get_group_membership)(ZigBeeDriver *driver); - gboolean (*remove_group)(ZigBeeDriver *driver); - gboolean (*remove_all_group)(ZigBeeDriver *driver); - gboolean (*add_group_if_identifying)(ZigBeeDriver *driver); + gboolean (*add_group)(ZigBeeDriver *driver, guint request_id); + gboolean (*view_group)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_group_membership)(ZigBeeDriver *driver, guint request_id); + gboolean (*remove_group)(ZigBeeDriver *driver, guint request_id); + gboolean (*remove_all_group)(ZigBeeDriver *driver, guint request_id); + gboolean (*add_group_if_identifying)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZclGroupOps_t; +/**< ZigBee 'Zcl group' ops IDs */ +typedef enum { + ZBLIB_ZCL_GROUP_OPS_ADD_GROUP = 1, /**< Move add group */ + ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP, /**< View group */ + ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP, /**< Get group membership */ + ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP, /**< Remove group */ + ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP, /**< Remove all group */ + ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING, /**< Add group if identifying */ +} ZblibZclGroupOps_e; + /* ZigBee 'Zcl group' driver APIs */ ZigBeeDriver *zblib_driver_zcl_group_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZclGroupOps_t *ops); void zblib_driver_zcl_group_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZCL_GROUP_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZCL_GROUP_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_poll_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_poll_control.h index e84bd17..39c5f0d 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_poll_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_poll_control.h @@ -16,21 +16,29 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZCL_POLL_CONTROL_H__ -#define __ZIGBEE_LIB_ZCL_POLL_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZCL_POLL_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_ZCL_POLL_CONTROL_H__ /**< ZigBee 'Zcl poll control' driver operations */ typedef struct { - gboolean (*check_in_response)(ZigBeeDriver *driver); - gboolean (*fast_poll_stop)(ZigBeeDriver *driver); - gboolean (*set_long_poll_interval)(ZigBeeDriver *driver); - gboolean (*set_short_poll_interval)(ZigBeeDriver *driver); + gboolean (*check_in_response)(ZigBeeDriver *driver, guint request_id); + gboolean (*fast_poll_stop)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_long_poll_interval)(ZigBeeDriver *driver, guint request_id); + gboolean (*set_short_poll_interval)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZclPollControlOps_t; +/**< ZigBee 'Zcl poll control' ops IDs */ +typedef enum { + ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE = 1, /**< Check in response */ + ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP, /**< Fast poll stop */ + ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL, /**< Set long poll interval */ + ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL, /**< Set short poll interval */ +} ZblibZclPollControlOps_e; + /* ZigBee 'Zcl poll control' driver APIs */ ZigBeeDriver *zblib_driver_zcl_poll_control_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZclPollControlOps_t *ops); void zblib_driver_zcl_poll_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZCL_POLL_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZCL_POLL_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_scene.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_scene.h index ec694bd..9064052 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_scene.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zcl_scene.h @@ -16,24 +16,35 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZCL_SCENE_H__ -#define __ZIGBEE_LIB_ZCL_SCENE_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZCL_SCENE_H__ +#define __ZIGBEE_LIB_DRIVER_ZCL_SCENE_H__ /**< ZigBee 'Zcl scene' driver operations */ typedef struct { - gboolean (*add_scene)(ZigBeeDriver *driver); - gboolean (*view_scene)(ZigBeeDriver *driver); - gboolean (*remove_scene)(ZigBeeDriver *driver); - gboolean (*store_scene)(ZigBeeDriver *driver); - gboolean (*recall_scene)(ZigBeeDriver *driver); - gboolean (*remove_all_scene)(ZigBeeDriver *driver); - gboolean (*get_scene_membership)(ZigBeeDriver *driver); + gboolean (*add_scene)(ZigBeeDriver *driver, guint request_id); + gboolean (*view_scene)(ZigBeeDriver *driver, guint request_id); + gboolean (*remove_scene)(ZigBeeDriver *driver, guint request_id); + gboolean (*store_scene)(ZigBeeDriver *driver, guint request_id); + gboolean (*recall_scene)(ZigBeeDriver *driver, guint request_id); + gboolean (*remove_all_scene)(ZigBeeDriver *driver, guint request_id); + gboolean (*get_scene_membership)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZclSceneOps_t; +/**< ZigBee 'Zcl scene' ops IDs */ +typedef enum { + ZBLIB_ZCL_SCENE_OPS_ADD_SCENE = 1, /**< Add scene */ + ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE, /**< View scene */ + ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE, /**< Remove scene */ + ZBLIB_ZCL_SCENE_OPS_STORE_SCENE, /**< Store scene */ + ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE, /**< Recall scene */ + ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE, /**< Remove all scene */ + ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP, /**< Get scene membership */ +} ZblibZclSceneOps_e; + /* ZigBee 'Zcl scene' driver APIs */ ZigBeeDriver *zblib_driver_zcl_scene_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZclSceneOps_t *ops); void zblib_driver_zcl_scene_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZCL_SCENE_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZCL_SCENE_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zclbasic_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zclbasic_control.h index de90115..a676c3d 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zclbasic_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zclbasic_control.h @@ -16,18 +16,23 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZCLBASIC_CONTROL_H__ -#define __ZIGBEE_LIB_ZCLBASIC_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZCLBASIC_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_ZCLBASIC_CONTROL_H__ /**< ZigBee 'Zclbasic control' driver operations */ typedef struct { - gboolean (*reset_factory_default)(ZigBeeDriver *driver); + gboolean (*reset_factory_default)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZclbasicControlOps_t; +/**< ZigBee 'Zclbasic control' ops IDs */ +typedef enum { + ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT = 1, /**< Reset factory default */ +} ZblibZclbasicControlOps_e; + /* ZigBee 'Zclbasic control' driver APIs */ ZigBeeDriver *zblib_driver_zclbasic_control_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZclbasicControlOps_t *ops); void zblib_driver_zclbasic_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZCLBASIC_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZCLBASIC_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zclglobal_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zclglobal_control.h index c65c6b3..f027faa 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zclglobal_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zclglobal_control.h @@ -16,29 +16,45 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZCLGLOBAL_CONTROL_H__ -#define __ZIGBEE_LIB_ZCLGLOBAL_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZCLGLOBAL_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_ZCLGLOBAL_CONTROL_H__ /**< ZigBee 'Zclglobal control' driver operations */ typedef struct { - gboolean (*read_attributes_req)(ZigBeeDriver *driver); - gboolean (*write_attributes_req)(ZigBeeDriver *driver); - gboolean (*write_attributes_undivided_req)(ZigBeeDriver *driver); - gboolean (*write_attributes_no_resp)(ZigBeeDriver *driver); - gboolean (*write_attributes_structured)(ZigBeeDriver *driver); - gboolean (*read_attributes_structured)(ZigBeeDriver *driver); - gboolean (*configure_reporting_req)(ZigBeeDriver *driver); - gboolean (*read_configure_reporting)(ZigBeeDriver *driver); - gboolean (*discover_attributes)(ZigBeeDriver *driver); - gboolean (*discover_attributes_extended)(ZigBeeDriver *driver); - gboolean (*discover_commands_received)(ZigBeeDriver *driver); - gboolean (*discover_commands_generated)(ZigBeeDriver *driver); + gboolean (*read_attributes_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*write_attributes_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*write_attributes_undivided_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*write_attributes_no_resp)(ZigBeeDriver *driver, guint request_id); + gboolean (*write_attributes_structured)(ZigBeeDriver *driver, guint request_id); + gboolean (*read_attributes_structured)(ZigBeeDriver *driver, guint request_id); + gboolean (*configure_reporting_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*read_configure_reporting)(ZigBeeDriver *driver, guint request_id); + gboolean (*discover_attributes)(ZigBeeDriver *driver, guint request_id); + gboolean (*discover_attributes_extended)(ZigBeeDriver *driver, guint request_id); + gboolean (*discover_commands_received)(ZigBeeDriver *driver, guint request_id); + gboolean (*discover_commands_generated)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZclglobalControlOps_t; +/**< ZigBee 'Zclglobal control' ops IDs */ +typedef enum { + ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ = 1, /**< Read attributes req */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ, /**< Write attributes req */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ, /**< Write attributes undivided req */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP, /**< Write attributes no resp */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED, /**< Write attributes structured */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED, /**< Read attributes structured */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ, /**< Configure reporting req */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING, /**< Read configure reporting */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES, /**< Discover attributes */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED, /**< Discover attributes extended */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED, /**< Discover commands received */ + ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED, /**< Discover commands generated */ +} ZblibZclglobalControlOps_e; + /* ZigBee 'Zclglobal control' driver APIs */ ZigBeeDriver *zblib_driver_zclglobal_control_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZclglobalControlOps_t *ops); void zblib_driver_zclglobal_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZCLGLOBAL_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZCLGLOBAL_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zclias_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zclias_control.h index d517152..82e4f91 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zclias_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zclias_control.h @@ -16,14 +16,20 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZCLIAS_CONTROL_H__ -#define __ZIGBEE_LIB_ZCLIAS_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZCLIAS_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_ZCLIAS_CONTROL_H__ /**< ZigBee 'Zclias control' driver operations */ typedef struct { - gboolean (*enroll_response)(ZigBeeDriver *driver); + gboolean (*enroll_response)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZcliasControlOps_t; +/**< ZigBee 'Zclias control' ops IDs */ +typedef enum { + ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE = 1, /**< Enroll response */ +} ZblibZcliasControlOps_e; + + /* ZigBee 'Zclias control' driver APIs */ ZigBeeDriver *zblib_driver_zclias_control_new(ZigBeePlugin *plugin, const gchar *driver_name, @@ -31,4 +37,4 @@ ZigBeeDriver *zblib_driver_zclias_control_new(ZigBeePlugin *plugin, void zblib_driver_zclias_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZCLIAS_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZCLIAS_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zclidentify_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zclidentify_control.h index 5b616b6..27e77dc 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zclidentify_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zclidentify_control.h @@ -16,19 +16,25 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZCLIDENTIFY_CONTROL_H__ -#define __ZIGBEE_LIB_ZCLIDENTIFY_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZCLIDENTIFY_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_ZCLIDENTIFY_CONTROL_H__ /**< ZigBee 'Zclidentify control' driver operations */ typedef struct { - gboolean (*identify)(ZigBeeDriver *driver); - gboolean (*query)(ZigBeeDriver *driver); + gboolean (*identify)(ZigBeeDriver *driver, guint request_id); + gboolean (*query)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZclidentifyControlOps_t; +/**< ZigBee 'Zclidentify control' ops IDs */ +typedef enum { + ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY = 1, /**< Identify */ + ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY, /**< Query */ +} ZblibZclidentifyControlOps_e; + /* ZigBee 'Zclidentify control' driver APIs */ ZigBeeDriver *zblib_driver_zclidentify_control_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZclidentifyControlOps_t *ops); void zblib_driver_zclidentify_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZCLIDENTIFY_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZCLIDENTIFY_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zdo_bind.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zdo_bind.h index d1d6ea1..a1397c4 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zdo_bind.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zdo_bind.h @@ -16,19 +16,25 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZDO_BIND_H__ -#define __ZIGBEE_LIB_ZDO_BIND_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZDO_BIND_H__ +#define __ZIGBEE_LIB_DRIVER_ZDO_BIND_H__ /**< ZigBee 'Zdo bind' driver operations */ typedef struct { - gboolean (*bind_req)(ZigBeeDriver *driver); - gboolean (*unbind_req)(ZigBeeDriver *driver); + gboolean (*bind_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*unbind_req)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZdoBindOps_t; +/**< ZigBee 'Zdo bind' ops IDs */ +typedef enum { + ZBLIB_ZDO_BIND_OPS_BIND_REQ = 1, /**< Bind req */ + ZBLIB_ZDO_BIND_OPS_UNBIND_REQ, /**< Unbind req */ +} ZblibZdoBindOps_e; + /* ZigBee 'Zdo bind' driver APIs */ ZigBeeDriver *zblib_driver_zdo_bind_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZdoBindOps_t *ops); void zblib_driver_zdo_bind_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZDO_BIND_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZDO_BIND_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_driver_zdodev_control.h b/zigbee-daemon/zigbee-lib/include/zblib_driver_zdodev_control.h index 2cbe62d..d233d37 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_driver_zdodev_control.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_driver_zdodev_control.h @@ -16,34 +16,55 @@ * limitations under the License. */ -#ifndef __ZIGBEE_LIB_ZDODEV_CONTROL_H__ -#define __ZIGBEE_LIB_ZDODEV_CONTROL_H__ +#ifndef __ZIGBEE_LIB_DRIVER_ZDODEV_CONTROL_H__ +#define __ZIGBEE_LIB_DRIVER_ZDODEV_CONTROL_H__ /**< ZigBee 'Zdodev control' driver operations */ typedef struct { - gboolean (*nwk_addr_req)(ZigBeeDriver *driver); - gboolean (*matched_descriptor_req)(ZigBeeDriver *driver); - gboolean (*ieee_addr_req)(ZigBeeDriver *driver); - gboolean (*active_ep_req)(ZigBeeDriver *driver); - gboolean (*node_desc_req)(ZigBeeDriver *driver); - gboolean (*power_desc_req)(ZigBeeDriver *driver); - gboolean (*complex_desc_req)(ZigBeeDriver *driver); - gboolean (*user_desc_req)(ZigBeeDriver *driver); - gboolean (*user_desc_set_req)(ZigBeeDriver *driver); - gboolean (*device_announce)(ZigBeeDriver *driver); - gboolean (*simple_desc_req)(ZigBeeDriver *driver); - gboolean (*mgmt_lqi_req)(ZigBeeDriver *driver); - gboolean (*mgmt_rtg_req)(ZigBeeDriver *driver); - gboolean (*mgmt_bind_req)(ZigBeeDriver *driver); - gboolean (*mgmt_permit_join_req)(ZigBeeDriver *driver); - gboolean (*nwk_update_req)(ZigBeeDriver *driver); - gboolean (*nwk_disc_req)(ZigBeeDriver *driver); + gboolean (*nwk_addr_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*matched_descriptor_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*ieee_addr_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*active_ep_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*node_desc_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*power_desc_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*complex_desc_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*user_desc_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*user_desc_set_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*device_announce)(ZigBeeDriver *driver, guint request_id); + gboolean (*simple_desc_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*mgmt_lqi_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*mgmt_rtg_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*mgmt_bind_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*mgmt_permit_join_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*nwk_update_req)(ZigBeeDriver *driver, guint request_id); + gboolean (*nwk_disc_req)(ZigBeeDriver *driver, guint request_id); } ZblibDriverZdodevControlOps_t; +/**< ZigBee 'Zdodev control' ops IDs */ +typedef enum { + ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ = 1, /**< Nwk addr req */ + ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ, /**< Matched descriptor req */ + ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ, /**< IEEE addr req */ + ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ, /**< Active ep req */ + ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ, /**< Mode desc req */ + ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ, /**< Power desc req */ + ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ, /**< Complex desc req */ + ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ, /**< User desc req */ + ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ, /**< User desc set req */ + ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE, /**< Device announce */ + ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ, /**< Simple desc req */ + ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ, /**< Mgmt lqi req */ + ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ, /**< Mgmt rtg req */ + ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ, /**< mgmt bind req */ + ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ, /**< mgmt permit join req */ + ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ, /**< Nwk update req */ + ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ, /**< Nwk disc req */ +} ZblibZdodevControlOps_e; + /* ZigBee 'Zdodev control' driver APIs */ ZigBeeDriver *zblib_driver_zdodev_control_new(ZigBeePlugin *plugin, const gchar *driver_name, ZblibDriverZdodevControlOps_t *ops); void zblib_driver_zdodev_control_free(ZigBeeDriver *driver); -#endif /* __ZIGBEE_LIB_ZDODEV_CONTROL_H__ */ +#endif /* __ZIGBEE_LIB_DRIVER_ZDODEV_CONTROL_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_plugin.h b/zigbee-daemon/zigbee-lib/include/zblib_plugin.h index 4e1907a..6fd6c40 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_plugin.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_plugin.h @@ -39,4 +39,6 @@ void zblib_plugin_free(ZigBeePlugin *plugin); const struct zblib_plugin_descriptor *zblib_plugin_get_descriptor(ZigBeePlugin *plugin); char *zblib_plugin_get_plugin_name(ZigBeePlugin *plugin); +ZigBeeDriver *zblib_plugin_ref_driver(ZigBeePlugin *plugin, ZblibDriverType_e driver_type); + #endif /* __ZIGBEE_LIB_PLUGIN_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_request.h b/zigbee-daemon/zigbee-lib/include/zblib_request.h new file mode 100644 index 0000000..2a800cc --- /dev/null +++ b/zigbee-daemon/zigbee-lib/include/zblib_request.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Suresh Kumar N (suresh.n@samsung.com) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __ZIGBEE_LIB_REQUEST_H__ +#define __ZIGBEE_LIB_REQUEST_H__ + +/**< ZigBee invalid request ID */ +#define ZIGBEE_REQUEST_INVALID_REQUEST_ID (-1) + +gint zblib_request_new(ZigBeeServiceInterface *service_interface, + guint request_type, gpointer request_data, guint request_data_len); +void zblib_request_free(ZigBeeRequest *request); + +ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request); +void zblib_request_unref(ZigBeeRequest *request); + +guint zblib_request_ref_request_type(ZigBeeRequest *request); +ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeRequest *request); +gpointer zblib_request_ref_request_data(ZigBeeRequest *request); + +guint zblib_request_generate_request_type(ZblibDriverType_e driver_type, + guint ops_id); +gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service, + guint request_id); + +ZblibDriverType_e zblib_request_get_driver_type(guint request_type); +guint zblib_request_get_ops_id(guint request_type); + +#endif /* __ZIGBEE_LIB_REQUEST_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_service.h b/zigbee-daemon/zigbee-lib/include/zblib_service.h index a32ed55..8d21a27 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_service.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_service.h @@ -42,4 +42,7 @@ gboolean zblib_service_remove_service_interface(ZigBeeService *service, ZigBeeServiceInterface *zblib_service_ref_service_interface(ZigBeeService *service, const gchar *service_interface_name); +GHashTable *zblib_service_ref_request_hash_table(ZigBeeService *service); +gint zblib_service_generate_request_id(ZigBeeService *service); + #endif /* __ZIGBEE_LIB_SERVICE_H__ */ diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_alarm.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_alarm.c index e793dd8..19b8bf9 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_alarm.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_alarm.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_alarm.h" @@ -26,13 +27,57 @@ typedef struct { ZblibDriverAlarmOps_t *ops; /**< Operations */ } ZblibDriverAlarmPrivData_t; -static gboolean __zblib_driver_alarm_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_alarm_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: { + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALARM: { + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: { + } + break; + + case ZBLIB_ALARM_OPS_ALARM: { + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: { + } + break; + + case ZBLIB_ALARM_OPS_GET_ALARM: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_custom.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_custom.c index 8003142..6957e1d 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_custom.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_custom.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_custom.h" @@ -26,13 +27,45 @@ typedef struct { ZblibDriverCustomOps_t *ops; /**< Operations */ } ZblibDriverCustomPrivData_t; -static gboolean __zblib_driver_custom_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_custom_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_CUSTOM_OPS_APS_SEND: { + } + break; + + case ZBLIB_CUSTOM_OPS_ZCL_SEND: { + } + break; + + case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_door_lock.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_door_lock.c index 46e1227..c06350a 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_door_lock.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_door_lock.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_door_lock.h" @@ -26,13 +27,49 @@ typedef struct { ZblibDriverDoorLockOps_t *ops; /**< Operations */ } ZblibDriverDoorLockPrivData_t; -static gboolean __zblib_driver_door_lock_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_door_lock_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: { + } + break; + + case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: { + } + break; + + case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: { + } + break; + + case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_fan_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_fan_control.c index a682f8a..b01117b 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_fan_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_fan_control.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_fan_control.h" @@ -26,13 +27,49 @@ typedef struct { ZblibDriverFanControlOps_t *ops; /**< Operations */ } ZblibDriverFanControlPrivData_t; -static gboolean __zblib_driver_fan_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_fan_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: { + } + break; + + case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: { + } + break; + + case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: { + } + break; + + case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_level_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_level_control.c index 027d563..69028f7 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_level_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_level_control.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_level_control.h" @@ -26,13 +27,61 @@ typedef struct { ZblibDriverLevelControlOps_t *ops; /**< Operations */ } ZblibDriverLevelControlPrivData_t; -static gboolean __zblib_driver_level_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_level_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STEP: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STOP: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_mfglib_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_mfglib_control.c index e8ae16e..b7a8846 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_mfglib_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_mfglib_control.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_mfglib_control.h" @@ -26,13 +27,101 @@ typedef struct { ZblibDriverMfglibControlOps_t *ops; /**< Operations */ } ZblibDriverMfglibControlPrivData_t; -static gboolean __zblib_driver_mfglib_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_mfglib_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_MFGLIB_CONTROL_OPS_START: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_END: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_on_off.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_on_off.c index 4bdfe98..643e2bc 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_on_off.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_on_off.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_on_off.h" @@ -26,13 +27,41 @@ typedef struct { ZblibDriverOnOffOps_t *ops; /**< Operations */ } ZblibDriverOnOffPrivData_t; -static gboolean __zblib_driver_on_off_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_on_off_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ON_OFF_OPS_SET_ON_OFF: { + } + break; + + case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_service.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_service.c index c2f7be9..fd7ff58 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_service.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_service.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_service.h" @@ -26,13 +27,97 @@ typedef struct { ZblibDriverServiceOps_t *ops; /**< Operations */ } ZblibDriverServicePrivData_t; -static gboolean __zblib_driver_service_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_service_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_SERVICE_OPS_ENABLE: { + } + break; + + case ZBLIB_SERVICE_OPS_DISABLE: { + } + break; + + case ZBLIB_SERVICE_OPS_ZB_HW_RESET: { + } + break; + + case ZBLIB_SERVICE_OPS_FORM_NETWORK: { + } + break; + + case ZBLIB_SERVICE_OPS_COEX_START: { + } + break; + + case ZBLIB_SERVICE_OPS_COEX_STOP: { + } + break; + + case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: { + } + break; + + case ZBLIB_SERVICE_OPS_PERMIT_JOIN: { + } + break; + + case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_MAC: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_thermostat.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_thermostat.c index 9456ad5..ea60480 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_thermostat.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_thermostat.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_thermostat.h" @@ -26,13 +27,53 @@ typedef struct { ZblibDriverThermostatOps_t *ops; /**< Operations */ } ZblibDriverThermostatPrivData_t; -static gboolean __zblib_driver_thermostat_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_thermostat_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: { + } + break; + + case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: { + } + break; + + case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: { + } + break; + + case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: { + } + break; + + case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_color.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_color.c index e2a6544..9f713bc 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_color.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_color.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zcl_color.h" @@ -26,13 +27,77 @@ typedef struct { ZblibDriverZclColorOps_t *ops; /**< Operations */ } ZblibDriverZclColorPrivData_t; -static gboolean __zblib_driver_zcl_color_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zcl_color_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_group.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_group.c index 9400a58..8209366 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_group.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_group.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zcl_group.h" @@ -26,13 +27,57 @@ typedef struct { ZblibDriverZclGroupOps_t *ops; /**< Operations */ } ZblibDriverZclGroupPrivData_t; -static gboolean __zblib_driver_zcl_group_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zcl_group_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_poll_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_poll_control.c index 768744b..b1e60ad 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_poll_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_poll_control.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zcl_poll_control.h" @@ -26,13 +27,49 @@ typedef struct { ZblibDriverZclPollControlOps_t *ops; /**< Operations */ } ZblibDriverZclPollControlPrivData_t; -static gboolean __zblib_driver_zcl_poll_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zcl_poll_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: { + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: { + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: { + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_scene.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_scene.c index c036e64..67139c2 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_scene.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_scene.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zcl_scene.h" @@ -26,13 +27,61 @@ typedef struct { ZblibDriverZclSceneOps_t *ops; /**< Operations */ } ZblibDriverZclScenePrivData_t; -static gboolean __zblib_driver_zcl_scene_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zcl_scene_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclbasic_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclbasic_control.c index d53790e..d8f4958 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclbasic_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclbasic_control.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zclbasic_control.h" @@ -26,13 +27,37 @@ typedef struct { ZblibDriverZclbasicControlOps_t *ops; /**< Operations */ } ZblibDriverZclbasicControlPrivData_t; -static gboolean __zblib_driver_zclbasic_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zclbasic_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclglobal_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclglobal_control.c index 3f9dae3..22cfbd1 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclglobal_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclglobal_control.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zclglobal_control.h" @@ -26,13 +27,81 @@ typedef struct { ZblibDriverZclglobalControlOps_t *ops; /**< Operations */ } ZblibDriverZclglobalControlPrivData_t; -static gboolean __zblib_driver_zclglobal_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zclglobal_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclias_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclias_control.c index 4456ce3..9702382 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclias_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclias_control.c @@ -15,8 +15,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + #include #include +#include #include "zblib_driver_zclias_control.h" @@ -25,13 +27,37 @@ typedef struct { ZblibDriverZcliasControlOps_t *ops; /**< Operations */ } ZblibDriverZcliasControlPrivData_t; -static gboolean __zblib_driver_zclias_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zclias_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclidentify_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclidentify_control.c index a582c68..0644eb9 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclidentify_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclidentify_control.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zclidentify_control.h" @@ -26,13 +27,41 @@ typedef struct { ZblibDriverZclidentifyControlOps_t *ops; /**< Operations */ } ZblibDriverZclidentifyControlPrivData_t; -static gboolean __zblib_driver_zclidentify_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zclidentify_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: { + } + break; + + case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdo_bind.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdo_bind.c index 3230d2f..c844d59 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdo_bind.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdo_bind.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zdo_bind.h" @@ -26,13 +27,41 @@ typedef struct { ZblibDriverZdoBindOps_t *ops; /**< Operations */ } ZblibDriverZdoBindPrivData_t; -static gboolean __zblib_driver_zdo_bind_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zdo_bind_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZDO_BIND_OPS_BIND_REQ: { + } + break; + + case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdodev_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdodev_control.c index c49645b..9ad3696 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdodev_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdodev_control.c @@ -18,6 +18,7 @@ #include #include +#include #include "zblib_driver_zdodev_control.h" @@ -26,13 +27,101 @@ typedef struct { ZblibDriverZdodevControlOps_t *ops; /**< Operations */ } ZblibDriverZdodevControlPrivData_t; -static gboolean __zblib_driver_zdodev_control_dispatcher(ZigBeeDriver *driver) +static gboolean __zblib_driver_zdodev_control_dispatcher(ZigBeeDriver *driver, guint request_id) { + ZigBeeService *service = NULL; + guint request_type; + guint ops_id; + if (NULL == driver) { Z_LOGE("driver is NULL"); return FALSE; } + service = zblib_driver_ref_service(driver); + if (NULL == service) { + Z_LOGE("service is NULL"); + return FALSE; + } + + /* Fetch request_type using request_id */ + request_type = zblib_request_ref_request_type_by_request_id(service, request_id); + + /* Fetch ops ID */ + ops_id = zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: { + } + break; + + default: + break; + } + return TRUE; } diff --git a/zigbee-daemon/zigbee-lib/src/zblib_driver.c b/zigbee-daemon/zigbee-lib/src/zblib_driver.c index 2ecd48d..a14b779 100644 --- a/zigbee-daemon/zigbee-lib/src/zblib_driver.c +++ b/zigbee-daemon/zigbee-lib/src/zblib_driver.c @@ -69,6 +69,26 @@ void zblib_driver_free(ZigBeeDriver *driver) g_free(driver); } +ZigBeeService *zblib_driver_ref_service(ZigBeeDriver *driver) +{ + if (driver == NULL) { + Z_LOGE("driver is NULL"); + return NULL; + } + + return driver->service; +} + +ZigBeePlugin *zblib_driver_ref_plugin(ZigBeeDriver *driver) +{ + if (driver == NULL) { + Z_LOGE("driver is NULL"); + return NULL; + } + + return driver->plugin; +} + gboolean zblib_driver_link_object(ZigBeeDriver *driver, gpointer object) { if (driver == NULL) { @@ -123,4 +143,20 @@ ZblibDriverType_e zblib_driver_ref_driver_type(ZigBeeDriver *driver) } return driver->driver_type; -} \ No newline at end of file +} + +gboolean zblib_driver_dispatch_request(ZigBeeDriver *driver, guint request_id) +{ + if (driver == NULL) { + Z_LOGE("driver is NULL"); + return FALSE; + } + + if (NULL == driver->dispatcher_fn) { + Z_LOGE("dispatcher_fn is NULL"); + return FALSE; + } + + /* Dispatch request to driver dispatcher function */ + return driver->dispatcher_fn(driver, request_id); +} diff --git a/zigbee-daemon/zigbee-lib/src/zblib_plugin.c b/zigbee-daemon/zigbee-lib/src/zblib_plugin.c index f2136dd..539e9df 100644 --- a/zigbee-daemon/zigbee-lib/src/zblib_plugin.c +++ b/zigbee-daemon/zigbee-lib/src/zblib_plugin.c @@ -56,7 +56,7 @@ ZigBeePlugin *zblib_plugin_new(ZigBeeService *service, void zblib_plugin_free(ZigBeePlugin *plugin) { - if (plugin == NULL) { + if (NULL == plugin) { Z_LOGE("ZigBee vendor plug-in is NULL"); return; } @@ -69,7 +69,7 @@ void zblib_plugin_free(ZigBeePlugin *plugin) for (list = plugin->driver_list; list; list = list->next) { driver = list->data; - if (!driver) + if (NULL == driver) continue; zblib_driver_free(driver); @@ -97,7 +97,7 @@ void zblib_plugin_free(ZigBeePlugin *plugin) const struct zblib_plugin_descriptor *zblib_plugin_get_descriptor(ZigBeePlugin *plugin) { - if (plugin == NULL) { + if (NULL == plugin) { Z_LOGE("ZigBee vendor plug-in is NULL"); return NULL; } @@ -107,10 +107,38 @@ const struct zblib_plugin_descriptor *zblib_plugin_get_descriptor(ZigBeePlugin * char *zblib_plugin_get_plugin_name(ZigBeePlugin *plugin) { - if (plugin == NULL) { + if (NULL == plugin) { Z_LOGE("ZigBee vendor plug-in is NULL"); return NULL; } return g_strdup(plugin->plugin_name); } + +ZigBeeDriver *zblib_plugin_ref_driver(ZigBeePlugin *plugin, ZblibDriverType_e driver_type) +{ + ZigBeeDriver *driver = NULL; + ZblibDriverType_e _driver_type; + GSList *list = NULL; + + if (NULL == plugin) { + Z_LOGE("ZigBee vendor plug-in is NULL"); + return NULL; + } + + list = plugin->driver_list; + while (list) { + /* Fetch driver type of driver */ + _driver_type = zblib_driver_ref_driver_type((ZigBeeDriver *)(list->data)); + if (_driver_type == driver_type) { + /* Driver found */ + driver = (ZigBeeDriver *)(list->data); + break; + } + + /* Move to next driver */ + list = g_slist_next(list); + } + + return driver; +} diff --git a/zigbee-daemon/zigbee-lib/src/zblib_request.c b/zigbee-daemon/zigbee-lib/src/zblib_request.c new file mode 100644 index 0000000..be8340b --- /dev/null +++ b/zigbee-daemon/zigbee-lib/src/zblib_request.c @@ -0,0 +1,1259 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Suresh Kumar N (suresh.n@samsung.com) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/**< ZigBee Request object */ +struct zblib_request_type { + gint request_id; /**< Request ID */ + guint request_type; /**< Request type */ + guint ref_count; /* Reference count */ + + gpointer request_data; /**< Request data */ + + ZigBeeServiceInterface *service_interface; /* Service interface */ +}; + +static ZblibDriverType_e __zblib_request_get_driver_type(guint request_type) +{ + ZblibDriverType_e driver_type; + + driver_type = ((request_type && 0xFF000000) >> 24); + + return driver_type; +} + +static ZblibDriverType_e __zblib_request_get_ops_id(guint request_type) +{ + guint ops_id; + + ops_id = (request_type && 0x000000FF); + + return ops_id; +} + +static gpointer __zblib_request_create_alarm_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer alarm_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: { + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALARM: { + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: { + } + break; + + case ZBLIB_ALARM_OPS_ALARM: { + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: { + } + break; + + case ZBLIB_ALARM_OPS_GET_ALARM: { + } + break; + + default: + break; + } + + return alarm_request_data; +} + +static gpointer __zblib_request_create_custom_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer custom_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_CUSTOM_OPS_APS_SEND: { + } + break; + + case ZBLIB_CUSTOM_OPS_ZCL_SEND: { + } + break; + + case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: { + } + break; + + default: + break; + } + + return custom_request_data; +} + +static gpointer __zblib_request_create_door_lock_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer door_lock_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: { + } + break; + + case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: { + } + break; + + case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: { + } + break; + + case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: { + } + break; + + default: + break; + } + + return door_lock_request_data; +} + +static gpointer __zblib_request_create_fan_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer fan_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: { + } + break; + + case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: { + } + break; + + case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: { + } + break; + + case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: { + } + break; + + default: + break; + } + + return fan_control_request_data; +} + +static gpointer __zblib_request_create_level_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer level_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STEP: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: { + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STOP: { + } + break; + + default: + break; + } + + return level_control_request_data; +} + +static gpointer __zblib_request_create_mfglib_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer mfglib_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_MFGLIB_CONTROL_OPS_START: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_END: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: { + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: { + } + break; + + default: + break; + } + + return mfglib_control_request_data; +} + +static gpointer __zblib_request_create_on_off_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer on_off_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ON_OFF_OPS_SET_ON_OFF: { + } + break; + + case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: { + } + break; + + default: + break; + } + + return on_off_request_data; +} + +static gpointer __zblib_request_create_service_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer service_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_SERVICE_OPS_ENABLE: { + } + break; + + case ZBLIB_SERVICE_OPS_DISABLE: { + } + break; + + case ZBLIB_SERVICE_OPS_ZB_HW_RESET: { + } + break; + + case ZBLIB_SERVICE_OPS_FORM_NETWORK: { + } + break; + + case ZBLIB_SERVICE_OPS_COEX_START: { + } + break; + + case ZBLIB_SERVICE_OPS_COEX_STOP: { + } + break; + + case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: { + } + break; + + case ZBLIB_SERVICE_OPS_PERMIT_JOIN: { + } + break; + + case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_MAC: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: { + } + break; + + case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: { + } + break; + + default: + break; + } + + return service_request_data; +} + +static gpointer __zblib_request_create_thermostat_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer thermostat_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: { + } + break; + + case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: { + } + break; + + case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: { + } + break; + + case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: { + } + break; + + case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: { + } + break; + + default: + break; + } + + return thermostat_request_data; +} + +static gpointer __zblib_request_create_zclbasic_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zclbasic_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: { + } + break; + + default: + break; + } + + return zclbasic_control_request_data; +} + +static gpointer __zblib_request_create_zclglobal_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zclglobal_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: { + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: { + } + break; + + default: + break; + } + + return zclglobal_control_request_data; +} + +static gpointer __zblib_request_create_zclias_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zclias_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: { + } + break; + + default: + break; + } + + return zclias_control_request_data; +} + +static gpointer __zblib_request_create_zclidentify_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zclidentify_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: { + } + break; + + case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: { + } + break; + + default: + break; + } + + return zclidentify_control_request_data; +} + +static gpointer __zblib_request_create_zcl_color_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zcl_color_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: { + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: { + } + break; + + default: + break; + } + + return zcl_color_request_data; +} + +static gpointer __zblib_request_create_zcl_group_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zcl_group_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: { + } + break; + + case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: { + } + break; + + default: + break; + } + + return zcl_group_request_data; +} + +static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zcl_poll_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: { + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: { + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: { + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: { + } + break; + + default: + break; + } + + return zcl_poll_control_request_data; +} + +static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zcl_scene_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: { + } + break; + + case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: { + } + break; + + default: + break; + } + + return zcl_scene_request_data; +} + +static gpointer __zblib_request_create_zdodev_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zdodev_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: { + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: { + } + break; + + default: + break; + } + + return zdodev_control_request_data; +} + +static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zdo_bind_request_data = NULL; + guint ops_id; + + NOT_USED(request_data); + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZDO_BIND_OPS_BIND_REQ: { + } + break; + + case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: { + } + break; + + default: + break; + } + + return zdo_bind_request_data; +} + +static gpointer __zblib_request_create_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer _request_data = NULL; + ZblibDriverType_e driver_type; + + /* Fetch driver type */ + driver_type = __zblib_request_get_driver_type(request_type); + switch (driver_type) { + case ZBLIB_DRIVER_TYPE_ALARM: { + _request_data = __zblib_request_create_alarm_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_CUSTOM: { + _request_data = __zblib_request_create_custom_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_DOOR_LOCK: { + _request_data = __zblib_request_create_door_lock_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_FAN_CONTROL: { + _request_data = __zblib_request_create_fan_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: { + _request_data = __zblib_request_create_level_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: { + _request_data = __zblib_request_create_mfglib_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ON_OFF: { + _request_data = __zblib_request_create_on_off_request_data(request_type, + request_data, request_data_len); + } + break; + case ZBLIB_DRIVER_TYPE_SERVICE: { + _request_data = __zblib_request_create_service_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_THERMOSTAT: { + _request_data = __zblib_request_create_thermostat_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: { + _request_data = __zblib_request_create_zclbasic_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: { + _request_data = __zblib_request_create_zclglobal_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: { + _request_data = __zblib_request_create_zclias_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: { + _request_data = __zblib_request_create_zclidentify_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCL_COLOR: { + _request_data = __zblib_request_create_zcl_color_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCL_GROUP: { + _request_data = __zblib_request_create_zcl_group_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: { + _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCL_SCENE: { + _request_data = __zblib_request_create_zcl_scene_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: { + _request_data = __zblib_request_create_zdodev_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZDO_BIND: { + _request_data = __zblib_request_create_zdo_bind_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_NONE: /* Fallthrough */ + default: { + Z_LOGE("Unhandled driver type: [%d]", driver_type); + } + break; + } + + return _request_data; +} + +static void __zblib_request_free_request_data(gpointer request_data) +{ + if (NULL == request_data) { + Z_LOGE("request_data is NULL"); + return; + } + + /* Free resources */ + g_free(request_data); +} + +gint zblib_request_new(ZigBeeServiceInterface *service_interface, + guint request_type, gpointer request_data, guint request_data_len) +{ + ZigBeeService *service = NULL; + ZigBeeRequest *request = NULL; + GHashTable *request_table = NULL; + + if (NULL == service_interface) { + Z_LOGE("service_interface is NULL"); + return ZIGBEE_REQUEST_INVALID_REQUEST_ID; + } + + service = zblib_service_interface_ref_service(service_interface); + if (NULL == service) { + Z_LOGE("service is NULL"); + return ZIGBEE_REQUEST_INVALID_REQUEST_ID; + } + + /* Allocate ZigBee request memory */ + request = g_malloc0(sizeof(ZigBeeRequest)); + + /* Update request */ + request->service_interface = service_interface; + request->ref_count = 1; /* Initialize reference count to '1' for new request */ + + /* Update request data for specific request */ + request->request_data = __zblib_request_create_request_data(request_type, + request_data, request_data_len); + request->request_type = request_type; + + /* Generate request ID */ + request->request_id = zblib_service_generate_request_id(service); + if (ZIGBEE_REQUEST_INVALID_REQUEST_ID == request->request_id) { + Z_LOGE("zblib_service_genrate_request_id failed!"); + + /* Free resources */ + g_free(request); + + return ZIGBEE_REQUEST_INVALID_REQUEST_ID; + } + + /* Fetch request table from service */ + request_table = zblib_service_ref_request_hash_table(service); + if (NULL == request_table) { + Z_LOGE("zblib_service_ref_request_hash_table failed!"); + + /* Free resources */ + g_free(request); + + return ZIGBEE_REQUEST_INVALID_REQUEST_ID; + } + + /* Insert request to request table */ + g_hash_table_insert(request_table, (gpointer)(request->request_id), request); + + return request->request_id; +} + +void zblib_request_free(ZigBeeRequest *request) +{ + if (NULL == request) { + Z_LOGE("request is NULL"); + return; + } + + /* Free resources */ + __zblib_request_free_request_data(request->request_data); + g_free(request); +} + +ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request) +{ + if (NULL == request) { + Z_LOGE("request is NULL"); + return request; + } + + request->ref_count++; + + return request; +} + +void zblib_request_unref(ZigBeeRequest *request) +{ + if (NULL == request) { + Z_LOGE("request is NULL"); + return; + } + + request->ref_count--; + if (0 == request->ref_count) { + Z_LOGD("Reference count is ZERO!"); + + /* Free 'request' */ + zblib_request_free(request); + } +} + +guint zblib_request_ref_request_type(ZigBeeRequest *request) +{ + if (NULL == request) { + Z_LOGE("request is NULL"); + return 0; + } + + return request->request_type; +} + +ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeRequest *request) +{ + if (NULL == request) { + Z_LOGE("request is NULL"); + return NULL; + } + + return request->service_interface; +} + +gpointer zblib_request_ref_request_data(ZigBeeRequest *request) +{ + if (NULL == request) { + Z_LOGE("request is NULL"); + return NULL; + } + + return request->request_data; +} + +guint zblib_request_generate_request_type(ZblibDriverType_e driver_type, + guint ops_id) +{ + guint request_type; + + /* + * request_type consists of driver_type and ops_id + * request_type = driver_type | 0x00 | 0x00 | ops_id + */ + request_type = (driver_type << 24) | (ops_id); + + return request_type; +} + +gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service, + guint request_id) +{ + ZigBeeRequest *request = NULL; + GHashTable *request_table = NULL; + + /* Fetch request table from service */ + request_table = zblib_service_ref_request_hash_table(service); + if (NULL == request_table) { + Z_LOGE("zblib_service_ref_request_hash_table failed!"); + return -1; + } + + /* Look-up requets_id in request hash table */ + request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id); + if (NULL == request_table) { + Z_LOGE("No request availabel for request_id: [%d]", request_id); + return -1; + } + + return (gint)(request->request_type); +} + +ZblibDriverType_e zblib_request_get_driver_type(guint request_type) +{ + return __zblib_request_get_driver_type(request_type); +} + +guint zblib_request_get_ops_id(guint request_type) +{ + return __zblib_request_get_ops_id(request_type); +} diff --git a/zigbee-daemon/zigbee-lib/src/zblib_service.c b/zigbee-daemon/zigbee-lib/src/zblib_service.c index 91aee37..135a6f6 100644 --- a/zigbee-daemon/zigbee-lib/src/zblib_service.c +++ b/zigbee-daemon/zigbee-lib/src/zblib_service.c @@ -30,6 +30,9 @@ struct zblib_service_type { GSList *interface_objs; /**< ZigBee Service interface objects */ GSList *plugins; /**< ZigBee plug-ins */ + + GHashTable *request_table; /**< Request Hash table */ + guint request_id; /**< Request ID */ }; static void *__zblib_service_load_plugin(gchar *filename, @@ -40,21 +43,21 @@ static void *__zblib_service_load_plugin(gchar *filename, struct stat stat_buf; char file_date[27]; - if (descriptor_out == NULL) { + if (G_UNLIKELY(NULL == descriptor_out)) { Z_LOGE("descriptor_out is NULL!!!"); return FALSE; } /* Open .so */ handle = dlopen(filename, RTLD_LAZY); - if (NULL == handle) { + if (G_UNLIKELY(NULL == handle)) { Z_LOGE("dlopen() failed:[%s]", filename); return NULL; } /* Get symbol - "zigbee_plugin_descriptor" */ descriptor = dlsym(handle, "zigbee_plugin_descriptor"); - if (NULL == descriptor) { + if (G_UNLIKELY(NULL == descriptor)) { Z_LOGE("dlsym() failed:[%s]", "plugin_define_desc"); dlclose(handle); return NULL; @@ -95,14 +98,14 @@ static gboolean __zblib_service_init_plugin(ZigBeePlugin *plugin) { const struct zblib_plugin_descriptor *descriptor = zblib_plugin_get_descriptor(plugin); - if ((descriptor == NULL) || (descriptor->init == NULL)) { + if ((NULL == descriptor) || (NULL == descriptor->init)) { Z_LOGE("descriptor OR init function is NULL!!!"); return FALSE; } - if (descriptor->init(plugin) == FALSE) { + if (G_UNLIKELY(FALSE == descriptor->init(plugin))) { char *plugin_name = zblib_plugin_get_plugin_name(plugin); - if (NULL != plugin_name) { + if (G_UNLIKELY(NULL != plugin_name)) { Z_LOGE("plugin(%s) init failed!", plugin_name); g_free(plugin_name); } @@ -117,7 +120,7 @@ static gboolean __zblib_service_unload_plugin(ZigBeePlugin *plugin) const struct zblib_plugin_descriptor *descriptor = zblib_plugin_get_descriptor(plugin); char *plugin_name = zblib_plugin_get_plugin_name(plugin); - if ((descriptor == NULL) || (descriptor->unload == NULL)) { + if ((NULL == descriptor) || (NULL == descriptor->unload)) { Z_LOGE("descriptor OR unload function is NULL!!!"); return FALSE; } @@ -137,18 +140,22 @@ ZigBeeService *zblib_service_new() /* Create g-main loop */ service->main_loop = g_main_loop_new(NULL, FALSE); - if (service->main_loop == NULL) { + if (G_UNLIKELY(NULL == service->main_loop)) { Z_LOGE("g-main loop creation failed!!!"); g_free(service); return NULL; } + /* Create request hash table */ + service->request_table = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, NULL); + return service; } void zblib_service_free(ZigBeeService *service) { - if (service == NULL) { + if (NULL == service) { Z_LOGE("service is NULL"); return; } @@ -168,7 +175,7 @@ void zblib_service_free(ZigBeeService *service) gboolean zblib_service_run(ZigBeeService *service) { - if ((service == NULL) || (service->main_loop == NULL)) { + if ((NULL == service) || (NULL == service->main_loop)) { Z_LOGE("service or mainloop is NULL"); return FALSE; } @@ -180,7 +187,7 @@ gboolean zblib_service_run(ZigBeeService *service) gboolean zblib_service_exit(ZigBeeService *service) { - if ((service == NULL) || (service->main_loop == NULL)) { + if ((NULL == service) || (NULL == service->main_loop)) { Z_LOGE("service or mainloop is NULL"); return FALSE; } @@ -194,7 +201,7 @@ gboolean zblib_service_add_plugin(ZigBeeService *service, ZigBeePlugin *plugin) { gchar *plugin_name; - if ((service == NULL) || (plugin == NULL)) { + if ((NULL == service) || (plugin == NULL)) { Z_LOGE("service: [%p] plugin: [%p]", service, plugin); return FALSE; } @@ -211,7 +218,7 @@ gboolean zblib_service_add_plugin(ZigBeeService *service, ZigBeePlugin *plugin) gboolean zblib_service_remove_plugin(ZigBeeService *service, ZigBeePlugin *plugin) { - if ((service == NULL) || (plugin == NULL)) { + if ((NULL == service) || (plugin == NULL)) { Z_LOGE("service: [%p] plugin: [%p]", service, plugin); return FALSE; } @@ -232,14 +239,14 @@ gboolean zblib_service_load_plugins(ZigBeeService *service, const char *plugin_p ZigBeePlugin *plugin = NULL; gboolean ret; - if ((service == NULL) || (plugin_path == NULL)) { + if ((NULL == service) || (NULL == plugin_path)) { Z_LOGE("service: [%p] plugin_path: [%p]", service, plugin_path); return FALSE; } /* Open plug-in directory */ dir = g_dir_open(plugin_path, 0, NULL); - if (dir == NULL) { + if (G_UNLIKELY(dir == NULL)) { Z_LOGE("Directory open failed!"); return FALSE; } @@ -254,21 +261,21 @@ gboolean zblib_service_load_plugins(ZigBeeService *service, const char *plugin_p /* Load plug-in */ handle = __zblib_service_load_plugin(filename, &descriptor); - if (NULL == handle) { + if (G_UNLIKELY(NULL == handle)) { g_free(filename); continue; } /* Create new plug-in */ plugin = zblib_plugin_new(service, filename, descriptor, handle); - if (NULL == plugin) { + if (G_UNLIKELY(NULL == plugin)) { g_free(filename); continue; } /* Add new plug-in */ ret = zblib_service_add_plugin(service, plugin); - if (FALSE == ret) { + if (G_UNLIKELY(FALSE == ret)) { zblib_plugin_free(plugin); } @@ -283,7 +290,7 @@ gboolean zblib_service_initialize_plugins(ZigBeeService *service) { GSList *list; - if (service == NULL) { + if (NULL == service) { Z_LOGE("service is NULL"); return FALSE; } @@ -306,7 +313,7 @@ gboolean zblib_service_unload_plugins(ZigBeeService *service) { GSList *list; - if (service == NULL) { + if (NULL == service) { Z_LOGE("service is NULL"); return FALSE; } @@ -330,7 +337,7 @@ gboolean zblib_service_unload_plugins(ZigBeeService *service) GSList *zblib_service_ref_plugins(ZigBeeService *service) { - if (service == NULL) { + if (NULL == service) { Z_LOGE("service is NULL"); return NULL; } @@ -343,7 +350,7 @@ gboolean zblib_service_add_service_interface(ZigBeeService *service, { gchar *object_name; - if ((service == NULL) || (service_interface == NULL)) { + if ((NULL == service) || (NULL == service_interface)) { Z_LOGE("service: [%p] service_interface: [%p]", service, service_interface); return FALSE; } @@ -363,7 +370,7 @@ gboolean zblib_service_add_service_interface(ZigBeeService *service, gboolean zblib_service_remove_service_interface(ZigBeeService *service, ZigBeeServiceInterface *service_interface) { - if ((service == NULL) || (service_interface == NULL)) { + if ((NULL == service) || (NULL == service_interface)) { Z_LOGE("service: [%p] service_interface: [%p]", service, service_interface); return FALSE; } @@ -385,7 +392,7 @@ ZigBeeServiceInterface *zblib_service_ref_service_interface(ZigBeeService *servi GSList *list; - if ((service == NULL) || (service_interface_name == NULL)) { + if ((NULL == service) || (NULL == service_interface_name)) { Z_LOGE("service: [%p] service_interface_name: [%p]", service, service_interface_name); return NULL; } @@ -406,7 +413,7 @@ ZigBeeServiceInterface *zblib_service_ref_service_interface(ZigBeeService *servi list = g_slist_next(list); } - if (service_interface == NULL) { + if (NULL == service_interface) { Z_LOGE("Service interface object of name '%s' not found!", service_interface_name); return NULL; @@ -417,3 +424,25 @@ ZigBeeServiceInterface *zblib_service_ref_service_interface(ZigBeeService *servi return service_interface; } +GHashTable *zblib_service_ref_request_hash_table(ZigBeeService *service) +{ + if (NULL == service) { + Z_LOGE("service is NULL"); + return NULL; + } + + return service->request_table; +} + +gint zblib_service_generate_request_id(ZigBeeService *service) +{ + if (NULL == service) { + Z_LOGE("service is NULL"); + return -1; + } + + /* Increment request ID */ + service->request_id++; + + return (gint)service->request_id; +} \ No newline at end of file -- 2.7.4