+/*
+ * 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;
+}