#include <zigbee_types.h>
/**
- * @brief Definition for alarm structure.
+ * @brief Definition for get alarm count structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
- short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
- char alarm_code; /**< Alarm code */
- short cluster_id; /**< Cluster ID */
-} ZigbeeAlarmAlarm_t;
+} ZigbeeAlarmGetAlarmCount_t;
/**
* @brief Definition for reset alarm structure.
} ZigbeeAlarmResetAllAlarm_t;
/**
+ * @brief Definition for alarm structure.
+ * @since_tizen 3.0
+ */
+typedef struct {
+ char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
+ char endpoint; /**< Endpoint */
+ char alarm_code; /**< Alarm code */
+ short cluster_id; /**< Cluster ID */
+} ZigbeeAlarmAlarm_t;
+
+/**
* @brief Definition for reset all alarm logs structure.
* @since_tizen 3.0
*/
} ZigbeeAlarmResetAlarmLogs_t;
/**
- * @brief Definition for get alarm count structure.
+ * @brief Definition for get alarm structure.
* @since_tizen 3.0
*/
typedef struct {
- char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
+ short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
-} ZigbeeAlarmGetAlarmCount_t;
-
+} ZigbeeAlarmGetAlarm_t;
#endif /* __ZIGBEE_ALARM_TYPE_H__ */
*/
typedef struct {
short node_id;
- char aps_frame_ctl;
+ char aps_frame_ctrl;
char src_ep;
char dest_ep;
short cluster_id;
short profile_id;
- char zcl_frame_ctl;
+ char zcl_frame_ctrl;
short mfg_code;
char payload[ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN];
} ZigbeeCustomApsSend_t;
char src_ep;
char dest_ep;
short cluster_id;
- char zcl_frame_ctl;
+ char zcl_frame_ctrl;
char cmd_id;
char payload[ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN];
} ZigbeeCustomZclSend_t;
char endpoint; /**< Endpoint */
char move_mode; /**< Move mode */
char rate; /**< Rate of movement */
-} ZigbeeLevelControlMoveOnOff_t;
+} ZigbeeLevelControlMoveWithOnOff_t;
/**
* @brief Definition for level control step with on/off structure.
SET(ZIGBEE_INTERFACE_SRCS
${CMAKE_CURRENT_BINARY_DIR}/zigbee_generated_code.c
src/zigbee_service_interface.c
+ src/zigbee_service_interface_common.c
src/zigbee_service_dbus_interface.c
src/zigbee_service_dbus_interface_alarm.c
src/zigbee_service_dbus_interface_custom.c
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ALARM_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ALARM_H__
-gboolean zigbee_service_dbus_interface_alarm_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_alarm_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ALARM_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_CUSTOM_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_CUSTOM_H__
-gboolean zigbee_service_dbus_interface_custom_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_custom_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_CUSTOM_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_DOOR_LOCK_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_DOOR_LOCK_H__
-gboolean zigbee_service_dbus_interface_door_lock_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_door_lock_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_DOOR_LOCK_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_FAN_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_FAN_CONTROL_H__
-gboolean zigbee_service_dbus_interface_fan_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_fan_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_FAN_CONTROL_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_LEVEL_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_LEVEL_CONTROL_H__
-gboolean zigbee_service_dbus_interface_level_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_level_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_LEVEL_CONTROL_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_MFGLIB_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_MFGLIB_CONTROL_H__
-gboolean zigbee_service_dbus_interface_mfglib_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_mfglib_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_MFGLIB_CONTROL_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ON_OFF_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ON_OFF_H__
-gboolean zigbee_service_dbus_interface_on_off_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_on_off_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ON_OFF_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_SERVICE_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_SERVICE_H__
-gboolean zigbee_service_dbus_interface_service_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_service_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_SERVICE_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_THERMOSTAT_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_THERMOSTAT_H__
-gboolean zigbee_service_dbus_interface_thermostat_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_thermostat_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_THERMOSTAT_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_H__
-gboolean zigbee_service_dbus_interface_zcl_color_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zcl_color_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_GROUP_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_GROUP_H__
-gboolean zigbee_service_dbus_interface_zcl_group_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zcl_group_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_GROUP_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_POLL_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_POLL_CONTROL_H__
-gboolean zigbee_service_dbus_interface_zcl_poll_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zcl_poll_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_POLL_CONTROL_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_SCENE_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_SCENE_H__
-gboolean zigbee_service_dbus_interface_zcl_scene_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zcl_scene_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_SCENE_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLBASIC_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLBASIC_CONTROL_H__
-gboolean zigbee_service_dbus_interface_zclbasic_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zclbasic_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLBASIC_CONTROL_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLGLOBAL_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLGLOBAL_CONTROL_H__
-gboolean zigbee_service_dbus_interface_zclglobal_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zclglobal_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLGLOBAL_CONTROL_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIAS_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIAS_CONTROL_H__
-gboolean zigbee_service_dbus_interface_zclias_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zclias_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIAS_CONTROL_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIDENTIFY_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIDENTIFY_CONTROL_H__
-gboolean zigbee_service_dbus_interface_zclidentify_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zclidentify_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIDENTIFY_CONTROL_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDO_BIND_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDO_BIND_H__
-gboolean zigbee_service_dbus_interface_zdo_bind_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zdo_bind_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDO_BIND_H__ */
#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDODEV_CONTROL_H__
#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDODEV_CONTROL_H__
-gboolean zigbee_service_dbus_interface_zdodev_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zdodev_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDODEV_CONTROL_H__ */
</method>
<method name='permit_join'>
<arg type='i' name='duration' direction='in'/>
- <arg type='b' name='broadcastMgmtPermitJoin' direction='in'/>
+ <arg type='b' name='permitJoin' direction='in'/>
<arg type='i' name='result' direction='out'/>
<arg type='y' name='status' direction='out'/>
</method>
#include "zigbee_service_interface_common.h"
#include "zigbee_service_dbus_interface.h"
+/**< ZigBee D-BUS service interface name */
#define ZIGBEE_DBUS_SERVICE_INTERFACE_NAME "zigbee-dbus"
static gboolean zigbee_on_manager_get_zigbee_state(ZigbeeManager *zigbee_mgr,
return TRUE;
}
-static void zigbee_service_dbus_interface_initialize_interfaces(ZigBeeService *service,
+static void zigbee_service_dbus_interface_initialize_interfaces(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
gboolean ret;
- ret = zigbee_service_dbus_interface_alarm_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_alarm_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_custom_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_custom_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_door_lock_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_door_lock_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_fan_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_fan_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_level_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_level_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_mfglib_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_mfglib_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_on_off_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_on_off_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_service_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_service_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_thermostat_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_thermostat_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zclbasic_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zclbasic_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zcl_color_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_color_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zclglobal_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zclglobal_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zcl_group_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_group_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zclias_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zclias_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zclidentify_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zclidentify_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zcl_poll_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_poll_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zcl_scene_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_scene_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zdo_bind_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zdo_bind_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zdodev_control_init(service, zigbee_object);
+ ret = zigbee_service_dbus_interface_zdodev_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
}
/*
* Initialize interfaces
*/
- zigbee_service_dbus_interface_initialize_interfaces(service, zigbee_object);
+ zigbee_service_dbus_interface_initialize_interfaces(service_interface, zigbee_object);
Z_LOGI("ZigBee service interfaces initialized!!!");
/* Export the Object to Manager */
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_alarm.h>
+
+static void on_alarm_get_alarm_count_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_alarm_get_alarm_count(ZigbeeAlarm *alarm_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeAlarmGetAlarmCount_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(alarm_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeAlarmGetAlarmCount_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ALARM,
+ ZBLIB_ALARM_OPS_GET_ALARM_COUNT,
+ &req, sizeof(req),
+ on_alarm_get_alarm_count_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_alarm_reset_alarm_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_alarm_reset_alarm(ZigbeeAlarm *alarm_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gshort cluster_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeAlarmResetAlarm_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(alarm_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(alarmcode);
- NOT_USED(cluster_id);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeAlarmResetAlarm_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.alarm_code = alarmcode;
+ req.cluster_id = cluster_id;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ALARM,
+ ZBLIB_ALARM_OPS_RESET_ALARM,
+ &req, sizeof(req),
+ on_alarm_reset_alarm_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_alarm_reset_all_alarm_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_alarm_reset_all_alarm(ZigbeeAlarm *alarm_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeAlarmResetAllAlarm_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(alarm_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeAlarmResetAllAlarm_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ALARM,
+ ZBLIB_ALARM_OPS_RESET_ALL_ALARM,
+ &req, sizeof(req),
+ on_alarm_reset_all_alarm_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_alarm_alarm_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_alarm_alarm(ZigbeeAlarm *alarm_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gshort cluster_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeAlarmAlarm_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(alarm_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
- NOT_USED(alarmcode);
- NOT_USED(cluster_id);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeAlarmAlarm_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+ req.alarm_code = alarmcode;
+ req.cluster_id = cluster_id;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ALARM,
+ ZBLIB_ALARM_OPS_ALARM,
+ &req, sizeof(req),
+ on_alarm_alarm_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_alarm_reset_alarm_log_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_alarm_reset_alarm_log(ZigbeeAlarm *alarm_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeAlarmResetAlarmLogs_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(alarm_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeAlarmResetAlarmLogs_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ALARM,
+ ZBLIB_ALARM_OPS_RESET_ALARM_LOG,
+ &req, sizeof(req),
+ on_alarm_reset_alarm_log_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_alarm_get_alarm_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_alarm_get_alarm(ZigbeeAlarm *alarm_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeAlarmGetAlarm_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(alarm_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeAlarmGetAlarm_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ALARM,
+ ZBLIB_ALARM_OPS_GET_ALARM,
+ &req, sizeof(req),
+ on_alarm_get_alarm_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_alarm_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_alarm_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeAlarm *alarm_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(alarm_object,
"handle-get-alarm-count",
- G_CALLBACK(on_alarm_get_alarm_count), service);
+ G_CALLBACK(on_alarm_get_alarm_count), service_interface);
g_signal_connect(alarm_object,
"handle-reset-alarm",
- G_CALLBACK(on_alarm_reset_alarm), service);
+ G_CALLBACK(on_alarm_reset_alarm), service_interface);
g_signal_connect(alarm_object,
"handle-reset-all-alarm",
- G_CALLBACK(on_alarm_reset_all_alarm), service);
+ G_CALLBACK(on_alarm_reset_all_alarm), service_interface);
g_signal_connect(alarm_object,
"handle-alarm",
- G_CALLBACK(on_alarm_alarm), service);
+ G_CALLBACK(on_alarm_alarm), service_interface);
g_signal_connect(alarm_object,
"handle-reset-alarm-log",
- G_CALLBACK(on_alarm_reset_alarm_log), service);
+ G_CALLBACK(on_alarm_reset_alarm_log), service_interface);
g_signal_connect(alarm_object,
"handle-get-alarm",
- G_CALLBACK(on_alarm_get_alarm), service);
+ G_CALLBACK(on_alarm_get_alarm), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_custom.h>
+
+static void on_custom_aps_send_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_custom_aps_send(ZigbeeCustom *custom_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar aps_frame_ctrl,
gchar src_ep,
- gchar dst_ep,
+ gchar dest_ep,
gshort cluster_id,
gshort profile_id,
gchar zcl_frame_ctrl,
GVariant *payload,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
-
- NOT_USED(custom_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(aps_frame_ctrl);
- NOT_USED(src_ep);
- NOT_USED(dst_ep);
- NOT_USED(cluster_id);
- NOT_USED(profile_id);
- NOT_USED(zcl_frame_ctrl);
- NOT_USED(mfg_code);
- NOT_USED(payload);
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeCustomApsSend_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- /*
- * TODO -
- * Create and send request for processing
- */
+ GVariantIter *iter = NULL;
+ guint i = 0;
+
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeCustomApsSend_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.aps_frame_ctrl = aps_frame_ctrl;
+ req.src_ep = src_ep;
+ req.dest_ep = dest_ep;
+ req.cluster_id = cluster_id;
+ req.profile_id = profile_id;
+ req.zcl_frame_ctrl = zcl_frame_ctrl;
+ req.mfg_code = mfg_code;
+ g_variant_get(payload, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.payload[i])) {
+ i++;
+ if (i >= ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(custom_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_CUSTOM,
+ ZBLIB_CUSTOM_OPS_APS_SEND,
+ &req, sizeof(req),
+ on_custom_aps_send_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_custom_zcl_send_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_custom_zcl_send(ZigbeeCustom *custom_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar src_ep,
- gchar dst_ep,
+ gchar dest_ep,
gshort cluster_id,
gchar zcl_frame_ctrl,
gchar cmd_id,
GVariant *payload,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
-
- NOT_USED(custom_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(src_ep);
- NOT_USED(dst_ep);
- NOT_USED(cluster_id);
- NOT_USED(zcl_frame_ctrl);
- NOT_USED(cmd_id);
- NOT_USED(payload);
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeCustomZclSend_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- /*
- * TODO -
- * Create and send request for processing
- */
+ GVariantIter *iter = NULL;
+ guint i = 0;
+
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeCustomZclSend_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.src_ep = src_ep;
+ req.dest_ep = dest_ep;
+ req.cluster_id = cluster_id;
+ req.zcl_frame_ctrl = zcl_frame_ctrl;
+ req.cmd_id = cmd_id;
+ g_variant_get(payload, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.payload[i])) {
+ i++;
+ if (i >= ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(custom_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_CUSTOM,
+ ZBLIB_CUSTOM_OPS_ZCL_SEND,
+ &req, sizeof(req),
+ on_custom_zcl_send_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_custom_send_to_local_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_custom_send_to_local(ZigbeeCustom *custom_object,
GDBusMethodInvocation *invocation,
GVariant *data,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeCustomSendToLocal_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(custom_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(data);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeCustomSendToLocal_t));
+
+ /* Update request structure */
+ g_variant_get(data, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.data[i])) {
+ i++;
+ if (i >= ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(custom_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_CUSTOM,
+ ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL,
+ &req, sizeof(req),
+ on_custom_send_to_local_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_custom_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_custom_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeCustom *custom_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(custom_object,
"handle-aps-send",
- G_CALLBACK(on_custom_aps_send), service);
+ G_CALLBACK(on_custom_aps_send), service_interface);
g_signal_connect(custom_object,
"handle-zcl-send",
- G_CALLBACK(on_custom_zcl_send), service);
+ G_CALLBACK(on_custom_zcl_send), service_interface);
g_signal_connect(custom_object,
"handle-send-to-local",
- G_CALLBACK(on_custom_send_to_local), service);
+ G_CALLBACK(on_custom_send_to_local), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_door_lock.h>
+
+static void on_door_lock_subscribe_lock_event_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_door_lock_subscribe_lock_event(ZigbeeDoor_lock *door_lock_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeDoorLockSubscriberLockEvent_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(door_lock_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeDoorLockSubscriberLockEvent_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(door_lock_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_DOOR_LOCK,
+ ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT,
+ &req, sizeof(req),
+ on_door_lock_subscribe_lock_event_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_door_lock_set_door_lock_pin_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_door_lock_set_door_lock_pin(ZigbeeDoor_lock *door_lock_object,
GDBusMethodInvocation *invocation,
gshort uid,
gchar *pin,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
-
- NOT_USED(door_lock_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(uid);
- NOT_USED(ustatus);
- NOT_USED(utype);
- NOT_USED(eui64);
- NOT_USED(endpoint);
- NOT_USED(pin);
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeDoorLockSetDoorLockPin_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- /*
- * TODO -
- * Create and send request for processing
- */
+ GVariantIter *iter = NULL;
+ guint i = 0;
+
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeDoorLockSetDoorLockPin_t));
+
+ /* Update request structure */
+ req.uid = uid;
+ req.ustatus = ustatus;
+ req.utype = utype;
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+ g_strlcpy(req.pin, pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN + 1);
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(door_lock_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_DOOR_LOCK,
+ ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN,
+ &req, sizeof(req),
+ on_door_lock_set_door_lock_pin_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_door_lock_set_door_lock_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_door_lock_set_door_lock(ZigbeeDoor_lock *door_lock_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gint lock_unlock_type,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeDoorLockSetDoorLock_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(door_lock_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
- NOT_USED(pin);
- NOT_USED(lock_unlock_type);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeDoorLockSetDoorLock_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+ g_strlcpy(req.pin, pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN + 1);
+ req.lock_unlock_type = lock_unlock_type;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(door_lock_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_DOOR_LOCK,
+ ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK,
+ &req, sizeof(req),
+ on_door_lock_set_door_lock_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_door_lock_get_lock_state_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_door_lock_get_lock_state(ZigbeeDoor_lock *door_lock_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeDoorLockGetDoorLock_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(door_lock_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeDoorLockGetDoorLock_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(door_lock_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_DOOR_LOCK,
+ ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE,
+ &req, sizeof(req),
+ on_door_lock_get_lock_state_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_door_lock_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_door_lock_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeDoor_lock *door_lock_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(door_lock_object,
"handle-subscribe-lock-event",
- G_CALLBACK(on_door_lock_subscribe_lock_event), service);
+ G_CALLBACK(on_door_lock_subscribe_lock_event), service_interface);
g_signal_connect(door_lock_object,
"handle-set-door-lock-pin",
- G_CALLBACK(on_door_lock_set_door_lock_pin), service);
+ G_CALLBACK(on_door_lock_set_door_lock_pin), service_interface);
g_signal_connect(door_lock_object,
"handle-set-door-lock",
- G_CALLBACK(on_door_lock_set_door_lock), service);
+ G_CALLBACK(on_door_lock_set_door_lock), service_interface);
g_signal_connect(door_lock_object,
"handle-get-lock-state",
- G_CALLBACK(on_door_lock_get_lock_state), service);
+ G_CALLBACK(on_door_lock_get_lock_state), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_fan_control.h>
+
+static void on_fan_control_set_fan_mode_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_fan_control_set_fan_mode(ZigbeeFan_control *fan_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeFanControlSetFanMode_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(fan_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeFanControlSetFanMode_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(fan_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_FAN_CONTROL,
+ ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE,
+ &req, sizeof(req),
+ on_fan_control_set_fan_mode_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_fan_control_get_fan_mode_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_fan_control_get_fan_mode(ZigbeeFan_control *fan_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeFanControlGetFanMode_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(fan_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeFanControlGetFanMode_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(fan_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_FAN_CONTROL,
+ ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE,
+ &req, sizeof(req),
+ on_fan_control_get_fan_mode_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_fan_control_set_fan_mode_sequence_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_fan_control_set_fan_mode_sequence(ZigbeeFan_control *fan_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeFanControlSetFanModeSequence_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(fan_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeFanControlSetFanModeSequence_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(fan_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_FAN_CONTROL,
+ ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE,
+ &req, sizeof(req),
+ on_fan_control_set_fan_mode_sequence_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_fan_control_get_fan_mode_sequence_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_fan_control_get_fan_mode_sequence(ZigbeeFan_control *fan_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeFanControlGetFanModeSequence_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(fan_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeFanControlGetFanModeSequence_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(fan_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_FAN_CONTROL,
+ ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE,
+ &req, sizeof(req),
+ on_fan_control_get_fan_mode_sequence_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_fan_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_fan_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeFan_control *fan_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(fan_control_object,
"handle-set-fan-mode",
- G_CALLBACK(on_fan_control_set_fan_mode), service);
+ G_CALLBACK(on_fan_control_set_fan_mode), service_interface);
g_signal_connect(fan_control_object,
"handle-get-fan-mode",
- G_CALLBACK(on_fan_control_get_fan_mode), service);
+ G_CALLBACK(on_fan_control_get_fan_mode), service_interface);
g_signal_connect(fan_control_object,
"handle-set-fan-mode-sequence",
- G_CALLBACK(on_fan_control_set_fan_mode_sequence), service);
+ G_CALLBACK(on_fan_control_set_fan_mode_sequence), service_interface);
g_signal_connect(fan_control_object,
"handle-get-fan-mode-sequence",
- G_CALLBACK(on_fan_control_get_fan_mode_sequence), service);
+ G_CALLBACK(on_fan_control_get_fan_mode_sequence), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_level_control.h>
+
+static void on_level_control_move_to_level_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_level_control_move_to_level(ZigbeeLevel_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gshort transition,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeLevelControlMoveToLevel_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(level_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(level);
- NOT_USED(transition);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveToLevel_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.level = level;
+ req.transition = transition;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
+ ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL,
+ &req, sizeof(req),
+ on_level_control_move_to_level_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_level_control_move_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_level_control_move(ZigbeeLevel_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar rate,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeLevelControlMove_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(level_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(move_mode);
- NOT_USED(rate);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeLevelControlMove_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.move_mode = move_mode;
+ req.rate = rate;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
+ ZBLIB_LEVEL_CONTROL_OPS_MOVE,
+ &req, sizeof(req),
+ on_level_control_move_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_level_control_step_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_level_control_step(ZigbeeLevel_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gshort transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeLevelControlStep_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(level_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(step_mode);
- NOT_USED(move_mode);
- NOT_USED(transition_time);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeLevelControlStep_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.step_mode = step_mode;
+ req.move_mode = move_mode;
+ req.transition_time = transition_time;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
+ ZBLIB_LEVEL_CONTROL_OPS_STEP,
+ &req, sizeof(req),
+ on_level_control_step_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_level_control_move_to_level_with_on_off_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_level_control_move_to_level_with_on_off(ZigbeeLevel_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gshort transition,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeLevelControlMoveToLevelWithOnOff_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(level_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(level);
- NOT_USED(transition);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveToLevelWithOnOff_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.level = level;
+ req.transition = transition;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
+ ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF,
+ &req, sizeof(req),
+ on_level_control_move_to_level_with_on_off_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_level_control_move_with_on_off_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_level_control_move_with_on_off(ZigbeeLevel_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar rate,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeLevelControlMoveWithOnOff_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(level_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(move_mode);
- NOT_USED(rate);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveWithOnOff_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.move_mode = move_mode;
+ req.rate = rate;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
+ ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF,
+ &req, sizeof(req),
+ on_level_control_move_with_on_off_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_level_control_step_with_on_off_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_level_control_step_with_on_off(ZigbeeLevel_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gshort transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeLevelControlStepWithOnOff_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(level_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(step_mode);
- NOT_USED(move_mode);
- NOT_USED(transition_time);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeLevelControlStepWithOnOff_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.step_mode = step_mode;
+ req.move_mode = move_mode;
+ req.transition_time = transition_time;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
+ ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF,
+ &req, sizeof(req),
+ on_level_control_step_with_on_off_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_level_control_stop_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_level_control_stop(ZigbeeLevel_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeLevelControlStop_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(level_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeLevelControlStop_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
+ ZBLIB_LEVEL_CONTROL_OPS_STOP,
+ &req, sizeof(req),
+ on_level_control_stop_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_level_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_level_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeLevel_control *level_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(level_control_object,
"handle-move-to-level",
- G_CALLBACK(on_level_control_move_to_level), service);
+ G_CALLBACK(on_level_control_move_to_level), service_interface);
g_signal_connect(level_control_object,
"handle-move",
- G_CALLBACK(on_level_control_move), service);
+ G_CALLBACK(on_level_control_move), service_interface);
g_signal_connect(level_control_object,
"handle-step",
- G_CALLBACK(on_level_control_step), service);
+ G_CALLBACK(on_level_control_step), service_interface);
g_signal_connect(level_control_object,
"handle-move-to-level-with-on-off",
- G_CALLBACK(on_level_control_move_to_level_with_on_off), service);
+ G_CALLBACK(on_level_control_move_to_level_with_on_off), service_interface);
g_signal_connect(level_control_object,
"handle-move-with-on-off",
- G_CALLBACK(on_level_control_move_with_on_off), service);
+ G_CALLBACK(on_level_control_move_with_on_off), service_interface);
g_signal_connect(level_control_object,
"handle-step-with-on-off",
- G_CALLBACK(on_level_control_step_with_on_off), service);
+ G_CALLBACK(on_level_control_step_with_on_off), service_interface);
g_signal_connect(level_control_object,
"handle-stop",
- G_CALLBACK(on_level_control_stop), service);
+ G_CALLBACK(on_level_control_stop), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_mfglib_control.h>
+
+static void on_mfglib_control_start_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_start(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gboolean mfglib_start,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlStart_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(mfglib_start);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlStart_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.mfglib_start = ((mfglib_start == TRUE) ? 1 : 0);
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_START,
+ &req, sizeof(req),
+ on_mfglib_control_start_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_end_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_end(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlEnd_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlEnd_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_END,
+ &req, sizeof(req),
+ on_mfglib_control_end_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_start_tone_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_start_tone(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlStartTone_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlStartTone_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_START_TONE,
+ &req, sizeof(req),
+ on_mfglib_control_start_tone_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_stop_tone_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_stop_tone(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlStopTone_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlStopTone_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE,
+ &req, sizeof(req),
+ on_mfglib_control_stop_tone_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_start_stream_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_start_stream(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlStartStream_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlStartStream_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM,
+ &req, sizeof(req),
+ on_mfglib_control_start_stream_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_stop_stream_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_stop_stream(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlStopStream_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlStopStream_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM,
+ &req, sizeof(req),
+ on_mfglib_control_stop_stream_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_send_packet_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_send_packet(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *packet_content,
gint packet_length,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlSendPacket_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(packet_content);
- NOT_USED(packet_length);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlSendPacket_t));
+
+ /* Update request structure */
+ g_variant_get(packet_content, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.packet_content[i])) {
+ i++;
+ if (i >= (guint)packet_length)
+ break;
+ }
+ req.packet_length = packet_length;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET,
+ &req, sizeof(req),
+ on_mfglib_control_send_packet_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_set_channel_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_set_channel(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar channel,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlSetChannel_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(channel);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlSetChannel_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.channel = channel;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL,
+ &req, sizeof(req),
+ on_mfglib_control_set_channel_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_get_channel_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_get_channel(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlGetChannel_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlGetChannel_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL,
+ &req, sizeof(req),
+ on_mfglib_control_get_channel_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_set_power_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_set_power(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
guint power,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlSetPower_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(tx_power_mode);
- NOT_USED(power);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlSetPower_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.tx_power_mode = tx_power_mode;
+ req.power = power;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER,
+ &req, sizeof(req),
+ on_mfglib_control_set_power_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_get_power_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_get_power(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlGetPower_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlGetPower_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER,
+ &req, sizeof(req),
+ on_mfglib_control_get_power_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_set_synoffset_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_set_synoffset(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar test_channel,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlSetSynOffset_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(test_channel);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlSetSynOffset_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.channel = test_channel;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET,
+ &req, sizeof(req),
+ on_mfglib_control_set_synoffset_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_get_synoffset_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_get_synoffset(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *packet,
gchar rssi,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlGetSynOffset_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(packet);
- NOT_USED(packet_length);
- NOT_USED(link_quality);
- NOT_USED(rssi);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlGetSynOffset_t));
+
+ /* Update request structure */
+ g_variant_get(packet, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.packet[i])) {
+ i++;
+ if (i >= (guint)packet_length)
+ break;
+ }
+ req.packet_length = packet_length;
+ req.link_quality = link_quality;
+ req.rssi = rssi;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET,
+ &req, sizeof(req),
+ on_mfglib_control_get_synoffset_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_rx_start_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_rx_start(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlRxStart_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlRxStart_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_RX_START,
+ &req, sizeof(req),
+ on_mfglib_control_rx_start_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_rx_stop_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_rx_stop(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlRxStop_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlRxStop_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP,
+ &req, sizeof(req),
+ on_mfglib_control_rx_stop_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_rx_verify_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_rx_verify(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlRxVerify_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlRxVerify_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY,
+ &req, sizeof(req),
+ on_mfglib_control_rx_verify_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_mfglib_control_get_rssi_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_mfglib_control_get_rssi(ZigbeeMfglib_control *mfglib_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeMfglibControlGetRssi_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(mfglib_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeMfglibControlGetRssi_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
+ ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI,
+ &req, sizeof(req),
+ on_mfglib_control_get_rssi_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_mfglib_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_mfglib_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeMfglib_control *mfglib_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(mfglib_control_object,
"handle-start",
- G_CALLBACK(on_mfglib_control_start), service);
+ G_CALLBACK(on_mfglib_control_start), service_interface);
g_signal_connect(mfglib_control_object,
"handle-end",
- G_CALLBACK(on_mfglib_control_end), service);
+ G_CALLBACK(on_mfglib_control_end), service_interface);
g_signal_connect(mfglib_control_object,
"handle-start-tone",
- G_CALLBACK(on_mfglib_control_start_tone), service);
+ G_CALLBACK(on_mfglib_control_start_tone), service_interface);
g_signal_connect(mfglib_control_object,
"handle-stop-tone",
- G_CALLBACK(on_mfglib_control_stop_tone), service);
+ G_CALLBACK(on_mfglib_control_stop_tone), service_interface);
g_signal_connect(mfglib_control_object,
"handle-start-stream",
- G_CALLBACK(on_mfglib_control_start_stream), service);
+ G_CALLBACK(on_mfglib_control_start_stream), service_interface);
g_signal_connect(mfglib_control_object,
"handle-stop-stream",
- G_CALLBACK(on_mfglib_control_stop_stream), service);
+ G_CALLBACK(on_mfglib_control_stop_stream), service_interface);
g_signal_connect(mfglib_control_object,
"handle-send-packet",
- G_CALLBACK(on_mfglib_control_send_packet), service);
+ G_CALLBACK(on_mfglib_control_send_packet), service_interface);
g_signal_connect(mfglib_control_object,
"handle-set-channel",
- G_CALLBACK(on_mfglib_control_set_channel), service);
+ G_CALLBACK(on_mfglib_control_set_channel), service_interface);
g_signal_connect(mfglib_control_object,
"handle-get-channel",
- G_CALLBACK(on_mfglib_control_get_channel), service);
+ G_CALLBACK(on_mfglib_control_get_channel), service_interface);
g_signal_connect(mfglib_control_object,
"handle-set-power",
- G_CALLBACK(on_mfglib_control_set_power), service);
+ G_CALLBACK(on_mfglib_control_set_power), service_interface);
g_signal_connect(mfglib_control_object,
"handle-get-power",
- G_CALLBACK(on_mfglib_control_get_power), service);
+ G_CALLBACK(on_mfglib_control_get_power), service_interface);
g_signal_connect(mfglib_control_object,
"handle-set-synoffset",
- G_CALLBACK(on_mfglib_control_set_synoffset), service);
+ G_CALLBACK(on_mfglib_control_set_synoffset), service_interface);
g_signal_connect(mfglib_control_object,
"handle-get-synoffset",
- G_CALLBACK(on_mfglib_control_get_synoffset), service);
+ G_CALLBACK(on_mfglib_control_get_synoffset), service_interface);
g_signal_connect(mfglib_control_object,
"handle-rx-start",
- G_CALLBACK(on_mfglib_control_rx_start), service);
+ G_CALLBACK(on_mfglib_control_rx_start), service_interface);
g_signal_connect(mfglib_control_object,
"handle-rx-stop",
- G_CALLBACK(on_mfglib_control_rx_stop), service);
+ G_CALLBACK(on_mfglib_control_rx_stop), service_interface);
g_signal_connect(mfglib_control_object,
"handle-rx-verify",
- G_CALLBACK(on_mfglib_control_rx_verify), service);
+ G_CALLBACK(on_mfglib_control_rx_verify), service_interface);
g_signal_connect(mfglib_control_object,
"handle-get-rssi",
- G_CALLBACK(on_mfglib_control_get_rssi), service);
+ G_CALLBACK(on_mfglib_control_get_rssi), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_on_off.h>
+
+static void on_on_off_set_on_off_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_on_off_set_on_off(ZigbeeOn_off *on_off_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar on_off_type,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeOnOffSetOnOff_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(on_off_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(on_off_type);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeOnOffSetOnOff_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.on_off_type = on_off_type;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(on_off_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ON_OFF,
+ ZBLIB_ON_OFF_OPS_SET_ON_OFF,
+ &req, sizeof(req),
+ on_on_off_set_on_off_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_on_off_get_on_off_state_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_on_off_get_on_off_state(ZigbeeOn_off *on_off_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeOnOffGetOnOffState_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(on_off_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeOnOffGetOnOffState_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(on_off_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ON_OFF,
+ ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE,
+ &req, sizeof(req),
+ on_on_off_get_on_off_state_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_on_off_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_on_off_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeOn_off *on_off_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(on_off_object,
"handle-set-on-off",
- G_CALLBACK(on_on_off_set_on_off), service);
+ G_CALLBACK(on_on_off_set_on_off), service_interface);
g_signal_connect(on_off_object,
"handle-get-on-off-state",
- G_CALLBACK(on_on_off_get_on_off_state), service);
+ G_CALLBACK(on_on_off_get_on_off_state), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_service.h>
+
+static void on_service_enable_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_enable(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_ENABLE,
+ NULL, 0,
+ on_service_enable_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_disable_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_disable(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_DISABLE,
+ NULL, 0,
+ on_service_disable_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_zb_hw_reset_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_zb_hw_reset(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_ZB_HW_RESET,
+ NULL, 0,
+ on_service_zb_hw_reset_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_form_network_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_form_network(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_FORM_NETWORK,
+ NULL, 0,
+ on_service_form_network_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_coex_start_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_coex_start(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gchar channel,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceCoexStart_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(channel);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeServiceCoexStart_t));
+
+ /* Update request structure */
+ req.channel = channel;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_COEX_START,
+ &req, sizeof(req),
+ on_service_coex_start_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_coex_stop_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_coex_stop(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_COEX_STOP,
+ NULL, 0,
+ on_service_coex_stop_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_leave_network_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_leave_network(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_LEAVE_NETWORK,
+ NULL, 0,
+ on_service_leave_network_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_get_network_info_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_get_network_info(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_GET_NETWORK_INFO,
+ NULL, 0,
+ on_service_get_network_info_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_permit_join_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_permit_join(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gint duration,
- gboolean broadcast_mgmt_permit_join,
+ gboolean permit_join,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServicePermitJoin_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(duration);
- NOT_USED(broadcast_mgmt_permit_join);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeServicePermitJoin_t));
+
+ /* Update request structure */
+ req.duration = duration;
+ req.permit_join = permit_join;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_PERMIT_JOIN,
+ &req, sizeof(req),
+ on_service_permit_join_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_leave_request_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_leave_request(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar rejoin,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceLeaveRequest_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(remove_child);
- NOT_USED(rejoin);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeServiceLeaveRequest_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.remove_child = remove_child;
+ req.rejoin = rejoin;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_LEAVE_REQUEST,
+ &req, sizeof(req),
+ on_service_leave_request_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_get_device_list_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_get_device_list(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_GET_DEVICE_LIST,
+ NULL, 0,
+ on_service_get_device_list_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_get_mac_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_get_mac(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_GET_MAC,
+ NULL, 0,
+ on_service_get_mac_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_get_device_info_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_get_device_info(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_GET_DEVICE_INFO,
+ NULL, 0,
+ on_service_get_device_info_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_get_endpoint_list_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_get_endpoint_list(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceGetEndpointList_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeServiceGetEndpointList_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST,
+ &req, sizeof(req),
+ on_service_get_endpoint_list_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_get_cluster_list_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_get_cluster_list(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceGetClusterList_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeServiceGetClusterList_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST,
+ &req, sizeof(req),
+ on_service_get_cluster_list_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_service_get_node_type_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_service_get_node_type(ZigbeeService *service_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeServiceGetNodeType_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(service_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeServiceGetNodeType_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(service_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_SERVICE,
+ ZBLIB_SERVICE_OPS_GET_NODE_TYPE,
+ &req, sizeof(req),
+ on_service_get_node_type_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_service_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_service_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeService *service_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(service_object,
"handle-enable",
- G_CALLBACK(on_service_enable), service);
+ G_CALLBACK(on_service_enable), service_interface);
g_signal_connect(service_object,
"handle-disable",
- G_CALLBACK(on_service_disable), service);
+ G_CALLBACK(on_service_disable), service_interface);
g_signal_connect(service_object,
"handle-zb-hw-reset",
- G_CALLBACK(on_service_zb_hw_reset), service);
+ G_CALLBACK(on_service_zb_hw_reset), service_interface);
g_signal_connect(service_object,
"handle-form-network",
- G_CALLBACK(on_service_form_network), service);
+ G_CALLBACK(on_service_form_network), service_interface);
g_signal_connect(service_object,
"handle-coex-start",
- G_CALLBACK(on_service_coex_start), service);
+ G_CALLBACK(on_service_coex_start), service_interface);
g_signal_connect(service_object,
"handle-coex-stop",
- G_CALLBACK(on_service_coex_stop), service);
+ G_CALLBACK(on_service_coex_stop), service_interface);
g_signal_connect(service_object,
"handle-leave-network",
- G_CALLBACK(on_service_leave_network), service);
+ G_CALLBACK(on_service_leave_network), service_interface);
g_signal_connect(service_object,
"handle-get-network-info",
- G_CALLBACK(on_service_get_network_info), service);
+ G_CALLBACK(on_service_get_network_info), service_interface);
g_signal_connect(service_object,
"handle-permit-join",
- G_CALLBACK(on_service_permit_join), service);
+ G_CALLBACK(on_service_permit_join), service_interface);
g_signal_connect(service_object,
"handle-leave-request",
- G_CALLBACK(on_service_leave_request), service);
+ G_CALLBACK(on_service_leave_request), service_interface);
g_signal_connect(service_object,
"handle-get-device-list",
- G_CALLBACK(on_service_get_device_list), service);
+ G_CALLBACK(on_service_get_device_list), service_interface);
g_signal_connect(service_object,
"handle-get-mac",
- G_CALLBACK(on_service_get_mac), service);
+ G_CALLBACK(on_service_get_mac), service_interface);
g_signal_connect(service_object,
"handle-get-device-info",
- G_CALLBACK(on_service_get_device_info), service);
+ G_CALLBACK(on_service_get_device_info), service_interface);
g_signal_connect(service_object,
"handle-get-endpoint-list",
- G_CALLBACK(on_service_get_endpoint_list), service);
+ G_CALLBACK(on_service_get_endpoint_list), service_interface);
g_signal_connect(service_object,
"handle-get-cluster-list",
- G_CALLBACK(on_service_get_cluster_list), service);
+ G_CALLBACK(on_service_get_cluster_list), service_interface);
g_signal_connect(service_object,
"handle-get-node-type",
- G_CALLBACK(on_service_get_node_type), service);
+ G_CALLBACK(on_service_get_node_type), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_thermostat.h>
+
+static void on_thermostat_get_local_temp_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_thermostat_get_local_temp(ZigbeeThermostat *thermostat_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeThermostatGetLocalTemp_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(thermostat_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeThermostatGetLocalTemp_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_THERMOSTAT,
+ ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP,
+ &req, sizeof(req),
+ on_thermostat_get_local_temp_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_thermostat_get_weekly_schedule_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_thermostat_get_weekly_schedule(ZigbeeThermostat *thermostat_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar mode,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeThermostatGetWeeklySchedule_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(thermostat_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
- NOT_USED(no_of_days);
- NOT_USED(mode);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeThermostatGetWeeklySchedule_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+ req.num_of_days = no_of_days;
+ req.mode = mode;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_THERMOSTAT,
+ ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE,
+ &req, sizeof(req),
+ on_thermostat_get_weekly_schedule_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_thermostat_set_weekly_schedule_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_thermostat_set_weekly_schedule(ZigbeeThermostat *thermostat_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar payload_len,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
-
- NOT_USED(thermostat_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
- NOT_USED(no_of_transitions);
- NOT_USED(no_of_days);
- NOT_USED(mode);
- NOT_USED(payload);
- NOT_USED(payload_len);
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeThermostatSetWeeklySchedule_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- /*
- * TODO -
- * Create and send request for processing
- */
+ GVariantIter *iter = NULL;
+ guint i = 0;
+
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeThermostatSetWeeklySchedule_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+ req.no_of_transitions = no_of_transitions;
+ req.num_of_days = no_of_days;
+ req.mode = mode;
+ g_variant_get(payload, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.payload[i])) {
+ i++;
+ if (i >= (guint)payload_len)
+ break;
+ }
+ req.payload_len = payload_len;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_THERMOSTAT,
+ ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE,
+ &req, sizeof(req),
+ on_thermostat_set_weekly_schedule_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_thermostat_clear_weekly_schedule_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_thermostat_clear_weekly_schedule(ZigbeeThermostat *thermostat_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeThermostatClearWeeklySchedule_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(thermostat_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(eui64);
- NOT_USED(endpoint);
+ GVariantIter *iter = NULL;
+ guint i = 0;
- /*
- * TODO -
- * Create and send request for processing
- */
+ gboolean ret;
+
+ memset(&req, 0x0, sizeof(ZigbeeThermostatClearWeeklySchedule_t));
+
+ /* Update request structure */
+ g_variant_get(eui64, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
+ i++;
+ if (i >= ZIGBEE_EUI64_SIZE)
+ break;
+ }
+ req.endpoint = endpoint;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_THERMOSTAT,
+ ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE,
+ &req, sizeof(req),
+ on_thermostat_clear_weekly_schedule_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
+static void on_thermostat_setpoint_raise_lower_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_thermostat_setpoint_raise_lower(ZigbeeThermostat *thermostat_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar amount,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeThermostatSetpointRaiseLower_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(thermostat_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(endpoint);
- NOT_USED(mode);
- NOT_USED(amount);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeThermostatSetpointRaiseLower_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.endpoint = endpoint;
+ req.mode = mode;
+ req.amount = amount;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_THERMOSTAT,
+ ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER,
+ &req, sizeof(req),
+ on_thermostat_setpoint_raise_lower_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_thermostat_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_thermostat_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeThermostat *thermostat_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(thermostat_object,
"handle-get-local-temp",
- G_CALLBACK(on_thermostat_get_local_temp), service);
+ G_CALLBACK(on_thermostat_get_local_temp), service_interface);
g_signal_connect(thermostat_object,
"handle-get-weekly-schedule",
- G_CALLBACK(on_thermostat_get_weekly_schedule), service);
+ G_CALLBACK(on_thermostat_get_weekly_schedule), service_interface);
g_signal_connect(thermostat_object,
"handle-set-weekly-schedule",
- G_CALLBACK(on_thermostat_set_weekly_schedule), service);
+ G_CALLBACK(on_thermostat_set_weekly_schedule), service_interface);
g_signal_connect(thermostat_object,
"handle-clear-weekly-schedule",
- G_CALLBACK(on_thermostat_clear_weekly_schedule), service);
+ G_CALLBACK(on_thermostat_clear_weekly_schedule), service_interface);
g_signal_connect(thermostat_object,
"handle-setpoint-raise-lower",
- G_CALLBACK(on_thermostat_setpoint_raise_lower), service);
+ G_CALLBACK(on_thermostat_setpoint_raise_lower), service_interface);
return TRUE;
}
gchar rate,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(move_mode);
gchar direction,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(hue);
gchar transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(step_mode);
gshort transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(saturation);
gchar rate,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(move_mode);
gchar transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(step_mode);
gshort transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(hue);
gshort transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(start_x);
gshort rate_y,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(rate_x);
gshort transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(rate_x);
gshort transition_time,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_color_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
NOT_USED(color_temperature);
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zcl_color_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zcl_color_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZcl_color *zcl_color_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zcl_color_object,
"handle-move-to-hue",
- G_CALLBACK(on_zcl_color_move_to_hue), service);
+ G_CALLBACK(on_zcl_color_move_to_hue), service_interface);
g_signal_connect(zcl_color_object,
"handle-move-hue",
- G_CALLBACK(on_zcl_color_move_hue), service);
+ G_CALLBACK(on_zcl_color_move_hue), service_interface);
g_signal_connect(zcl_color_object,
"handle-step-hue",
- G_CALLBACK(on_zcl_color_step_hue), service);
+ G_CALLBACK(on_zcl_color_step_hue), service_interface);
g_signal_connect(zcl_color_object,
"handle-move-to-saturation",
- G_CALLBACK(on_zcl_color_move_to_saturation), service);
+ G_CALLBACK(on_zcl_color_move_to_saturation), service_interface);
g_signal_connect(zcl_color_object,
"handle-move-saturation",
- G_CALLBACK(on_zcl_color_move_saturation), service);
+ G_CALLBACK(on_zcl_color_move_saturation), service_interface);
g_signal_connect(zcl_color_object,
"handle-step-saturation",
- G_CALLBACK(on_zcl_color_step_saturation), service);
+ G_CALLBACK(on_zcl_color_step_saturation), service_interface);
g_signal_connect(zcl_color_object,
"handle-move-to-hue-and-saturation",
- G_CALLBACK(on_zcl_color_move_to_hue_and_saturation), service);
+ G_CALLBACK(on_zcl_color_move_to_hue_and_saturation), service_interface);
g_signal_connect(zcl_color_object,
"handle-move-to-color",
- G_CALLBACK(on_zcl_color_move_to_color), service);
+ G_CALLBACK(on_zcl_color_move_to_color), service_interface);
g_signal_connect(zcl_color_object,
"handle-move-color",
- G_CALLBACK(on_zcl_color_move_color), service);
+ G_CALLBACK(on_zcl_color_move_color), service_interface);
g_signal_connect(zcl_color_object,
"handle-step-color",
- G_CALLBACK(on_zcl_color_step_color), service);
+ G_CALLBACK(on_zcl_color_step_color), service_interface);
g_signal_connect(zcl_color_object,
"handle-move-color-temperature",
- G_CALLBACK(on_zcl_color_move_color_temperature), service);
+ G_CALLBACK(on_zcl_color_move_color_temperature), service_interface);
return TRUE;
}
GVariant *group_name,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_group_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
gshort group_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_group_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
GVariant *group_list,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_group_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_count);
gshort group_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_group_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
gchar dst_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_group_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
GVariant *group_name,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_group_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zcl_group_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zcl_group_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZcl_group *zcl_group_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zcl_group_object,
"handle-add-group",
- G_CALLBACK(on_zcl_group_add_group), service);
+ G_CALLBACK(on_zcl_group_add_group), service_interface);
g_signal_connect(zcl_group_object,
"handle-view-group",
- G_CALLBACK(on_zcl_group_view_group), service);
+ G_CALLBACK(on_zcl_group_view_group), service_interface);
g_signal_connect(zcl_group_object,
"handle-get-group-membership",
- G_CALLBACK(on_zcl_group_get_group_membership), service);
+ G_CALLBACK(on_zcl_group_get_group_membership), service_interface);
g_signal_connect(zcl_group_object,
"handle-remove-group",
- G_CALLBACK(on_zcl_group_remove_group), service);
+ G_CALLBACK(on_zcl_group_remove_group), service_interface);
g_signal_connect(zcl_group_object,
"handle-remove-all-group",
- G_CALLBACK(on_zcl_group_remove_all_group), service);
+ G_CALLBACK(on_zcl_group_remove_all_group), service_interface);
g_signal_connect(zcl_group_object,
"handle-add-group-if-identifying",
- G_CALLBACK(on_zcl_group_add_group_if_identifying), service);
+ G_CALLBACK(on_zcl_group_add_group_if_identifying), service_interface);
return TRUE;
}
gshort fast_poll_timeout,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_poll_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(start_fast_polling);
gchar dst_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_poll_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
guint new_long_poll_interval,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_poll_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(new_long_poll_interval);
guint new_short_poll_interval,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_poll_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(new_short_poll_interval);
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zcl_poll_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zcl_poll_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZcl_poll_control *zcl_poll_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zcl_poll_control_object,
"handle-check-in-response",
- G_CALLBACK(on_zcl_poll_control_check_in_response), service);
+ G_CALLBACK(on_zcl_poll_control_check_in_response), service_interface);
g_signal_connect(zcl_poll_control_object,
"handle-fast-poll-stop",
- G_CALLBACK(on_zcl_poll_control_fast_poll_stop), service);
+ G_CALLBACK(on_zcl_poll_control_fast_poll_stop), service_interface);
g_signal_connect(zcl_poll_control_object,
"handle-set-long-poll-interval",
- G_CALLBACK(on_zcl_poll_control_set_long_poll_interval), service);
+ G_CALLBACK(on_zcl_poll_control_set_long_poll_interval), service_interface);
g_signal_connect(zcl_poll_control_object,
"handle-set-short-poll-interval",
- G_CALLBACK(on_zcl_poll_control_set_short_poll_interval), service);
+ G_CALLBACK(on_zcl_poll_control_set_short_poll_interval), service_interface);
return TRUE;
}
GVariant *ext_field_set,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_scene_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
gchar scene_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_scene_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
gchar scene_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_scene_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
gchar scene_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_scene_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
gchar scene_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_scene_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
gshort group_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_scene_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
gshort group_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zcl_scene_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(group_id);
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zcl_scene_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zcl_scene_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZcl_scene *zcl_scene_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zcl_scene_object,
"handle-add-scene",
- G_CALLBACK(on_zcl_scene_add_scene), service);
+ G_CALLBACK(on_zcl_scene_add_scene), service_interface);
g_signal_connect(zcl_scene_object,
"handle-view-scene",
- G_CALLBACK(on_zcl_scene_view_scene), service);
+ G_CALLBACK(on_zcl_scene_view_scene), service_interface);
g_signal_connect(zcl_scene_object,
"handle-remove-scene",
- G_CALLBACK(on_zcl_scene_remove_scene), service);
+ G_CALLBACK(on_zcl_scene_remove_scene), service_interface);
g_signal_connect(zcl_scene_object,
"handle-store-scene",
- G_CALLBACK(on_zcl_scene_store_scene), service);
+ G_CALLBACK(on_zcl_scene_store_scene), service_interface);
g_signal_connect(zcl_scene_object,
"handle-recall-scene",
- G_CALLBACK(on_zcl_scene_recall_scene), service);
+ G_CALLBACK(on_zcl_scene_recall_scene), service_interface);
g_signal_connect(zcl_scene_object,
"handle-remove-all-scene",
- G_CALLBACK(on_zcl_scene_remove_all_scene), service);
+ G_CALLBACK(on_zcl_scene_remove_all_scene), service_interface);
g_signal_connect(zcl_scene_object,
"handle-get-scene-membership",
- G_CALLBACK(on_zcl_scene_get_scene_membership), service);
+ G_CALLBACK(on_zcl_scene_get_scene_membership), service_interface);
return TRUE;
}
#include "zigbee_service_interface_common.h"
+#include <zblib_driver_zclbasic_control.h>
+
+static void on_zclbasic_control_reset_factory_default_resp(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
+{
+ ZigbeeServiceInterfaceRespCbData_t *cb_data =
+ (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
+
+ NOT_USED(cb_data);
+ NOT_USED(service_interface);
+ NOT_USED(request_id);
+ NOT_USED(resp_data);
+ NOT_USED(resp_data_len);
+}
+
static gboolean on_zclbasic_control_reset_factory_default(ZigbeeZclbasic_control *zclbasic_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
- gchar dst_ep,
+ gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
+ ZigbeeZclbasicControlResetFactoryDefault_t req;
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
- NOT_USED(zclbasic_control_object);
- NOT_USED(invocation);
- NOT_USED(service);
- NOT_USED(node_id);
- NOT_USED(dst_ep);
+ gboolean ret;
- /*
- * TODO -
- * Create and send request for processing
- */
+ memset(&req, 0x0, sizeof(ZigbeeZclbasicControlResetFactoryDefault_t));
+
+ /* Update request structure */
+ req.node_id = node_id;
+ req.dest_ep = dest_ep;
+
+ /* Allocate response callback data */
+ resp_cb_data =
+ zigbee_service_dbus_interface_create_resp_cb_data(zclbasic_control_object,
+ invocation, NULL, 0);
+ if (NULL == resp_cb_data) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
+
+ /* Dispatch request */
+ ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
+ ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL,
+ ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT,
+ &req, sizeof(req),
+ on_zclbasic_control_reset_factory_default_resp, resp_cb_data);
+ if (FALSE == ret) {
+ Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
+
+ /* Free response callback data */
+ zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
+
+ /* Send failure response */
+ ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
+
+ return TRUE;
+ }
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zclbasic_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zclbasic_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZclbasic_control *zclbasic_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zclbasic_control_object,
"handle-reset-factory-default",
- G_CALLBACK(on_zclbasic_control_reset_factory_default), service);
+ G_CALLBACK(on_zclbasic_control_reset_factory_default), service_interface);
return TRUE;
}
gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(attribute_id);
NOT_USED(attribute_ids_length);
NOT_USED(node_id);
gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(write_attribute);
NOT_USED(records_length);
NOT_USED(node_id);
gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(write_attribute);
NOT_USED(records_length);
NOT_USED(node_id);
gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(write_attribute);
NOT_USED(records_length);
NOT_USED(node_id);
gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(write_attribute);
NOT_USED(records_length);
NOT_USED(node_id);
gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(read_attribute);
NOT_USED(records_length);
NOT_USED(node_id);
gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(read_attribute);
NOT_USED(records_length);
NOT_USED(node_id);
gchar dest_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(read_attribute);
NOT_USED(records_length);
NOT_USED(node_id);
gchar max,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dest_ep);
NOT_USED(zcl_frame_ctrl);
gchar max,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dest_ep);
NOT_USED(zcl_frame_ctrl);
gchar max,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dest_ep);
NOT_USED(zcl_frame_ctrl);
gchar max,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclglobal_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dest_ep);
NOT_USED(zcl_frame_ctrl);
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zclglobal_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zclglobal_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZclglobal_control *zclglobal_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zclglobal_control_object,
"handle-read-attributes-req",
- G_CALLBACK(on_zclglobal_control_read_attributes_req), service);
+ G_CALLBACK(on_zclglobal_control_read_attributes_req), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-write-attributes-req",
- G_CALLBACK(on_zclglobal_control_write_attributes_req), service);
+ G_CALLBACK(on_zclglobal_control_write_attributes_req), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-write-attributes-undivided-req",
- G_CALLBACK(on_zclglobal_control_write_attributes_undivided_req), service);
+ G_CALLBACK(on_zclglobal_control_write_attributes_undivided_req), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-write-attributes-no-resp",
- G_CALLBACK(on_zclglobal_control_write_attributes_no_resp), service);
+ G_CALLBACK(on_zclglobal_control_write_attributes_no_resp), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-write-attributes-structured",
- G_CALLBACK(on_zclglobal_control_write_attributes_structured), service);
+ G_CALLBACK(on_zclglobal_control_write_attributes_structured), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-read-attributes-structured",
- G_CALLBACK(on_zclglobal_control_read_attributes_structured), service);
+ G_CALLBACK(on_zclglobal_control_read_attributes_structured), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-configure-reporting-req",
- G_CALLBACK(on_zclglobal_control_configure_reporting_req), service);
+ G_CALLBACK(on_zclglobal_control_configure_reporting_req), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-read-configure-reporting",
- G_CALLBACK(on_zclglobal_control_read_configure_reporting), service);
+ G_CALLBACK(on_zclglobal_control_read_configure_reporting), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-discover-attributes",
- G_CALLBACK(on_zclglobal_control_discover_attributes), service);
+ G_CALLBACK(on_zclglobal_control_discover_attributes), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-discover-attributes-extended",
- G_CALLBACK(on_zclglobal_control_discover_attributes_extended), service);
+ G_CALLBACK(on_zclglobal_control_discover_attributes_extended), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-discover-commands-received",
- G_CALLBACK(on_zclglobal_control_discover_commands_received), service);
+ G_CALLBACK(on_zclglobal_control_discover_commands_received), service_interface);
g_signal_connect(zclglobal_control_object,
"handle-discover-commands-generated",
- G_CALLBACK(on_zclglobal_control_discover_commands_generated), service);
+ G_CALLBACK(on_zclglobal_control_discover_commands_generated), service_interface);
return TRUE;
}
gchar zone_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclias_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(enroll_code);
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zclias_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zclias_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZclias_control *zclias_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zclias_control_object,
"handle-get-alarm-count",
- G_CALLBACK(on_zclias_control_enroll_response), service);
+ G_CALLBACK(on_zclias_control_enroll_response), service_interface);
return TRUE;
}
gshort identifytime,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclidentify_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(dst_ep);
NOT_USED(identifytime);
gshort node_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zclidentify_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
/*
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zclidentify_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zclidentify_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZclidentify_control *zclidentify_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zclidentify_control_object,
"handle-identify",
- G_CALLBACK(on_zclidentify_control_identify), service);
+ G_CALLBACK(on_zclidentify_control_identify), service_interface);
g_signal_connect(zclidentify_control_object,
"handle-query",
- G_CALLBACK(on_zclidentify_control_query), service);
+ G_CALLBACK(on_zclidentify_control_query), service_interface);
return TRUE;
}
gchar dst_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdo_bind_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(src_addr);
NOT_USED(src_ep);
gchar dst_ep,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdo_bind_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(src_addr);
NOT_USED(src_ep);
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zdo_bind_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zdo_bind_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZdo_bind *zdo_bind_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zdo_bind_object,
"handle-bind-req",
- G_CALLBACK(on_zdo_bind_bind_req), service);
+ G_CALLBACK(on_zdo_bind_bind_req), service_interface);
g_signal_connect(zdo_bind_object,
"handle-unbind-req",
- G_CALLBACK(on_zdo_bind_unbind_req), service);
+ G_CALLBACK(on_zdo_bind_unbind_req), service_interface);
return TRUE;
}
gchar start_index,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(eui64);
NOT_USED(request_type);
NOT_USED(start_index);
GVariant *out_cl,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(profile_id);
NOT_USED(num_in_cl);
gshort node_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
/*
gshort node_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
/*
gshort node_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
/*
gshort node_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
/*
gshort node_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
/*
gshort node_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
/*
GVariant *user_desc,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(length);
NOT_USED(user_desc);
gchar capability,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(mac_addr);
NOT_USED(capability);
gchar endpoint,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(endpoint);
gchar start_idx,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(start_idx);
gchar start_idx,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(start_idx);
gchar start_idx,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(start_idx);
gchar tc_significance,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(addr16);
NOT_USED(duration);
NOT_USED(tc_significance);
gint nwk_update_id,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(scan_channel);
NOT_USED(scan_duration);
gchar start_index,
gpointer user_data)
{
- ZigBeeService *service = (ZigBeeService *)user_data;
+ ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
NOT_USED(zdodev_control_object);
NOT_USED(invocation);
- NOT_USED(service);
+ NOT_USED(service_interface);
NOT_USED(node_id);
NOT_USED(scan_channel);
NOT_USED(scan_duration);
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zdodev_control_init(ZigBeeService *service,
+gboolean zigbee_service_dbus_interface_zdodev_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
ZigbeeZdodev_control *zdodev_control_object;
- if (NULL == service) {
- Z_LOGE("service is NULL");
+ if (NULL == service_interface) {
+ Z_LOGE("service_interface is NULL");
return FALSE;
}
*/
g_signal_connect(zdodev_control_object,
"handle-nwk-addr-req",
- G_CALLBACK(on_zdodev_control_nwk_addr_req), service);
+ G_CALLBACK(on_zdodev_control_nwk_addr_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-matched-descriptor-req",
- G_CALLBACK(on_zdodev_control_matched_descriptor_req), service);
+ G_CALLBACK(on_zdodev_control_matched_descriptor_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-ieee-addr-req",
- G_CALLBACK(on_zdodev_control_ieee_addr_req), service);
+ G_CALLBACK(on_zdodev_control_ieee_addr_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-active-ep-req",
- G_CALLBACK(on_zdodev_control_active_ep_req), service);
+ G_CALLBACK(on_zdodev_control_active_ep_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-node-desc-req",
- G_CALLBACK(on_zdodev_control_node_desc_req), service);
+ G_CALLBACK(on_zdodev_control_node_desc_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-power-desc-req",
- G_CALLBACK(on_zdodev_control_power_desc_req), service);
+ G_CALLBACK(on_zdodev_control_power_desc_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-complex-desc-req",
- G_CALLBACK(on_zdodev_control_complex_desc_req), service);
+ G_CALLBACK(on_zdodev_control_complex_desc_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-user-desc-req",
- G_CALLBACK(on_zdodev_control_user_desc_req), service);
+ G_CALLBACK(on_zdodev_control_user_desc_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-user-desc-set-req",
- G_CALLBACK(on_zdodev_control_user_desc_set_req), service);
+ G_CALLBACK(on_zdodev_control_user_desc_set_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-device-announce",
- G_CALLBACK(on_zdodev_control_device_announce), service);
+ G_CALLBACK(on_zdodev_control_device_announce), service_interface);
g_signal_connect(zdodev_control_object,
"handle-simple-desc-req",
- G_CALLBACK(on_zdodev_control_simple_desc_req), service);
+ G_CALLBACK(on_zdodev_control_simple_desc_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-mgmt-lqi-req",
- G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service);
+ G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-mgmt-rtg-req",
- G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service);
+ G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-mgmt-bind-req",
- G_CALLBACK(on_zdodev_control_mgmt_bind_req), service);
+ G_CALLBACK(on_zdodev_control_mgmt_bind_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-mgmt-permit-join-req",
- G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service);
+ G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-nwk-update-req",
- G_CALLBACK(on_zdodev_control_nwk_update_req), service);
+ G_CALLBACK(on_zdodev_control_nwk_update_req), service_interface);
g_signal_connect(zdodev_control_object,
"handle-nwk-disc-req",
- G_CALLBACK(on_zdodev_control_nwk_disc_req), service);
+ G_CALLBACK(on_zdodev_control_nwk_disc_req), service_interface);
return TRUE;
}
--- /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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+#include <dlog.h>
+
+#include <zblib.h>
+#include <zblib_service.h>
+#include <zblib_service_interface.h>
+
+#include "zigbee_service_interface.h"
+#include "zigbee_service_interface_common.h"
+#include "zigbee_service_dbus_interface.h"
+
+/**< ZigBee D-BUS response callback data */
+struct zigbee_service_interface_resp_cb_type {
+ void *interface_object; /**< D-BUS interface object */
+ GDBusMethodInvocation *invocation; /**< D-BUS invocation */
+ char user_data[0]; /* Additional user data base pointer */
+};
+
+ZigbeeServiceInterfaceRespCbData_t *
+zigbee_service_dbus_interface_create_resp_cb_data(void *interface_object,
+ GDBusMethodInvocation *invocation,
+ void *user_data, unsigned int user_data_len)
+{
+ ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
+
+ /* Allocate memory for response callback data */
+ resp_cb_data = g_malloc0(sizeof(ZigbeeServiceInterfaceRespCbData_t) + user_data_len);
+
+ /* Update interface object and invocation */
+ resp_cb_data->interface_object = interface_object;
+ resp_cb_data->invocation = invocation;
+
+ /* Update user data */
+ if ((user_data != NULL) && (user_data_len > 0))
+ memcpy(resp_cb_data->user_data, user_data, user_data_len);
+
+ return resp_cb_data;
+}
+
+void zigbee_service_dbus_interface_destroy_resp_cb_data(ZigbeeServiceInterfaceRespCbData_t *resp_cb_data)
+{
+ if (NULL == resp_cb_data) {
+ Z_LOGE("resp_cb_data is NULL");
+ return;
+ }
+
+ /* Free response callback data */
+ g_free(resp_cb_data);
+}
+
+gboolean zigbee_service_dbus_interface_dispatch_request(ZigBeeServiceInterface *service_interface,
+ ZblibDriverType_e driver_type, guint ops_id,
+ gpointer request_data, guint request_data_len,
+ ZblibServiceInterfaceResponseCb_t resp_cb, gpointer resp_cb_data)
+{
+ gint request_id;
+ gboolean ret;
+
+ /* Create request_id */
+ request_id = zblib_service_interface_new_request(service_interface,
+ driver_type,
+ ops_id,
+ &request_data, request_data_len,
+ resp_cb, resp_cb_data);
+ if (ZIGBEE_SERVICE_INTERFACE_INVALID_REQUEST_ID == request_id) {
+ Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
+
+ return FALSE;
+ }
+
+ /* Dispatch request */
+ ret = zblib_service_interface_dispatch_request(service_interface, request_id);
+ if (FALSE == ret) {
+ Z_LOGE("zblib_service_interface_dispatch_request failed!");
+
+ /* Free request_id */
+ zblib_service_interface_free_request(service_interface, request_id);
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
#include <gio/gio.h>
#include <zblib.h>
+#include <zblib_service_interface.h>
#include "zigbee_generated_code.h"
/**< ZigBee D-BUS service path */
#define ZIGBEE_DBUS_PATH "/org/tizen/zigbee"
+/**< ZigBee D-BUS generic fail response macro */
+#define ZIGBEE_DBUS_FAIL_RESPONSE(invocation, msg) do { \
+ g_dbus_method_invocation_return_error(invocation, \
+ G_DBUS_ERROR, G_DBUS_ERROR_FAILED, msg); \
+} while (0)
+
+/**< ZigBee D-BUS default fail message */
+#define ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG "Request failed"
+
/**< ZigBee D-BUS interface custom data */
typedef struct {
GDBusObjectManagerServer *manager; /**< ZigBee object */
gboolean zigbee_state; /**< ZigBee service state */
} ZigbeeCustomData_t;
+/**< ZigBee D-BUS response callback data */
+typedef struct zigbee_service_interface_resp_cb_type ZigbeeServiceInterfaceRespCbData_t;
+
+/**< Common APIs */
+ZigbeeServiceInterfaceRespCbData_t *
+zigbee_service_dbus_interface_create_resp_cb_data(void *interface_object,
+ GDBusMethodInvocation *invocation,
+ void *user_data, unsigned int user_data_len);
+
+void zigbee_service_dbus_interface_destroy_resp_cb_data(ZigbeeServiceInterfaceRespCbData_t *resp_cb_data);
+
+gboolean zigbee_service_dbus_interface_dispatch_request(ZigBeeServiceInterface *service_interface,
+ ZblibDriverType_e driver_type, guint ops_id,
+ gpointer request_data, guint request_data_len,
+ ZblibServiceInterfaceResponseCb_t resp_cb, gpointer resp_cb_data);
+
#endif /* __ZIGBEE_SERVICE_INTERFACE_COMMON_H__ */
#ifndef __ZIGBEE_LIB_SERVICE_INTERFACE_H__
#define __ZIGBEE_LIB_SERVICE_INTERFACE_H__
+/**< ZigBee service interface invalid request ID */
+#define ZIGBEE_SERVICE_INTERFACE_INVALID_REQUEST_ID (-1)
+
/**< ZigBee Service interface response callback function pointer */
-typedef gboolean (*ZblibServiceInterfaceResponseCb_t)(ZigBeeServiceInterface *service_interface,
+typedef void (*ZblibServiceInterfaceResponseCb_t)(ZigBeeServiceInterface *service_interface,
guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data);
/**< Service interface APIs */
ZigBeeService *zblib_service_interface_ref_service(ZigBeeServiceInterface *service_interface);
gint zblib_service_interface_new_request(ZigBeeServiceInterface *service_interface,
- guint request_type,
+ ZblibDriverType_e driver_type, guint ops_id,
gpointer request_data, guint request_data_len,
ZblibServiceInterfaceResponseCb_t resp_cb, gpointer resp_cb_data);
+void zblib_service_interface_free_request(ZigBeeServiceInterface *service_interface,
+ guint request_id);
gboolean zblib_service_interface_dispatch_request(ZigBeeServiceInterface *service_interface,
guint request_id);
/* Copy data */
memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
- req->node_id = in_req->node_id;
req->endpoint = in_req->endpoint;
req->alarm_code = in_req->alarm_code;
req->cluster_id = in_req->cluster_id;
/* Copy data */
req->node_id = in_req->node_id;
- req->aps_frame_ctl = in_req->aps_frame_ctl;
+ req->aps_frame_ctrl = in_req->aps_frame_ctrl;
req->src_ep = in_req->src_ep;
req->dest_ep = in_req->dest_ep;
req->cluster_id = in_req->cluster_id;
req->profile_id = in_req->profile_id;
- req->zcl_frame_ctl = in_req->zcl_frame_ctl;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
req->mfg_code = in_req->mfg_code;
memcpy(req->payload,
in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
req->src_ep = in_req->src_ep;
req->dest_ep = in_req->dest_ep;
req->cluster_id = in_req->cluster_id;
- req->zcl_frame_ctl = in_req->zcl_frame_ctl;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
req->cmd_id = in_req->cmd_id;
memcpy(req->payload,
in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
break;
case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
- ZigbeeLevelControlMoveOnOff_t *in_req;
- ZigbeeLevelControlMoveOnOff_t *req = NULL;
+ ZigbeeLevelControlMoveWithOnOff_t *in_req;
+ ZigbeeLevelControlMoveWithOnOff_t *req = NULL;
- in_req = (ZigbeeLevelControlMoveOnOff_t *)request_data;
+ in_req = (ZigbeeLevelControlMoveWithOnOff_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeLevelControlMoveOnOff_t *)
- g_malloc0(sizeof(ZigbeeLevelControlMoveOnOff_t));
+ req = (ZigbeeLevelControlMoveWithOnOff_t *)
+ g_malloc0(sizeof(ZigbeeLevelControlMoveWithOnOff_t));
/* Copy data */
req->node_id = in_req->node_id;
break;
case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
- ZigbeeLevelControlMoveOnOff_t *req = NULL;
+ ZigbeeLevelControlMoveWithOnOff_t *req = NULL;
- req = (ZigbeeLevelControlMoveOnOff_t *)request->request_data;
+ req = (ZigbeeLevelControlMoveWithOnOff_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
Z_LOGE("zblib_service_genrate_request_id failed!");
/* Free resources */
+ __zblib_request_free_request_data(request);
g_free(request);
return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
Z_LOGE("zblib_service_ref_request_hash_table failed!");
/* Free resources */
+ __zblib_request_free_request_data(request);
g_free(request);
return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
}
gint zblib_service_interface_new_request(ZigBeeServiceInterface *service_interface,
- guint request_type,
+ ZblibDriverType_e driver_type, guint ops_id,
gpointer request_data, guint request_data_len,
ZblibServiceInterfaceResponseCb_t resp_cb, gpointer resp_cb_data)
{
+ guint request_type;
gint request_id = 0;
gboolean ret;
- zblib_check_null_ret_error("service_interface", service_interface, -1);
+ zblib_check_null_ret_error("service_interface",
+ service_interface, ZIGBEE_SERVICE_INTERFACE_INVALID_REQUEST_ID);
+
+ /* Create request type */
+ request_type = zblib_request_generate_request_type(driver_type, ops_id);
/* Create new request */
request_id = zblib_request_new(service_interface,
/* Free request_id */
zblib_request_free(service_interface, request_id);
- request_id = -1;
+ request_id = ZIGBEE_SERVICE_INTERFACE_INVALID_REQUEST_ID;
}
return request_id;
}
+void zblib_service_interface_free_request(ZigBeeServiceInterface *service_interface,
+ guint request_id)
+{
+ zblib_check_null_ret("service_interface", service_interface);
+
+ /* Free request_id */
+ zblib_request_free(service_interface, request_id);
+}
+
gboolean zblib_service_interface_dispatch_request(ZigBeeServiceInterface *service_interface,
guint request_id)
{
projects / platform / core / connectivity / zigbee-manager.git / commitdiff