${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
#include <zblib_log.h>
+#include <zigbee_alarm_type.h>
+#include <zigbee_custom_type.h>
+#include <zigbee_door_lock_type.h>
+#include <zigbee_fan_control_type.h>
+#include <zigbee_level_control_type.h>
+#include <zigbee_mfglib_control_type.h>
+#include <zigbee_on_off_type.h>
+#include <zigbee_service_type.h>
+#include <zigbee_thermostat_type.h>
+#include <zigbee_zclbasic_control_type.h>
+#include <zigbee_zclglobal_control_type.h>
+#include <zigbee_zclias_control_type.h>
+#include <zigbee_zclidentify_control_type.h>
+#include <zigbee_zcl_color_type.h>
+#include <zigbee_zcl_group_type.h>
+#include <zigbee_zcl_poll_control_type.h>
+#include <zigbee_zcl_scene_type.h>
+#include <zigbee_zdodev_control_type.h>
+#include <zigbee_zdo_bind_type.h>
+
#define NOT_USED(var) ((var) = (var))
/**< ZigBee module typedefs */
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__ */
#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);
ZblibDriverType_e zblib_driver_ref_driver_type(ZigBeeDriver *driver);
+gboolean zblib_driver_dispatch_request(ZigBeeDriver *driver, guint request_id);
+
#endif /* __ZIGBEE_LIB_DRIVER_H__ */
* 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__ */
* 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__ */
* 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__ */
* 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,
void zblib_driver_fan_control_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_FAN_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_FAN_CONTROL_H__ */
* 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__ */
* 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__ */
* 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__ */
* 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__ */
* 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__ */
* 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__ */
* 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__ */
* 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__ */
* 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__ */
* 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__ */
* 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__ */
* 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,
void zblib_driver_zclias_control_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_ZCLIAS_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCLIAS_CONTROL_H__ */
* 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__ */
* 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__ */
* 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__ */
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__ */
--- /dev/null
+/*
+ * 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__ */
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__ */
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_alarm.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_custom.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_door_lock.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_fan_control.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_level_control.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_mfglib_control.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_on_off.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_service.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_thermostat.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zcl_color.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zcl_group.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zcl_poll_control.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zcl_scene.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zclbasic_control.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zclglobal_control.h"
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;
}
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zclias_control.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zclidentify_control.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zdo_bind.h"
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;
}
#include <zblib.h>
#include <zblib_driver.h>
+#include <zblib_request.h>
#include "zblib_driver_zdodev_control.h"
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;
}
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) {
}
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);
+}
void zblib_plugin_free(ZigBeePlugin *plugin)
{
- if (plugin == NULL) {
+ if (NULL == plugin) {
Z_LOGE("ZigBee vendor plug-in is NULL");
return;
}
for (list = plugin->driver_list; list; list = list->next) {
driver = list->data;
- if (!driver)
+ if (NULL == driver)
continue;
zblib_driver_free(driver);
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;
}
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;
+}
--- /dev/null
+/*
+ * 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 <zblib.h>
+#include <zblib_request.h>
+#include <zblib_service.h>
+#include <zblib_service_interface.h>
+
+#include <zblib_driver.h>
+#include <zblib_driver_alarm.h>
+#include <zblib_driver_custom.h>
+#include <zblib_driver_door_lock.h>
+#include <zblib_driver_fan_control.h>
+#include <zblib_driver_level_control.h>
+#include <zblib_driver_mfglib_control.h>
+#include <zblib_driver_on_off.h>
+#include <zblib_driver_service.h>
+#include <zblib_driver_thermostat.h>
+#include <zblib_driver_zclbasic_control.h>
+#include <zblib_driver_zclglobal_control.h>
+#include <zblib_driver_zclias_control.h>
+#include <zblib_driver_zclidentify_control.h>
+#include <zblib_driver_zcl_color.h>
+#include <zblib_driver_zcl_group.h>
+#include <zblib_driver_zcl_poll_control.h>
+#include <zblib_driver_zcl_scene.h>
+#include <zblib_driver_zdodev_control.h>
+#include <zblib_driver_zdo_bind.h>
+
+/**< 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);
+}
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,
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;
{
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);
}
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;
}
/* 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;
}
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;
}
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;
}
{
gchar *plugin_name;
- if ((service == NULL) || (plugin == NULL)) {
+ if ((NULL == service) || (plugin == NULL)) {
Z_LOGE("service: [%p] plugin: [%p]", service, plugin);
return FALSE;
}
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;
}
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;
}
/* 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);
}
{
GSList *list;
- if (service == NULL) {
+ if (NULL == service) {
Z_LOGE("service is NULL");
return FALSE;
}
{
GSList *list;
- if (service == NULL) {
+ if (NULL == service) {
Z_LOGE("service is NULL");
return FALSE;
}
GSList *zblib_service_ref_plugins(ZigBeeService *service)
{
- if (service == NULL) {
+ if (NULL == service) {
Z_LOGE("service is NULL");
return NULL;
}
{
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;
}
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;
}
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;
}
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;
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
projects / platform / core / connectivity / zigbee-manager.git / commitdiff