unittest/zbl.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include <errno.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <glib.h>
  20 #include <gio/gio.h>
  21
  22 #include "zbl.h"
  23
  24 Zigbee::Zigbee(void)
  25 {
  26         Create();
  27 }
  28
  29 Zigbee::~Zigbee(void)
  30 {
  31         Destroy();
  32 }
  33
  34 int Zigbee::zbl_enable(void)
  35 {
  36         int error = ZIGBEE_ERROR_NONE;
  37         GVariant *message;
  38
  39         GLOGD("zbl_enable()");
  40
  41         message = InvokeMethod(ZIGBEE_MANAGER_INTERFACE,
  42                         ZIGBEE_DBUS_OBJPATH,
  43                         ZIGBEE_MANAGER_INTERFACE,
  44                         "enable", NULL, &error);
  45
  46         if (message)
  47                 g_variant_unref(message);
  48
  49         return error;
  50 }
  51
  52 int Zigbee::zbl_disable(void)
  53 {
  54         int error = ZIGBEE_ERROR_NONE;
  55         GVariant *message = NULL;
  56
  57         GLOGD("zbl_disable()");
  58
  59         message = InvokeMethod(ZIGBEE_MANAGER_INTERFACE,
  60                         ZIGBEE_DBUS_OBJPATH,
  61                         ZIGBEE_MANAGER_INTERFACE,
  62                         "disable", NULL, &error);
  63
  64         if (message) {
  65                 g_variant_get(message, "(i)", &error);
  66                 GLOGD("ret = 0x%x", error);
  67                 g_variant_unref(message);
  68         }
  69
  70         return error;
  71 }
  72
  73 int Zigbee::zbl_is_enable(bool* state)
  74 {
  75         int error = ZIGBEE_ERROR_NONE;
  76         GVariant *message = NULL;
  77
  78         GLOGD("zbl_is_enable()");
  79
  80         message = InvokeMethod(ZIGBEE_MANAGER_INTERFACE,
  81                         ZIGBEE_DBUS_OBJPATH,
  82                         ZIGBEE_MANAGER_INTERFACE,
  83                         "get_zigbee_state", NULL, &error);
  84
  85         if (message) {
  86                 g_variant_get(message, "(ib)", &error, state);
  87                 GLOGD("enable = %s", state ? "TRUE" : "FALSE");
  88                 g_variant_unref(message);
  89         }
  90
  91         return error;
  92 }
  93
  94 int Zigbee::zbl_hw_reset(void)
  95 {
  96         int error = ZIGBEE_ERROR_NONE;
  97         GVariant *message = NULL;
  98
  99         GLOGD("zbl_hw_reset()");
 100
 101         message = invoke_proxy_method(SERVICE_GPROXY, "zb_hw_reset",
 102                         NULL,
 103                         &error);
 104
 105         if (message) {
 106                 g_variant_get(message, "(i)", &error);
 107                 GLOGD("ret = [0x%x]", error);
 108                 g_variant_unref(message);
 109         }
 110
 111         return error;
 112 }
 113
 114 int Zigbee::zbl_get_network_info(void)
 115 {
 116         GVariant *message = NULL;
 117         GVariantIter *iter = NULL;
 118         int error = ZIGBEE_ERROR_NONE;
 119
 120         nwk_addr _nodeid;
 121         nwk_addr _panid;
 122         unsigned char _radio_channel;
 123         unsigned char _radio_tx_power;
 124
 125         GLOGD("zbl_get_network_info()");
 126
 127         message = invoke_proxy_method(SERVICE_GPROXY, "get_network_info",
 128                         NULL,
 129                         &error);
 130
 131         if (message) {
 132                 g_variant_get(message, "(ia(y)qqyy)", &error, &iter,
 133                                 &_nodeid, &_panid, &_radio_channel, &_radio_tx_power);
 134                 GLOGD("ret = [0x%x]", error);
 135                 g_variant_iter_free(iter);
 136                 g_variant_unref(message);
 137         }
 138
 139         return error;
 140 }
 141
 142 int Zigbee::zbl_get_controller_mac_address(ieee_addr mac)
 143 {
 144         GVariant *message = NULL;
 145         GVariantIter *iter = NULL;
 146         int error = ZIGBEE_ERROR_NONE;
 147         int j = 0;
 148         char value;
 149
 150         GLOGD("zbl_get_controller_mac_address()");
 151
 152         message = invoke_proxy_method(SERVICE_GPROXY, "get_mac",
 153                         NULL,
 154                         &error);
 155
 156         if (message) {
 157                 g_variant_get(message, "(ia(y))", &error, &iter);
 158                 GLOGD("ret = [0x%x]", error);
 159
 160                 while (g_variant_iter_loop(iter, "(y)", &value))
 161                         mac[j++] = value;
 162
 163                 g_variant_iter_free(iter);
 164                 g_variant_unref(message);
 165         }
 166
 167         return error;
 168 }
 169
 170 int Zigbee::zbl_get_cluster_list(ieee_addr eui64, unsigned char endpoint,
 171                 unsigned char *in_cluster_count, unsigned short in_cluster_list[],
 172                 unsigned char *out_cluster_count, unsigned short out_cluster_list[])
 173 {
 174         GVariant *message = NULL;
 175         GVariantBuilder *mac_builder = NULL;
 176         GVariant *mac_variant = NULL;
 177         GVariantIter *in_cluster_iter = NULL;
 178         GVariantIter *out_cluster_iter = NULL;
 179         int error = ZIGBEE_ERROR_NONE;
 180
 181         unsigned short cluster = 0;
 182         int i = 0;
 183
 184         GLOGD("zbl_get_cluster_list()");
 185
 186         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 187         g_variant_builder_add(mac_builder, "(y)", eui64[7]);
 188         g_variant_builder_add(mac_builder, "(y)", eui64[6]);
 189         g_variant_builder_add(mac_builder, "(y)", eui64[5]);
 190         g_variant_builder_add(mac_builder, "(y)", eui64[4]);
 191         g_variant_builder_add(mac_builder, "(y)", eui64[3]);
 192         g_variant_builder_add(mac_builder, "(y)", eui64[2]);
 193         g_variant_builder_add(mac_builder, "(y)", eui64[1]);
 194         g_variant_builder_add(mac_builder, "(y)", eui64[0]);
 195         mac_variant = g_variant_builder_end(mac_builder);
 196         g_variant_builder_unref(mac_builder);
 197
 198         message = invoke_proxy_method(SERVICE_GPROXY, "get_cluster_list",
 199                         g_variant_new("(@a(y)y)", mac_variant, endpoint),
 200                         &error);
 201
 202         if (message) {
 203                 g_variant_get(message, "(iaqaq)", &error, &in_cluster_iter, &out_cluster_iter);
 204                 GLOGD("ret = [0x%x]", error);
 205
 206                 /* In clusters */
 207                 while (g_variant_iter_loop(in_cluster_iter, "q", &cluster))
 208                         in_cluster_list[i++] = cluster;
 209
 210                 *in_cluster_count = i;
 211                 g_variant_iter_free(in_cluster_iter);
 212                 i = 0;
 213
 214                 /* Out clusters */
 215                 while (g_variant_iter_loop(out_cluster_iter, "q", &cluster))
 216                         out_cluster_list[i++] = cluster;
 217
 218                 *out_cluster_count = i;
 219                 g_variant_iter_free(out_cluster_iter);
 220                 g_variant_unref(message);
 221         }
 222
 223         return error;
 224 }
 225
 226 int Zigbee::zbl_get_endpoint_list(ieee_addr eui64, unsigned char *count,
 227                 unsigned char list[])
 228 {
 229         GVariant *message = NULL;
 230         GVariantBuilder *mac_builder = NULL;
 231         GVariant *mac_variant = NULL;
 232         GVariantIter *iter = NULL;
 233         int error = ZIGBEE_ERROR_NONE;
 234
 235         unsigned char endpoint;
 236         int i = 0;
 237
 238         GLOGD("zbl_get_endpoint_list()");
 239
 240         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 241         g_variant_builder_add(mac_builder, "(y)", eui64[7]);
 242         g_variant_builder_add(mac_builder, "(y)", eui64[6]);
 243         g_variant_builder_add(mac_builder, "(y)", eui64[5]);
 244         g_variant_builder_add(mac_builder, "(y)", eui64[4]);
 245         g_variant_builder_add(mac_builder, "(y)", eui64[3]);
 246         g_variant_builder_add(mac_builder, "(y)", eui64[2]);
 247         g_variant_builder_add(mac_builder, "(y)", eui64[1]);
 248         g_variant_builder_add(mac_builder, "(y)", eui64[0]);
 249         mac_variant = g_variant_builder_end(mac_builder);
 250         g_variant_builder_unref(mac_builder);
 251
 252         message = invoke_proxy_method(SERVICE_GPROXY, "get_endpoint_list",
 253                         g_variant_new("(@a(y))", mac_variant),
 254                         &error);
 255
 256         if (message) {
 257                 g_variant_get(message, "(ia(y))", &error, &iter);
 258                 GLOGD("ret = [0x%x]", error);
 259
 260                 while (g_variant_iter_loop(iter, "(y)", &endpoint))
 261                         list[i++] = endpoint;
 262
 263                 *count = i;
 264                 g_variant_iter_free(iter);
 265                 g_variant_unref(message);
 266         }
 267
 268         return error;
 269 }
 270
 271 int Zigbee::zbl_api_get_node_type(ieee_addr eui64)
 272 {
 273         GVariant *message = NULL;
 274         GVariantBuilder *mac_builder = NULL;
 275         GVariant *mac_variant = NULL;
 276         int error = ZIGBEE_ERROR_NONE;
 277         unsigned char node_type;
 278
 279         GLOGD("zbl_api_get_node_type()");
 280
 281         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 282         g_variant_builder_add(mac_builder, "(y)", eui64[7]);
 283         g_variant_builder_add(mac_builder, "(y)", eui64[6]);
 284         g_variant_builder_add(mac_builder, "(y)", eui64[5]);
 285         g_variant_builder_add(mac_builder, "(y)", eui64[4]);
 286         g_variant_builder_add(mac_builder, "(y)", eui64[3]);
 287         g_variant_builder_add(mac_builder, "(y)", eui64[2]);
 288         g_variant_builder_add(mac_builder, "(y)", eui64[1]);
 289         g_variant_builder_add(mac_builder, "(y)", eui64[0]);
 290         mac_variant = g_variant_builder_end(mac_builder);
 291         g_variant_builder_unref(mac_builder);
 292
 293         message = invoke_proxy_method(SERVICE_GPROXY, "get_node_type",
 294                         g_variant_new("(@a(y))", mac_variant),
 295                         &error);
 296
 297         if (message) {
 298                 g_variant_get(message, "(iy)", &error, &node_type);
 299                 GLOGD("ret = [0x%x]", error);
 300                 g_variant_unref(message);
 301         }
 302
 303         return error;
 304 }
 305
 306 int Zigbee::zbl_get_all_device_info(void)
 307 {
 308         GVariant *message = NULL;
 309         GVariantIter *iter = NULL;
 310         int error = ZIGBEE_ERROR_NONE;
 311
 312         GLOGD("zbl_get_all_device_info()");
 313
 314         message = invoke_proxy_method(SERVICE_GPROXY, "get_device_info", NULL, &error);
 315
 316         if (message) {
 317                 g_variant_get(message, "(ia(qyayyay))", &error, &iter);
 318                 GLOGD("ret = [0x%x]", error);
 319                 g_variant_iter_free(iter);
 320                 g_variant_unref(message);
 321         }
 322
 323         return error;
 324 }
 325
 326 int Zigbee::zbl_coex_start(unsigned char channel)
 327 {
 328         int error = ZIGBEE_ERROR_NONE;
 329         GVariant *message = NULL;
 330
 331         GLOGD("zbl_coex_start()");
 332
 333         message = invoke_proxy_method(SERVICE_GPROXY, "coex_start", g_variant_new("(y)", channel),
 334                         &error);
 335
 336         if (message) {
 337                 g_variant_get(message, "(i)", &error);
 338                 GLOGD("ret = [0x%x]", error);
 339                 g_variant_unref(message);
 340         }
 341
 342         return error;
 343 }
 344
 345 int Zigbee::zbl_coex_stop(void)
 346 {
 347         int error = ZIGBEE_ERROR_NONE;
 348         GVariant *message = NULL;
 349
 350         GLOGD("zbl_coex_stop()");
 351
 352         message = invoke_proxy_method(SERVICE_GPROXY, "coex_stop", NULL, &error);
 353
 354         if (message) {
 355                 g_variant_get(message, "(i)", &error);
 356                 GLOGD("ret = [0x%x]", error);
 357                 g_variant_unref(message);
 358         }
 359
 360         return error;
 361 }
 362
 363 int Zigbee::zbl_form_network(void)
 364 {
 365         int error = ZIGBEE_ERROR_NONE;
 366         GVariant *message = NULL;
 367
 368         GLOGD("zbl_form_network()");
 369
 370         message = invoke_proxy_method(SERVICE_GPROXY, "form_network", NULL, &error);
 371
 372         if (message) {
 373                 g_variant_get(message, "(i)", &error);
 374                 GLOGD("ret = [0x%x]", error);
 375                 g_variant_unref(message);
 376         }
 377
 378         return error;
 379 }
 380
 381 int Zigbee::zbl_disable_network(void)
 382 {
 383         int error = ZIGBEE_ERROR_NONE;
 384         GVariant *message = NULL;
 385
 386         GLOGD("zbl_disable_network()");
 387
 388         message = invoke_proxy_method(SERVICE_GPROXY, "leave_network", NULL, &error);
 389
 390         if (message) {
 391                 g_variant_get(message, "(i)", &error);
 392                 GLOGD("ret = [0x%x]", error);
 393                 g_variant_unref(message);
 394         }
 395
 396         return error;
 397 }
 398
 399 int Zigbee::zbl_leave_device(ieee_addr addr64, bool remove_children, bool rejoin)
 400 {
 401         int error = ZIGBEE_ERROR_NONE;
 402         GVariant *message = NULL;
 403
 404         GVariantBuilder *mac_builder = NULL;
 405         GVariant* mac_variant = NULL;
 406         unsigned char _remove_children = (remove_children) ? 1 : 0;
 407         unsigned char _rejoin = (rejoin) ? 1 : 0;
 408
 409         GLOGD("zbl_leave_device()");
 410
 411         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 412         g_variant_builder_add(mac_builder, "(y)", addr64[7]);
 413         g_variant_builder_add(mac_builder, "(y)", addr64[6]);
 414         g_variant_builder_add(mac_builder, "(y)", addr64[5]);
 415         g_variant_builder_add(mac_builder, "(y)", addr64[4]);
 416         g_variant_builder_add(mac_builder, "(y)", addr64[3]);
 417         g_variant_builder_add(mac_builder, "(y)", addr64[2]);
 418         g_variant_builder_add(mac_builder, "(y)", addr64[1]);
 419         g_variant_builder_add(mac_builder, "(y)", addr64[0]);
 420         mac_variant = g_variant_builder_end(mac_builder);
 421         g_variant_builder_unref(mac_builder);
 422
 423         message = invoke_proxy_method(SERVICE_GPROXY, "leave_request",
 424                         g_variant_new("(@a(y)yy)", mac_variant, _remove_children, _rejoin),
 425                         &error);
 426
 427         if (message) {
 428                 g_variant_get(message, "(i)", &error);
 429                 GLOGD("ret = [0x%x]", error);
 430                 g_variant_unref(message);
 431         }
 432
 433         return error;
 434 }
 435
 436 int Zigbee::zbl_permit_join(unsigned char duration, bool broadcast)
 437 {
 438         int error = ZIGBEE_ERROR_NONE;
 439         GVariant *message = NULL;
 440
 441         GLOGD("zbl_permit_join()");
 442
 443         message = invoke_proxy_method(SERVICE_GPROXY, "permit_join",
 444                         g_variant_new("(ib)", duration, broadcast),
 445                         &error);
 446
 447         if (message) {
 448                 g_variant_get(message, "(i)", &error);
 449                 GLOGD("ret = [0x%x]", error);
 450                 g_variant_unref(message);
 451         }
 452
 453         return error;
 454 }
 455
 456 int Zigbee::zbl_nwk_addr_req(ieee_addr addr64, unsigned char request_type,
 457                 unsigned char start_idx)
 458 {
 459         GVariantBuilder *mac_builder = NULL;
 460         GVariant* mac_variant = NULL;
 461
 462         int error = ZIGBEE_ERROR_NONE;
 463         GVariant *message = NULL;
 464
 465         GLOGD(" zbl_nwk_addr_req()");
 466
 467         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 468         g_variant_builder_add(mac_builder, "(y)", addr64[7]);
 469         g_variant_builder_add(mac_builder, "(y)", addr64[6]);
 470         g_variant_builder_add(mac_builder, "(y)", addr64[5]);
 471         g_variant_builder_add(mac_builder, "(y)", addr64[4]);
 472         g_variant_builder_add(mac_builder, "(y)", addr64[3]);
 473         g_variant_builder_add(mac_builder, "(y)", addr64[2]);
 474         g_variant_builder_add(mac_builder, "(y)", addr64[1]);
 475         g_variant_builder_add(mac_builder, "(y)", addr64[0]);
 476         mac_variant = g_variant_builder_end(mac_builder);
 477         g_variant_builder_unref(mac_builder);
 478
 479         message = invoke_proxy_method(ZDO_DEV_PROXY, "nwk_addr_req",
 480                         g_variant_new("(@a(y)yy)", mac_variant, request_type, start_idx),
 481                         &error);
 482
 483         if (message) {
 484                 g_variant_get(message, "(i)", &error);
 485                 GLOGD("ret = [0x%x]", error);
 486                 g_variant_unref(message);
 487         }
 488
 489         return error;
 490 }
 491
 492 int Zigbee::zbl_ieee_addr_req(nwk_addr addr16)
 493 {
 494         int error = ZIGBEE_ERROR_NONE;
 495         GVariant *message = NULL;
 496
 497         GLOGD("zbl_ieee_addr_req()");
 498
 499         message = invoke_proxy_method(ZDO_DEV_PROXY, "ieee_addr_req",
 500                         g_variant_new("(q)", addr16), &error);
 501
 502         if (message) {
 503                 g_variant_get(message, "(i)", &error);
 504                 GLOGD("ret = [0x%x]", error);
 505                 g_variant_unref(message);
 506         }
 507
 508         return error;
 509 }
 510
 511 int Zigbee::zbl_active_ep(nwk_addr addr16)
 512 {
 513         int error = ZIGBEE_ERROR_NONE;
 514         GVariant *message = NULL;
 515
 516         GLOGD("zbl_active_ep()");
 517
 518         message = invoke_proxy_method(ZDO_DEV_PROXY, "active_ep_req",
 519                         g_variant_new("(q)", addr16), &error);
 520
 521         if (message) {
 522                 g_variant_get(message, "(i)", &error);
 523                 GLOGD("ret = [0x%x]", error);
 524                 g_variant_unref(message);
 525         }
 526
 527         return error;
 528 }
 529
 530 int Zigbee::zbl_simple_desc_req(nwk_addr addr16, unsigned char ep)
 531 {
 532         int error = ZIGBEE_ERROR_NONE;
 533         GVariant *message = NULL;
 534
 535         GLOGD("zbl_simple_desc_req() : [%X]", addr16);
 536
 537         message = invoke_proxy_method(ZDO_DEV_PROXY, "simple_desc_req",
 538                         g_variant_new("(qy)", addr16, ep), &error);
 539
 540         if (message) {
 541                 g_variant_get(message, "(i)", &error);
 542                 GLOGD("ret = [0x%x]", error);
 543                 g_variant_unref(message);
 544         }
 545
 546         return error;
 547 }
 548
 549 int Zigbee::zbl_match_desc_req(nwk_addr addr16,
 550                 unsigned short profile_id, unsigned char num_in_clusters,
 551                 unsigned short *in_clusters, unsigned char num_out_clusters,
 552                 unsigned short *out_clusters)
 553 {
 554         int error = ZIGBEE_ERROR_NONE;
 555         GVariant *message = NULL;
 556
 557         int i;
 558         GVariantBuilder *incl_builder = NULL;
 559         GVariant* incl_variant = NULL;
 560         GVariantBuilder *outcl_builder = NULL;
 561         GVariant* outcl_variant = NULL;
 562
 563         GLOGD("zbl_match_desc_req()");
 564
 565         incl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
 566         for (i = 0; i < num_in_clusters; i++)
 567                 g_variant_builder_add(incl_builder, "q", in_clusters[i]);
 568
 569         outcl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
 570         for (i = 0; i < num_out_clusters; i++)
 571                 g_variant_builder_add(outcl_builder, "q", out_clusters[i]);
 572
 573         incl_variant = g_variant_builder_end(incl_builder);
 574         outcl_variant = g_variant_builder_end(outcl_builder);
 575         g_variant_builder_unref(incl_builder);
 576         g_variant_builder_unref(outcl_builder);
 577
 578         message = invoke_proxy_method(ZDO_DEV_PROXY, "matched_descriptor_req",
 579                         g_variant_new("(qqy@aqy@aq)", addr16, profile_id, num_in_clusters,
 580                                 incl_variant, num_out_clusters, outcl_variant),
 581                         &error);
 582
 583         if (message) {
 584                 g_variant_get(message, "(i)", &error);
 585                 GLOGD("ret = [0x%x]", error);
 586                 g_variant_unref(message);
 587         }
 588
 589         return error;
 590 }
 591
 592 int Zigbee::zbl_node_desc_req(nwk_addr addr16)
 593 {
 594         int error = ZIGBEE_ERROR_NONE;
 595         GVariant *message = NULL;
 596
 597         GLOGD("zbl_node_desc_req()");
 598
 599         message = invoke_proxy_method(ZDO_DEV_PROXY, "node_desc_req",
 600                         g_variant_new("(q)", addr16),
 601                         &error);
 602
 603         if (message) {
 604                 g_variant_get(message, "(i)", &error);
 605                 GLOGD("ret = [0x%x]", error);
 606                 g_variant_unref(message);
 607         }
 608
 609         return error;
 610 }
 611
 612 int Zigbee::zbl_power_desc_req(nwk_addr addr16)
 613 {
 614         int error = ZIGBEE_ERROR_NONE;
 615         GVariant *message = NULL;
 616
 617         GLOGD("zbl_power_desc_req()");
 618
 619         message = invoke_proxy_method(ZDO_DEV_PROXY, "power_desc_req",
 620                         g_variant_new("(q)", addr16),
 621                         &error);
 622
 623         if (message) {
 624                 g_variant_get(message, "(i)", &error);
 625                 GLOGD("ret = [0x%x]", error);
 626                 g_variant_unref(message);
 627         }
 628
 629         return error;
 630 }
 631
 632 int Zigbee::zbl_complex_desc_req(nwk_addr addr16)
 633 {
 634         int error = ZIGBEE_ERROR_NONE;
 635         GVariant *message = NULL;
 636
 637         GLOGD("zbl_complex_desc_req()");
 638
 639         message = invoke_proxy_method(ZDO_DEV_PROXY, "complex_desc_req",
 640                         g_variant_new("(q)", addr16),
 641                         &error);
 642
 643         if (message) {
 644                 g_variant_get(message, "(i)", &error);
 645                 GLOGD("ret = [0x%x]", error);
 646                 g_variant_unref(message);
 647         }
 648
 649         return error;
 650 }
 651
 652 int Zigbee::zbl_user_desc_req(nwk_addr addr16)
 653 {
 654         int error = ZIGBEE_ERROR_NONE;
 655         GVariant *message = NULL;
 656
 657         GLOGD("zbl_user_desc_req()");
 658
 659         message = invoke_proxy_method(ZDO_DEV_PROXY, "user_desc_req",
 660                         g_variant_new("(q)", addr16),
 661                         &error);
 662
 663         if (message) {
 664                 g_variant_get(message, "(i)", &error);
 665                 GLOGD("ret = [0x%x]", error);
 666                 g_variant_unref(message);
 667         }
 668
 669         return error;
 670 }
 671
 672 int Zigbee::zbl_user_desc_set(nwk_addr addr16, unsigned char len,
 673                 unsigned char *user_desc)
 674 {
 675         int error = ZIGBEE_ERROR_NONE;
 676         GVariant *message = NULL;
 677
 678         unsigned char j = 0x00;
 679         GVariantBuilder *user_desc_builder = NULL;
 680         GVariant *user_desc_variant = NULL;
 681
 682         GLOGD("zbl_user_desc_set()");
 683
 684         user_desc_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 685         for (j = 0; j < len; j++)
 686                 g_variant_builder_add(user_desc_builder, "(y)", user_desc[j]);
 687
 688         user_desc_variant = g_variant_builder_end(user_desc_builder);
 689         g_variant_builder_unref(user_desc_builder);
 690
 691         message = invoke_proxy_method(ZDO_DEV_PROXY, "user_desc_set_req",
 692                         g_variant_new("(qy@a(y))", addr16, len, user_desc_variant),
 693                         &error);
 694
 695         if (message) {
 696                 g_variant_get(message, "(i)", &error);
 697                 GLOGD("ret = [0x%x]", error);
 698                 g_variant_unref(message);
 699         }
 700
 701         return error;
 702 }
 703
 704 int Zigbee::zbl_device_annce(nwk_addr addr16, ieee_addr addr64,
 705                 unsigned char capability)
 706 {
 707         int error = ZIGBEE_ERROR_NONE;
 708         GVariant *message = NULL;
 709
 710         GVariantBuilder *mac_builder = NULL;
 711         GVariant* mac_variant = NULL;
 712
 713         GLOGD("zbl_device_annce()");
 714
 715         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 716         g_variant_builder_add(mac_builder, "(y)", addr64[7]);
 717         g_variant_builder_add(mac_builder, "(y)", addr64[6]);
 718         g_variant_builder_add(mac_builder, "(y)", addr64[5]);
 719         g_variant_builder_add(mac_builder, "(y)", addr64[4]);
 720         g_variant_builder_add(mac_builder, "(y)", addr64[3]);
 721         g_variant_builder_add(mac_builder, "(y)", addr64[2]);
 722         g_variant_builder_add(mac_builder, "(y)", addr64[1]);
 723         g_variant_builder_add(mac_builder, "(y)", addr64[0]);
 724         mac_variant = g_variant_builder_end(mac_builder);
 725         g_variant_builder_unref(mac_builder);
 726
 727         message = invoke_proxy_method(ZDO_DEV_PROXY, "device_announce",
 728                         g_variant_new("(q@a(y)y)", addr16, mac_variant, capability),
 729                         &error);
 730
 731         if (message) {
 732                 g_variant_get(message, "(i)", &error);
 733                 GLOGD("ret = [0x%x]", error);
 734                 g_variant_unref(message);
 735         }
 736
 737         return error;
 738 }
 739
 740 int Zigbee::zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64,
 741                 unsigned char src_ep, unsigned short cluster_id, ieee_addr dst_addr64,
 742                 unsigned char type, nwk_addr group_addr, unsigned char dst_ep)
 743 {
 744         int error = ZIGBEE_ERROR_NONE;
 745         GVariant *message = NULL;
 746
 747         int i;
 748         GVariantBuilder *src_addr64_builder = NULL;
 749         GVariant* src_addr64_variant = NULL;
 750         GVariantBuilder *dst_addr64_builder = NULL;
 751         GVariant* dst_addr64_variant = NULL;
 752
 753         GLOGD("zbl_bind_req()");
 754
 755         src_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 756
 757         if (src_addr64) {
 758                 for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--)
 759                         g_variant_builder_add(src_addr64_builder, "(y)", src_addr64[i]);
 760         }
 761         src_addr64_variant = g_variant_builder_end(src_addr64_builder);
 762         g_variant_builder_unref(src_addr64_builder);
 763
 764         dst_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 765         if (dst_addr64) {
 766                 for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--)
 767                         g_variant_builder_add(dst_addr64_builder, "(y)", dst_addr64[i]);
 768         }
 769         dst_addr64_variant = g_variant_builder_end(dst_addr64_builder);
 770         g_variant_builder_unref(dst_addr64_builder);
 771
 772         message = invoke_proxy_method(ZDO_BIND_PROXY, "bind_req",
 773                         g_variant_new("(q@a(y)yq@a(y)yqy)", dst_addr16, src_addr64_variant, src_ep,
 774                                 cluster_id, dst_addr64_variant, type, group_addr, dst_ep),
 775                         &error);
 776
 777         if (message) {
 778                 g_variant_get(message, "(i)", &error);
 779                 GLOGD("ret = [0x%x]", error);
 780                 g_variant_unref(message);
 781         }
 782
 783         return error;
 784 }
 785
 786 int Zigbee::zbl_unbind_req(nwk_addr dst_addr16,
 787                 ieee_addr src_addr64, unsigned char src_ep, unsigned short cluster_id,
 788                 ieee_addr dst_addr64, unsigned char type, nwk_addr group_addr,
 789                 unsigned char dst_ep)
 790 {
 791         int i;
 792         int error = ZIGBEE_ERROR_NONE;
 793         GVariant *message = NULL;
 794
 795         GVariantBuilder *src_addr64_builder = NULL;
 796         GVariant* src_addr64_variant = NULL;
 797         GVariantBuilder *dst_addr64_builder = NULL;
 798         GVariant* dst_addr64_variant = NULL;
 799
 800         GLOGD("zbl_zdo_unbind_req()");
 801
 802         src_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 803         if (src_addr64) {
 804                 for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--)
 805                         g_variant_builder_add(src_addr64_builder, "(y)", src_addr64[i]);
 806         }
 807
 808         src_addr64_variant = g_variant_builder_end(src_addr64_builder);
 809         g_variant_builder_unref(src_addr64_builder);
 810
 811         dst_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 812         if (dst_addr64) {
 813                 for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--)
 814                         g_variant_builder_add(dst_addr64_builder, "(y)", dst_addr64[i]);
 815         }
 816
 817         dst_addr64_variant = g_variant_builder_end(dst_addr64_builder);
 818         g_variant_builder_unref(dst_addr64_builder);
 819
 820         message = invoke_proxy_method(ZDO_BIND_PROXY, "unbind_req",
 821                         g_variant_new("(q@a(y)yq@a(y)yqy)",
 822                                 dst_addr16, src_addr64_variant, src_ep,
 823                                 cluster_id, dst_addr64_variant, type, group_addr, dst_ep),
 824                         &error);
 825
 826         if (message) {
 827                 g_variant_get(message, "(i)", &error);
 828                 GLOGD("ret = [0x%x]", error);
 829                 g_variant_unref(message);
 830         }
 831
 832         return error;
 833 }
 834
 835 int Zigbee::zbl_mgmt_nwk_disc_req(nwk_addr addr16, unsigned int scan_channels,
 836                 unsigned char scan_duration, unsigned char scan_count, unsigned char start_idx)
 837 {
 838         int error = ZIGBEE_ERROR_NONE;
 839         GVariant *message = NULL;
 840
 841         GLOGD("zbl_mgmt_nwk_disc_req()");
 842
 843         message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_nwk_disc_req",
 844                         g_variant_new("(quyqy)",
 845                                 addr16,
 846                                 scan_channels,
 847                                 scan_duration,
 848                                 scan_count,
 849                                 start_idx),
 850                         &error);
 851
 852         if (message) {
 853                 g_variant_get(message, "(i)", &error);
 854                 GLOGD("ret = [0x%x]", error);
 855                 g_variant_unref(message);
 856         }
 857
 858         return error;
 859 }
 860
 861 int Zigbee::zbl_mgmt_nwk_update_req(unsigned int scan_channels, unsigned char scan_duration,
 862                 unsigned char scan_count, unsigned char nwk_update_id, nwk_addr nwk_manager_addr)
 863 {
 864         int error = ZIGBEE_ERROR_NONE;
 865         GVariant *message = NULL;
 866
 867         GLOGD("zbl_mgmt_nwk_update_req()");
 868
 869         message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_nwk_update_req",
 870                         g_variant_new("(quyyy)", nwk_manager_addr,
 871                                 scan_channels, scan_duration,
 872                                 scan_count, nwk_update_id),
 873                         &error);
 874
 875         if (message) {
 876                 g_variant_get(message, "(i)", &error);
 877                 GLOGD("ret = [0x%x]", error);
 878                 g_variant_unref(message);
 879         }
 880
 881         return error;
 882 }
 883
 884 int Zigbee::zbl_mgmt_lqi_req(nwk_addr addr16, unsigned char start_idx)
 885 {
 886         int error = ZIGBEE_ERROR_NONE;
 887         GVariant *message = NULL;
 888
 889         GLOGD("zbl_mgmt_lqi_req()");
 890
 891         message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_lqi_req",
 892                         g_variant_new("(qy)", addr16, start_idx),
 893                         &error);
 894
 895         if (message) {
 896                 g_variant_get(message, "(i)", &error);
 897                 GLOGD("ret = [0x%x]", error);
 898                 g_variant_unref(message);
 899         }
 900
 901         return error;
 902 }
 903
 904 int Zigbee::zbl_mgmt_rtg_req(nwk_addr addr16, unsigned char start_idx)
 905 {
 906         int error = ZIGBEE_ERROR_NONE;
 907         GVariant *message = NULL;
 908
 909         GLOGD("zbl_mgmt_rtg_req()");
 910
 911         message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_rtg_req",
 912                         g_variant_new("(qy)", addr16, start_idx),
 913                         &error);
 914
 915         if (message) {
 916                 g_variant_get(message, "(i)", &error);
 917                 GLOGD("ret = [0x%x]", error);
 918                 g_variant_unref(message);
 919         }
 920
 921         return error;
 922 }
 923
 924 int Zigbee::zbl_mgmt_bind_req(nwk_addr addr16, unsigned char start_idx)
 925 {
 926         int error = ZIGBEE_ERROR_NONE;
 927         GVariant *message = NULL;
 928
 929         GLOGD("zbl_mgmt_bind_req()");
 930
 931         message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_bind_req",
 932                         g_variant_new("(qy)", addr16, start_idx),
 933                         &error);
 934
 935         if (message) {
 936                 g_variant_get(message, "(i)", &error);
 937                 GLOGD("ret = [0x%x]", error);
 938                 g_variant_unref(message);
 939         }
 940
 941         return error;
 942 }
 943
 944 int Zigbee::zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children,
 945                 unsigned rejoin)
 946 {
 947         int error = ZIGBEE_ERROR_NONE;
 948         GVariant *message = NULL;
 949
 950         GVariantBuilder *mac_builder = NULL;
 951         GVariant* mac_variant = NULL;
 952
 953         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 954         g_variant_builder_add(mac_builder, "(y)", addr64[7]);
 955         g_variant_builder_add(mac_builder, "(y)", addr64[6]);
 956         g_variant_builder_add(mac_builder, "(y)", addr64[5]);
 957         g_variant_builder_add(mac_builder, "(y)", addr64[4]);
 958         g_variant_builder_add(mac_builder, "(y)", addr64[3]);
 959         g_variant_builder_add(mac_builder, "(y)", addr64[2]);
 960         g_variant_builder_add(mac_builder, "(y)", addr64[1]);
 961         g_variant_builder_add(mac_builder, "(y)", addr64[0]);
 962         mac_variant = g_variant_builder_end(mac_builder);
 963         g_variant_builder_unref(mac_builder);
 964
 965         GLOGD("zbl_mgmt_leave_device()");
 966
 967         message = invoke_proxy_method(SERVICE_GPROXY, "leave_request",
 968                         g_variant_new("(@a(y)yy)", mac_variant, remove_children, rejoin),
 969                         &error);
 970
 971         if (message) {
 972                 g_variant_get(message, "(i)", &error);
 973                 GLOGD("ret = [0x%x]", error);
 974                 g_variant_unref(message);
 975         }
 976
 977         return error;
 978 }
 979
 980 int Zigbee::zbl_mgmt_permit_joining_req(nwk_addr addr16, unsigned char duration,
 981                 unsigned char tc_significance)
 982 {
 983         int error = ZIGBEE_ERROR_NONE;
 984         GVariant *message = NULL;
 985
 986         GLOGD("zbl_mgmt_permit_joining_req()");
 987
 988         message = invoke_proxy_method(ZDO_DEV_PROXY, "mgmt_permit_join_req",
 989                         g_variant_new("(qyy)", addr16, duration, tc_significance),
 990                         &error);
 991
 992         if (message) {
 993                 g_variant_get(message, "(i)", &error);
 994                 GLOGD("ret = [0x%x]", error);
 995                 g_variant_unref(message);
 996         }
 997
 998         return error;
 999 }
1000
1001 int Zigbee::zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, unsigned char src_ep,
1002                 unsigned char dst_ep, unsigned short cluster_id, unsigned short profile_id,
1003                 unsigned char zcl_frame_ctl, unsigned short mfg_code, unsigned char cmd_id,
1004                 unsigned short payload_len, unsigned char *payload)
1005 {
1006         int i;
1007         int error = ZIGBEE_ERROR_NONE;
1008         GVariant *message = NULL;
1009
1010         GVariantBuilder *payload_builder = NULL;
1011         GVariant *payload_variant = NULL;
1012
1013         payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
1014         if (payload_len > 0) {
1015                 for (i = payload_len - 1; i >= 0 ; i--)
1016                         g_variant_builder_add(payload_builder, "(y)", payload[i]);
1017         }
1018         payload_variant = g_variant_builder_end(payload_builder);
1019         g_variant_builder_unref(payload_builder);
1020
1021         GLOGD("zbl_aps_send()");
1022
1023         message = invoke_proxy_method(CUSTOM_GPROXY, "aps_send",
1024                         g_variant_new("(qyyyqqyqyq@a(y))", addr16,
1025                                 aps_frame_ctl, src_ep, dst_ep, cluster_id,
1026                                 profile_id, zcl_frame_ctl, mfg_code,
1027                                 cmd_id, payload_len, payload_variant),
1028                         &error);
1029
1030         if (message) {
1031                 g_variant_get(message, "(i)", &error);
1032                 GLOGD("ret = [0x%x]", error);
1033                 g_variant_unref(message);
1034         }
1035
1036         return error;
1037 }
1038
1039 int Zigbee::zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
1040                 unsigned short cluster_id, unsigned char zcl_frame_ctl, unsigned char cmd,
1041                 unsigned short payload_len, unsigned char *payload)
1042 {
1043         int i;
1044
1045         int error = ZIGBEE_ERROR_NONE;
1046         GVariant *message = NULL;
1047
1048         GVariantBuilder *payload_builder = NULL;
1049         GVariant *payload_variant = NULL;
1050
1051         GLOGD("zbl_zcl_send()");
1052
1053         payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
1054         if (payload_len > 0) {
1055                 for (i = payload_len - 1; i >= 0 ; i--)
1056                         g_variant_builder_add(payload_builder, "(y)", payload[i]);
1057         }
1058         payload_variant = g_variant_builder_end(payload_builder);
1059         g_variant_builder_unref(payload_builder);
1060
1061         message = invoke_proxy_method(CUSTOM_GPROXY, "zcl_send",
1062                         g_variant_new("(qyyqyyq@a(y))", addr16, src_ep, dst_ep, cluster_id, zcl_frame_ctl,
1063                                 cmd, payload_len, payload_variant), &error);
1064
1065         if (message) {
1066                 g_variant_get(message, "(i)", &error);
1067                 GLOGD("ret = [0x%x]", error);
1068                 g_variant_unref(message);
1069         }
1070
1071         return error;
1072 }
1073
1074 int Zigbee::zbl_send_to_local(unsigned short length, unsigned char *data)
1075 {
1076         int i;
1077
1078         int error = ZIGBEE_ERROR_NONE;
1079         GVariant *message = NULL;
1080
1081         GLOGD("zbl_send_to_local()");
1082
1083         GVariantBuilder *payload_builder = NULL;
1084         GVariant *payload_variant = NULL;
1085
1086         payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
1087         if (length > 0) {
1088                 for (i = length - 1; i >= 0 ; i--)
1089                         g_variant_builder_add(payload_builder, "(y)", data[i]);
1090         }
1091         payload_variant = g_variant_builder_end(payload_builder);
1092         g_variant_builder_unref(payload_builder);
1093
1094         message = invoke_proxy_method(CUSTOM_GPROXY, "send_to_local",
1095                         g_variant_new("(q@a(y))", length, payload_variant),
1096                         &error);
1097
1098         if (message) {
1099                 g_variant_get(message, "(i)", &error);
1100                 GLOGD("ret = [0x%x]", error);
1101                 g_variant_unref(message);
1102         }
1103
1104         return error;
1105 }
1106
1107 int Zigbee::zbl_read_attr_req(unsigned short addr16, unsigned char dest_ep,
1108                 unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned short *attribute_ids,
1109                 int attribute_ids_len)
1110 {
1111         int error = ZIGBEE_ERROR_NONE;
1112         GVariant *message = NULL;
1113
1114         int i = 0;
1115         unsigned char *t;
1116         GVariant *attr_variant = NULL;
1117         GVariantBuilder *attr_builder = NULL;
1118
1119         GLOGD("zbl_read_attr_req()");
1120
1121         t = (unsigned char *)attribute_ids;
1122         attr_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
1123         for (i = 0; i < attribute_ids_len*sizeof(unsigned short); i++)
1124                 g_variant_builder_add(attr_builder, "(y)", t[i]);
1125         attr_variant = g_variant_builder_end(attr_builder);
1126         g_variant_builder_unref(attr_builder);
1127
1128         message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "read_attributes_req",
1129                         g_variant_new("(@a(y)iqqyy)", attr_variant, attribute_ids_len,
1130                                 addr16, cluster_id, zcl_frame_ctl, dest_ep), &error);
1131
1132         if (message) {
1133                 g_variant_get(message, "(i)", &error);
1134                 GLOGD("ret = [0x%x]", error);
1135                 g_variant_unref(message);
1136         }
1137
1138         return error;
1139 }
1140
1141 int Zigbee::zbl_discover_attr_req(unsigned short addr16, unsigned char src_ep,
1142                 unsigned char dest_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id,
1143                 unsigned short start_id, unsigned char max_attribute_ids)
1144 {
1145         int error = ZIGBEE_ERROR_NONE;
1146         GVariant *message = NULL;
1147
1148         GLOGD("zbl_discover_attr_req()");
1149
1150         message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "discover_attributes",
1151                         g_variant_new("(qyyqqy)", addr16, dest_ep, zcl_frame_ctl,
1152                                 cluster_id, start_id, max_attribute_ids),
1153                         &error);
1154
1155         if (message) {
1156                 g_variant_get(message, "(i)", &error);
1157                 GLOGD("ret = [0x%x]", error);
1158                 g_variant_unref(message);
1159         }
1160
1161         return error;
1162 }
1163
1164 int Zigbee::zbl_discover_cmds_gen(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
1165                 unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id,
1166                 unsigned char max_command_ids)
1167 {
1168         int error = ZIGBEE_ERROR_NONE;
1169         GVariant *message = NULL;
1170
1171         GLOGD("zbl_discover_attr_gen()");
1172
1173         message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "discover_commands_generated",
1174                         g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl,
1175                                 cluster_id, start_command_id, max_command_ids),
1176                         &error);
1177
1178         if (message) {
1179                 g_variant_get(message, "(i)", &error);
1180                 GLOGD("ret = [0x%x]", error);
1181                 g_variant_unref(message);
1182         }
1183
1184         return error;
1185 }
1186
1187 int Zigbee::zbl_discover_cmds_recv(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
1188                 unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id,
1189                 unsigned char max_command_ids)
1190 {
1191         int error = ZIGBEE_ERROR_NONE;
1192         GVariant *message = NULL;
1193
1194         GLOGD("zbl_discover_cmds_recv()");
1195
1196         message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "discover_commands_received",
1197                         g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl,
1198                                 cluster_id, start_command_id, max_command_ids),
1199                         &error);
1200
1201         if (message) {
1202                 g_variant_get(message, "(i)", &error);
1203                 GLOGD("ret = [0x%x]", error);
1204                 g_variant_unref(message);
1205         }
1206
1207         return error;
1208 }
1209
1210 int Zigbee::zbl_discover_attr_ext(nwk_addr addr16, unsigned char src_ep,
1211                 unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id,
1212                 unsigned short start_id, unsigned char max_attribute_ids)
1213 {
1214         int error = ZIGBEE_ERROR_NONE;
1215         GVariant *message = NULL;
1216
1217         GLOGD("zbl_discover_attr_ext()");
1218
1219         message = invoke_proxy_method(ZCL_GLOBAL_PROXY, "discover_attributes_extended",
1220                         g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl, cluster_id, start_id,
1221                                 max_attribute_ids),
1222                         &error);
1223
1224         if (message) {
1225                 g_variant_get(message, "(i)", &error);
1226                 GLOGD("ret = [0x%x]", error);
1227                 g_variant_unref(message);
1228         }
1229
1230         return error;
1231 }
1232
1233 int Zigbee::zbl_reset_alarm(nwk_addr addr16, unsigned char ep, unsigned char alarm_code,
1234                 unsigned short cluster_id)
1235 {
1236         int error = ZIGBEE_ERROR_NONE;
1237         GVariant *message = NULL;
1238
1239         GLOGD("zbl_reset_alarm()");
1240
1241         message = invoke_proxy_method(ALARM_GPROXY, "reset_alarm",
1242                         g_variant_new("(qyyq)", addr16, ep, alarm_code, cluster_id),
1243                         &error);
1244
1245         if (message) {
1246                 g_variant_get(message, "(i)", &error);
1247                 GLOGD("ret = [0x%x]", error);
1248                 g_variant_unref(message);
1249         }
1250
1251         return error;
1252 }
1253
1254 int Zigbee::zbl_get_alarm(nwk_addr addr16, unsigned char ep)
1255 {
1256         int error = ZIGBEE_ERROR_NONE;
1257         GVariant *message = NULL;
1258
1259         GLOGD("zbl_get_alarm()");
1260
1261         message = invoke_proxy_method(ALARM_GPROXY, "get_alarm",
1262                         g_variant_new("(qy)", addr16, ep),
1263                         &error);
1264
1265         if (message) {
1266                 g_variant_get(message, "(i)", &error);
1267                 GLOGD("ret = [0x%x]", error);
1268                 g_variant_unref(message);
1269         }
1270
1271         return error;
1272 }
1273
1274 int Zigbee::zbl_reset_all_alarm_log(nwk_addr addr16, unsigned char ep)
1275 {
1276         int error = ZIGBEE_ERROR_NONE;
1277         GVariant *message = NULL;
1278
1279         message = invoke_proxy_method(ALARM_GPROXY, "reset_alarm_log",
1280                         g_variant_new("(qy)", addr16, ep), &error);
1281
1282         if (message) {
1283                 g_variant_get(message, "(i)", &error);
1284                 GLOGD("ret = [0x%x]", error);
1285                 g_variant_unref(message);
1286         }
1287
1288         return error;
1289 }
1290
1291 int Zigbee::zbl_ccontrol_move_to_hue(nwk_addr addr16, unsigned char ep,
1292                 unsigned char hue, unsigned char direction,
1293                 unsigned short transition_time)
1294 {
1295         int error = ZIGBEE_ERROR_NONE;
1296         GVariant *message = NULL;
1297
1298         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_to_hue",
1299                         g_variant_new("(qyyyq)", addr16, ep, hue, direction, transition_time),
1300                         &error);
1301
1302         if (message) {
1303                 g_variant_get(message, "(i)", &error);
1304                 GLOGD("ret = [0x%x]", error);
1305                 g_variant_unref(message);
1306         }
1307
1308         return error;
1309 }
1310
1311 int Zigbee::zbl_ccontrol_move_hue(nwk_addr addr16, unsigned char ep,
1312                 unsigned char move_mode, unsigned char rate)
1313 {
1314         int error = ZIGBEE_ERROR_NONE;
1315         GVariant *message = NULL;
1316
1317         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_hue",
1318                         g_variant_new("(qyyy)", addr16, ep, move_mode, rate),
1319                         &error);
1320
1321         if (message) {
1322                 g_variant_get(message, "(i)", &error);
1323                 GLOGD("ret = [0x%x]", error);
1324                 g_variant_unref(message);
1325         }
1326
1327         return error;
1328 }
1329
1330 int Zigbee::zbl_ccontrol_step_hue(nwk_addr addr16, unsigned char ep,
1331                 unsigned char step_mode, unsigned char step_size,
1332                 unsigned char transition_time)
1333 {
1334         int error = ZIGBEE_ERROR_NONE;
1335         GVariant *message = NULL;
1336
1337         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "step_hue",
1338                         g_variant_new("(qyyyy)", addr16, ep, step_mode, step_size, transition_time),
1339                         &error);
1340
1341         if (message) {
1342                 g_variant_get(message, "(i)", &error);
1343                 GLOGD("ret = [0x%x]", error);
1344                 g_variant_unref(message);
1345         }
1346
1347         return error;
1348 }
1349
1350 int Zigbee::zbl_ccontrol_move_to_saturation(nwk_addr addr16, unsigned char ep,
1351                 unsigned char saturation, unsigned short transition_time)
1352 {
1353         int error = ZIGBEE_ERROR_NONE;
1354         GVariant *message = NULL;
1355
1356         GLOGD("zbl_ccontrol_move_to_saturation()");
1357
1358         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_to_saturation",
1359                         g_variant_new("(qyyq)", addr16, ep, saturation, transition_time),
1360                         &error);
1361
1362         if (message) {
1363                 g_variant_get(message, "(i)", &error);
1364                 GLOGD("ret = [0x%x]", error);
1365                 g_variant_unref(message);
1366         }
1367
1368         return error;
1369 }
1370
1371 int Zigbee::zbl_ccontrol_move_saturation(nwk_addr addr16, unsigned char ep,
1372                 unsigned char move_mode, unsigned char rate)
1373 {
1374         int error = ZIGBEE_ERROR_NONE;
1375         GVariant *message = NULL;
1376
1377         GLOGD("zbl_ccontrol_move_saturation()");
1378
1379         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_saturation",
1380                         g_variant_new("(qyyy)", addr16, ep, move_mode, rate),
1381                         &error);
1382
1383         if (message) {
1384                 g_variant_get(message, "(i)", &error);
1385                 GLOGD("ret = [0x%x]", error);
1386                 g_variant_unref(message);
1387         }
1388
1389         return error;
1390 }
1391
1392 int Zigbee::zbl_ccontrol_step_saturation(nwk_addr addr16, unsigned char ep,
1393                 unsigned char step_mode, unsigned char step_size,
1394                 unsigned char transition_time)
1395 {
1396         int error = ZIGBEE_ERROR_NONE;
1397         GVariant *message = NULL;
1398
1399         GLOGD("zbl_ccontrol_step_saturation()");
1400
1401         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "step_saturation",
1402                         g_variant_new("(qyyyy)", addr16, ep, step_mode, step_size, transition_time),
1403                         &error);
1404
1405         if (message) {
1406                 g_variant_get(message, "(i)", &error);
1407                 GLOGD("ret = [0x%x]", error);
1408                 g_variant_unref(message);
1409         }
1410
1411         return error;
1412 }
1413
1414 int Zigbee::zbl_ccontrol_move_to_hue_and_saturation(nwk_addr addr16, unsigned char ep,
1415                 unsigned char hue, unsigned char saturation,
1416                 unsigned short transition_time)
1417 {
1418         int error = ZIGBEE_ERROR_NONE;
1419         GVariant *message = NULL;
1420
1421         GLOGD("zbl_ccontrol_move_to_hue_and_saturation()");
1422
1423         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_to_hue_and_saturation",
1424                         g_variant_new("(qyyyq)", addr16, ep, hue, saturation, transition_time),
1425                         &error);
1426
1427         if (message) {
1428                 g_variant_get(message, "(i)", &error);
1429                 GLOGD("ret = [0x%x]", error);
1430                 g_variant_unref(message);
1431         }
1432
1433         return error;
1434 }
1435
1436 int Zigbee::zbl_ccontrol_move_to_color(nwk_addr addr16, unsigned char ep,
1437                 unsigned short color_x, unsigned short color_y,
1438                 unsigned short transition_time)
1439 {
1440         int error = ZIGBEE_ERROR_NONE;
1441         GVariant *message = NULL;
1442
1443         GLOGD("zbl_ccontrol_move_to_color()");
1444
1445         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_to_color",
1446                         g_variant_new("(qyqqq)", addr16, ep, color_x, color_y, transition_time),
1447                         &error);
1448
1449         if (message) {
1450                 g_variant_get(message, "(i)", &error);
1451                 GLOGD("ret = [0x%x]", error);
1452                 g_variant_unref(message);
1453         }
1454
1455         return error;
1456 }
1457
1458 int Zigbee::zbl_ccontrol_move_color(nwk_addr addr16, unsigned char ep,
1459                 unsigned short rate_x, unsigned short rate_y)
1460 {
1461         int error = ZIGBEE_ERROR_NONE;
1462         GVariant *message = NULL;
1463
1464         GLOGD("zbl_ccontrol_move_color()");
1465
1466         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_color",
1467                         g_variant_new("(qyqq)", addr16, ep, rate_x, rate_y),
1468                         &error);
1469
1470         if (message) {
1471                 g_variant_get(message, "(i)", &error);
1472                 GLOGD("ret = [0x%x]", error);
1473                 g_variant_unref(message);
1474         }
1475
1476         return error;
1477 }
1478
1479 int Zigbee::zbl_ccontrol_step_color(nwk_addr addr16, unsigned char ep,
1480                 unsigned short step_x, unsigned short step_y,
1481                 unsigned short transition_time)
1482 {
1483         int error = ZIGBEE_ERROR_NONE;
1484         GVariant *message = NULL;
1485
1486         GLOGD("zbl_ccontrol_step_color()");
1487
1488         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "step_color",
1489                         g_variant_new("(qyqqq)", addr16, ep, step_x, step_y, transition_time),
1490                         &error);
1491
1492         if (message) {
1493                 g_variant_get(message, "(i)", &error);
1494                 GLOGD("ret = [0x%x]", error);
1495                 g_variant_unref(message);
1496         }
1497
1498         return error;
1499 }
1500
1501 int Zigbee::zbl_ccontrol_move_to_color_temperature(nwk_addr addr16, unsigned char ep,
1502                 unsigned short color_temperature,
1503                 unsigned short transition_time)
1504 {
1505         int error = ZIGBEE_ERROR_NONE;
1506         GVariant *message = NULL;
1507
1508         GLOGD("zbl_ccontrol_move_to_color_temperature()");
1509
1510         message = invoke_proxy_method(ZCL_COLOR_CONTROL_PROXY, "move_color_temperature",
1511                         g_variant_new("(qyqq)", addr16, ep, color_temperature, transition_time),
1512                         &error);
1513
1514         if (message) {
1515                 g_variant_get(message, "(i)", &error);
1516                 GLOGD("ret = [0x%x]", error);
1517                 g_variant_unref(message);
1518         }
1519
1520         return error;
1521 }
1522
1523 int Zigbee::zbl_reset_factory_default(nwk_addr addr16, unsigned char ep)
1524 {
1525         int error = ZIGBEE_ERROR_NONE;
1526         GVariant *message = NULL;
1527
1528         GLOGD("zbl_reset_factory_default()");
1529
1530         message = invoke_proxy_method(ZCL_BASIC_PROXY, "reset_factory_default",
1531                         g_variant_new("(qy)", addr16, ep), &error);
1532
1533         if (message) {
1534                 g_variant_get(message, "(i)", &error);
1535                 GLOGD("ret = [0x%x]", error);
1536                 g_variant_unref(message);
1537         }
1538
1539         return error;
1540 }
1541
1542 int Zigbee::zbl_identify(nwk_addr addr16, unsigned char dst_ep, unsigned short identify_time)
1543 {
1544         int error = ZIGBEE_ERROR_NONE;
1545         GVariant *message = NULL;
1546
1547         GLOGD("zbl_identify()");
1548
1549         message = invoke_proxy_method(ZCL_IDENTIFY_PROXY, "identify",
1550                         g_variant_new("(qyq)", addr16, dst_ep, identify_time),
1551                         &error);
1552
1553         if (message) {
1554                 g_variant_get(message, "(i)", &error);
1555                 GLOGD("ret = [0x%x]", error);
1556                 g_variant_unref(message);
1557         }
1558
1559         return error;
1560 }
1561
1562 int Zigbee::zbl_identify_query(nwk_addr addr16, unsigned char dst_ep)
1563 {
1564         int error = ZIGBEE_ERROR_NONE;
1565         GVariant *message = NULL;
1566
1567         GLOGD("zbl_identify_query()");
1568
1569         message = invoke_proxy_method(ZCL_IDENTIFY_PROXY, "query",
1570                         g_variant_new("(qy)", addr16, dst_ep), &error);
1571
1572         if (message) {
1573                 g_variant_get(message, "(i)", &error);
1574                 GLOGD("ret = [0x%x]", error);
1575                 g_variant_unref(message);
1576         }
1577
1578         return error;
1579 }
1580
1581 int Zigbee::zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id,
1582                 const char *group_name)
1583 {
1584         int error = ZIGBEE_ERROR_NONE;
1585         GVariant *message = NULL;
1586
1587         int j = 0;
1588         GVariant *groupname_variant = NULL;
1589         GVariantBuilder *groupname_builder = NULL;
1590
1591         GLOGD("zbl_add_group()");
1592
1593         groupname_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
1594         while (group_name[j] != '\0') {
1595                 g_variant_builder_add(groupname_builder, "(y)", (group_name[j]));
1596                 j++;
1597         }
1598         groupname_variant = g_variant_builder_end(groupname_builder);
1599         g_variant_builder_unref(groupname_builder);
1600
1601         message = invoke_proxy_method(ZCL_GROUP_PROXY, "add_group",
1602                         g_variant_new("(qyq@a(y))", addr16, ep, group_id, groupname_variant),
1603                         &error);
1604
1605         if (message) {
1606                 g_variant_get(message, "(i)", &error);
1607                 GLOGD("ret = [0x%x]", error);
1608                 g_variant_unref(message);
1609         }
1610
1611         return error;
1612 }
1613
1614 int Zigbee::zbl_view_group(nwk_addr addr16, unsigned char ep, unsigned short group_id)
1615 {
1616         int error = ZIGBEE_ERROR_NONE;
1617         GVariant *message = NULL;
1618
1619         GLOGD("zbl_view_group()");
1620
1621         message = invoke_proxy_method(ZCL_GROUP_PROXY, "view_group",
1622                         g_variant_new("(qyq)", addr16, ep, group_id), &error);
1623
1624         if (message) {
1625                 g_variant_get(message, "(i)", &error);
1626                 GLOGD("ret = [0x%x]", error);
1627                 g_variant_unref(message);
1628         }
1629
1630         return error;
1631 }
1632
1633 int Zigbee::zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep,
1634                 unsigned char group_count, unsigned short *group_list)
1635 {
1636         int error = ZIGBEE_ERROR_NONE;
1637         GVariant *message = NULL;
1638
1639         int j = 0;
1640         GVariant *grouplist_variant = NULL;
1641         GVariantBuilder *grouplist_builder = NULL;
1642
1643         GLOGD("zbl_group_get_group_membership()");
1644
1645         grouplist_builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
1646         while (j < group_count) {
1647                 g_variant_builder_add(grouplist_builder, "q", group_list[j]);
1648                 j++;
1649         }
1650         grouplist_variant = g_variant_builder_end(grouplist_builder);
1651         g_variant_builder_unref(grouplist_builder);
1652
1653         message = invoke_proxy_method(ZCL_GROUP_PROXY, "get_group_membership",
1654                         g_variant_new("(qyy@aq)", addr16, ep, group_count,      grouplist_variant),
1655                         &error);
1656
1657         if (message) {
1658                 g_variant_get(message, "(i)", &error);
1659                 GLOGD("ret = [0x%x]", error);
1660                 g_variant_unref(message);
1661         }
1662
1663         return error;
1664 }
1665
1666 int Zigbee::zbl_remove_group(nwk_addr addr16, unsigned char ep, unsigned short group_id)
1667 {
1668         int error = ZIGBEE_ERROR_NONE;
1669         GVariant *message = NULL;
1670
1671         GLOGD("zbl_group_remove_group()");
1672
1673         message = invoke_proxy_method(ZCL_GROUP_PROXY, "remove_group", g_variant_new("(qyq)",
1674                                 addr16, ep, group_id), &error);
1675
1676         if (message) {
1677                 g_variant_get(message, "(i)", &error);
1678                 GLOGD("ret = [0x%x]", error);
1679                 g_variant_unref(message);
1680         }
1681
1682         return error;
1683 }
1684
1685 int Zigbee::zbl_remove_all_group(nwk_addr addr16, unsigned char ep)
1686 {
1687         int error = ZIGBEE_ERROR_NONE;
1688         GVariant *message = NULL;
1689
1690         GLOGD("zbl_group_remove_all_group()");
1691
1692         message = invoke_proxy_method(ZCL_GROUP_PROXY, "remove_all_group",
1693                         g_variant_new("(qy)", addr16, ep), &error);
1694
1695         if (message) {
1696                 g_variant_get(message, "(i)", &error);
1697                 GLOGD("ret = [0x%x]", error);
1698                 g_variant_unref(message);
1699         }
1700
1701         return error;
1702 }
1703
1704 int Zigbee::zbl_add_group_if_identifying(nwk_addr addr16, unsigned char ep,
1705                 unsigned short group_id, const char *group_name)
1706 {
1707         int error = ZIGBEE_ERROR_NONE;
1708         GVariant *message = NULL;
1709
1710         GLOGD("zbl_add_group_if_identifying()");
1711
1712         int j = 0;
1713         GVariant *groupname_variant = NULL;
1714         GVariantBuilder *groupname_builder = NULL;
1715
1716         groupname_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
1717         while (group_name[j] != '\0') {
1718                 g_variant_builder_add(groupname_builder, "(y)", group_name[j]);
1719                 j++;
1720         }
1721         groupname_variant = g_variant_builder_end(groupname_builder);
1722         g_variant_builder_unref(groupname_builder);
1723
1724         message = invoke_proxy_method(ZCL_GROUP_PROXY, "add_group_if_identifying",
1725                         g_variant_new("(qyq@a(y))", addr16, ep, group_id, groupname_variant),
1726                         &error);
1727
1728         if (message) {
1729                 g_variant_get(message, "(i)", &error);
1730                 GLOGD("ret = [0x%x]", error);
1731                 g_variant_unref(message);
1732         }
1733
1734         return error;
1735 }
1736
1737 int Zigbee::zbl_level_control_move_to_level(nwk_addr addr16, unsigned char ep,
1738                 unsigned char level, unsigned short transition_time)
1739 {
1740         int error = ZIGBEE_ERROR_NONE;
1741         GVariant *message = NULL;
1742
1743         GLOGD("zbl_level_control_move_to_level()");
1744
1745         message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "move_to_level",
1746                         g_variant_new("(qyyq)", addr16, ep, level, transition_time),
1747                         &error);
1748
1749         if (message) {
1750                 g_variant_get(message, "(i)", &error);
1751                 GLOGD("ret = [0x%x]", error);
1752                 g_variant_unref(message);
1753         }
1754
1755         return error;
1756 }
1757
1758 int Zigbee::zbl_level_control_move(nwk_addr addr16, unsigned char ep,
1759                 unsigned char move_mode, unsigned char rate)
1760 {
1761         int error = ZIGBEE_ERROR_NONE;
1762         GVariant *message = NULL;
1763
1764         GLOGD("zbl_level_control_move()");
1765
1766         message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "move",
1767                         g_variant_new("(qyyy)", addr16, ep, move_mode, rate),
1768                         &error);
1769
1770         if (message) {
1771                 g_variant_get(message, "(i)", &error);
1772                 GLOGD("ret = [0x%x]", error);
1773                 g_variant_unref(message);
1774         }
1775
1776         return error;
1777 }
1778
1779 int Zigbee::zbl_level_control_step(nwk_addr addr16, unsigned char ep,
1780                 unsigned char step_mode, unsigned char step_size,
1781                 unsigned short transition_time)
1782 {
1783         int error = ZIGBEE_ERROR_NONE;
1784         GVariant *message = NULL;
1785
1786         GLOGD("zbl_level_control_step()");
1787
1788         message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "step",
1789                         g_variant_new("(qyyyq)", addr16, ep, step_mode, step_size, transition_time),
1790                         &error);
1791
1792         if (message) {
1793                 g_variant_get(message, "(i)", &error);
1794                 GLOGD("ret = [0x%x]", error);
1795                 g_variant_unref(message);
1796         }
1797
1798         return error;
1799 }
1800
1801 int Zigbee::zbl_level_control_stop(nwk_addr addr16, unsigned char ep)
1802 {
1803         int error = ZIGBEE_ERROR_NONE;
1804         GVariant *message = NULL;
1805
1806         GLOGD("zbl_level_control_stop()");
1807
1808         message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "stop",
1809                         g_variant_new("(qy)", addr16, ep), &error);
1810
1811         if (message) {
1812                 g_variant_get(message, "(i)", &error);
1813                 GLOGD("ret = [0x%x]", error);
1814                 g_variant_unref(message);
1815         }
1816
1817         return error;
1818 }
1819
1820 int Zigbee::zbl_level_control_move_to_level_with_on_off(nwk_addr addr16,
1821                 unsigned char ep, unsigned char level, unsigned short transition_time)
1822 {
1823         int error = ZIGBEE_ERROR_NONE;
1824         GVariant *message = NULL;
1825
1826         GLOGD("zbl_level_control_move_to_level_with_on_off()");
1827
1828         message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "move_to_level_with_on_off",
1829                         g_variant_new("(qyyq)", addr16, ep, level, transition_time),
1830                         &error);
1831
1832         if (message) {
1833                 g_variant_get(message, "(i)", &error);
1834                 GLOGD("ret = [0x%x]", error);
1835                 g_variant_unref(message);
1836         }
1837
1838         return error;
1839 }
1840
1841 int Zigbee::zbl_level_control_move_with_on_off(nwk_addr addr16, unsigned char ep,
1842                 unsigned char move_mode, unsigned char rate)
1843 {
1844         int error = ZIGBEE_ERROR_NONE;
1845         GVariant *message = NULL;
1846
1847         GLOGD("zbl_level_control_move_with_on_off()");
1848
1849         message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "move_with_on_off",
1850                         g_variant_new("(qyyy)", addr16, ep, move_mode, rate),
1851                         &error);
1852
1853         if (message) {
1854                 g_variant_get(message, "(i)", &error);
1855                 GLOGD("ret = [0x%x]", error);
1856                 g_variant_unref(message);
1857         }
1858
1859         return error;
1860 }
1861
1862 int Zigbee::zbl_level_control_step_with_on_off(nwk_addr addr16, unsigned char ep,
1863                 unsigned char step_mode, unsigned char step_size,
1864                 unsigned short transition_time)
1865 {
1866         int error = ZIGBEE_ERROR_NONE;
1867         GVariant *message = NULL;
1868
1869         GLOGD("zbl_level_control_step_with_on_off()");
1870
1871         message = invoke_proxy_method(LEVEL_CONTROL_GPROXY, "step_with_on_off",
1872                         g_variant_new("(qyyyq)", addr16, ep, step_mode, step_size, transition_time),
1873                         &error);
1874
1875         if (message) {
1876                 g_variant_get(message, "(i)", &error);
1877                 GLOGD("ret = [0x%x]", error);
1878                 g_variant_unref(message);
1879         }
1880
1881         return error;
1882 }
1883
1884 int Zigbee::zbl_onoff_set(nwk_addr addr16, unsigned char ep, unsigned char on_off_type)
1885 {
1886         int error = ZIGBEE_ERROR_NONE;
1887         GVariant *message = NULL;
1888
1889         GLOGD("zbl_onoff_set()");
1890
1891         message = invoke_proxy_method(ON_OFF_GPROXY, "set_on_off",
1892                         g_variant_new("(qyy)", addr16, ep, on_off_type), &error);
1893
1894         if (message) {
1895                 g_variant_get(message, "(i)", &error);
1896                 GLOGD("ret = [0x%x]", error);
1897                 g_variant_unref(message);
1898         }
1899
1900         return error;
1901 }
1902
1903 int Zigbee::zbl_zone_enroll_response(nwk_addr addr16, unsigned char dst_ep,
1904                 unsigned char enroll_response_code, unsigned char zone_id)
1905 {
1906         int error = ZIGBEE_ERROR_NONE;
1907         GVariant *message = NULL;
1908
1909         GLOGD("zbl_zone_enroll_response()");
1910
1911         message = invoke_proxy_method(ZCL_IAS_ZONE_PROXY, "enroll_response",
1912                         g_variant_new("(qyyy)", addr16, dst_ep, enroll_response_code, zone_id),
1913                         &error);
1914
1915         if (message) {
1916                 g_variant_get(message, "(i)", &error);
1917                 GLOGD("ret = [0x%x]", error);
1918                 g_variant_unref(message);
1919         }
1920
1921         return error;
1922 }
1923
1924 int Zigbee::zbl_pollcontrol_check_in_response(nwk_addr addr16, unsigned char ep,
1925                 unsigned char start_fast_polling, unsigned short fast_poll_timeout)
1926 {
1927         int error = ZIGBEE_ERROR_NONE;
1928         GVariant *message = NULL;
1929
1930         GLOGD("zbl_pollcontrol_check_in_response()");
1931
1932         message = invoke_proxy_method(ZCL_POLL_CONTROL_PROXY, "check_in_response",
1933                         g_variant_new("(qyyq)", addr16, ep, start_fast_polling, fast_poll_timeout),
1934                         &error);
1935
1936         if (message) {
1937                 g_variant_get(message, "(i)", &error);
1938                 GLOGD("ret = [0x%x]", error);
1939                 g_variant_unref(message);
1940         }
1941
1942         return error;
1943 }
1944
1945 int Zigbee::zbl_pollcontrol_fast_poll_stop(nwk_addr addr16, unsigned char ep)
1946 {
1947         int error = ZIGBEE_ERROR_NONE;
1948         GVariant *message = NULL;
1949
1950         GLOGD("zbl_pollcontrol_fast_poll_stop()");
1951
1952         message = invoke_proxy_method(ZCL_POLL_CONTROL_PROXY, "fast_poll_stop",
1953                         g_variant_new("(qy)", addr16, ep), &error);
1954
1955         if (message) {
1956                 g_variant_get(message, "(i)", &error);
1957                 GLOGD("ret = [0x%x]", error);
1958                 g_variant_unref(message);
1959         }
1960
1961         return error;
1962 }
1963
1964 int Zigbee::zbl_pollcontrol_set_long_poll_interval(nwk_addr addr16, unsigned char ep,
1965                 unsigned int new_long_poll_interval)
1966 {
1967         int error = ZIGBEE_ERROR_NONE;
1968         GVariant *message = NULL;
1969
1970         GLOGD("zbl_pollcontrol_set_long_poll_interval()");
1971
1972         message = invoke_proxy_method(ZCL_POLL_CONTROL_PROXY, "set_long_poll_interval",
1973                         g_variant_new("(qyu)", addr16, ep, new_long_poll_interval),
1974                         &error);
1975
1976         if (message) {
1977                 g_variant_get(message, "(i)", &error);
1978                 GLOGD("ret = [0x%x]", error);
1979                 g_variant_unref(message);
1980         }
1981
1982         return error;
1983 }
1984
1985 int Zigbee::zbl_pollcontrol_set_short_poll_interval(nwk_addr addr16, unsigned char ep,
1986                 unsigned int new_short_poll_interval)
1987 {
1988         int error = ZIGBEE_ERROR_NONE;
1989         GVariant *message = NULL;
1990
1991         GLOGD("zbl_pollcontrol_set_short_poll_interval()");
1992
1993         message = invoke_proxy_method(ZCL_POLL_CONTROL_PROXY, "set_short_poll_interval",
1994                         g_variant_new("(qyu)", addr16, ep, new_short_poll_interval),
1995                         &error);
1996
1997         if (message) {
1998                 g_variant_get(message, "(i)", &error);
1999                 GLOGD("ret = [0x%x]", error);
2000                 g_variant_unref(message);
2001         }
2002
2003         return error;
2004 }
2005
2006 int Zigbee::zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id,
2007                 unsigned char scene_id, unsigned short transition_time, const char *scene_name,
2008                 unsigned short ext_field_len, const char *extension_field_sets)
2009
2010 {
2011         int error = ZIGBEE_ERROR_NONE;
2012         GVariant *message = NULL;
2013
2014         int j = 0;
2015         int index = 0;
2016         GVariant *scenename_variant = NULL;
2017         GVariantBuilder *scenename_builder = NULL;
2018         GVariant *extensionfieldSet_variant = NULL;
2019         GVariantBuilder *extensionfieldSet_builder = NULL;
2020
2021         GLOGD("zbl_add_scene()");
2022
2023         scenename_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
2024         while ('\0' != scene_name[j]) {
2025                 g_variant_builder_add(scenename_builder, "(y)", scene_name[j]);
2026                 j++;
2027         }
2028         scenename_variant = g_variant_builder_end(scenename_builder);
2029         g_variant_builder_unref(scenename_builder);
2030
2031         extensionfieldSet_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
2032
2033         while (index < ext_field_len) {
2034                 GLOGD("Ext contents 0x%02X", extension_field_sets[index]);
2035                 g_variant_builder_add(extensionfieldSet_builder, "(y)", extension_field_sets[index]);
2036                 index++;
2037         }
2038         extensionfieldSet_variant = g_variant_builder_end(extensionfieldSet_builder);
2039         g_variant_builder_unref(extensionfieldSet_builder);
2040
2041         message = invoke_proxy_method(ZCL_SCENE_PROXY, "add_scene",
2042                         g_variant_new("(qyqyqq@a(y)@a(y))", addr16, ep, group_id, scene_id, transition_time,
2043                                 ext_field_len, scenename_variant, extensionfieldSet_variant), &error);
2044
2045         if (message) {
2046                 g_variant_get(message, "(i)", &error);
2047                 GLOGD("ret = [0x%x]", error);
2048                 g_variant_unref(message);
2049         }
2050
2051         return error;
2052 }
2053
2054 int Zigbee::zbl_view_scene(nwk_addr addr16, unsigned char ep,
2055                 unsigned short group_id, unsigned char scene_id)
2056 {
2057         int error = ZIGBEE_ERROR_NONE;
2058         GVariant *message = NULL;
2059
2060         GLOGD("zbl_scene_view_scene()");
2061
2062         message = invoke_proxy_method(ZCL_SCENE_PROXY, "view_scene",
2063                         g_variant_new("(qyqy)", addr16, ep, group_id, scene_id),
2064                         &error);
2065
2066         if (message) {
2067                 g_variant_get(message, "(i)", &error);
2068                 GLOGD("ret = [0x%x]", error);
2069                 g_variant_unref(message);
2070         }
2071
2072         return error;
2073 }
2074
2075 int Zigbee::zbl_remove_scene(nwk_addr addr16, unsigned char ep,
2076                 unsigned short group_id, unsigned char scene_id)
2077 {
2078         int error = ZIGBEE_ERROR_NONE;
2079         GVariant *message = NULL;
2080
2081         GLOGD("zbl_scene_remove_scene()");
2082
2083         message = invoke_proxy_method(ZCL_SCENE_PROXY, "remove_scene",
2084                         g_variant_new("(qyqy)", addr16, ep, group_id, scene_id),
2085                         &error);
2086
2087         if (message) {
2088                 g_variant_get(message, "(i)", &error);
2089                 GLOGD("ret = [0x%x]", error);
2090                 g_variant_unref(message);
2091         }
2092
2093         return error;
2094 }
2095
2096 int Zigbee::zbl_remove_all_scene(nwk_addr addr16, unsigned char ep,
2097                 unsigned short group_id)
2098 {
2099         int error = ZIGBEE_ERROR_NONE;
2100         GVariant *message = NULL;
2101
2102         GLOGD("zbl_scene_remove_all_scene()");
2103
2104         message = invoke_proxy_method(ZCL_SCENE_PROXY, "remove_all_scene",
2105                         g_variant_new("(qyq)", addr16, ep, group_id),
2106                         &error);
2107
2108         if (message) {
2109                 g_variant_get(message, "(i)", &error);
2110                 GLOGD("ret = [0x%x]", error);
2111                 g_variant_unref(message);
2112         }
2113
2114         return error;
2115 }
2116
2117 int Zigbee::zbl_store_scene(nwk_addr addr16, unsigned char ep,
2118                 unsigned short group_id, unsigned char scene_id)
2119 {
2120         int error = ZIGBEE_ERROR_NONE;
2121         GVariant *message = NULL;
2122
2123         GLOGD("zbl_scene_store_scene()");
2124
2125         message = invoke_proxy_method(ZCL_SCENE_PROXY, "store_scene",
2126                         g_variant_new("(qyqy)", addr16, ep, group_id, scene_id),
2127                         &error);
2128
2129         if (message) {
2130                 g_variant_get(message, "(i)", &error);
2131                 GLOGD("ret = [0x%x]", error);
2132                 g_variant_unref(message);
2133         }
2134
2135         return error;
2136 }
2137
2138 int Zigbee::zbl_recall_scene(nwk_addr addr16, unsigned char ep,
2139                 unsigned short group_id, unsigned char scene_id)
2140 {
2141         int error = ZIGBEE_ERROR_NONE;
2142         GVariant *message = NULL;
2143
2144         GLOGD("zbl_recall_scene()");
2145
2146         message = invoke_proxy_method(ZCL_SCENE_PROXY, "recall_scene",
2147                         g_variant_new("(qyqy)", addr16, ep, group_id, scene_id),
2148                         &error);
2149
2150         if (message) {
2151                 g_variant_get(message, "(i)", &error);
2152                 GLOGD("ret = [0x%x]", error);
2153                 g_variant_unref(message);
2154         }
2155
2156         return error;
2157 }
2158
2159 int Zigbee::zbl_get_scene_membership(nwk_addr addr16, unsigned char ep,
2160                 unsigned short group_id)
2161 {
2162         int error = ZIGBEE_ERROR_NONE;
2163         GVariant *message = NULL;
2164
2165         GLOGD("zbl_scene_get_scene_membership()");
2166
2167         message = invoke_proxy_method(ZCL_SCENE_PROXY, "get_scene_membership",
2168                         g_variant_new("(qyq)", addr16, ep, group_id),
2169                         &error);
2170
2171         if (message) {
2172                 g_variant_get(message, "(i)", &error);
2173                 GLOGD("ret = [0x%x]", error);
2174                 g_variant_unref(message);
2175         }
2176
2177         return error;
2178 }
2179
2180 int Zigbee::zbl_thermostat_adjust_setpoint(nwk_addr addr16, unsigned char ep,
2181                 unsigned char mode, unsigned char amount)
2182 {
2183         int error = ZIGBEE_ERROR_NONE;
2184         GVariant *message = NULL;
2185
2186         GLOGD("zbl_thermostat_adjust_setpoint()");
2187
2188         message = invoke_proxy_method(THERMOSTAT_GPROXY, "setpoint_raise_lower",
2189                         g_variant_new("(qyyy)", addr16, ep, mode, amount),
2190                         &error);
2191
2192         if (message) {
2193                 g_variant_get(message, "(i)", &error);
2194                 GLOGD("ret = [0x%x]", error);
2195                 g_variant_unref(message);
2196         }
2197
2198         return error;
2199 }