From 94f9f9a0ca5f308b9640f5c2507a960e6a6fe802 Mon Sep 17 00:00:00 2001 From: Milind Murhekar Date: Wed, 23 May 2018 11:27:44 +0530 Subject: [PATCH] Add initial code for GTest Change-Id: I8c0ec43efe59fa82b3e14d320fa3c66f073158f7 Signed-off-by: Milind Murhekar --- CMakeLists.txt | 13 + packaging/zigbee-manager.spec | 14 + unittest/CMakeLists.txt | 32 + unittest/common.h | 47 + unittest/gdbus.cpp | 462 +++++++++ unittest/gdbus.h | 122 +++ unittest/unittest.cpp | 1024 +++++++++++++++++++ unittest/zbl.cpp | 2199 +++++++++++++++++++++++++++++++++++++++++ unittest/zbl.h | 222 +++++ zigbee-daemon/src/main.c | 12 + 10 files changed, 4147 insertions(+) create mode 100644 unittest/CMakeLists.txt create mode 100644 unittest/common.h create mode 100644 unittest/gdbus.cpp create mode 100644 unittest/gdbus.h create mode 100644 unittest/unittest.cpp create mode 100644 unittest/zbl.cpp create mode 100644 unittest/zbl.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 7e2078a..329ad66 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -13,8 +13,13 @@ SET(zigbee_pkgs glib-2.0 dlog gio-2.0 gio-unix-2.0) pkg_check_modules(pkgs REQUIRED "${zigbee_pkgs}") +IF (BUILD_GTESTS) +SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fpic -Wall -Werror-implicit-function-declaration") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Werror -Wextra -Wall -Wdeclaration-after-statement -Wmissing-declarations -Wredundant-decls -Wcast-align -Wno-array-bounds -Wno-empty-body -Wno-ignored-qualifiers -Wshadow -Wwrite-strings -Wswitch-default -Wno-unused-but-set-parameter -Wno-unused-but-set-variable -fvisibility=default -fprofile-arcs -ftest-coverage") +ELSE (BUILD_GTESTS) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Werror -Wextra -Wall -Wdeclaration-after-statement -Wmissing-declarations -Wredundant-decls -Wcast-align -Wno-array-bounds -Wno-empty-body -Wno-ignored-qualifiers -Wshadow -Wwrite-strings -Wswitch-default -Wno-unused-but-set-parameter -Wno-unused-but-set-variable") #SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Werror -Wextra -Wall -Wdeclaration-after-statement -Wmissing-declarations -Wredundant-decls -Wcast-align -Wcast-qual -Wno-array-bounds -Wno-empty-body -Wno-ignored-qualifiers -Wshadow -Wwrite-strings -Wswitch-default -Wno-unused-but-set-parameter -Wno-unused-but-set-variable") +ENDIF (BUILD_TESTS) ### Address-Space Layout Randomization ### SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIE") @@ -25,5 +30,13 @@ ADD_DEFINITIONS("-DEXPORT_API=\"__attribute__((visibility(\\\"default\\\")))\" " ADD_DEFINITIONS("-DFEATURE_DLOG_DEBUG=1") ADD_DEFINITIONS("-DZIGBEE_DEFAULT_PLUGINS_PATH=\"/usr/lib/zigbee/plugins/\"") +IF(BUILD_GCOV) + ADD_DEFINITIONS(-DBUILD_GCOV) +ENDIF(BUILD_GCOV) + ### Build ### ADD_SUBDIRECTORY(zigbee-daemon) + +IF(BUILD_GTESTS) + ADD_SUBDIRECTORY(unittest) +ENDIF(BUILD_GTESTS) diff --git a/packaging/zigbee-manager.spec b/packaging/zigbee-manager.spec index 44ef413..6a2b4c5 100644 --- a/packaging/zigbee-manager.spec +++ b/packaging/zigbee-manager.spec @@ -18,6 +18,11 @@ BuildRequires: pkgconfig(gio-2.0) BuildRequires: pkgconfig(gio-unix-2.0) BuildRequires: pkgconfig(glib-2.0) BuildRequires: pkgconfig(vconf) + +%if 0%{?gtests:1} +BuildRequires: pkgconfig(gmock) +%endif + # if image creater does not know 'network_fw' Requires: security-config @@ -52,10 +57,16 @@ cp -a %{SOURCE2} . %endif %build +%if 0%{?gcov:1} +export LDFLAGS+=" -lgcov" +%endif + cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} \ -DVERSION=%{version} \ -DLIB_INSTALL_DIR=%{_libdir} \ -DUNIT_INSTALL_DIR=%{_unitdir} \ + -DBUILD_GTESTS=%{?gtests:1}%{!?gtests:0} \ + -DBUILD_GCOV=%{?gcov:1}%{!?gcov:0} make %{?_smp_mflags} @@ -88,6 +99,9 @@ cp %{SOURCE2} %{buildroot}%{_datadir}/dbus-1/system.d/zigbee.conf %{_datadir}/dbus-1/system.d/zigbee.conf %endif %license LICENSE +%if 0%{?gtests:1} +%{_bindir}/gtest* +%endif %files -n zigbee-lib %defattr(644,system,system,-) diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt new file mode 100644 index 0000000..a32f713 --- /dev/null +++ b/unittest/CMakeLists.txt @@ -0,0 +1,32 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(gtest-zigbee-manager C CXX) + +SET(GTEST_TEST "gtest-zigbee-manager") +ADD_DEFINITIONS("-DUSE_DLOG") + +SET(REQUIRES_LIST ${REQUIRES_LIST} + glib-2.0 + gio-2.0 + gmock + dlog +) + +INCLUDE(FindPkgConfig) +PKG_CHECK_MODULES(GTEST_TEST_PKG REQUIRED ${REQUIRES_LIST}) + +FOREACH(flag ${GTEST_TEST_PKG_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wall -fPIE") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS}") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie") + +FILE(GLOB GTEST_TEST_SRCS *.cpp) +SET(GTEST_TEST_SRCS ${GTEST_TEST_SRCS}) + +ADD_EXECUTABLE(${GTEST_TEST} ${GTEST_TEST_SRCS}) +TARGET_LINK_LIBRARIES(${GTEST_TEST} ${GTEST_TEST_LDFLAGS} ${GTEST_TEST_PKG_LDFLAGS} -ldl -lgcov) + +INSTALL(TARGETS ${GTEST_TEST} RUNTIME DESTINATION bin) diff --git a/unittest/common.h b/unittest/common.h new file mode 100644 index 0000000..e2707a7 --- /dev/null +++ b/unittest/common.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 __COMMON_H__ +#define __COMMON_H__ + +#include + +#ifdef USE_DLOG +#include +#undef LOG_TAG +#define LOG_TAG "ZIGBEE_GTEST" +#define GLOGD(format, args...) LOGD(format, ##args) +#else +#define GLOGD(format, args...) +#endif + +#ifndef TIZEN_ERROR_ZIGBEE +#define TIZEN_ERROR_ZIGBEE -0x02F70000 +#endif + +typedef enum { + ZIGBEE_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + ZIGBEE_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + ZIGBEE_ERROR_PARAMETER_OUT_OF_RANGE = TIZEN_ERROR_RESULT_OUT_OF_RANGE, /**< Out of range */ + ZIGBEE_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ + ZIGBEE_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR, /**< DBus error */ + ZIGBEE_ERROR_NO_DATA = TIZEN_ERROR_NO_DATA, /**< No data available */ + ZIGBEE_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ + ZIGBEE_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + ZIGBEE_ERROR_INVALID_ENDPOINT = TIZEN_ERROR_ZIGBEE | 0x01, /**< Endpoint 0 is reserved for ZDP */ + ZIGBEE_ERROR_INVALID_ADDRESS = TIZEN_ERROR_ZIGBEE | 0x02, /**< Wrong address */ + ZIGBEE_ERROR_OPERATION_FAILED = TIZEN_ERROR_ZIGBEE | 0x03, /**< Operation failed */ +} zb_error_e; +#endif /* __COMMON_H__ */ diff --git a/unittest/gdbus.cpp b/unittest/gdbus.cpp new file mode 100644 index 0000000..81432df --- /dev/null +++ b/unittest/gdbus.cpp @@ -0,0 +1,462 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#include "zbl.h" + +GDbus::GDbus() +{ + this->m_pConnection = NULL; + this->m_pCancellable = NULL; + this->service_gproxy = NULL; + this->on_off_gproxy = NULL; + this->door_lock_gproxy = NULL; + this->level_control_gproxy = NULL; + this->thermostat_gproxy = NULL; + this->alarm_gproxy = NULL; + this->fan_control_gproxy = NULL; + + this->mfglib_gproxy = NULL; + this->zcl_global_proxy = NULL; + this->zdo_dev_proxy = NULL; + this->zcl_basic_proxy = NULL; + this->zcl_identify_proxy = NULL; + this->zcl_ias_zone_proxy = NULL; + this->zcl_poll_control_proxy = NULL; + this->zcl_group_proxy = NULL; + this->zcl_scene_proxy = NULL; + this->zdo_bind_proxy = NULL; + this->zcl_color_control_proxy = NULL; + this->custom_gproxy = NULL; +} + +GDbus::~GDbus() +{ + GDBusConnection *conn = this->m_pConnection; + GCancellable *cancel = this->m_pCancellable; + + if (cancel) { + g_cancellable_cancel(cancel); + g_object_unref(cancel); + cancel = NULL; + } + + if (conn) { + g_object_unref(this->service_gproxy); + this->service_gproxy = NULL; + g_object_unref(this->on_off_gproxy); + this->on_off_gproxy = NULL; + g_object_unref(this->door_lock_gproxy); + this->door_lock_gproxy = NULL; + g_object_unref(this->level_control_gproxy); + this->level_control_gproxy = NULL; + g_object_unref(this->thermostat_gproxy); + this->thermostat_gproxy = NULL; + g_object_unref(this->alarm_gproxy); + this->alarm_gproxy = NULL; + g_object_unref(this->fan_control_gproxy); + this->fan_control_gproxy = NULL; + + g_object_unref(this->mfglib_gproxy); + this->mfglib_gproxy = NULL; + g_object_unref(this->zcl_global_proxy); + this->zcl_global_proxy = NULL; + + g_object_unref(this->zdo_dev_proxy); + this->zdo_dev_proxy = NULL; + g_object_unref(this->zcl_basic_proxy); + this->zcl_basic_proxy = NULL; + g_object_unref(this->zcl_identify_proxy); + this->zcl_identify_proxy = NULL; + g_object_unref(this->zcl_ias_zone_proxy); + this->zcl_ias_zone_proxy = NULL; + g_object_unref(this->zcl_poll_control_proxy); + this->zcl_poll_control_proxy = NULL; + g_object_unref(this->zcl_group_proxy); + this->zcl_group_proxy = NULL; + g_object_unref(this->zcl_scene_proxy); + this->zcl_scene_proxy = NULL; + g_object_unref(this->zdo_bind_proxy); + this->zdo_bind_proxy = NULL; + + g_object_unref(this->zcl_color_control_proxy); + this->zcl_color_control_proxy = NULL; + g_object_unref(this->custom_gproxy); + this->custom_gproxy = NULL; + + g_object_unref(conn); + conn = NULL; + } +} + +zb_error_e GDbus::Create(void) +{ + GError *err = NULL; + GDBusConnection *gdbus_conn; + +#if !GLIB_CHECK_VERSION(2, 36, 0) + g_type_init(); +#endif + + this->m_pConnection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err); + if (this->m_pConnection == NULL) { + if (err != NULL) { + GLOGD("Failed to connect to the D-BUS daemon [%s]", err->message); + g_error_free(err); + } + + return ZIGBEE_ERROR_OPERATION_FAILED; + } + + gdbus_conn = this->m_pConnection; + + this->service_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_SERVICE_INTERFACE, + NULL, NULL); + + this->on_off_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_ON_OFF_INTERFACE, NULL, NULL); + + this->door_lock_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_DOOR_LOCK_INTERFACE, NULL, NULL); + + this->level_control_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_LEVEL_CONTROL_INTERFACE, NULL, NULL); + + this->thermostat_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_THERMOSTAT_INTERFACE, NULL, NULL); + + this->alarm_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZCL_ALARM_INTERFACE, + NULL, NULL); + + this->fan_control_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_FAN_CONTROL_INTERFACE, NULL, NULL); + + this->mfglib_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_MFGLIB_CONTROL_INTERFACE, NULL, NULL); + + this->zcl_global_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, NULL, NULL); + + this->zdo_dev_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, NULL, NULL); + + this->zcl_basic_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZCL_BASIC_INTERFACE, + NULL, NULL); + + this->zcl_identify_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_IDENTIFY_INTERFACE, NULL, NULL); + + this->zcl_ias_zone_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_IAS_ZONE_INTERFACE, NULL, NULL); + + this->zcl_poll_control_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_POLL_CONTROL_INTERFACE, NULL, NULL); + + this->zcl_group_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZCL_GROUP_INTERFACE, + NULL, NULL); + + this->zcl_scene_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZCL_SCENE_INTERFACE, + NULL, NULL); + + this->zdo_bind_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZDO_BIND_INTERFACE, + NULL, NULL); + + this->zcl_color_control_proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, + ZIGBEE_ZCL_COLOR_CONTROL_INTERFACE, NULL, NULL); + + this->custom_gproxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL, + ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_CUSTOM_INTERFACE, + NULL, NULL); + + this->m_pCancellable = g_cancellable_new(); + + return ZIGBEE_ERROR_NONE; +} + +zb_error_e GDbus::Destroy(void) +{ + g_object_unref(this->service_gproxy); + this->service_gproxy = NULL; + g_object_unref(this->on_off_gproxy); + this->on_off_gproxy = NULL; + g_object_unref(this->door_lock_gproxy); + this->door_lock_gproxy = NULL; + g_object_unref(this->level_control_gproxy); + this->level_control_gproxy = NULL; + g_object_unref(this->thermostat_gproxy); + this->thermostat_gproxy = NULL; + g_object_unref(this->alarm_gproxy); + this->alarm_gproxy = NULL; + g_object_unref(this->fan_control_gproxy); + this->fan_control_gproxy = NULL; + + g_object_unref(this->mfglib_gproxy); + this->mfglib_gproxy = NULL; + g_object_unref(this->zcl_global_proxy); + this->zcl_global_proxy = NULL; + + g_object_unref(this->zdo_dev_proxy); + this->zdo_dev_proxy = NULL; + g_object_unref(this->zcl_basic_proxy); + this->zcl_basic_proxy = NULL; + g_object_unref(this->zcl_identify_proxy); + this->zcl_identify_proxy = NULL; + g_object_unref(this->zcl_ias_zone_proxy); + this->zcl_ias_zone_proxy = NULL; + g_object_unref(this->zcl_poll_control_proxy); + this->zcl_poll_control_proxy = NULL; + g_object_unref(this->zcl_group_proxy); + this->zcl_group_proxy = NULL; + g_object_unref(this->zcl_scene_proxy); + this->zcl_scene_proxy = NULL; + g_object_unref(this->zdo_bind_proxy); + this->zdo_bind_proxy = NULL; + g_object_unref(this->zcl_color_control_proxy); + this->zcl_color_control_proxy = NULL; + g_object_unref(this->custom_gproxy); + this->custom_gproxy = NULL; + + g_cancellable_cancel(this->m_pCancellable); + g_object_unref(this->m_pCancellable); + this->m_pCancellable = NULL; + + g_object_unref(this->m_pConnection); + this->m_pConnection = NULL; + + return ZIGBEE_ERROR_NONE; +} + +GDBusConnection *GDbus::GetConnection(void) +{ + return this->m_pConnection; +} + +GCancellable *GDbus::GetCancellable(void) +{ + return this->m_pCancellable; +} + +GDBusProxy *GDbus::get_proxy_type(gproxy_type_e type) +{ + GDBusProxy *proxy = NULL; + + switch (type) + { + case SERVICE_GPROXY: + proxy = this->service_gproxy; + break; + case ON_OFF_GPROXY: + proxy = this->on_off_gproxy; + break; + case DOOR_LOCK_GPROXY: + proxy = this->door_lock_gproxy; + break; + case LEVEL_CONTROL_GPROXY: + proxy = this->level_control_gproxy; + break; + case THERMOSTAT_GPROXY: + proxy = this->thermostat_gproxy; + break; + case ALARM_GPROXY: + proxy = this->alarm_gproxy; + break; + case FAN_CONTROL_GPROXY: + proxy = this->fan_control_gproxy; + break; + case MFGLIB_GPROXY: + proxy = this->mfglib_gproxy; + break; + case ZCL_GLOBAL_PROXY: + proxy = this->zcl_global_proxy; + break; + case ZDO_DEV_PROXY: + proxy = this->zdo_dev_proxy; + break; + case ZCL_BASIC_PROXY: + proxy = this->zcl_basic_proxy; + break; + case ZCL_IDENTIFY_PROXY: + proxy = this->zcl_identify_proxy; + break; + case ZCL_IAS_ZONE_PROXY: + proxy = this->zcl_ias_zone_proxy; + break; + case ZCL_POLL_CONTROL_PROXY: + proxy = this->zcl_poll_control_proxy; + break; + case ZCL_GROUP_PROXY: + proxy = this->zcl_group_proxy; + break; + case ZCL_SCENE_PROXY: + proxy = this->zcl_scene_proxy; + break; + case ZDO_BIND_PROXY: + proxy = this->zdo_bind_proxy; + break; + case ZCL_COLOR_CONTROL_PROXY: + proxy = this->zcl_color_control_proxy; + break; + case CUSTOM_GPROXY: + proxy = this->custom_gproxy; + break; + } + + return proxy; +} + +GVariant *GDbus::invoke_proxy_method(gproxy_type_e type, const char *method, GVariant *params, int *error) +{ + GError *dbus_error = NULL; + GVariant *reply = NULL; + GDBusConnection *connection = NULL; + GDBusProxy *proxy = NULL; + + connection = GetConnection(); + if (connection == NULL) { + GLOGD("GDBusconnection is NULL"); + *error = ZIGBEE_ERROR_IO_ERROR; + return reply; + } + + proxy = get_proxy_type(type); + if (proxy == NULL) { + GLOGD("GDBusProxy is NULL"); + *error = ZIGBEE_ERROR_IO_ERROR; + return reply; + } + + reply = g_dbus_proxy_call_sync(proxy, + method, + params, + G_DBUS_CALL_FLAGS_NONE, + ZIGBEE_BROADCAST_TIMEOUT, + GetCancellable(), + &dbus_error); + + if (reply == NULL) { + if (dbus_error != NULL) { + GLOGD("g_dbus_connection_call_sync() failed " + "error [%d: %s]", dbus_error->code, dbus_error->message); + if (strstr(dbus_error->message, "AccessDenied")) + *error = ZIGBEE_ERROR_PERMISSION_DENIED; + else + *error = ZIGBEE_ERROR_IO_ERROR; + g_error_free(dbus_error); + } else { + GLOGD("g_dbus_connection_call_sync() failed"); + *error = ZIGBEE_ERROR_OPERATION_FAILED; + } + return NULL; + } + + return reply; +} + +GVariant *GDbus::InvokeMethod(const char *dest, const char *path, + const char *iface_name, const char *method, GVariant *params, int *error) +{ + GError *dbus_error = NULL; + GVariant *reply = NULL; + GDBusConnection *connection = NULL; + + connection = GetConnection(); + if (connection == NULL) { + GLOGD("GDBusconnection is NULL"); + *error = ZIGBEE_ERROR_IO_ERROR; + return reply; + } + + reply = g_dbus_connection_call_sync(connection, + dest, + path, + iface_name, + method, + params, + NULL, + G_DBUS_CALL_FLAGS_NONE, + ZIGBEE_BROADCAST_TIMEOUT, + GetCancellable(), + &dbus_error); + + if (reply == NULL) { + if (dbus_error != NULL) { + GLOGD("g_dbus_connection_call_sync() failed " + "error [%d: %s]", dbus_error->code, dbus_error->message); + if (strstr(dbus_error->message, "AccessDenied")) + *error = ZIGBEE_ERROR_PERMISSION_DENIED; + else + *error = ZIGBEE_ERROR_IO_ERROR; + g_error_free(dbus_error); + } else { + GLOGD("g_dbus_connection_call_sync() failed"); + *error = ZIGBEE_ERROR_OPERATION_FAILED; + } + return NULL; + } + + return reply; +} + +zb_error_e GDbus::InvokeMethodNonblock(const char *dest, const char *path, + const char *iface_name, const char *method, GVariant *params, int timeout, + GAsyncReadyCallback notify_func, void *user_data) +{ + GDBusConnection *connection = NULL; + + connection = GetConnection(); + if (connection == NULL) { + GLOGD("GDBusconnection is NULL"); + return ZIGBEE_ERROR_IO_ERROR; + } + + g_dbus_connection_call(connection, + dest, + path, + iface_name, + method, + params, + NULL, + G_DBUS_CALL_FLAGS_NONE, + timeout, + GetCancellable(), + (GAsyncReadyCallback) notify_func, + (gpointer)user_data); + + return ZIGBEE_ERROR_NONE; +} diff --git a/unittest/gdbus.h b/unittest/gdbus.h new file mode 100644 index 0000000..2c0775b --- /dev/null +++ b/unittest/gdbus.h @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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_GDBUS_H__ +#define __ZIGBEE_GDBUS_H__ + +#include +#include "common.h" + +#define GMAINTIMEOUT 10000 +#define ZIGBEE_BROADCAST_TIMEOUT (9.5 + 2) * 1000 /**< default timeout for gdbus */ + + +#ifndef ZIGBEE_DBUS_INTERFACE +#define ZIGBEE_DBUS_INTERFACE "org.tizen.zigbee" +#endif + +#ifndef ZIGBEE_DBUS_OBJPATH +#define ZIGBEE_DBUS_OBJPATH "/org/tizen/zigbee" +#endif + +#define ZIGBEE_SERVER_NAME "org.tizen.zigbee" +#define ZIGBEE_CONTROL_OBJECT_PATH "/org/tizen/zigbee/control" + +#define ZIGBEE_MANAGER_INTERFACE "org.tizen.zigbee.manager" +#define ZIGBEE_SERVICE_INTERFACE "org.tizen.zigbee.service" +#define ZIGBEE_SERVICE_OBJECT_PATH "/org/tizen/zigbee/service" + +#define ZIGBEE_ZDO_DEV_CONTROL_INTERFACE "org.tizen.zigbee.zdo_dev_control" +#define ZIGBEE_ZDO_BIND_INTERFACE "org.tizen.zigbee.zdo_bind" +#define ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE "org.tizen.zigbee.zcl_global_control" +#define ZIGBEE_ZCL_ALARM_INTERFACE "org.tizen.zigbee.zcl_alarm" +#define ZIGBEE_ZCL_BASIC_INTERFACE "org.tizen.zigbee.zcl_basic" +#define ZIGBEE_ZCL_COLOR_CONTROL_INTERFACE "org.tizen.zigbee.zcl_color_control" +#define ZIGBEE_ZCL_ON_OFF_INTERFACE "org.tizen.zigbee.zcl_on_off" +#define ZIGBEE_ZCL_DOOR_LOCK_INTERFACE "org.tizen.zigbee.zcl_door_lock" +#define ZIGBEE_ZCL_GROUP_INTERFACE "org.tizen.zigbee.zcl_group" +#define ZIGBEE_ZCL_FAN_CONTROL_INTERFACE "org.tizen.zigbee.zcl_fan_control" +#define ZIGBEE_ZCL_IAS_ZONE_INTERFACE "org.tizen.zigbee.zcl_ias_zone" +#define ZIGBEE_ZCL_IDENTIFY_INTERFACE "org.tizen.zigbee.zcl_identify" +#define ZIGBEE_ZCL_LEVEL_CONTROL_INTERFACE "org.tizen.zigbee.zcl_level_control" +#define ZIGBEE_ZCL_POLL_CONTROL_INTERFACE "org.tizen.zigbee.zcl_poll_control" +#define ZIGBEE_ZCL_SCENE_INTERFACE "org.tizen.zigbee.zcl_scene" +#define ZIGBEE_ZCL_THERMOSTAT_INTERFACE "org.tizen.zigbee.zcl_thermostat" +#define ZIGBEE_CUSTOM_INTERFACE "org.tizen.zigbee.custom" +#define ZIGBEE_MFGLIB_CONTROL_INTERFACE "org.tizen.zigbee.mfglib_control" + +typedef enum { + SERVICE_GPROXY, + ON_OFF_GPROXY, + DOOR_LOCK_GPROXY, + LEVEL_CONTROL_GPROXY, + THERMOSTAT_GPROXY, + ALARM_GPROXY, + FAN_CONTROL_GPROXY, + MFGLIB_GPROXY, + ZCL_GLOBAL_PROXY, + ZDO_DEV_PROXY, + ZCL_BASIC_PROXY, + ZCL_IDENTIFY_PROXY, + ZCL_IAS_ZONE_PROXY, + ZCL_POLL_CONTROL_PROXY, + ZCL_GROUP_PROXY, + ZCL_SCENE_PROXY, + ZDO_BIND_PROXY, + ZCL_COLOR_CONTROL_PROXY, + CUSTOM_GPROXY, +} gproxy_type_e; + +class GDbus { + private: + GDBusConnection *m_pConnection; + GDBusProxy *service_gproxy; + GDBusProxy *on_off_gproxy; + GDBusProxy *door_lock_gproxy; + GDBusProxy *level_control_gproxy; + GDBusProxy *thermostat_gproxy; + GDBusProxy *alarm_gproxy; + GDBusProxy *fan_control_gproxy; + GDBusProxy *mfglib_gproxy; + GDBusProxy *zcl_global_proxy; + GDBusProxy *zdo_dev_proxy; + GDBusProxy *zcl_basic_proxy; + GDBusProxy *zcl_identify_proxy; + GDBusProxy *zcl_ias_zone_proxy; + GDBusProxy *zcl_poll_control_proxy; + GDBusProxy *zcl_group_proxy; + GDBusProxy *zcl_scene_proxy; + GDBusProxy *zdo_bind_proxy; + GDBusProxy *zcl_color_control_proxy; + GDBusProxy *custom_gproxy; + GCancellable *m_pCancellable; + GDBusProxy *get_proxy_type(gproxy_type_e type); + + public: + GDbus(); + ~GDbus(); + zb_error_e Create(void); + zb_error_e Destroy(void); + GDBusConnection *GetConnection(void); + GCancellable *GetCancellable(void); + + GVariant *invoke_proxy_method(gproxy_type_e type, const char *method, GVariant *params, int *error); + GVariant *InvokeMethod(const char *dest, const char *path, + const char *iface_name, const char *method, GVariant *params, int *error); + zb_error_e InvokeMethodNonblock(const char *dest, const char *path, + const char *iface_name, const char *method, GVariant *params, int timeout, + GAsyncReadyCallback notify_func, void *user_data); +}; +#endif /* __ZIGBEE_GDBUS_H__ */ diff --git a/unittest/unittest.cpp b/unittest/unittest.cpp new file mode 100644 index 0000000..16ae17a --- /dev/null +++ b/unittest/unittest.cpp @@ -0,0 +1,1024 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +#include "zbl.h" + +using ::testing::InitGoogleTest; +using ::testing::Test; +using ::testing::TestCase; + +TEST(ZigbeeManager, Enable_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_enable(); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, Disable_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_disable(); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, IsEnable_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + bool state; + + ret = zb_mgr.zbl_is_enable(&state); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, Enable_p1) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_enable(); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, HwReset_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_hw_reset(); + EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_IO_ERROR == ret) ); +} + +TEST(ZigbeeManager, GetNetworkInfo_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_get_network_info(); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, GetControllerMacAddr_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char mac[8]; + + ret = zb_mgr.zbl_get_controller_mac_address(mac); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, GetClusterList_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char ep = 1; + ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00, + 0x02, 0xF2, 0x58, 0x5B }; + unsigned char in_count = 0; + unsigned char out_count = 0; + unsigned short in_cluster_list[MAX_ENDPOINT_CLUSTERS] = { 0 }; + unsigned short out_cluster_list[MAX_ENDPOINT_CLUSTERS] = { 0 }; + + ret = zb_mgr.zbl_get_cluster_list(dest_addr64, ep, &in_count, + in_cluster_list, &out_count, out_cluster_list); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, GetEndPointList_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00, + 0x02, 0xF2, 0x58, 0x5B }; + unsigned char count = 0; + unsigned char ep_list[10] = { 0 }; + + ret = zb_mgr.zbl_get_endpoint_list(dest_addr64, &count, ep_list); + EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) ); +} + +TEST(ZigbeeManager, ApiGetNodeType_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00, + 0x02, 0xF2, 0x58, 0x5B }; + + ret = zb_mgr.zbl_api_get_node_type(dest_addr64); + EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) ); +} + +TEST(ZigbeeManager, GetAllDeviceInfo_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_get_all_device_info(); + EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) ); +} + +TEST(ZigbeeManager, CoexStart_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char channel = 11; + + ret = zb_mgr.zbl_coex_start(channel); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CoexStop_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_coex_stop(); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, FormNetwork_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_form_network(); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, DisableNetwork_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + + ret = zb_mgr.zbl_disable_network(); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, LeaveDevice_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00, + 0x02, 0xF2, 0x58, 0x5B }; + bool remove_children = true; + bool rejoin = false; + + ret = zb_mgr.zbl_leave_device(dest_addr64, remove_children, + rejoin); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, PermitJoin_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char timeout = 90; + bool broadcast = true; + + ret = zb_mgr.zbl_permit_join(timeout, broadcast); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, NwkAddrReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00, + 0x02, 0xF2, 0x58, 0x5B }; + + ret = zb_mgr.zbl_nwk_addr_req(dest_addr64, 0x00, 0x00); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, IeeeAddrReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ieee_addr_req(dest_addr16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ActiveEp_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_active_ep(dest_addr16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, SimpleDescReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_simple_desc_req(dest_addr16, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, MatchDescReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned char in_num = 0; + unsigned char out_num = 0; + unsigned short in_clusters[MAX_ENDPOINT_CLUSTERS] = { 0 }; + unsigned short out_clusters[MAX_ENDPOINT_CLUSTERS] = { 0 }; + + ret = zb_mgr.zbl_match_desc_req(dest_addr16, 0x00, in_num, + in_clusters, out_num, out_clusters); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, NodeDescReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_node_desc_req(dest_addr16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, PowerDescReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_power_desc_req(dest_addr16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ComplexDescReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_complex_desc_req(dest_addr16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, UserDescReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_user_desc_req(dest_addr16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, UserDescSet_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_user_desc_set(dest_addr16, 4, (unsigned char *)"test"); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, DeviceAnnce_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr st_addr16 = 0x708B; + ieee_addr st_addr64 = { 0x00, 0x0D, 0x6F, 0x00, + 0x04, 0x2B, 0xBE, 0x14 }; + + ret = zb_mgr.zbl_device_annce(st_addr16, st_addr64, + ZB_ZDP_ALTERNATIVE_PAN_COORDINATOR | ZB_ZDP_DEVICE_TYPE + | ZB_ZDP_POWER_SOURCE | ZB_ZDP_RECEIVER_ON_WHEN_IDLE + | ZB_ZDP_ALLOCATE_ADDRESS); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, BindReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + ieee_addr sj_addr64 = { 0x24, 0xFD, 0x5B, 0x00, + 0x01, 0x01, 0x86, 0xB6 }; + ieee_addr co_addr64 = { 0xD0, 0x52, 0xA8, 0xA9, + 0x8F, 0xB7, 0x00, 0x01 }; + + ret = zb_mgr.zbl_bind_req(dest_addr16, sj_addr64, 1, 0x0006, + co_addr64, 0x03, 0x0004, 1); + + EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) ); +} + +TEST(ZigbeeManager, UbindReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + ieee_addr sj_addr64 = { 0x24, 0xFD, 0x5B, 0x00, + 0x01, 0x01, 0x86, 0xB6 }; + ieee_addr co_addr64 = { 0xD0, 0x52, 0xA8, 0xA9, + 0x8F, 0xB7, 0x00, 0x01 }; + + ret = zb_mgr.zbl_unbind_req(dest_addr16, sj_addr64, 1, 0x0006, + co_addr64, 0x03, 0x0004, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, MgmtNwkDiscReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned int scan_channels = ZB_802_15_4_CHANNELS_MASK; + unsigned char scan_duration = 5; + unsigned char scan_count = 4; + unsigned char start_idx = 0; + + ret = zb_mgr.zbl_mgmt_nwk_disc_req(dest_addr16, scan_channels, + scan_duration, scan_count, start_idx); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, MgmtNwkUpdateReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned int scan_channels = ZB_802_15_4_CHANNELS_MASK; + unsigned char scan_duration = 5; + unsigned char scan_count = 4; + unsigned char start_idx = 0; + + ret = zb_mgr.zbl_mgmt_nwk_update_req(dest_addr16, scan_channels, + scan_duration, scan_count, start_idx); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, MgmtLqiReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned char start_idx = 0; + + ret = zb_mgr.zbl_mgmt_lqi_req(dest_addr16, start_idx); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, MgmtRtgReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned char start_idx = 0; + + ret = zb_mgr.zbl_mgmt_rtg_req(dest_addr16, start_idx); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, MgmtBindReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned char start_idx = 0; + + ret = zb_mgr.zbl_mgmt_bind_req(dest_addr16, start_idx); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, MgmtLeaveDevice_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + bool remove_children = true; + bool rejoin = true; + ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00, + 0x02, 0xF2, 0x58, 0x5B }; + + ret = zb_mgr.zbl_mgmt_leave_device(dest_addr64, remove_children, rejoin); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, MgmtPermitJoiningReq_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char permit_duration = 1; + unsigned char tc_significance = 1; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_mgmt_permit_joining_req(dest_addr16, permit_duration, + tc_significance); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ApsSend_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char aps_frame_ctl = ZB_APS_DELIVERY_UNICAST | ZB_APS_NO_ACK_REQUEST; + unsigned char src_ep = 1; + unsigned char dst_ep = 1; + unsigned short cluster_id = 0xFC05; + unsigned short profile_id = 0xFC01; + unsigned char zcl_frame_ctl = ZB_ZCL_FC_GLOBALLY_USED | ZB_ZCL_CLIENT_TO_SERVER | + ZB_ZCL_FC_NOT_MANUFACTURER | ZB_ZCL_DISABLE_DEFAULT_RESPONSE; + unsigned short mfg_code = 0x110A; + unsigned char cmd_id = 0x01; + unsigned short payload_len = 4; + unsigned char payload[4] = { 0x00, 0x01, 0x02, 0x03 }; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_aps_send(dest_addr16, aps_frame_ctl, src_ep, dst_ep, cluster_id, + profile_id, zcl_frame_ctl, mfg_code, cmd_id, payload_len, payload); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ZclSend_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char src_ep = 2; + unsigned char dst_ep = 2; + unsigned short cluster_id = 0x0000; + unsigned char zcl_frame_ctl = ZB_ZCL_FC_GLOBALLY_USED | ZB_ZCL_CLIENT_TO_SERVER | + ZB_ZCL_FC_NOT_MANUFACTURER | ZB_ZCL_DISABLE_DEFAULT_RESPONSE; + unsigned char cmd = 0x0; + unsigned short payload_len = 4; + unsigned char payload[4] = { 0x00, 0x01, 0x02, 0x03 }; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_zcl_send(dest_addr16, src_ep, dst_ep, cluster_id, + zcl_frame_ctl, cmd, payload_len, payload); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, SendToLocal_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned short length = 4; + unsigned char data[4] = { 0x00, 0x01, 0x02, 0x03 }; + + ret = zb_mgr.zbl_send_to_local(length, data); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, DiscoverCmdsGen_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_discover_cmds_gen(dest_addr16, 1, 1, + ZB_ZCL_DISABLE_DEFAULT_RESPONSE, 0x0004, 0x00, 4); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, DiscoverAttrExt_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_discover_attr_ext(dest_addr16, 1, 1, + ZB_ZCL_DISABLE_DEFAULT_RESPONSE, 0x0006, 0x0000, 5); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ResetAlarm_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char alarm_code = 0x01; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_reset_alarm(dest_addr16, 1, alarm_code, + 0x0006); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, GetAlarm_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_get_alarm(dest_addr16, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ResetAllAlarmLog_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_reset_all_alarm_log(dest_addr16, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolMoveToHue_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char move_hue = 0x20; + unsigned char direction = 0x00; + unsigned short trans_time16 = 0x00C8; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_move_to_hue(dest_addr16, 1, move_hue, + direction, trans_time16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolMoveHue_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char move_mode = 0x03; + unsigned char color_rate = 2; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_move_hue(dest_addr16, 1, move_mode, + color_rate); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolStepHue_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char step_mode = 0x03; + unsigned char step_size = 0x20; + unsigned char trans_time8 = 0x0A; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_step_hue(dest_addr16, 1, step_mode, + step_size, trans_time8); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolMoveToSaturation_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char saturation = 0x0A; + unsigned char trans_time16 = 0x00C8; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_move_to_saturation(dest_addr16, 1, saturation, + trans_time16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolMoveSaturation_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char move_mode = 0x03; + unsigned char color_rate = 2; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_move_saturation(dest_addr16, 1, move_mode, + color_rate); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolStepSaturation_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char step_mode = 0x03; + unsigned char step_size = 0x20; + unsigned char trans_time8 = 0x0A; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_step_saturation(dest_addr16, 1, step_mode, + step_size, trans_time8); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolMoveToHueAndSaturation_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char move_hue = 0x20; + unsigned char saturation = 0x0A; + unsigned short trans_time16 = 0x00C8; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_move_to_hue_and_saturation(dest_addr16, 1, move_hue, + saturation, trans_time16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolMoveToColor_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned short color_x = 0x280A; + unsigned short color_y = 0x2710; + unsigned short trans_time16 = 0x00C8; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_move_to_color(dest_addr16, 1, color_x, + color_y, trans_time16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolMoveColor_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned short rate_x = 0x0002; + unsigned short rate_y = 0x0002; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_move_color(dest_addr16, 1, rate_x, + rate_y); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolStepColor_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned short step_x = 0x3961; + unsigned short step_y = 0x396D; + unsigned short trans_time16 = 0x00C8; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_step_color(dest_addr16, 1, step_x, + step_y, trans_time16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, CcontrolMoveToColorTemperature_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned char color_temp = 0x78; + unsigned short trans_time16 = 0x00C8; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_ccontrol_move_to_color_temperature(dest_addr16, 1, color_temp, + trans_time16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ResetFactoryDefault_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_reset_factory_default(dest_addr16, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, Identify_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + unsigned short identify_time = 10; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_identify(dest_addr16, 1, identify_time); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, Identify_query_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_identify_query(dest_addr16, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, AddGroup_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_add_group(dest_addr16, 1, 0x0002, "6grpone"); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ViewGroup_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_view_group(dest_addr16, 1, 0x0002); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, GetGroupMembership_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned short group_list[2] = { 0x0002, 0x0003 }; + + ret = zb_mgr.zbl_group_get_group_membership(dest_addr16, 1, + 2, group_list); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, RemoveGroup_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_remove_group(dest_addr16, 1, 0x0002); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, RemoveAllGroup_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_remove_all_group(dest_addr16, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, AddGroupIfIdentifying_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_add_group_if_identifying(dest_addr16, 1, 0x0002, + "6grpone"); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, LevelControlMoveToLevel_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned short trans_time16 = 0x00C8; + + ret = zb_mgr.zbl_level_control_move_to_level(dest_addr16, 1, 0x01, + trans_time16); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, LevelControlMove_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_level_control_move(dest_addr16, 1, 0x03, 2); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, LevelControlSetp_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_level_control_step(dest_addr16, 1, 0x03, 0x20, + 0x00C8); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, LevelControlStop_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_level_control_stop(dest_addr16, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, LevelControlMoveToLevelWithOnOff_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_level_control_move_to_level_with_on_off(dest_addr16, 1, 0x02, + 0x00C8); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, LevelControlMoveWithOnOff_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_level_control_move_with_on_off(dest_addr16, 1, 0x03, 2); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, LevelControlSetpWithOnOff_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_level_control_step_with_on_off(dest_addr16, 1, 0x03, 0x20, + 0x00C8); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, OnOffSet_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_onoff_set(dest_addr16, 1, 0x01); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ZoneEnrollResponse_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned char enroll_response_code = 10; + unsigned char zone_id = 10; + + ret = zb_mgr.zbl_zone_enroll_response(dest_addr16, 1, enroll_response_code, + zone_id); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, PollcontrolCheckinResponse_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_pollcontrol_check_in_response(dest_addr16, 1, 0x01, 0x00C8); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, PollcontrolFastPollStop_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_pollcontrol_fast_poll_stop(dest_addr16, 1); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, PollcontrolSetShortPollInterval_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_pollcontrol_set_short_poll_interval(dest_addr16, 1, 5); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, PollcontrolSetLongPollInterval_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_pollcontrol_set_long_poll_interval(dest_addr16, 1, 10); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, AddScene_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + const char ext_field_set[] = {0x00, 0x06, 0x01, 0x00}; + + ret = zb_mgr.zbl_add_scene(dest_addr16, 1, 0x0002, 0x01, 0x0000, + "6scnone", 4, ext_field_set); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ViewScene_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_view_scene(dest_addr16, 1, 0x0002, 0x01); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, RemoveScene_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_remove_scene(dest_addr16, 1, 0x0002, 0x01); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, RemoveAllScene_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_remove_all_scene(dest_addr16, 1, 0x0002); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, StoreScene_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_store_scene(dest_addr16, 1, 0x0002, 0x01); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, RecallScene_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_recall_scene(dest_addr16, 1, 0x0002, 0x01); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, GetSceneMembership_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + + ret = zb_mgr.zbl_get_scene_membership(dest_addr16, 1, 0x0002); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +TEST(ZigbeeManager, ThermostatAdjustSetpoint_p) +{ + int ret = ZIGBEE_ERROR_NONE; + Zigbee zb_mgr; + nwk_addr dest_addr16 = 0x1D1A; + unsigned char mode = 0x00; + unsigned char amount = 0x01; + + ret = zb_mgr.zbl_thermostat_adjust_setpoint(dest_addr16, 1, mode, + amount); + EXPECT_EQ(ZIGBEE_ERROR_NONE, ret); +} + +int main(int argc, char **argv) +{ + InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/unittest/zbl.cpp b/unittest/zbl.cpp new file mode 100644 index 0000000..63f2f25 --- /dev/null +++ b/unittest/zbl.cpp @@ -0,0 +1,2199 @@ +/* + * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include +#include +#include + +#include "zbl.h" + +Zigbee::Zigbee(void) +{ + Create(); +} + +Zigbee::~Zigbee(void) +{ + Destroy(); +} + +int Zigbee::zbl_enable(void) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message; + + GLOGD("zbl_enable()"); + + message = InvokeMethod(ZIGBEE_MANAGER_INTERFACE, + ZIGBEE_DBUS_OBJPATH, + ZIGBEE_MANAGER_INTERFACE, + "enable", NULL, &error); + + if (message) + g_variant_unref(message); + + return error; +} + +int Zigbee::zbl_disable(void) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_disable()"); + + message = InvokeMethod(ZIGBEE_MANAGER_INTERFACE, + ZIGBEE_DBUS_OBJPATH, + ZIGBEE_MANAGER_INTERFACE, + "disable", NULL, &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = 0x%x", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_is_enable(bool* state) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_is_enable()"); + + message = InvokeMethod(ZIGBEE_MANAGER_INTERFACE, + ZIGBEE_DBUS_OBJPATH, + ZIGBEE_MANAGER_INTERFACE, + "get_zigbee_state", NULL, &error); + + if (message) { + g_variant_get(message, "(ib)", &error, state); + GLOGD("enable = %s", state ? "TRUE" : "FALSE"); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_hw_reset(void) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_hw_reset()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "zb_hw_reset", + NULL, + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_get_network_info(void) +{ + GVariant *message = NULL; + GVariantIter *iter = NULL; + int error = ZIGBEE_ERROR_NONE; + + nwk_addr _nodeid; + nwk_addr _panid; + unsigned char _radio_channel; + unsigned char _radio_tx_power; + + GLOGD("zbl_get_network_info()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "get_network_info", + NULL, + &error); + + if (message) { + g_variant_get(message, "(ia(y)qqyy)", &error, &iter, + &_nodeid, &_panid, &_radio_channel, &_radio_tx_power); + GLOGD("ret = [0x%x]", error); + g_variant_iter_free(iter); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_get_controller_mac_address(ieee_addr mac) +{ + GVariant *message = NULL; + GVariantIter *iter = NULL; + int error = ZIGBEE_ERROR_NONE; + int j = 0; + char value; + + GLOGD("zbl_get_controller_mac_address()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "get_mac", + NULL, + &error); + + if (message) { + g_variant_get(message, "(ia(y))", &error, &iter); + GLOGD("ret = [0x%x]", error); + + while (g_variant_iter_loop(iter, "(y)", &value)) + mac[j++] = value; + + g_variant_iter_free(iter); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_get_cluster_list(ieee_addr eui64, unsigned char endpoint, + unsigned char *in_cluster_count, unsigned short in_cluster_list[], + unsigned char *out_cluster_count, unsigned short out_cluster_list[]) +{ + GVariant *message = NULL; + GVariantBuilder *mac_builder = NULL; + GVariant *mac_variant = NULL; + GVariantIter *in_cluster_iter = NULL; + GVariantIter *out_cluster_iter = NULL; + int error = ZIGBEE_ERROR_NONE; + + unsigned short cluster = 0; + int i = 0; + + GLOGD("zbl_get_cluster_list()"); + + mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + g_variant_builder_add(mac_builder, "(y)", eui64[7]); + g_variant_builder_add(mac_builder, "(y)", eui64[6]); + g_variant_builder_add(mac_builder, "(y)", eui64[5]); + g_variant_builder_add(mac_builder, "(y)", eui64[4]); + g_variant_builder_add(mac_builder, "(y)", eui64[3]); + g_variant_builder_add(mac_builder, "(y)", eui64[2]); + g_variant_builder_add(mac_builder, "(y)", eui64[1]); + g_variant_builder_add(mac_builder, "(y)", eui64[0]); + mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); + + message = invoke_proxy_method(SERVICE_GPROXY, "get_cluster_list", + g_variant_new("(@a(y)y)", mac_variant, endpoint), + &error); + + if (message) { + g_variant_get(message, "(iaqaq)", &error, &in_cluster_iter, &out_cluster_iter); + GLOGD("ret = [0x%x]", error); + + /* In clusters */ + while (g_variant_iter_loop(in_cluster_iter, "q", &cluster)) + in_cluster_list[i++] = cluster; + + *in_cluster_count = i; + g_variant_iter_free(in_cluster_iter); + i = 0; + + /* Out clusters */ + while (g_variant_iter_loop(out_cluster_iter, "q", &cluster)) + out_cluster_list[i++] = cluster; + + *out_cluster_count = i; + g_variant_iter_free(out_cluster_iter); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_get_endpoint_list(ieee_addr eui64, unsigned char *count, + unsigned char list[]) +{ + GVariant *message = NULL; + GVariantBuilder *mac_builder = NULL; + GVariant *mac_variant = NULL; + GVariantIter *iter = NULL; + int error = ZIGBEE_ERROR_NONE; + + unsigned char endpoint; + int i = 0; + + GLOGD("zbl_get_endpoint_list()"); + + mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + g_variant_builder_add(mac_builder, "(y)", eui64[7]); + g_variant_builder_add(mac_builder, "(y)", eui64[6]); + g_variant_builder_add(mac_builder, "(y)", eui64[5]); + g_variant_builder_add(mac_builder, "(y)", eui64[4]); + g_variant_builder_add(mac_builder, "(y)", eui64[3]); + g_variant_builder_add(mac_builder, "(y)", eui64[2]); + g_variant_builder_add(mac_builder, "(y)", eui64[1]); + g_variant_builder_add(mac_builder, "(y)", eui64[0]); + mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); + + message = invoke_proxy_method(SERVICE_GPROXY, "get_endpoint_list", + g_variant_new("(@a(y))", mac_variant), + &error); + + if (message) { + g_variant_get(message, "(ia(y))", &error, &iter); + GLOGD("ret = [0x%x]", error); + + while (g_variant_iter_loop(iter, "(y)", &endpoint)) + list[i++] = endpoint; + + *count = i; + g_variant_iter_free(iter); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_api_get_node_type(ieee_addr eui64) +{ + GVariant *message = NULL; + GVariantBuilder *mac_builder = NULL; + GVariant *mac_variant = NULL; + int error = ZIGBEE_ERROR_NONE; + unsigned char node_type; + + GLOGD("zbl_api_get_node_type()"); + + mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + g_variant_builder_add(mac_builder, "(y)", eui64[7]); + g_variant_builder_add(mac_builder, "(y)", eui64[6]); + g_variant_builder_add(mac_builder, "(y)", eui64[5]); + g_variant_builder_add(mac_builder, "(y)", eui64[4]); + g_variant_builder_add(mac_builder, "(y)", eui64[3]); + g_variant_builder_add(mac_builder, "(y)", eui64[2]); + g_variant_builder_add(mac_builder, "(y)", eui64[1]); + g_variant_builder_add(mac_builder, "(y)", eui64[0]); + mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); + + message = invoke_proxy_method(SERVICE_GPROXY, "get_node_type", + g_variant_new("(@a(y))", mac_variant), + &error); + + if (message) { + g_variant_get(message, "(iy)", &error, &node_type); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_get_all_device_info(void) +{ + GVariant *message = NULL; + GVariantIter *iter = NULL; + int error = ZIGBEE_ERROR_NONE; + + GLOGD("zbl_get_all_device_info()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "get_device_info", NULL, &error); + + if (message) { + g_variant_get(message, "(ia(qyayyay))", &error, &iter); + GLOGD("ret = [0x%x]", error); + g_variant_iter_free(iter); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_coex_start(unsigned char channel) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_coex_start()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "coex_start", g_variant_new("(y)", channel), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_coex_stop(void) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_coex_stop()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "coex_stop", NULL, &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_form_network(void) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_form_network()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "form_network", NULL, &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_disable_network(void) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_disable_network()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "leave_network", NULL, &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_leave_device(ieee_addr addr64, bool remove_children, bool rejoin) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GVariantBuilder *mac_builder = NULL; + GVariant* mac_variant = NULL; + unsigned char _remove_children = (remove_children) ? 1 : 0; + unsigned char _rejoin = (rejoin) ? 1 : 0; + + GLOGD("zbl_leave_device()"); + + mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + g_variant_builder_add(mac_builder, "(y)", addr64[7]); + g_variant_builder_add(mac_builder, "(y)", addr64[6]); + g_variant_builder_add(mac_builder, "(y)", addr64[5]); + g_variant_builder_add(mac_builder, "(y)", addr64[4]); + g_variant_builder_add(mac_builder, "(y)", addr64[3]); + g_variant_builder_add(mac_builder, "(y)", addr64[2]); + g_variant_builder_add(mac_builder, "(y)", addr64[1]); + g_variant_builder_add(mac_builder, "(y)", addr64[0]); + mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); + + message = invoke_proxy_method(SERVICE_GPROXY, "leave_request", + g_variant_new("(@a(y)yy)", mac_variant, _remove_children, _rejoin), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_permit_join(unsigned char duration, bool broadcast) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_permit_join()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "permit_join", + g_variant_new("(ib)", duration, broadcast), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_nwk_addr_req(ieee_addr addr64, unsigned char request_type, + unsigned char start_idx) +{ + GVariantBuilder *mac_builder = NULL; + GVariant* mac_variant = NULL; + + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD(" zbl_nwk_addr_req()"); + + mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + g_variant_builder_add(mac_builder, "(y)", addr64[7]); + g_variant_builder_add(mac_builder, "(y)", addr64[6]); + g_variant_builder_add(mac_builder, "(y)", addr64[5]); + g_variant_builder_add(mac_builder, "(y)", addr64[4]); + g_variant_builder_add(mac_builder, "(y)", addr64[3]); + g_variant_builder_add(mac_builder, "(y)", addr64[2]); + g_variant_builder_add(mac_builder, "(y)", addr64[1]); + g_variant_builder_add(mac_builder, "(y)", addr64[0]); + mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "nwk_addr_req", + g_variant_new("(@a(y)yy)", mac_variant, request_type, start_idx), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ieee_addr_req(nwk_addr addr16) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ieee_addr_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "ieee_addr_req", + g_variant_new("(q)", addr16), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_active_ep(nwk_addr addr16) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_active_ep()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "active_ep_req", + g_variant_new("(q)", addr16), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_simple_desc_req(nwk_addr addr16, unsigned char ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_simple_desc_req() : [%X]", addr16); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "simple_desc_req", + g_variant_new("(qy)", addr16, ep), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_match_desc_req(nwk_addr addr16, + unsigned short profile_id, unsigned char num_in_clusters, + unsigned short *in_clusters, unsigned char num_out_clusters, + unsigned short *out_clusters) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + int i; + GVariantBuilder *incl_builder = NULL; + GVariant* incl_variant = NULL; + GVariantBuilder *outcl_builder = NULL; + GVariant* outcl_variant = NULL; + + GLOGD("zbl_match_desc_req()"); + + incl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq")); + for (i = 0; i < num_in_clusters; i++) + g_variant_builder_add(incl_builder, "q", in_clusters[i]); + + outcl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq")); + for (i = 0; i < num_out_clusters; i++) + g_variant_builder_add(outcl_builder, "q", out_clusters[i]); + + incl_variant = g_variant_builder_end(incl_builder); + outcl_variant = g_variant_builder_end(outcl_builder); + g_variant_builder_unref(incl_builder); + g_variant_builder_unref(outcl_builder); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "matched_descriptor_req", + g_variant_new("(qqy@aqy@aq)", addr16, profile_id, num_in_clusters, + incl_variant, num_out_clusters, outcl_variant), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_node_desc_req(nwk_addr addr16) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_node_desc_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "node_desc_req", + g_variant_new("(q)", addr16), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_power_desc_req(nwk_addr addr16) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_power_desc_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "power_desc_req", + g_variant_new("(q)", addr16), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_complex_desc_req(nwk_addr addr16) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_complex_desc_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "complex_desc_req", + g_variant_new("(q)", addr16), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_user_desc_req(nwk_addr addr16) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_user_desc_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "user_desc_req", + g_variant_new("(q)", addr16), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_user_desc_set(nwk_addr addr16, unsigned char len, + unsigned char *user_desc) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + unsigned char j = 0x00; + GVariantBuilder *user_desc_builder = NULL; + GVariant *user_desc_variant = NULL; + + GLOGD("zbl_user_desc_set()"); + + user_desc_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + for (j = 0; j < len; j++) + g_variant_builder_add(user_desc_builder, "(y)", user_desc[j]); + + user_desc_variant = g_variant_builder_end(user_desc_builder); + g_variant_builder_unref(user_desc_builder); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "user_desc_set_req", + g_variant_new("(qy@a(y))", addr16, len, user_desc_variant), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_device_annce(nwk_addr addr16, ieee_addr addr64, + unsigned char capability) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GVariantBuilder *mac_builder = NULL; + GVariant* mac_variant = NULL; + + GLOGD("zbl_device_annce()"); + + mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + g_variant_builder_add(mac_builder, "(y)", addr64[7]); + g_variant_builder_add(mac_builder, "(y)", addr64[6]); + g_variant_builder_add(mac_builder, "(y)", addr64[5]); + g_variant_builder_add(mac_builder, "(y)", addr64[4]); + g_variant_builder_add(mac_builder, "(y)", addr64[3]); + g_variant_builder_add(mac_builder, "(y)", addr64[2]); + g_variant_builder_add(mac_builder, "(y)", addr64[1]); + g_variant_builder_add(mac_builder, "(y)", addr64[0]); + mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "device_announce", + g_variant_new("(q@a(y)y)", addr16, mac_variant, capability), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64, + unsigned char src_ep, unsigned short cluster_id, ieee_addr dst_addr64, + unsigned char type, nwk_addr group_addr, unsigned char dst_ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + int i; + GVariantBuilder *src_addr64_builder = NULL; + GVariant* src_addr64_variant = NULL; + GVariantBuilder *dst_addr64_builder = NULL; + GVariant* dst_addr64_variant = NULL; + + GLOGD("zbl_bind_req()"); + + src_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + + if (src_addr64) { + for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--) + g_variant_builder_add(src_addr64_builder, "(y)", src_addr64[i]); + } + src_addr64_variant = g_variant_builder_end(src_addr64_builder); + g_variant_builder_unref(src_addr64_builder); + + dst_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + if (dst_addr64) { + for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--) + g_variant_builder_add(dst_addr64_builder, "(y)", dst_addr64[i]); + } + dst_addr64_variant = g_variant_builder_end(dst_addr64_builder); + g_variant_builder_unref(dst_addr64_builder); + + message = invoke_proxy_method(ZDO_BIND_PROXY, "bind_req", + g_variant_new("(q@a(y)yq@a(y)yqy)", dst_addr16, src_addr64_variant, src_ep, + cluster_id, dst_addr64_variant, type, group_addr, dst_ep), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_unbind_req(nwk_addr dst_addr16, + ieee_addr src_addr64, unsigned char src_ep, unsigned short cluster_id, + ieee_addr dst_addr64, unsigned char type, nwk_addr group_addr, + unsigned char dst_ep) +{ + int i; + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GVariantBuilder *src_addr64_builder = NULL; + GVariant* src_addr64_variant = NULL; + GVariantBuilder *dst_addr64_builder = NULL; + GVariant* dst_addr64_variant = NULL; + + GLOGD("zbl_zdo_unbind_req()"); + + src_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + if (src_addr64) { + for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--) + g_variant_builder_add(src_addr64_builder, "(y)", src_addr64[i]); + } + + src_addr64_variant = g_variant_builder_end(src_addr64_builder); + g_variant_builder_unref(src_addr64_builder); + + dst_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + if (dst_addr64) { + for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--) + g_variant_builder_add(dst_addr64_builder, "(y)", dst_addr64[i]); + } + + dst_addr64_variant = g_variant_builder_end(dst_addr64_builder); + g_variant_builder_unref(dst_addr64_builder); + + message = invoke_proxy_method(ZDO_BIND_PROXY, "unbind_req", + g_variant_new("(q@a(y)yq@a(y)yqy)", + dst_addr16, src_addr64_variant, src_ep, + cluster_id, dst_addr64_variant, type, group_addr, dst_ep), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_mgmt_nwk_disc_req(nwk_addr addr16, unsigned int scan_channels, + unsigned char scan_duration, unsigned char scan_count, unsigned char start_idx) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_mgmt_nwk_disc_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_nwk_disc_req", + g_variant_new("(quyqy)", + addr16, + scan_channels, + scan_duration, + scan_count, + start_idx), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_mgmt_nwk_update_req(unsigned int scan_channels, unsigned char scan_duration, + unsigned char scan_count, unsigned char nwk_update_id, nwk_addr nwk_manager_addr) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_mgmt_nwk_update_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_nwk_update_req", + g_variant_new("(quyyy)", nwk_manager_addr, + scan_channels, scan_duration, + scan_count, nwk_update_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_mgmt_lqi_req(nwk_addr addr16, unsigned char start_idx) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_mgmt_lqi_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_lqi_req", + g_variant_new("(qy)", addr16, start_idx), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_mgmt_rtg_req(nwk_addr addr16, unsigned char start_idx) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_mgmt_rtg_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_rtg_req", + g_variant_new("(qy)", addr16, start_idx), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_mgmt_bind_req(nwk_addr addr16, unsigned char start_idx) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_mgmt_bind_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_bind_req", + g_variant_new("(qy)", addr16, start_idx), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children, + unsigned rejoin) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GVariantBuilder *mac_builder = NULL; + GVariant* mac_variant = NULL; + + mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + g_variant_builder_add(mac_builder, "(y)", addr64[7]); + g_variant_builder_add(mac_builder, "(y)", addr64[6]); + g_variant_builder_add(mac_builder, "(y)", addr64[5]); + g_variant_builder_add(mac_builder, "(y)", addr64[4]); + g_variant_builder_add(mac_builder, "(y)", addr64[3]); + g_variant_builder_add(mac_builder, "(y)", addr64[2]); + g_variant_builder_add(mac_builder, "(y)", addr64[1]); + g_variant_builder_add(mac_builder, "(y)", addr64[0]); + mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); + + GLOGD("zbl_mgmt_leave_device()"); + + message = invoke_proxy_method(SERVICE_GPROXY, "leave_request", + g_variant_new("(@a(y)yy)", mac_variant, remove_children, rejoin), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_mgmt_permit_joining_req(nwk_addr addr16, unsigned char duration, + unsigned char tc_significance) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_mgmt_permit_joining_req()"); + + message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_permit_join_req", + g_variant_new("(qyy)", addr16, duration, tc_significance), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, unsigned char src_ep, + unsigned char dst_ep, unsigned short cluster_id, unsigned short profile_id, + unsigned char zcl_frame_ctl, unsigned short mfg_code, unsigned char cmd_id, + unsigned short payload_len, unsigned char *payload) +{ + int i; + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GVariantBuilder *payload_builder = NULL; + GVariant *payload_variant = NULL; + + payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + if (payload_len > 0) { + for (i = payload_len - 1; i >= 0 ; i--) + g_variant_builder_add(payload_builder, "(y)", payload[i]); + } + payload_variant = g_variant_builder_end(payload_builder); + g_variant_builder_unref(payload_builder); + + GLOGD("zbl_aps_send()"); + + message = invoke_proxy_method(CUSTOM_GPROXY, "aps_send", + g_variant_new("(qyyyqqyqyq@a(y))", addr16, + aps_frame_ctl, src_ep, dst_ep, cluster_id, + profile_id, zcl_frame_ctl, mfg_code, + cmd_id, payload_len, payload_variant), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, + unsigned short cluster_id, unsigned char zcl_frame_ctl, unsigned char cmd, + unsigned short payload_len, unsigned char *payload) +{ + int i; + + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GVariantBuilder *payload_builder = NULL; + GVariant *payload_variant = NULL; + + GLOGD("zbl_zcl_send()"); + + payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + if (payload_len > 0) { + for (i = payload_len - 1; i >= 0 ; i--) + g_variant_builder_add(payload_builder, "(y)", payload[i]); + } + payload_variant = g_variant_builder_end(payload_builder); + g_variant_builder_unref(payload_builder); + + message = invoke_proxy_method(CUSTOM_GPROXY, "zcl_send", + g_variant_new("(qyyqyyq@a(y))", addr16, src_ep, dst_ep, cluster_id, zcl_frame_ctl, + cmd, payload_len, payload_variant), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_send_to_local(unsigned short length, unsigned char *data) +{ + int i; + + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_send_to_local()"); + + GVariantBuilder *payload_builder = NULL; + GVariant *payload_variant = NULL; + + payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + if (length > 0) { + for (i = length - 1; i >= 0 ; i--) + g_variant_builder_add(payload_builder, "(y)", data[i]); + } + payload_variant = g_variant_builder_end(payload_builder); + g_variant_builder_unref(payload_builder); + + message = invoke_proxy_method(CUSTOM_GPROXY, "send_to_local", + g_variant_new("(q@a(y))", length, payload_variant), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_read_attr_req(unsigned short addr16, unsigned char dest_ep, + unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned short *attribute_ids, + int attribute_ids_len) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + int i = 0; + unsigned char *t; + GVariant *attr_variant = NULL; + GVariantBuilder *attr_builder = NULL; + + GLOGD("zbl_read_attr_req()"); + + t = (unsigned char *)attribute_ids; + attr_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + for (i = 0; i < attribute_ids_len*sizeof(unsigned short); i++) + g_variant_builder_add(attr_builder, "(y)", t[i]); + attr_variant = g_variant_builder_end(attr_builder); + g_variant_builder_unref(attr_builder); + + message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "read_attributes_req", + g_variant_new("(@a(y)iqqyy)", attr_variant, attribute_ids_len, + addr16, cluster_id, zcl_frame_ctl, dest_ep), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_discover_attr_req(unsigned short addr16, unsigned char src_ep, + unsigned char dest_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, + unsigned short start_id, unsigned char max_attribute_ids) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_discover_attr_req()"); + + message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "discover_attributes", + g_variant_new("(qyyqqy)", addr16, dest_ep, zcl_frame_ctl, + cluster_id, start_id, max_attribute_ids), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_discover_cmds_gen(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, + unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id, + unsigned char max_command_ids) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_discover_attr_gen()"); + + message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "discover_commands_generated", + g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl, + cluster_id, start_command_id, max_command_ids), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_discover_cmds_recv(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, + unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id, + unsigned char max_command_ids) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_discover_cmds_recv()"); + + message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "discover_commands_received", + g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl, + cluster_id, start_command_id, max_command_ids), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_discover_attr_ext(nwk_addr addr16, unsigned char src_ep, + unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, + unsigned short start_id, unsigned char max_attribute_ids) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_discover_attr_ext()"); + + message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "discover_attributes_extended", + g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl, cluster_id, start_id, + max_attribute_ids), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_reset_alarm(nwk_addr addr16, unsigned char ep, unsigned char alarm_code, + unsigned short cluster_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_reset_alarm()"); + + message = invoke_proxy_method(ALARM_GPROXY, "reset_alarm", + g_variant_new("(qyyq)", addr16, ep, alarm_code, cluster_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_get_alarm(nwk_addr addr16, unsigned char ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_get_alarm()"); + + message = invoke_proxy_method(ALARM_GPROXY, "get_alarm", + g_variant_new("(qy)", addr16, ep), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_reset_all_alarm_log(nwk_addr addr16, unsigned char ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + message = invoke_proxy_method(ALARM_GPROXY, "reset_alarm_log", + g_variant_new("(qy)", addr16, ep), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_move_to_hue(nwk_addr addr16, unsigned char ep, + unsigned char hue, unsigned char direction, + unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_to_hue", + g_variant_new("(qyyyq)", addr16, ep, hue, direction, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_move_hue(nwk_addr addr16, unsigned char ep, + unsigned char move_mode, unsigned char rate) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_hue", + g_variant_new("(qyyy)", addr16, ep, move_mode, rate), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_step_hue(nwk_addr addr16, unsigned char ep, + unsigned char step_mode, unsigned char step_size, + unsigned char transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "step_hue", + g_variant_new("(qyyyy)", addr16, ep, step_mode, step_size, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_move_to_saturation(nwk_addr addr16, unsigned char ep, + unsigned char saturation, unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ccontrol_move_to_saturation()"); + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_to_saturation", + g_variant_new("(qyyq)", addr16, ep, saturation, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_move_saturation(nwk_addr addr16, unsigned char ep, + unsigned char move_mode, unsigned char rate) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ccontrol_move_saturation()"); + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_saturation", + g_variant_new("(qyyy)", addr16, ep, move_mode, rate), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_step_saturation(nwk_addr addr16, unsigned char ep, + unsigned char step_mode, unsigned char step_size, + unsigned char transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ccontrol_step_saturation()"); + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "step_saturation", + g_variant_new("(qyyyy)", addr16, ep, step_mode, step_size, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_move_to_hue_and_saturation(nwk_addr addr16, unsigned char ep, + unsigned char hue, unsigned char saturation, + unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ccontrol_move_to_hue_and_saturation()"); + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_to_hue_and_saturation", + g_variant_new("(qyyyq)", addr16, ep, hue, saturation, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_move_to_color(nwk_addr addr16, unsigned char ep, + unsigned short color_x, unsigned short color_y, + unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ccontrol_move_to_color()"); + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_to_color", + g_variant_new("(qyqqq)", addr16, ep, color_x, color_y, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_move_color(nwk_addr addr16, unsigned char ep, + unsigned short rate_x, unsigned short rate_y) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ccontrol_move_color()"); + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_color", + g_variant_new("(qyqq)", addr16, ep, rate_x, rate_y), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_step_color(nwk_addr addr16, unsigned char ep, + unsigned short step_x, unsigned short step_y, + unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ccontrol_step_color()"); + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "step_color", + g_variant_new("(qyqqq)", addr16, ep, step_x, step_y, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_ccontrol_move_to_color_temperature(nwk_addr addr16, unsigned char ep, + unsigned short color_temperature, + unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_ccontrol_move_to_color_temperature()"); + + message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_color_temperature", + g_variant_new("(qyqq)", addr16, ep, color_temperature, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_reset_factory_default(nwk_addr addr16, unsigned char ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_reset_factory_default()"); + + message = invoke_proxy_method(ZCL_BASIC_PROXY, "reset_factory_default", + g_variant_new("(qy)", addr16, ep), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_identify(nwk_addr addr16, unsigned char dst_ep, unsigned short identify_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_identify()"); + + message = invoke_proxy_method(ZCL_IDENTIFY_PROXY, "identify", + g_variant_new("(qyq)", addr16, dst_ep, identify_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_identify_query(nwk_addr addr16, unsigned char dst_ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_identify_query()"); + + message = invoke_proxy_method(ZCL_IDENTIFY_PROXY, "query", + g_variant_new("(qy)", addr16, dst_ep), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, + const char *group_name) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + int j = 0; + GVariant *groupname_variant = NULL; + GVariantBuilder *groupname_builder = NULL; + + GLOGD("zbl_add_group()"); + + groupname_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + while (group_name[j] != '\0') { + g_variant_builder_add(groupname_builder, "(y)", (group_name[j])); + j++; + } + groupname_variant = g_variant_builder_end(groupname_builder); + g_variant_builder_unref(groupname_builder); + + message = invoke_proxy_method(ZCL_GROUP_PROXY, "add_group", + g_variant_new("(qyq@a(y))", addr16, ep, group_id, groupname_variant), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_view_group(nwk_addr addr16, unsigned char ep, unsigned short group_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_view_group()"); + + message = invoke_proxy_method(ZCL_GROUP_PROXY, "view_group", + g_variant_new("(qyq)", addr16, ep, group_id), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep, + unsigned char group_count, unsigned short *group_list) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + int j = 0; + GVariant *grouplist_variant = NULL; + GVariantBuilder *grouplist_builder = NULL; + + GLOGD("zbl_group_get_group_membership()"); + + grouplist_builder = g_variant_builder_new(G_VARIANT_TYPE("aq")); + while (j < group_count) { + g_variant_builder_add(grouplist_builder, "q", group_list[j]); + j++; + } + grouplist_variant = g_variant_builder_end(grouplist_builder); + g_variant_builder_unref(grouplist_builder); + + message = invoke_proxy_method(ZCL_GROUP_PROXY, "get_group_membership", + g_variant_new("(qyy@aq)", addr16, ep, group_count, grouplist_variant), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_remove_group(nwk_addr addr16, unsigned char ep, unsigned short group_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_group_remove_group()"); + + message = invoke_proxy_method(ZCL_GROUP_PROXY, "remove_group", g_variant_new("(qyq)", + addr16, ep, group_id), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_remove_all_group(nwk_addr addr16, unsigned char ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_group_remove_all_group()"); + + message = invoke_proxy_method(ZCL_GROUP_PROXY, "remove_all_group", + g_variant_new("(qy)", addr16, ep), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_add_group_if_identifying(nwk_addr addr16, unsigned char ep, + unsigned short group_id, const char *group_name) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_add_group_if_identifying()"); + + int j = 0; + GVariant *groupname_variant = NULL; + GVariantBuilder *groupname_builder = NULL; + + groupname_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + while (group_name[j] != '\0') { + g_variant_builder_add(groupname_builder, "(y)", group_name[j]); + j++; + } + groupname_variant = g_variant_builder_end(groupname_builder); + g_variant_builder_unref(groupname_builder); + + message = invoke_proxy_method(ZCL_GROUP_PROXY, "add_group_if_identifying", + g_variant_new("(qyq@a(y))", addr16, ep, group_id, groupname_variant), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_level_control_move_to_level(nwk_addr addr16, unsigned char ep, + unsigned char level, unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_level_control_move_to_level()"); + + message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "move_to_level", + g_variant_new("(qyyq)", addr16, ep, level, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_level_control_move(nwk_addr addr16, unsigned char ep, + unsigned char move_mode, unsigned char rate) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_level_control_move()"); + + message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "move", + g_variant_new("(qyyy)", addr16, ep, move_mode, rate), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_level_control_step(nwk_addr addr16, unsigned char ep, + unsigned char step_mode, unsigned char step_size, + unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_level_control_step()"); + + message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "step", + g_variant_new("(qyyyq)", addr16, ep, step_mode, step_size, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_level_control_stop(nwk_addr addr16, unsigned char ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_level_control_stop()"); + + message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "stop", + g_variant_new("(qy)", addr16, ep), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_level_control_move_to_level_with_on_off(nwk_addr addr16, + unsigned char ep, unsigned char level, unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_level_control_move_to_level_with_on_off()"); + + message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "move_to_level_with_on_off", + g_variant_new("(qyyq)", addr16, ep, level, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_level_control_move_with_on_off(nwk_addr addr16, unsigned char ep, + unsigned char move_mode, unsigned char rate) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_level_control_move_with_on_off()"); + + message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "move_with_on_off", + g_variant_new("(qyyy)", addr16, ep, move_mode, rate), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_level_control_step_with_on_off(nwk_addr addr16, unsigned char ep, + unsigned char step_mode, unsigned char step_size, + unsigned short transition_time) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_level_control_step_with_on_off()"); + + message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "step_with_on_off", + g_variant_new("(qyyyq)", addr16, ep, step_mode, step_size, transition_time), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_onoff_set(nwk_addr addr16, unsigned char ep, unsigned char on_off_type) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_onoff_set()"); + + message = invoke_proxy_method(ON_OFF_GPROXY, "set_on_off", + g_variant_new("(qyy)", addr16, ep, on_off_type), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_zone_enroll_response(nwk_addr addr16, unsigned char dst_ep, + unsigned char enroll_response_code, unsigned char zone_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_zone_enroll_response()"); + + message = invoke_proxy_method(ZCL_IAS_ZONE_PROXY, "enroll_response", + g_variant_new("(qyyy)", addr16, dst_ep, enroll_response_code, zone_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_pollcontrol_check_in_response(nwk_addr addr16, unsigned char ep, + unsigned char start_fast_polling, unsigned short fast_poll_timeout) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_pollcontrol_check_in_response()"); + + message = invoke_proxy_method(ZCL_POLL_CONTROL_PROXY, "check_in_response", + g_variant_new("(qyyq)", addr16, ep, start_fast_polling, fast_poll_timeout), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_pollcontrol_fast_poll_stop(nwk_addr addr16, unsigned char ep) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_pollcontrol_fast_poll_stop()"); + + message = invoke_proxy_method(ZCL_POLL_CONTROL_PROXY, "fast_poll_stop", + g_variant_new("(qy)", addr16, ep), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_pollcontrol_set_long_poll_interval(nwk_addr addr16, unsigned char ep, + unsigned int new_long_poll_interval) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_pollcontrol_set_long_poll_interval()"); + + message = invoke_proxy_method(ZCL_POLL_CONTROL_PROXY, "set_long_poll_interval", + g_variant_new("(qyu)", addr16, ep, new_long_poll_interval), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_pollcontrol_set_short_poll_interval(nwk_addr addr16, unsigned char ep, + unsigned int new_short_poll_interval) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_pollcontrol_set_short_poll_interval()"); + + message = invoke_proxy_method(ZCL_POLL_CONTROL_PROXY, "set_short_poll_interval", + g_variant_new("(qyu)", addr16, ep, new_short_poll_interval), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, + unsigned char scene_id, unsigned short transition_time, const char *scene_name, + unsigned short ext_field_len, const char *extension_field_sets) + +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + int j = 0; + int index = 0; + GVariant *scenename_variant = NULL; + GVariantBuilder *scenename_builder = NULL; + GVariant *extensionfieldSet_variant = NULL; + GVariantBuilder *extensionfieldSet_builder = NULL; + + GLOGD("zbl_add_scene()"); + + scenename_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + while ('\0' != scene_name[j]) { + g_variant_builder_add(scenename_builder, "(y)", scene_name[j]); + j++; + } + scenename_variant = g_variant_builder_end(scenename_builder); + g_variant_builder_unref(scenename_builder); + + extensionfieldSet_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)")); + + while (index < ext_field_len) { + GLOGD("Ext contents 0x%02X", extension_field_sets[index]); + g_variant_builder_add(extensionfieldSet_builder, "(y)", extension_field_sets[index]); + index++; + } + extensionfieldSet_variant = g_variant_builder_end(extensionfieldSet_builder); + g_variant_builder_unref(extensionfieldSet_builder); + + message = invoke_proxy_method(ZCL_SCENE_PROXY, "add_scene", + g_variant_new("(qyqyqq@a(y)@a(y))", addr16, ep, group_id, scene_id, transition_time, + ext_field_len, scenename_variant, extensionfieldSet_variant), &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_view_scene(nwk_addr addr16, unsigned char ep, + unsigned short group_id, unsigned char scene_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_scene_view_scene()"); + + message = invoke_proxy_method(ZCL_SCENE_PROXY, "view_scene", + g_variant_new("(qyqy)", addr16, ep, group_id, scene_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_remove_scene(nwk_addr addr16, unsigned char ep, + unsigned short group_id, unsigned char scene_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_scene_remove_scene()"); + + message = invoke_proxy_method(ZCL_SCENE_PROXY, "remove_scene", + g_variant_new("(qyqy)", addr16, ep, group_id, scene_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_remove_all_scene(nwk_addr addr16, unsigned char ep, + unsigned short group_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_scene_remove_all_scene()"); + + message = invoke_proxy_method(ZCL_SCENE_PROXY, "remove_all_scene", + g_variant_new("(qyq)", addr16, ep, group_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_store_scene(nwk_addr addr16, unsigned char ep, + unsigned short group_id, unsigned char scene_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_scene_store_scene()"); + + message = invoke_proxy_method(ZCL_SCENE_PROXY, "store_scene", + g_variant_new("(qyqy)", addr16, ep, group_id, scene_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_recall_scene(nwk_addr addr16, unsigned char ep, + unsigned short group_id, unsigned char scene_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_recall_scene()"); + + message = invoke_proxy_method(ZCL_SCENE_PROXY, "recall_scene", + g_variant_new("(qyqy)", addr16, ep, group_id, scene_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_get_scene_membership(nwk_addr addr16, unsigned char ep, + unsigned short group_id) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_scene_get_scene_membership()"); + + message = invoke_proxy_method(ZCL_SCENE_PROXY, "get_scene_membership", + g_variant_new("(qyq)", addr16, ep, group_id), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} + +int Zigbee::zbl_thermostat_adjust_setpoint(nwk_addr addr16, unsigned char ep, + unsigned char mode, unsigned char amount) +{ + int error = ZIGBEE_ERROR_NONE; + GVariant *message = NULL; + + GLOGD("zbl_thermostat_adjust_setpoint()"); + + message = invoke_proxy_method(THERMOSTAT_GPROXY, "setpoint_raise_lower", + g_variant_new("(qyyy)", addr16, ep, mode, amount), + &error); + + if (message) { + g_variant_get(message, "(i)", &error); + GLOGD("ret = [0x%x]", error); + g_variant_unref(message); + } + + return error; +} diff --git a/unittest/zbl.h b/unittest/zbl.h new file mode 100644 index 0000000..baf8c12 --- /dev/null +++ b/unittest/zbl.h @@ -0,0 +1,222 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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_MANAGER_H__ +#define __ZIGBEE_MANAGER_H__ + +#include +#include + +#include "gdbus.h" +#include "common.h" + +#define MAX_ENDPOINT_CLUSTERS 32 +#define ZB_802_15_4_CHANNELS_MASK 0x07FFF800UL + +typedef unsigned char ieee_addr[8]; +typedef unsigned short nwk_addr; +typedef unsigned char aes128_key[16]; + +typedef enum { + ZB_ZDP_ALTERNATIVE_PAN_COORDINATOR = (1 << 0), + ZB_ZDP_DEVICE_TYPE = (1 << 1), + ZB_ZDP_POWER_SOURCE = (1 << 2), + ZB_ZDP_RECEIVER_ON_WHEN_IDLE = (1 << 3), + ZB_ZDP_SECURITY_CAPABILITY = (1 << 6), + ZB_ZDP_ALLOCATE_ADDRESS = (1 << 7), +} zb_zdo_mac_capability_field_e; + +typedef enum { + ZB_APS_NO_ACK_REQUEST = (0 << 6), + ZB_APS_ACK_REQUEST = (1 << 6), +} zb_aps_ack_request_e; + +typedef enum { + ZB_APS_DELIVERY_UNICAST = 0, + ZB_APS_DELIVERY_INDIRECT = 1, + ZB_APS_DELIVERY_BROADCAST = 2, + ZB_APS_DELIVERY_MULTICAST = 3, +} zb_aps_delivery_mode_e; + +typedef enum { + ZB_ZCL_FC_GLOBALLY_USED = (0 << 0), + ZB_APS_FC_CLUSTER_SPECIFIC = (1 << 0), +} zb_zcl_fc_type_e; + +typedef enum { + ZB_ZCL_CLIENT_TO_SERVER = (0 << 3), + ZB_ZCL_SERVER_TO_CLIENT = (1 << 3), +} zb_zcl_fc_direction_e; + +typedef enum { + ZB_ZCL_LEAVE_WELL_ALONE = (0 << 4), + ZB_ZCL_DISABLE_DEFAULT_RESPONSE = (1 << 4), +} zb_zcl_fc_disable_default_response_e; + +typedef enum { + ZB_ZCL_FC_NOT_MANUFACTURER = (0 << 2), + ZB_ZCL_FC_MANUFACTURER = (1 << 2), +} zb_zcl_fc_manufacturer_present_e; + +class Zigbee:public GDbus { + private: + public: + Zigbee(); + ~Zigbee(); + int zbl_enable(void); + int zbl_disable(void); + int zbl_is_enable(bool* state); + int zbl_hw_reset(void); + int zbl_coex_stop(void); + int zbl_form_network(void); + int zbl_disable_network(void); + int zbl_get_controller_mac_address(ieee_addr mac); + int zbl_get_network_info(void); + int zbl_get_cluster_list(ieee_addr eui64, unsigned char endpoint, + unsigned char *in_cluster_count, unsigned short in_cluster_list[], + unsigned char *out_cluster_count, unsigned short out_cluster_list[]); + int zbl_get_endpoint_list(ieee_addr eui64, unsigned char *count, unsigned char list[]); + int zbl_api_get_node_type(ieee_addr eui64); + int zbl_get_all_device_info(void); + int zbl_coex_start(unsigned char channel); + int zbl_leave_device(ieee_addr addr64, bool remove_children, bool rejoin); + int zbl_permit_join(unsigned char duration, bool broadcast); + int zbl_nwk_addr_req(ieee_addr addr64, unsigned char request_type, unsigned char start_idx); + int zbl_ieee_addr_req(nwk_addr addr16); + int zbl_active_ep(nwk_addr addr16); + int zbl_simple_desc_req(nwk_addr addr16, unsigned char ep); + int zbl_match_desc_req(nwk_addr addr16, unsigned short profile_id, unsigned char num_in_clusters, + unsigned short *in_clusters, unsigned char num_out_clusters, unsigned short *out_clusters); + int zbl_node_desc_req(nwk_addr addr16); + int zbl_power_desc_req(nwk_addr addr16); + int zbl_complex_desc_req(nwk_addr addr16); + int zbl_user_desc_req(nwk_addr addr16); + int zbl_user_desc_set(nwk_addr addr16, unsigned char len, unsigned char *user_desc); + int zbl_device_annce(nwk_addr addr16, ieee_addr addr64, unsigned char capability); + int zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64, unsigned char src_ep, + unsigned short cluster_id, ieee_addr dst_addr64, unsigned char type, + nwk_addr group_addr, unsigned char dst_ep); + int zbl_unbind_req(nwk_addr dst_addr16, ieee_addr src_addr64, unsigned char src_ep, + unsigned short cluster_id, ieee_addr dst_addr64, unsigned char type, + nwk_addr group_addr, unsigned char dst_ep); + int zbl_mgmt_nwk_disc_req(nwk_addr addr16, unsigned int scan_channels, + unsigned char scan_duration, unsigned char scan_count, unsigned char start_idx); + int zbl_mgmt_nwk_update_req(unsigned int scan_channels, unsigned char scan_duration, + unsigned char scan_count, unsigned char nwk_update_id, nwk_addr nwk_manager_addr); + int zbl_mgmt_lqi_req(nwk_addr addr16, unsigned char start_idx); + int zbl_mgmt_rtg_req(nwk_addr addr16, unsigned char start_idx); + int zbl_mgmt_bind_req(nwk_addr addr16, unsigned char start_idx); + int zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children, unsigned rejoin); + int zbl_mgmt_permit_joining_req(nwk_addr addr16, unsigned char duration, unsigned char tc_significance); + int zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, unsigned char src_ep, + unsigned char dst_ep, unsigned short cluster_id, unsigned short profile_id, + unsigned char zcl_frame_ctl, unsigned short mfg_code, unsigned char cmd_id, + unsigned short payload_len, unsigned char *payload); + int zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, + unsigned short cluster_id, unsigned char zcl_frame_ctl, unsigned char cmd, + unsigned short payload_len, unsigned char *payload); + int zbl_send_to_local(unsigned short length, unsigned char *data); + int zbl_read_attr_req(unsigned short addr16, unsigned char dest_ep, + unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned short *attribute_ids, + int attribute_ids_len); + int zbl_discover_attr_req(unsigned short addr16, unsigned char src_ep, + unsigned char dest_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, + unsigned short start_id, unsigned char max_attribute_ids); + int zbl_discover_cmds_gen(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, + unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id, + unsigned char max_command_ids); + int zbl_discover_cmds_recv(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, + unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id, + unsigned char max_command_ids); + int zbl_discover_attr_ext(nwk_addr addr16, unsigned char src_ep, + unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, + unsigned short start_id, unsigned char max_attribute_ids); + int zbl_reset_alarm(nwk_addr addr16, unsigned char ep, unsigned char alarm_code, + unsigned short cluster_id); + int zbl_get_alarm(nwk_addr addr16, unsigned char ep); + int zbl_reset_all_alarm_log(nwk_addr addr16, unsigned char ep); + int zbl_ccontrol_move_to_hue(nwk_addr addr16, unsigned char ep, unsigned char hue, + unsigned char direction, unsigned short transition_time); + int zbl_ccontrol_move_hue(nwk_addr addr16, unsigned char ep, unsigned char move_mode, + unsigned char rate); + int zbl_ccontrol_step_hue(nwk_addr addr16, unsigned char ep, unsigned char step_mode, + unsigned char step_size, unsigned char transition_time); + int zbl_ccontrol_move_to_saturation(nwk_addr addr16, unsigned char ep, unsigned char saturation, + unsigned short transition_time); + int zbl_ccontrol_move_saturation(nwk_addr addr16, unsigned char ep, unsigned char move_mode, + unsigned char rate); + int zbl_ccontrol_step_saturation(nwk_addr addr16, unsigned char ep, + unsigned char step_mode, unsigned char step_size, unsigned char transition_time); + int zbl_ccontrol_move_to_hue_and_saturation(nwk_addr addr16, unsigned char ep, + unsigned char hue, unsigned char saturation, + unsigned short transition_time); + int zbl_ccontrol_move_to_color(nwk_addr addr16, unsigned char ep, + unsigned short color_x, unsigned short color_y, + unsigned short transition_time); + int zbl_ccontrol_move_color(nwk_addr addr16, unsigned char ep, unsigned short rate_x, + unsigned short rate_y); + int zbl_ccontrol_step_color(nwk_addr addr16, unsigned char ep, unsigned short step_x, + unsigned short step_y, unsigned short transition_time); + int zbl_ccontrol_move_to_color_temperature(nwk_addr addr16, unsigned char ep, + unsigned short color_temperature, unsigned short transition_time); + int zbl_reset_factory_default(nwk_addr addr16, unsigned char ep); + int zbl_identify(nwk_addr addr16, unsigned char dst_ep, unsigned short identify_time); + int zbl_identify_query(nwk_addr addr16, unsigned char dst_ep); + int zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, + const char *group_name); + int zbl_view_group(nwk_addr addr16, unsigned char ep, unsigned short group_id); + int zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep, + unsigned char group_count, unsigned short *group_list); + int zbl_remove_group(nwk_addr addr16, unsigned char ep, unsigned short group_id); + int zbl_remove_all_group(nwk_addr addr16, unsigned char ep); + int zbl_add_group_if_identifying(nwk_addr addr16, unsigned char ep, + unsigned short group_id, const char *group_name); + int zbl_level_control_move_to_level(nwk_addr addr16, unsigned char ep, + unsigned char level, unsigned short transition_time); + int zbl_level_control_move(nwk_addr addr16, unsigned char ep, + unsigned char move_mode, unsigned char rate); + int zbl_level_control_step(nwk_addr addr16, unsigned char ep, + unsigned char step_mode, unsigned char step_size, + unsigned short transition_time); + int zbl_level_control_stop(nwk_addr addr16, unsigned char ep); + int zbl_level_control_move_to_level_with_on_off(nwk_addr addr16, + unsigned char ep, unsigned char level, unsigned short transition_time); + int zbl_level_control_move_with_on_off(nwk_addr addr16, unsigned char ep, + unsigned char move_mode, unsigned char rate); + int zbl_level_control_step_with_on_off(nwk_addr addr16, unsigned char ep, + unsigned char step_mode, unsigned char step_size, + unsigned short transition_time); + int zbl_onoff_set(nwk_addr addr16, unsigned char ep, unsigned char on_off_type); + int zbl_zone_enroll_response(nwk_addr addr16, unsigned char dst_ep, + unsigned char enroll_response_code, unsigned char zone_id); + int zbl_pollcontrol_check_in_response(nwk_addr addr16, unsigned char ep, + unsigned char start_fast_polling, unsigned short fast_poll_timeout); + int zbl_pollcontrol_fast_poll_stop(nwk_addr addr16, unsigned char ep); + int zbl_pollcontrol_set_long_poll_interval(nwk_addr addr16, unsigned char ep, + unsigned int new_long_poll_interval); + int zbl_pollcontrol_set_short_poll_interval(nwk_addr addr16, unsigned char ep, + unsigned int new_short_poll_interval); + int zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id, + unsigned short transition_time, const char *scene_name, unsigned short ext_field_len, + const char *extension_field_sets); + int zbl_view_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id); + int zbl_remove_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id); + int zbl_remove_all_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id); + int zbl_store_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id); + int zbl_recall_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id); + int zbl_get_scene_membership(nwk_addr addr16, unsigned char ep, unsigned short group_id); + int zbl_thermostat_adjust_setpoint(nwk_addr addr16, unsigned char ep, unsigned char mode, unsigned char amount); +}; +#endif /* __ZIGBEE_MANAGER_H__ */ diff --git a/zigbee-daemon/src/main.c b/zigbee-daemon/src/main.c index 78639c3..14439d3 100644 --- a/zigbee-daemon/src/main.c +++ b/zigbee-daemon/src/main.c @@ -34,6 +34,10 @@ /**< ZigBee Service */ ZigBeeService *zigbee_service; +#if (BUILD_GCOV != 0) +extern void __gcov_flush(void); +#endif + static gboolean _request_terminate(gpointer user_data) { NOTUSED(user_data); @@ -58,6 +62,10 @@ int main(int arg, char **argv) NOTUSED(arg); NOTUSED(argv); +#if (BUILD_GCOV != 0) + setenv("GCOV_PREFIX", "/tmp/", 1); +#endif + /* Create ZigBee service */ zigbee_service = service = zblib_service_new(); @@ -95,5 +103,9 @@ END: zblib_service_free(service); zigbee_service = NULL; +#if (BUILD_GCOV != 0) + __gcov_flush(); +#endif + return ret_code; } -- 2.7.4