SET(ZIGBEE_LIB_SRC_PATH "zigbee-lib/src")
SET(ZIGBEE_LIB_SRCS
- ${ZIGBEE_LIB_SRC_PATH}/zblib_service.c
- ${ZIGBEE_LIB_SRC_PATH}/zblib_service_interface.c
- ${ZIGBEE_LIB_SRC_PATH}/zblib_plugin.c
- ${ZIGBEE_LIB_SRC_PATH}/zblib_driver.c
- ${ZIGBEE_LIB_SRC_PATH}/zblib_request.c
- ${ZIGBEE_LIB_SRC_PATH}/zblib_log.c
- ${ZIGBEE_LIB_SRC_PATH}/zblib_common.c
- ${ZIGBEE_LIB_SRC_PATH}/zblib_util.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_alarm.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_custom.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_door_lock.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_fan_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_level_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_mfglib_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_on_off.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_service.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_thermostat.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zclbasic_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zclglobal_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zclias_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zclidentify_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_color.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_group.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_poll_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_scene.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zdodev_control.c
- ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zdo_bind.c
+ ${ZIGBEE_LIB_SRC_PATH}/zblib_service.c
+ ${ZIGBEE_LIB_SRC_PATH}/zblib_service_interface.c
+ ${ZIGBEE_LIB_SRC_PATH}/zblib_plugin.c
+ ${ZIGBEE_LIB_SRC_PATH}/zblib_driver.c
+ ${ZIGBEE_LIB_SRC_PATH}/zblib_request.c
+ ${ZIGBEE_LIB_SRC_PATH}/zblib_log.c
+ ${ZIGBEE_LIB_SRC_PATH}/zblib_common.c
+ ${ZIGBEE_LIB_SRC_PATH}/zblib_util.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_alarm.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_custom.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_door_lock.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_fan_control.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_level_control.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_mfglib_control.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_on_off.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_service.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_thermostat.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_basic.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_global_control.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_ias_zone.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_identify.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_color_control.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_group.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_poll_control.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zcl_scene.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zdo_dev_control.c
+ ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_zdo_bind.c
)
### Sub-directotries ###
INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_SOURCE_DIR}/src
${CMAKE_CURRENT_SOURCE_DIR}/include
- ${CMAKE_CURRENT_BINARY_DIR}/
+ ${CMAKE_CURRENT_BINARY_DIR}/
${CMAKE_CURRENT_SOURCE_DIR}/../zigbee-lib/include
${CMAKE_SOURCE_DIR}/common/include
${CMAKE_CURRENT_SOURCE_DIR}/../zigbee-service/include
--c-generate-object-manager --generate-docbook zigbee-generated-docs
${INTROSPECTION_PATH}/manager.xml
${INTROSPECTION_PATH}/service.xml
- ${INTROSPECTION_PATH}/on_off.xml
- ${INTROSPECTION_PATH}/door_lock.xml
- ${INTROSPECTION_PATH}/level_control.xml
- ${INTROSPECTION_PATH}/thermostat.xml
- ${INTROSPECTION_PATH}/fan_control.xml
- ${INTROSPECTION_PATH}/alarm.xml
- ${INTROSPECTION_PATH}/mfglib_control.xml
- ${INTROSPECTION_PATH}/zclglobal_control.xml
- ${INTROSPECTION_PATH}/zdodev_control.xml
- ${INTROSPECTION_PATH}/zclbasic_control.xml
- ${INTROSPECTION_PATH}/zclidentify_control.xml
- ${INTROSPECTION_PATH}/zclias_control.xml
- ${INTROSPECTION_PATH}/zcl_poll_control.xml
- ${INTROSPECTION_PATH}/zcl_group.xml
- ${INTROSPECTION_PATH}/zcl_scene.xml
- ${INTROSPECTION_PATH}/zdo_bind.xml
- ${INTROSPECTION_PATH}/zcl_color.xml
+ ${INTROSPECTION_PATH}/mfglib-control.xml
+ ${INTROSPECTION_PATH}/zdo-bind.xml
+ ${INTROSPECTION_PATH}/zdo-dev-control.xml
${INTROSPECTION_PATH}/custom.xml
+ ${INTROSPECTION_PATH}/zcl-on-off.xml
+ ${INTROSPECTION_PATH}/zcl-door-lock.xml
+ ${INTROSPECTION_PATH}/zcl-level-control.xml
+ ${INTROSPECTION_PATH}/zcl-thermostat.xml
+ ${INTROSPECTION_PATH}/zcl-fan-control.xml
+ ${INTROSPECTION_PATH}/zcl-alarm.xml
+ ${INTROSPECTION_PATH}/zcl-global-control.xml
+ ${INTROSPECTION_PATH}/zcl-basic.xml
+ ${INTROSPECTION_PATH}/zcl-identify.xml
+ ${INTROSPECTION_PATH}/zcl-ias-zone.xml
+ ${INTROSPECTION_PATH}/zcl-poll-control.xml
+ ${INTROSPECTION_PATH}/zcl-group.xml
+ ${INTROSPECTION_PATH}/zcl-scene.xml
+ ${INTROSPECTION_PATH}/zcl-color-control.xml
COMMENT "Generating ZigBee GDBus .c/.h"
)
### Sources ###
SET(ZIGBEE_INTERFACE_SRCS
- ${CMAKE_CURRENT_BINARY_DIR}/zigbee_generated_code.c
+ ${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_zcl_alarm.c
src/zigbee_service_dbus_interface_custom.c
- src/zigbee_service_dbus_interface_door_lock.c
- src/zigbee_service_dbus_interface_fan_control.c
- src/zigbee_service_dbus_interface_level_control.c
+ src/zigbee_service_dbus_interface_zcl_door_lock.c
+ src/zigbee_service_dbus_interface_zcl_fan_control.c
+ src/zigbee_service_dbus_interface_zcl_level_control.c
src/zigbee_service_dbus_interface_mfglib_control.c
- src/zigbee_service_dbus_interface_on_off.c
+ src/zigbee_service_dbus_interface_zcl_on_off.c
src/zigbee_service_dbus_interface_service.c
- src/zigbee_service_dbus_interface_thermostat.c
- src/zigbee_service_dbus_interface_zclbasic_control.c
- src/zigbee_service_dbus_interface_zcl_color.c
- src/zigbee_service_dbus_interface_zclglobal_control.c
+ src/zigbee_service_dbus_interface_zcl_thermostat.c
+ src/zigbee_service_dbus_interface_zcl_basic.c
+ src/zigbee_service_dbus_interface_zcl_color_control.c
+ src/zigbee_service_dbus_interface_zcl_global_control.c
src/zigbee_service_dbus_interface_zcl_group.c
- src/zigbee_service_dbus_interface_zclias_control.c
- src/zigbee_service_dbus_interface_zclidentify_control.c
+ src/zigbee_service_dbus_interface_zcl_ias_zone.c
+ src/zigbee_service_dbus_interface_zcl_identify.c
src/zigbee_service_dbus_interface_zcl_poll_control.c
src/zigbee_service_dbus_interface_zcl_scene.c
src/zigbee_service_dbus_interface_zdo_bind.c
- src/zigbee_service_dbus_interface_zdodev_control.c
+ src/zigbee_service_dbus_interface_zdo_dev_control.c
)
### Binary build ###
+++ /dev/null
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Suresh Kumar N (suresh.n@samsung.com)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ON_OFF_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ON_OFF_H__
-
-gboolean zigbee_service_dbus_interface_on_off_init(ZigBeeServiceInterface *service_interface,
- ZigbeeObjectSkeleton *zigbee_object);
-
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ON_OFF_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_DOOR_LOCK_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_DOOR_LOCK_H__
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_ALARM_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_ALARM_H__
-gboolean zigbee_service_dbus_interface_door_lock_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_alarm_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_DOOR_LOCK_H__ */
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_ALARM_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_H__
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_BASIC_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_BASIC_H__
-gboolean zigbee_service_dbus_interface_zcl_color_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_basic_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_H__ */
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_BASIC_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLGLOBAL_CONTROL_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLGLOBAL_CONTROL_H__
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_CONTROL_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_CONTROL_H__
-gboolean zigbee_service_dbus_interface_zclglobal_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_color_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLGLOBAL_CONTROL_H__ */
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_COLOR_CONTROL_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_LEVEL_CONTROL_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_LEVEL_CONTROL_H__
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_DOOR_LOCK_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_DOOR_LOCK_H__
-gboolean zigbee_service_dbus_interface_level_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_door_lock_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_LEVEL_CONTROL_H__ */
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_DOOR_LOCK_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Suresh Kumar N (suresh.n@samsung.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_FAN_CONTROL_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_FAN_CONTROL_H__
+
+gboolean zigbee_service_dbus_interface_zcl_fan_control_init(ZigBeeServiceInterface *service_interface,
+ ZigbeeObjectSkeleton *zigbee_object);
+
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_FAN_CONTROL_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Suresh Kumar N (suresh.n@samsung.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_GLOBAL_CONTROL_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_GLOBAL_CONTROL_H__
+
+gboolean zigbee_service_dbus_interface_zcl_global_control_init(ZigBeeServiceInterface *service_interface,
+ ZigbeeObjectSkeleton *zigbee_object);
+
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_GLOBAL_CONTROL_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ALARM_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ALARM_H__
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_IAS_ZONE_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_IAS_ZONE_H__
-gboolean zigbee_service_dbus_interface_alarm_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_ias_zone_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ALARM_H__ */
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_IAS_ZONE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_FAN_CONTROL_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_FAN_CONTROL_H__
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_IDENTIFYL_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_IDENTIFYL_H__
-gboolean zigbee_service_dbus_interface_fan_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_identify_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_FAN_CONTROL_H__ */
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_IDENTIFYL_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Suresh Kumar N (suresh.n@samsung.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_LEVEL_CONTROL_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_LEVEL_CONTROL_H__
+
+gboolean zigbee_service_dbus_interface_zcl_level_control_init(ZigBeeServiceInterface *service_interface,
+ ZigbeeObjectSkeleton *zigbee_object);
+
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_LEVEL_CONTROL_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_THERMOSTAT_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_THERMOSTAT_H__
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_ON_OFF_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_ON_OFF_H__
-gboolean zigbee_service_dbus_interface_thermostat_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_on_off_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_THERMOSTAT_H__ */
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_ON_OFF_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIAS_CONTROL_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIAS_CONTROL_H__
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_THERMOSTAT_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_THERMOSTAT_H__
-gboolean zigbee_service_dbus_interface_zclias_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_thermostat_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object);
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIAS_CONTROL_H__ */
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCL_THERMOSTAT_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Suresh Kumar N (suresh.n@samsung.com)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLBASIC_CONTROL_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLBASIC_CONTROL_H__
-
-gboolean zigbee_service_dbus_interface_zclbasic_control_init(ZigBeeServiceInterface *service_interface,
- ZigbeeObjectSkeleton *zigbee_object);
-
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLBASIC_CONTROL_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Suresh Kumar N (suresh.n@samsung.com)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIDENTIFY_CONTROL_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIDENTIFY_CONTROL_H__
-
-gboolean zigbee_service_dbus_interface_zclidentify_control_init(ZigBeeServiceInterface *service_interface,
- ZigbeeObjectSkeleton *zigbee_object);
-
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZCLIDENTIFY_CONTROL_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Suresh Kumar N (suresh.n@samsung.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDO_DEV_CONTROL_H__
+#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDO_DEV_CONTROL_H__
+
+gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
+ ZigbeeObjectSkeleton *zigbee_object);
+
+#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDO_DEV_CONTROL_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Suresh Kumar N (suresh.n@samsung.com)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDODEV_CONTROL_H__
-#define __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDODEV_CONTROL_H__
-
-gboolean zigbee_service_dbus_interface_zdodev_control_init(ZigBeeServiceInterface *service_interface,
- ZigbeeObjectSkeleton *zigbee_object);
-
-#endif /* __ZIGBEE_SERVICE_DBUS_INTERFACE_ZDODEV_CONTROL_H__ */
-gdbus-codegen --interface-prefix org.tizen.zigbee. \\r
- --generate-c-code zigbee_generated_code \\r
- --c-namespace Zigbee \\r
- --c-generate-object-manager \\r
- --generate-docbook generated-docs \\r
- manager.xml \\r
- service.xml \\r
- on_off.xml \\r
- door_lock.xml \\r
- level_control.xml \\r
- thermostat.xml \\r
- fan_control.xml \\r
- alarm.xml \\r
- mfglib_control.xml \\r
- zclglobal_control.xml \\r
- zdodev_control.xml \\r
- zclbasic_control.xml \\r
- zclidentify_control.xml \\r
- zclias_control.xml \\r
- zcl_poll_control.xml \\r
- zcl_group.xml \\r
- zcl_scene.xml \\r
- zdo_bind.xml \\r
- zcl_color.xml \\r
- custom.xml\r
+gdbus-codegen --interface-prefix org.tizen.zigbee. \
+ --generate-c-code zigbee_generated_code \
+ --c-namespace Zigbee \
+ --c-generate-object-manager \
+ --generate-docbook generated-docs \
+ manager.xml \
+ service.xml \
+ mfglib-control.xml \
+ custom.xml \
+ zdo-dev-control.xml \
+ zdo-bind.xml \
+ zcl-global-control.xml \
+ zcl-on-off.xml \
+ zcl-door-lock.xml \
+ zcl-level-control.xml \
+ zcl-thermostat.xml \
+ zcl-fan-control.xml \
+ zcl-alarm.xml \
+ zcl-basic.xml \
+ zcl-identify.xml \
+ zcl-ias-zone.xml \
+ zcl-poll-control.xml \
+ zcl-group.xml \
+ zcl-scene.xml \
+ zcl-color-control.xml
<node>
- <interface name='org.tizen.zigbee.alarm'>
+ <interface name='org.tizen.zigbee.zcl_alarm'>
<method name='get_alarm_count'>
<arg type='ay' name='eui64' direction='in'/>
<arg type='y' name='endpoint' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.zclbasic_control'>
+ <interface name='org.tizen.zigbee.zcl_basic'>
<method name='reset_factory_default'>
<arg type='q' name='nodeId' direction='in'/>
<arg type='y' name='dst_ep' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.zcl_color'>
+ <interface name='org.tizen.zigbee.zcl_color_control'>
<method name='move_to_hue'>
<arg type='q' name='nodeId' direction='in'/>
<arg type='y' name='endpoint' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.door_lock'>
+ <interface name='org.tizen.zigbee.zcl_door_lock'>
<method name='subscribe_lock_event'>
<arg type='ay' name='eui64' direction='in'/>
<arg type='y' name='endpoint' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.fan_control'>
+ <interface name='org.tizen.zigbee.zcl_fan_control'>
<method name='set_fan_mode'>
<arg type='ay' name='eui64' direction='in'/>
<arg type='y' name='endpoint' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.zclglobal_control'>
+ <interface name='org.tizen.zigbee.zcl_global_control'>
<method name='read_attributes_req'>
<arg type='ay' name='attributeId' direction='in'/>
<arg type='i' name='attributeIdsLen' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.zclias_control'>
+ <interface name='org.tizen.zigbee.zcl_ias_zone'>
<method name='enroll_response'>
<arg type='q' name='nodeId' direction='in'/>
<arg type='y' name='dst_ep' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.zclidentify_control'>
+ <interface name='org.tizen.zigbee.zcl_identify'>
<method name='identify'>
<arg type='q' name='nodeId' direction='in'/>
<arg type='y' name='dst_ep' direction='in'/>
<arg type='i' name='result' direction='out'/>
</method>
- <signal name='query_sp'>
+ <signal name='query_rsp'>
<arg type='q' name='nodeId'/>
<arg type='q' name='identify_time'/>
</signal>
<node>
- <interface name='org.tizen.zigbee.level_control'>
+ <interface name='org.tizen.zigbee.zcl_level_control'>
<method name='move_to_level'>
<arg type='q' name='nodeId' direction='in'/>
<arg type='y' name='endpoint' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.on_off'>
+ <interface name='org.tizen.zigbee.zcl_on_off'>
<method name='set_on_off'>
<arg type='q' name='node_id' direction='in'/>
<arg type='y' name='endpoint' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.thermostat'>
+ <interface name='org.tizen.zigbee.zcl_thermostat'>
<method name='get_local_temp'>
<arg type='ay' name='eui64' direction='in'/>
<arg type='y' name='endpoint' direction='in'/>
<node>
- <interface name='org.tizen.zigbee.zdodev_control'>
+ <interface name='org.tizen.zigbee.zdo_dev_control'>
<method name='nwk_addr_req'>
<arg type='ay' name='EUI64' direction='in'/>
<arg type='y' name='requestType' direction='in'/>
{
gboolean ret;
- ret = zigbee_service_dbus_interface_alarm_init(service_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_alarm_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
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_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_door_lock_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_fan_control_init(service_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_fan_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_level_control_init(service_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_level_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
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_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_on_off_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
ret = zigbee_service_dbus_interface_service_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_thermostat_init(service_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_thermostat_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zclbasic_control_init(service_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_basic_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zcl_color_init(service_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_color_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zclglobal_control_init(service_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_global_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
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_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_ias_zone_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
- ret = zigbee_service_dbus_interface_zclidentify_control_init(service_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zcl_identify_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
ret = zigbee_service_dbus_interface_zcl_poll_control_init(service_interface, 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_interface, zigbee_object);
+ ret = zigbee_service_dbus_interface_zdo_dev_control_init(service_interface, zigbee_object);
Z_LOGD("ret: %d", ret);
}
gboolean ret;
+ Z_LOGE("KSR");
+
/* Allocate response callback data */
resp_cb_data =
zigbee_service_dbus_interface_create_resp_cb_data(service_object,
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_alarm.h>
+#include <zblib_driver_zcl_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)
NOT_USED(resp_data_len);
}
-static gboolean on_alarm_get_alarm_count(ZigbeeAlarm *alarm_object,
+static gboolean on_alarm_get_alarm_count(ZigbeeZcl_alarm *alarm_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_alarm_reset_alarm(ZigbeeAlarm *alarm_object,
+static gboolean on_alarm_reset_alarm(ZigbeeZcl_alarm *alarm_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_alarm_reset_all_alarm(ZigbeeAlarm *alarm_object,
+static gboolean on_alarm_reset_all_alarm(ZigbeeZcl_alarm *alarm_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_alarm_alarm(ZigbeeAlarm *alarm_object,
+static gboolean on_alarm_alarm(ZigbeeZcl_alarm *alarm_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_alarm_reset_alarm_log(ZigbeeAlarm *alarm_object,
+static gboolean on_alarm_reset_alarm_log(ZigbeeZcl_alarm *alarm_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_alarm_get_alarm(ZigbeeAlarm *alarm_object,
+static gboolean on_alarm_get_alarm(ZigbeeZcl_alarm *alarm_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_alarm_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_alarm_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeAlarm *alarm_object;
+ ZigbeeZcl_alarm *alarm_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- alarm_object = zigbee_alarm_skeleton_new();
- zigbee_object_skeleton_set_alarm(zigbee_object, alarm_object);
+ alarm_object = zigbee_zcl_alarm_skeleton_new();
+ zigbee_object_skeleton_set_zcl_alarm(zigbee_object, alarm_object);
g_object_unref(alarm_object);
Z_LOGI("alarm_object: [%p]", alarm_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_zclbasic_control.h>
+#include <zblib_driver_zcl_basic.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)
NOT_USED(resp_data_len);
}
-static gboolean on_zclbasic_control_reset_factory_default(ZigbeeZclbasic_control *zclbasic_control_object,
+static gboolean on_zclbasic_control_reset_factory_default(ZigbeeZcl_basic *zclbasic_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar dest_ep,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zclbasic_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_basic_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeZclbasic_control *zclbasic_control_object;
+ ZigbeeZcl_basic *zclbasic_control_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- zclbasic_control_object = zigbee_zclbasic_control_skeleton_new();
- zigbee_object_skeleton_set_zclbasic_control(zigbee_object, zclbasic_control_object);
+ zclbasic_control_object = zigbee_zcl_basic_skeleton_new();
+ zigbee_object_skeleton_set_zcl_basic(zigbee_object, zclbasic_control_object);
g_object_unref(zclbasic_control_object);
Z_LOGI("zclbasic_control_object: [%p]", zclbasic_control_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_zcl_color.h>
+#include <zblib_driver_zcl_color_control.h>
static void on_zcl_color_move_to_hue_resp(ZigBeeServiceInterface *service_interface,
guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_move_to_hue(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_move_to_hue(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_move_hue(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_move_hue(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_step_hue(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_step_hue(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_move_to_saturation(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_move_to_saturation(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_move_saturation(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_move_saturation(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_step_saturation(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_step_saturation(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_move_to_hue_and_saturation(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_move_to_hue_and_saturation(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_move_to_color(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_move_to_color(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_move_color(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_move_color(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_step_color(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_step_color(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zcl_color_move_color_temperature(ZigbeeZcl_color *zcl_color_object,
+static gboolean on_zcl_color_move_color_temperature(ZigbeeZcl_color_control *zcl_color_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zcl_color_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_color_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeZcl_color *zcl_color_object;
+ ZigbeeZcl_color_control *zcl_color_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- zcl_color_object = zigbee_zcl_color_skeleton_new();
- zigbee_object_skeleton_set_zcl_color(zigbee_object, zcl_color_object);
+ zcl_color_object = zigbee_zcl_color_control_skeleton_new();
+ zigbee_object_skeleton_set_zcl_color_control(zigbee_object, zcl_color_object);
g_object_unref(zcl_color_object);
Z_LOGI("zcl_color_object: [%p]", zcl_color_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_door_lock.h>
+#include <zblib_driver_zcl_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)
NOT_USED(resp_data_len);
}
-static gboolean on_door_lock_subscribe_lock_event(ZigbeeDoor_lock *door_lock_object,
+static gboolean on_door_lock_subscribe_lock_event(ZigbeeZcl_door_lock *door_lock_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_door_lock_set_door_lock_pin(ZigbeeDoor_lock *door_lock_object,
+static gboolean on_door_lock_set_door_lock_pin(ZigbeeZcl_door_lock *door_lock_object,
GDBusMethodInvocation *invocation,
gshort uid,
gchar ustatus,
NOT_USED(resp_data_len);
}
-static gboolean on_door_lock_set_door_lock(ZigbeeDoor_lock *door_lock_object,
+static gboolean on_door_lock_set_door_lock(ZigbeeZcl_door_lock *door_lock_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_door_lock_get_lock_state(ZigbeeDoor_lock *door_lock_object,
+static gboolean on_door_lock_get_lock_state(ZigbeeZcl_door_lock *door_lock_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_door_lock_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_door_lock_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeDoor_lock *door_lock_object;
+ ZigbeeZcl_door_lock *door_lock_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- door_lock_object = zigbee_door_lock_skeleton_new();
- zigbee_object_skeleton_set_door_lock(zigbee_object, door_lock_object);
+ door_lock_object = zigbee_zcl_door_lock_skeleton_new();
+ zigbee_object_skeleton_set_zcl_door_lock(zigbee_object, door_lock_object);
g_object_unref(door_lock_object);
Z_LOGI("door_lock_object: [%p]", door_lock_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_fan_control.h>
+#include <zblib_driver_zcl_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)
NOT_USED(resp_data_len);
}
-static gboolean on_fan_control_set_fan_mode(ZigbeeFan_control *fan_control_object,
+static gboolean on_fan_control_set_fan_mode(ZigbeeZcl_fan_control *fan_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_fan_control_get_fan_mode(ZigbeeFan_control *fan_control_object,
+static gboolean on_fan_control_get_fan_mode(ZigbeeZcl_fan_control *fan_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_fan_control_set_fan_mode_sequence(ZigbeeFan_control *fan_control_object,
+static gboolean on_fan_control_set_fan_mode_sequence(
+ ZigbeeZcl_fan_control *fan_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_fan_control_get_fan_mode_sequence(ZigbeeFan_control *fan_control_object,
+static gboolean on_fan_control_get_fan_mode_sequence(
+ ZigbeeZcl_fan_control *fan_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_fan_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_fan_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeFan_control *fan_control_object;
+ ZigbeeZcl_fan_control *fan_control_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- fan_control_object = zigbee_fan_control_skeleton_new();
- zigbee_object_skeleton_set_fan_control(zigbee_object, fan_control_object);
+ fan_control_object = zigbee_zcl_fan_control_skeleton_new();
+ zigbee_object_skeleton_set_zcl_fan_control(zigbee_object, fan_control_object);
g_object_unref(fan_control_object);
Z_LOGI("fan_control_object: [%p]", fan_control_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_zclglobal_control.h>
+#include <zblib_driver_zcl_global_control.h>
static void on_zclglobal_control_read_attributes_req_resp(ZigBeeServiceInterface *service_interface,
guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_read_attributes_req(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_read_attributes_req(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
GVariant *attribute_id,
gint attribute_ids_length,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_write_attributes_req(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_write_attributes_req(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
GVariant *write_attribute,
gint records_length,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_write_attributes_undivided_req(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_write_attributes_undivided_req(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
GVariant *write_attribute,
gint records_length,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_write_attributes_no_resp(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_write_attributes_no_resp(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
GVariant *write_attribute,
gint records_length,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_write_attributes_structured(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_write_attributes_structured(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
GVariant *write_attribute,
gint records_length,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_read_attributes_structured(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_read_attributes_structured(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
GVariant *read_attribute,
gint records_length,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_configure_reporting_req(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_configure_reporting_req(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
GVariant *read_attribute,
gint records_length,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_read_configure_reporting(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_read_configure_reporting(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
GVariant *read_attribute,
gint records_length,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_discover_attributes(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_discover_attributes(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar dest_ep,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_discover_attributes_extended(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_discover_attributes_extended(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar dest_ep,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_discover_commands_received(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_discover_commands_received(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar dest_ep,
NOT_USED(resp_data_len);
}
-static gboolean on_zclglobal_control_discover_commands_generated(ZigbeeZclglobal_control *zclglobal_control_object,
+static gboolean on_zclglobal_control_discover_commands_generated(ZigbeeZcl_global_control *zclglobal_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar dest_ep,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zclglobal_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_global_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeZclglobal_control *zclglobal_control_object;
+ ZigbeeZcl_global_control *zclglobal_control_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- zclglobal_control_object = zigbee_zclglobal_control_skeleton_new();
- zigbee_object_skeleton_set_zclglobal_control(zigbee_object, zclglobal_control_object);
+ zclglobal_control_object = zigbee_zcl_global_control_skeleton_new();
+ zigbee_object_skeleton_set_zcl_global_control(zigbee_object, zclglobal_control_object);
g_object_unref(zclglobal_control_object);
Z_LOGI("zclglobal_control_object: [%p]", zclglobal_control_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_zclias_control.h>
+#include <zblib_driver_zcl_ias_zone.h>
static void on_zclias_control_enroll_response_resp(ZigBeeServiceInterface *service_interface,
guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zclias_control_enroll_response(ZigbeeZclias_control *zclias_control_object,
+static gboolean on_zclias_control_enroll_response(ZigbeeZcl_ias_zone *zclias_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar dest_ep,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zclias_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_ias_zone_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeZclias_control *zclias_control_object;
+ ZigbeeZcl_ias_zone *zclias_control_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- zclias_control_object = zigbee_zclias_control_skeleton_new();
- zigbee_object_skeleton_set_zclias_control(zigbee_object, zclias_control_object);
+ zclias_control_object = zigbee_zcl_ias_zone_skeleton_new();
+ zigbee_object_skeleton_set_zcl_ias_zone(zigbee_object, zclias_control_object);
g_object_unref(zclias_control_object);
Z_LOGI("zclias_control_object: [%p]", zclias_control_object);
* Register signal handlers for 'zclias_control' interface
*/
g_signal_connect(zclias_control_object,
- "handle-get-alarm-count",
+ "handle-enroll-response",
G_CALLBACK(on_zclias_control_enroll_response), service_interface);
return TRUE;
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_zclidentify_control.h>
+#include <zblib_driver_zcl_identify.h>
static void on_zclidentify_control_identify_resp(ZigBeeServiceInterface *service_interface,
guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zclidentify_control_identify(ZigbeeZclidentify_control *zclidentify_control_object,
+static gboolean on_zclidentify_control_identify(ZigbeeZcl_identify *zclidentify_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar dest_ep,
NOT_USED(resp_data_len);
}
-static gboolean on_zclidentify_control_query(ZigbeeZclidentify_control *zclidentify_control_object,
+static gboolean on_zclidentify_control_query(ZigbeeZcl_identify *zclidentify_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar dest_ep,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zclidentify_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_identify_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeZclidentify_control *zclidentify_control_object;
+ ZigbeeZcl_identify *zclidentify_control_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- zclidentify_control_object = zigbee_zclidentify_control_skeleton_new();
- zigbee_object_skeleton_set_zclidentify_control(zigbee_object, zclidentify_control_object);
+ zclidentify_control_object = zigbee_zcl_identify_skeleton_new();
+ zigbee_object_skeleton_set_zcl_identify(zigbee_object, zclidentify_control_object);
g_object_unref(zclidentify_control_object);
Z_LOGI("zclidentify_control_object: [%p]", zclidentify_control_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_level_control.h>
+#include <zblib_driver_zcl_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)
NOT_USED(resp_data_len);
}
-static gboolean on_level_control_move_to_level(ZigbeeLevel_control *level_control_object,
+static gboolean on_level_control_move_to_level(ZigbeeZcl_level_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_level_control_move(ZigbeeLevel_control *level_control_object,
+static gboolean on_level_control_move(ZigbeeZcl_level_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_level_control_step(ZigbeeLevel_control *level_control_object,
+static gboolean on_level_control_step(ZigbeeZcl_level_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_level_control_move_to_level_with_on_off(ZigbeeLevel_control *level_control_object,
+static gboolean on_level_control_move_to_level_with_on_off(
+ ZigbeeZcl_level_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_level_control_move_with_on_off(ZigbeeLevel_control *level_control_object,
+static gboolean on_level_control_move_with_on_off(
+ ZigbeeZcl_level_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_level_control_step_with_on_off(ZigbeeLevel_control *level_control_object,
+static gboolean on_level_control_step_with_on_off(
+ ZigbeeZcl_level_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_level_control_stop(ZigbeeLevel_control *level_control_object,
+static gboolean on_level_control_stop(ZigbeeZcl_level_control *level_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_level_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_level_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeLevel_control *level_control_object;
+ ZigbeeZcl_level_control *level_control_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- level_control_object = zigbee_level_control_skeleton_new();
- zigbee_object_skeleton_set_level_control(zigbee_object, level_control_object);
+ level_control_object = zigbee_zcl_level_control_skeleton_new();
+ zigbee_object_skeleton_set_zcl_level_control(zigbee_object, level_control_object);
g_object_unref(level_control_object);
Z_LOGI("level_control_object: [%p]", level_control_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_on_off.h>
+#include <zblib_driver_zcl_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)
NOT_USED(resp_data_len);
}
-static gboolean on_on_off_set_on_off(ZigbeeOn_off *on_off_object,
+static gboolean on_on_off_set_on_off(ZigbeeZcl_on_off *on_off_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_on_off_get_on_off_state(ZigbeeOn_off *on_off_object,
+static gboolean on_on_off_get_on_off_state(ZigbeeZcl_on_off *on_off_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_on_off_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_on_off_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeOn_off *on_off_object;
+ ZigbeeZcl_on_off *on_off_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- on_off_object = zigbee_on_off_skeleton_new();
- zigbee_object_skeleton_set_on_off(zigbee_object, on_off_object);
+ on_off_object = zigbee_zcl_on_off_skeleton_new();
+ zigbee_object_skeleton_set_zcl_on_off(zigbee_object, on_off_object);
g_object_unref(on_off_object);
Z_LOGI("on_off_object: [%p]", on_off_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_thermostat.h>
+#include <zblib_driver_zcl_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)
NOT_USED(resp_data_len);
}
-static gboolean on_thermostat_get_local_temp(ZigbeeThermostat *thermostat_object,
+static gboolean on_thermostat_get_local_temp(ZigbeeZcl_thermostat *thermostat_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_thermostat_get_weekly_schedule(ZigbeeThermostat *thermostat_object,
+static gboolean on_thermostat_get_weekly_schedule(ZigbeeZcl_thermostat *thermostat_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_thermostat_set_weekly_schedule(ZigbeeThermostat *thermostat_object,
+static gboolean on_thermostat_set_weekly_schedule(ZigbeeZcl_thermostat *thermostat_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_thermostat_clear_weekly_schedule(ZigbeeThermostat *thermostat_object,
+static gboolean on_thermostat_clear_weekly_schedule(ZigbeeZcl_thermostat *thermostat_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_thermostat_setpoint_raise_lower(ZigbeeThermostat *thermostat_object,
+static gboolean on_thermostat_setpoint_raise_lower(ZigbeeZcl_thermostat *thermostat_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_thermostat_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zcl_thermostat_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeThermostat *thermostat_object;
+ ZigbeeZcl_thermostat *thermostat_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- thermostat_object = zigbee_thermostat_skeleton_new();
- zigbee_object_skeleton_set_thermostat(zigbee_object, thermostat_object);
+ thermostat_object = zigbee_zcl_thermostat_skeleton_new();
+ zigbee_object_skeleton_set_zcl_thermostat(zigbee_object, thermostat_object);
g_object_unref(thermostat_object);
Z_LOGI("thermostat_object: [%p]", thermostat_object);
#include "zigbee_service_interface_common.h"
-#include <zblib_driver_zdodev_control.h>
+#include <zblib_driver_zdo_dev_control.h>
static void on_zdodev_control_nwk_addr_req_resp(ZigBeeServiceInterface *service_interface,
guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_nwk_addr_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_nwk_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
GVariant *eui64,
gchar request_type,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_matched_descriptor_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_matched_descriptor_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gshort profile_id,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_ieee_addr_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_ieee_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gpointer user_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_active_ep_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_active_ep_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gpointer user_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_node_desc_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_node_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gpointer user_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_power_desc_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_power_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gpointer user_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_complex_desc_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_complex_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gpointer user_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_user_desc_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_user_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gpointer user_data)
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar length,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_device_announce(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_device_announce(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
GVariant *mac_addr,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_simple_desc_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_simple_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar endpoint,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_mgmt_lqi_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_mgmt_lqi_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar start_idx,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_mgmt_rtg_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_mgmt_rtg_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar start_idx,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_mgmt_bind_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_mgmt_bind_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
gchar start_idx,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort addr16,
gchar duration,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
guint scan_channel,
NOT_USED(resp_data_len);
}
-static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdodev_control *zdodev_control_object,
+static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_control_object,
GDBusMethodInvocation *invocation,
gshort node_id,
guint scan_channel,
return TRUE;
}
-gboolean zigbee_service_dbus_interface_zdodev_control_init(ZigBeeServiceInterface *service_interface,
+gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
ZigbeeObjectSkeleton *zigbee_object)
{
- ZigbeeZdodev_control *zdodev_control_object;
+ ZigbeeZdo_dev_control *zdodev_control_object;
if (NULL == service_interface) {
Z_LOGE("service_interface is NULL");
return FALSE;
}
- zdodev_control_object = zigbee_zdodev_control_skeleton_new();
- zigbee_object_skeleton_set_zdodev_control(zigbee_object, zdodev_control_object);
+ zdodev_control_object = zigbee_zdo_dev_control_skeleton_new();
+ zigbee_object_skeleton_set_zdo_dev_control(zigbee_object, zdodev_control_object);
g_object_unref(zdodev_control_object);
Z_LOGI("zdodev_control_object: [%p]", zdodev_control_object);
#include "zigbee_generated_code.h"
#include "zigbee_service_dbus_interface_service.h"
-#include "zigbee_service_dbus_interface_on_off.h"
-#include "zigbee_service_dbus_interface_door_lock.h"
-#include "zigbee_service_dbus_interface_level_control.h"
-#include "zigbee_service_dbus_interface_thermostat.h"
-#include "zigbee_service_dbus_interface_fan_control.h"
-#include "zigbee_service_dbus_interface_alarm.h"
+#include "zigbee_service_dbus_interface_zcl_on_off.h"
+#include "zigbee_service_dbus_interface_zcl_door_lock.h"
+#include "zigbee_service_dbus_interface_zcl_level_control.h"
+#include "zigbee_service_dbus_interface_zcl_thermostat.h"
+#include "zigbee_service_dbus_interface_zcl_fan_control.h"
+#include "zigbee_service_dbus_interface_zcl_alarm.h"
#include "zigbee_service_dbus_interface_mfglib_control.h"
-#include "zigbee_service_dbus_interface_zclglobal_control.h"
-#include "zigbee_service_dbus_interface_zdodev_control.h"
-#include "zigbee_service_dbus_interface_zclbasic_control.h"
-#include "zigbee_service_dbus_interface_zclidentify_control.h"
-#include "zigbee_service_dbus_interface_zclias_control.h"
+#include "zigbee_service_dbus_interface_zcl_global_control.h"
+#include "zigbee_service_dbus_interface_zdo_dev_control.h"
+#include "zigbee_service_dbus_interface_zcl_basic.h"
+#include "zigbee_service_dbus_interface_zcl_identify.h"
+#include "zigbee_service_dbus_interface_zcl_ias_zone.h"
#include "zigbee_service_dbus_interface_zcl_poll_control.h"
#include "zigbee_service_dbus_interface_zcl_group.h"
#include "zigbee_service_dbus_interface_zcl_scene.h"
#include "zigbee_service_dbus_interface_zdo_bind.h"
-#include "zigbee_service_dbus_interface_zcl_color.h"
+#include "zigbee_service_dbus_interface_zcl_color_control.h"
#include "zigbee_service_dbus_interface_custom.h"
/**< ZigBee D-BUS service*/
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_ALARM_H__
-#define __ZIGBEE_LIB_DRIVER_ALARM_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_ALARM_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_ALARM_H__
/**< ZigBee 'alarm' driver operations */
typedef struct {
gboolean (*alarm)(ZigBeeDriver *driver, guint request_id);
gboolean (*reset_alarm_log)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_alarm)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverAlarmOps_t;
+} ZblibDriverZclAlarmOps_t;
/**< ZigBee 'alarm' ops IDs */
typedef enum {
} ZblibAlarmOps_e;
/* ZigBee 'alarm' driver APIs */
-ZigBeeDriver *zblib_driver_alarm_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_alarm_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverAlarmOps_t *ops);
-void zblib_driver_alarm_free(ZigBeeDriver *driver);
+ ZblibDriverZclAlarmOps_t *ops);
+void zblib_driver_zcl_alarm_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_ALARM_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_ALARM_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_ZCLBASIC_CONTROL_H__
-#define __ZIGBEE_LIB_DRIVER_ZCLBASIC_CONTROL_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_BASIC_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_BASIC_H__
/**< ZigBee 'Zclbasic control' driver operations */
typedef struct {
} ZblibZclbasicControlOps_e;
/* ZigBee 'Zclbasic control' driver APIs */
-ZigBeeDriver *zblib_driver_zclbasic_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_basic_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclbasicControlOps_t *ops);
-void zblib_driver_zclbasic_control_free(ZigBeeDriver *driver);
+void zblib_driver_zcl_basic_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_ZCLBASIC_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_BASIC_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_ZCL_COLOR_H__
-#define __ZIGBEE_LIB_DRIVER_ZCL_COLOR_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_COLOR_CONTROL_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_COLOR_CONTROL_H__
/**< ZigBee 'Zcl color' driver operations */
typedef struct {
} ZblibZclColorOps_e;
/* ZigBee 'Zcl color' driver APIs */
-ZigBeeDriver *zblib_driver_zcl_color_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_color_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclColorOps_t *ops);
-void zblib_driver_zcl_color_free(ZigBeeDriver *driver);
+void zblib_driver_zcl_color_control_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_ZCL_COLOR_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_COLOR_CONTROL_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_DOOR_LOCK_H__
-#define __ZIGBEE_LIB_DRIVER_DOOR_LOCK_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_DOOR_LOCK_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_DOOR_LOCK_H__
/**< ZigBee 'door lock' driver operations */
typedef struct {
gboolean (*set_door_lock_pin)(ZigBeeDriver *driver, guint request_id);
gboolean (*set_door_lock)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_lock_state)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverDoorLockOps_t;
+} ZblibDriverZclDoorLockOps_t;
/**< ZigBee 'door lock' ops IDs */
typedef enum {
ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN, /**< Set door lock pin */
ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK, /**< Set door lock */
ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE, /**< Get lock state */
-} ZblibDoorLockOps_e;
+} ZblibZclDoorLockOps_e;
/* ZigBee 'door lock' driver APIs */
-ZigBeeDriver *zblib_driver_door_lock_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_door_lock_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverDoorLockOps_t *ops);
-void zblib_driver_door_lock_free(ZigBeeDriver *driver);
+ ZblibDriverZclDoorLockOps_t *ops);
+void zblib_driver_zcl_door_lock_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_DOOR_LOCK_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_DOOR_LOCK_H__ */
} ZblibFanControlOps_e;
/* ZigBee 'fan control' driver APIs */
-ZigBeeDriver *zblib_driver_fan_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_fan_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverFanControlOps_t *ops);
-void zblib_driver_fan_control_free(ZigBeeDriver *driver);
+void zblib_driver_zcl_fan_control_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_FAN_CONTROL_H__ */
} ZblibZclglobalControlOps_e;
/* ZigBee 'Zclglobal control' driver APIs */
-ZigBeeDriver *zblib_driver_zclglobal_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_global_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclglobalControlOps_t *ops);
-void zblib_driver_zclglobal_control_free(ZigBeeDriver *driver);
+void zblib_driver_zcl_global_control_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_ZCLGLOBAL_CONTROL_H__ */
/**< ZigBee 'Zclias control' driver operations */
typedef struct {
gboolean (*enroll_response)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverZcliasControlOps_t;
+} ZblibDriverZcliasZoneOps_t;
/**< ZigBee 'Zclias control' ops IDs */
typedef enum {
ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE = 1, /**< Enroll response */
-} ZblibZcliasControlOps_e;
+} ZblibZcliasZoneOps_e;
/* ZigBee 'Zclias control' driver APIs */
-ZigBeeDriver *zblib_driver_zclias_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_ias_zone_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZcliasControlOps_t *ops);
-void zblib_driver_zclias_control_free(ZigBeeDriver *driver);
+ ZblibDriverZcliasZoneOps_t *ops);
+void zblib_driver_zcl_ias_zone_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_ZCLIAS_CONTROL_H__ */
typedef struct {
gboolean (*identify)(ZigBeeDriver *driver, guint request_id);
gboolean (*query)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverZclidentifyControlOps_t;
+} ZblibDriverZclidentifyOps_t;
/**< ZigBee 'Zclidentify control' ops IDs */
typedef enum {
ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY = 1, /**< Identify */
ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY, /**< Query */
-} ZblibZclidentifyControlOps_e;
+} ZblibZclidentifyOps_e;
/* ZigBee 'Zclidentify control' driver APIs */
-ZigBeeDriver *zblib_driver_zclidentify_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_identify_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclidentifyControlOps_t *ops);
-void zblib_driver_zclidentify_control_free(ZigBeeDriver *driver);
+ ZblibDriverZclidentifyOps_t *ops);
+void zblib_driver_zcl_identify_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_ZCLIDENTIFY_CONTROL_H__ */
} ZblibLevelControlOps_e;
/* ZigBee 'level control' driver APIs */
-ZigBeeDriver *zblib_driver_level_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_level_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverLevelControlOps_t *ops);
-void zblib_driver_level_control_free(ZigBeeDriver *driver);
+void zblib_driver_zcl_level_control_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_LEVEL_CONTROL_H__ */
typedef struct {
gboolean (*set_on_off)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_on_off_state)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverOnOffOps_t;
+} ZblibDriverZclOnOffOps_t;
/**< ZigBee 'on off' ops IDs */
typedef enum {
ZBLIB_ON_OFF_OPS_SET_ON_OFF = 1, /**< Set ON OFF */
ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE, /**< Get ON OFF state */
-} ZblibOnOffOps_e;
+} ZblibZclOnOffOps_e;
/* ZigBee 'on off' driver APIs */
-ZigBeeDriver *zblib_driver_on_off_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_on_off_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverOnOffOps_t *ops);
-void zblib_driver_on_off_free(ZigBeeDriver *driver);
+ ZblibDriverZclOnOffOps_t *ops);
+void zblib_driver_zcl_on_off_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_ON_OFF_H__ */
gboolean (*set_weekly_schedule)(ZigBeeDriver *driver, guint request_id);
gboolean (*clear_weekly_schedule)(ZigBeeDriver *driver, guint request_id);
gboolean (*setpoint_raise_lower)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverThermostatOps_t;
+} ZblibDriverZclThermostatOps_t;
/**< ZigBee 'thermostat' ops IDs */
typedef enum {
ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE, /**< Set weekly schedule */
ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE, /**< Clear weekly schedule */
ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER, /**< Setpoint raise lower */
-} ZblibThermostatOps_e;
+} ZblibZclThermostatOps_e;
/* ZigBee 'thermostat' driver APIs */
-ZigBeeDriver *zblib_driver_thermostat_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_thermostat_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverThermostatOps_t *ops);
-void zblib_driver_thermostat_free(ZigBeeDriver *driver);
+ ZblibDriverZclThermostatOps_t *ops);
+void zblib_driver_zcl_thermostat_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_THERMOSTAT_H__ */
} ZblibZdodevControlOps_e;
/* ZigBee 'Zdodev control' driver APIs */
-ZigBeeDriver *zblib_driver_zdodev_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zdo_dev_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZdodevControlOps_t *ops);
-void zblib_driver_zdodev_control_free(ZigBeeDriver *driver);
+void zblib_driver_zdo_dev_control_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_ZDODEV_CONTROL_H__ */
extern gboolean zblib_debug;
#ifndef ZIGBEE_LOG_TAG
-#define ZIGBEE_LOG_TAG "UNKNOWN"
+#define ZIGBEE_LOG_TAG "KSR"
#endif
enum zblib_log_type {
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_alarm.h"
+#include "zblib_driver_zcl_alarm.h"
/**< Private data */
typedef struct {
- ZblibDriverAlarmOps_t *ops; /**< Operations */
-} ZblibDriverAlarmPrivData_t;
+ ZblibDriverZclAlarmOps_t *ops; /**< Operations */
+} ZblibDriverZclAlarmPrivData_t;
static gboolean __zblib_driver_alarm_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverAlarmPrivData_t *priv_data = NULL;
- ZblibDriverAlarmOps_t *ops = NULL;
+ ZblibDriverZclAlarmPrivData_t *priv_data = NULL;
+ ZblibDriverZclAlarmOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
static void __zblib_driver_alarm_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverAlarmPrivData_t *priv_data = NULL;
+ ZblibDriverZclAlarmPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_alarm_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_alarm_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverAlarmOps_t *ops)
+ ZblibDriverZclAlarmOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverAlarmPrivData_t *priv_data = NULL;
+ ZblibDriverZclAlarmPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverAlarmPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclAlarmPrivData_t));
/* Update private data */
priv_data->ops = ops;
return driver;
}
-void zblib_driver_alarm_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_alarm_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_zclbasic_control.h"
+#include "zblib_driver_zcl_basic.h"
/**< Private data */
typedef struct {
ZblibDriverZclbasicControlOps_t *ops; /**< Operations */
} ZblibDriverZclbasicControlPrivData_t;
-static gboolean __zblib_driver_zclbasic_control_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_basic_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
ZblibDriverZclbasicControlPrivData_t *priv_data = NULL;
return ret;
}
-static void __zblib_driver_zclbasic_control_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_basic_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclbasicControlPrivData_t *priv_data = NULL;
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_zclbasic_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_basic_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclbasicControlOps_t *ops)
{
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zclbasic_control_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_basic_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_zclbasic_control_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_basic_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_zclbasic_control_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_basic_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_zcl_color.h"
+#include "zblib_driver_zcl_color_control.h"
/**< Private data */
typedef struct {
ZblibDriverZclColorOps_t *ops; /**< Operations */
} ZblibDriverZclColorPrivData_t;
-static gboolean __zblib_driver_zcl_color_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_color_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
ZblibDriverZclColorPrivData_t *priv_data = NULL;
return ret;
}
-static void __zblib_driver_zcl_color_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_color_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclColorPrivData_t *priv_data = NULL;
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_zcl_color_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_color_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclColorOps_t *ops)
{
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_color_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_color_control_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_color_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_color_control_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_zcl_color_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_color_control_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_door_lock.h"
+#include "zblib_driver_zcl_door_lock.h"
/**< Private data */
typedef struct {
- ZblibDriverDoorLockOps_t *ops; /**< Operations */
-} ZblibDriverDoorLockPrivData_t;
+ ZblibDriverZclDoorLockOps_t *ops; /**< Operations */
+} ZblibDriverZclDoorLockPrivData_t;
-static gboolean __zblib_driver_door_lock_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_door_lock_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverDoorLockPrivData_t *priv_data = NULL;
- ZblibDriverDoorLockOps_t *ops = NULL;
+ ZblibDriverZclDoorLockPrivData_t *priv_data = NULL;
+ ZblibDriverZclDoorLockOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
return ret;
}
-static void __zblib_driver_door_lock_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_door_lock_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverDoorLockPrivData_t *priv_data = NULL;
+ ZblibDriverZclDoorLockPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_door_lock_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_door_lock_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverDoorLockOps_t *ops)
+ ZblibDriverZclDoorLockOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverDoorLockPrivData_t *priv_data = NULL;
+ ZblibDriverZclDoorLockPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverDoorLockPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclDoorLockPrivData_t));
/* Update private data */
priv_data->ops = ops;
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_door_lock_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_door_lock_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_door_lock_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_door_lock_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_door_lock_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_door_lock_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_fan_control.h"
+#include "zblib_driver_zcl_fan_control.h"
/**< Private data */
typedef struct {
ZblibDriverFanControlOps_t *ops; /**< Operations */
} ZblibDriverFanControlPrivData_t;
-static gboolean __zblib_driver_fan_control_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_fan_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
ZblibDriverFanControlPrivData_t *priv_data = NULL;
return ret;
}
-static void __zblib_driver_fan_control_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_fan_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverFanControlPrivData_t *priv_data = NULL;
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_fan_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_fan_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverFanControlOps_t *ops)
{
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_fan_control_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_fan_control_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_fan_control_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_fan_control_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_fan_control_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_fan_control_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_zclglobal_control.h"
+#include "zblib_driver_zcl_global_control.h"
/**< Private data */
typedef struct {
ZblibDriverZclglobalControlOps_t *ops; /**< Operations */
} ZblibDriverZclglobalControlPrivData_t;
-static gboolean __zblib_driver_zclglobal_control_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_global_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
ZblibDriverZclglobalControlPrivData_t *priv_data = NULL;
return ret;
}
-static void __zblib_driver_zclglobal_control_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_global_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclglobalControlPrivData_t *priv_data = NULL;
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_zclglobal_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_global_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclglobalControlOps_t *ops)
{
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zclglobal_control_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_global_control_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_zclglobal_control_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_global_control_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_zclglobal_control_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_global_control_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_zclias_control.h"
+#include "zblib_driver_zcl_ias_zone.h"
/**< Private data */
typedef struct {
- ZblibDriverZcliasControlOps_t *ops; /**< Operations */
-} ZblibDriverZcliasControlPrivData_t;
+ ZblibDriverZcliasZoneOps_t *ops; /**< Operations */
+} ZblibDriverZcliasZonePrivData_t;
-static gboolean __zblib_driver_zclias_control_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_ias_zone_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverZcliasControlPrivData_t *priv_data = NULL;
- ZblibDriverZcliasControlOps_t *ops = NULL;
+ ZblibDriverZcliasZonePrivData_t *priv_data = NULL;
+ ZblibDriverZcliasZoneOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
return ret;
}
-static void __zblib_driver_zclias_control_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_ias_zone_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverZcliasControlPrivData_t *priv_data = NULL;
+ ZblibDriverZcliasZonePrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_zclias_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_ias_zone_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZcliasControlOps_t *ops)
+ ZblibDriverZcliasZoneOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverZcliasControlPrivData_t *priv_data = NULL;
+ ZblibDriverZcliasZonePrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverZcliasControlPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZcliasZonePrivData_t));
/* Update private data */
priv_data->ops = ops;
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zclias_control_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_ias_zone_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_zclias_control_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_ias_zone_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_zclias_control_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_ias_zone_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_zclidentify_control.h"
+#include "zblib_driver_zcl_identify.h"
/**< Private data */
typedef struct {
- ZblibDriverZclidentifyControlOps_t *ops; /**< Operations */
-} ZblibDriverZclidentifyControlPrivData_t;
+ ZblibDriverZclidentifyOps_t *ops; /**< Operations */
+} ZblibDriverZclidentifyPrivData_t;
-static gboolean __zblib_driver_zclidentify_control_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_identify_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverZclidentifyControlPrivData_t *priv_data = NULL;
- ZblibDriverZclidentifyControlOps_t *ops = NULL;
+ ZblibDriverZclidentifyPrivData_t *priv_data = NULL;
+ ZblibDriverZclidentifyOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
return ret;
}
-static void __zblib_driver_zclidentify_control_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_identify_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverZclidentifyControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclidentifyPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_zclidentify_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_identify_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclidentifyControlOps_t *ops)
+ ZblibDriverZclidentifyOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverZclidentifyControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclidentifyPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverZclidentifyControlPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclidentifyPrivData_t));
/* Update private data */
priv_data->ops = ops;
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zclidentify_control_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_identify_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_zclidentify_control_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_identify_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_zclidentify_control_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_identify_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_level_control.h"
+#include "zblib_driver_zcl_level_control.h"
/**< Private data */
typedef struct {
ZblibDriverLevelControlOps_t *ops; /**< Operations */
} ZblibDriverLevelControlPrivData_t;
-static gboolean __zblib_driver_level_control_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_level_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
ZblibDriverLevelControlPrivData_t *priv_data = NULL;
return ret;
}
-static void __zblib_driver_level_control_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_level_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverLevelControlPrivData_t *priv_data = NULL;
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_level_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_level_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverLevelControlOps_t *ops)
{
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_level_control_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_level_control_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_level_control_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_level_control_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_level_control_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_level_control_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_on_off.h"
+#include "zblib_driver_zcl_on_off.h"
/**< Private data */
typedef struct {
- ZblibDriverOnOffOps_t *ops; /**< Operations */
-} ZblibDriverOnOffPrivData_t;
+ ZblibDriverZclOnOffOps_t *ops; /**< Operations */
+} ZblibDriverZclOnOffPrivData_t;
-static gboolean __zblib_driver_on_off_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_on_off_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverOnOffPrivData_t *priv_data = NULL;
- ZblibDriverOnOffOps_t *ops = NULL;
+ ZblibDriverZclOnOffPrivData_t *priv_data = NULL;
+ ZblibDriverZclOnOffOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
return ret;
}
-static void __zblib_driver_on_off_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_on_off_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverOnOffPrivData_t *priv_data = NULL;
+ ZblibDriverZclOnOffPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_on_off_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_on_off_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverOnOffOps_t *ops)
+ ZblibDriverZclOnOffOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverOnOffPrivData_t *priv_data = NULL;
+ ZblibDriverZclOnOffPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverOnOffPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclOnOffPrivData_t));
/* Update private data */
priv_data->ops = ops;
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_on_off_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_on_off_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_on_off_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_on_off_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_on_off_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_on_off_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_thermostat.h"
+#include "zblib_driver_zcl_thermostat.h"
/**< Private data */
typedef struct {
- ZblibDriverThermostatOps_t *ops; /**< Operations */
-} ZblibDriverThermostatPrivData_t;
+ ZblibDriverZclThermostatOps_t *ops; /**< Operations */
+} ZblibDriverZclThermostatPrivData_t;
-static gboolean __zblib_driver_thermostat_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zcl_thermostat_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverThermostatPrivData_t *priv_data = NULL;
- ZblibDriverThermostatOps_t *ops = NULL;
+ ZblibDriverZclThermostatPrivData_t *priv_data = NULL;
+ ZblibDriverZclThermostatOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
return ret;
}
-static void __zblib_driver_thermostat_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zcl_thermostat_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverThermostatPrivData_t *priv_data = NULL;
+ ZblibDriverZclThermostatPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_thermostat_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zcl_thermostat_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverThermostatOps_t *ops)
+ ZblibDriverZclThermostatOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverThermostatPrivData_t *priv_data = NULL;
+ ZblibDriverZclThermostatPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverThermostatPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclThermostatPrivData_t));
/* Update private data */
priv_data->ops = ops;
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_thermostat_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zcl_thermostat_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_thermostat_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zcl_thermostat_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_thermostat_free(ZigBeeDriver *driver)
+void zblib_driver_zcl_thermostat_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_driver.h>
#include <zblib_request.h>
-#include "zblib_driver_zdodev_control.h"
+#include "zblib_driver_zdo_dev_control.h"
/**< Private data */
typedef struct {
ZblibDriverZdodevControlOps_t *ops; /**< Operations */
} ZblibDriverZdodevControlPrivData_t;
-static gboolean __zblib_driver_zdodev_control_dispatcher(ZigBeeDriver *driver, guint request_id)
+static gboolean __zblib_driver_zdo_dev_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
ZblibDriverZdodevControlPrivData_t *priv_data = NULL;
return ret;
}
-static void __zblib_driver_zdodev_control_free_hook(ZigBeeDriver *driver)
+static void __zblib_driver_zdo_dev_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZdodevControlPrivData_t *priv_data = NULL;
g_free(priv_data);
}
-ZigBeeDriver *zblib_driver_zdodev_control_new(ZigBeePlugin *plugin,
+ZigBeeDriver *zblib_driver_zdo_dev_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZdodevControlOps_t *ops)
{
}
/* Set operations dispatcher function */
- ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zdodev_control_dispatcher);
+ ret = zblib_driver_set_dispatcher(driver, __zblib_driver_zdo_dev_control_dispatcher);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_dispatcher failed!");
}
/* Set free hook function */
- ret = zblib_driver_set_free_hook(driver, __zblib_driver_zdodev_control_free_hook);
+ ret = zblib_driver_set_free_hook(driver, __zblib_driver_zdo_dev_control_free_hook);
if (FALSE == ret) {
Z_LOGE("zblib_driver_set_free_hook failed!");
return driver;
}
-void zblib_driver_zdodev_control_free(ZigBeeDriver *driver)
+void zblib_driver_zdo_dev_control_free(ZigBeeDriver *driver)
{
zblib_check_null_ret("driver", driver);
#include <zblib_service_interface.h>
#include <zblib_driver.h>
-#include <zblib_driver_alarm.h>
+#include <zblib_driver_zcl_alarm.h>
#include <zblib_driver_custom.h>
-#include <zblib_driver_door_lock.h>
-#include <zblib_driver_fan_control.h>
-#include <zblib_driver_level_control.h>
+#include <zblib_driver_zcl_door_lock.h>
+#include <zblib_driver_zcl_fan_control.h>
+#include <zblib_driver_zcl_level_control.h>
#include <zblib_driver_mfglib_control.h>
-#include <zblib_driver_on_off.h>
+#include <zblib_driver_zcl_on_off.h>
#include <zblib_driver_service.h>
-#include <zblib_driver_thermostat.h>
-#include <zblib_driver_zclbasic_control.h>
-#include <zblib_driver_zclglobal_control.h>
-#include <zblib_driver_zclias_control.h>
-#include <zblib_driver_zclidentify_control.h>
-#include <zblib_driver_zcl_color.h>
+#include <zblib_driver_zcl_thermostat.h>
+#include <zblib_driver_zcl_basic.h>
+#include <zblib_driver_zcl_global_control.h>
+#include <zblib_driver_zcl_ias_zone.h>
+#include <zblib_driver_zcl_identify.h>
+#include <zblib_driver_zcl_color_control.h>
#include <zblib_driver_zcl_group.h>
#include <zblib_driver_zcl_poll_control.h>
#include <zblib_driver_zcl_scene.h>
-#include <zblib_driver_zdodev_control.h>
+#include <zblib_driver_zdo_dev_control.h>
#include <zblib_driver_zdo_bind.h>
/**< ZigBee Request object */
projects / platform / core / connectivity / zigbee-manager.git / commitdiff