--- /dev/null
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#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;
+}
--- /dev/null
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#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();
+}
--- /dev/null
+/*
+ * 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 <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <glib.h>
+#include <gio/gio.h>
+
+#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;
+}
projects / platform / core / connectivity / zigbee-manager.git / commitdiff