zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zcl_scene.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Contact: Suresh Kumar N (suresh.n@samsung.com)
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include "zigbee_service_interface_common.h"
  20
  21 #include <zblib_driver_zcl_scene.h>
  22
  23 static void *_service_interface_ref_zigbee_zcl_scene(
  24         ZigBeeServiceInterface *service_interface)
  25 {
  26         ZigbeeObjectSkeleton *zigbee_object = NULL;
  27         ZigbeeCustomData_t *custom_data = NULL;
  28         ZigbeeZcl_scene *scene_object = NULL;
  29
  30         custom_data = (ZigbeeCustomData_t *)zblib_service_interface_ref_user_data(service_interface);
  31         if (NULL == custom_data) {
  32                 Z_LOGE("D-BUS service interface custom_data is NULL!");
  33                 return NULL;
  34         }
  35
  36         /* Get zigbee object */
  37         zigbee_object = g_hash_table_lookup(custom_data->objects, ZIGBEE_SERVICE_PATH);
  38         if (NULL == zigbee_object) {
  39                 Z_LOGW("Cannot find ZigBee D-BUS interface object!", zigbee_object);
  40                 return NULL;
  41         }
  42
  43         scene_object = zigbee_object_get_zcl_scene(ZIGBEE_OBJECT(zigbee_object));
  44         return scene_object;
  45 }
  46
  47 static void on_zcl_scene_add_scene_resp(ZigBeeServiceInterface *service_interface,
  48         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
  49 {
  50         ZigbeeServiceInterfaceRespCbData_t *cb_data =
  51                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
  52
  53         ZigbeeZcl_scene *scene_object = NULL;
  54         GDBusMethodInvocation *invocation = NULL;
  55
  56         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
  57
  58         NOT_USED(service_interface);
  59         NOT_USED(request_id);
  60
  61         if (NULL == resp_data || 0 == resp_data_len) {
  62                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
  63                 g_free(cb_data);
  64                 return;
  65         }
  66
  67         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
  68         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
  69
  70         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
  71         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
  72
  73         zigbee_zcl_scene_complete_add_scene(scene_object, invocation, payload->result);
  74
  75         g_free(cb_data);
  76 }
  77
  78 static gboolean on_zcl_scene_add_scene(ZigbeeZcl_scene *zcl_scene_object,
  79         GDBusMethodInvocation *invocation,
  80         gshort node_id,
  81         gchar dest_ep,
  82         gshort group_id,
  83         gchar scene_id,
  84         gshort transition_time,
  85         gshort ext_length,
  86         GVariant *scene_name,
  87         GVariant *ext_field_set,
  88         gpointer user_data)
  89 {
  90         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  91         ZigbeeZclSceneAddScene_t req;
  92         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  93
  94         GVariantIter *iter = NULL;
  95         gint i = 0;
  96         unsigned char value = 0;
  97
  98         gboolean ret;
  99
 100         memset(&req, 0x0, sizeof(ZigbeeZclSceneAddScene_t));
 101
 102         /* Update request structure */
 103         req.node_id = node_id;
 104         req.dest_ep = dest_ep;
 105         req.group_id = group_id;
 106         req.scene_id = scene_id;
 107         req.transition_time = transition_time;
 108         g_variant_get(scene_name, "a(y)", &iter);
 109         while (g_variant_iter_loop(iter, "(y)", &(req.scene_name[i]))) {
 110                 i++;
 111                 if (i >= ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1)
 112                         break;
 113         }
 114
 115         i = 0;
 116         req.ext_field_set_len = ext_length;
 117         req.ext_field_set = g_malloc0(ext_length);
 118         g_variant_get(ext_field_set, "a(y)", &iter);
 119         while (g_variant_iter_loop(iter, "(y)", &value)) {
 120                 req.ext_field_set[i] = value;
 121                 i++;
 122                 if (i >= ext_length)
 123                         break;
 124         }
 125
 126         /* Allocate response callback data */
 127         resp_cb_data =
 128                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 129                         invocation, NULL, 0);
 130         if (NULL == resp_cb_data) {
 131                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 132
 133                 /* Send failure response */
 134                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 135
 136                 g_free(req.ext_field_set);
 137                 return TRUE;
 138         }
 139
 140         /* Dispatch request */
 141         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 142                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 143                 ZBLIB_ZCL_SCENE_OPS_ADD_SCENE,
 144                 &req, sizeof(req),
 145                 on_zcl_scene_add_scene_resp, resp_cb_data);
 146
 147         /* Free resource */
 148         g_free(req.ext_field_set);
 149
 150         if (FALSE == ret) {
 151                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 152
 153                 /* Free response callback data */
 154                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 155
 156                 /* Send failure response */
 157                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 158
 159                 return TRUE;
 160         }
 161
 162         return TRUE;
 163 }
 164
 165 static void on_zcl_scene_view_scene_resp(ZigBeeServiceInterface *service_interface,
 166         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 167 {
 168         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 169                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 170
 171         ZigbeeZcl_scene *scene_object = NULL;
 172         GDBusMethodInvocation *invocation = NULL;
 173
 174         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 175
 176         NOT_USED(service_interface);
 177         NOT_USED(request_id);
 178
 179         if (NULL == resp_data || 0 == resp_data_len) {
 180                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 181                 g_free(cb_data);
 182                 return;
 183         }
 184
 185         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 186         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 187
 188         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 189         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 190
 191         zigbee_zcl_scene_complete_view_scene(scene_object, invocation, payload->result);
 192
 193         g_free(cb_data);
 194 }
 195
 196 static gboolean on_zcl_scene_view_scene(ZigbeeZcl_scene *zcl_scene_object,
 197         GDBusMethodInvocation *invocation,
 198         gshort node_id,
 199         gchar dest_ep,
 200         gshort group_id,
 201         gchar scene_id,
 202         gpointer user_data)
 203 {
 204         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 205         ZigbeeZclSceneViewScene_t req;
 206         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 207
 208         gboolean ret;
 209
 210         memset(&req, 0x0, sizeof(ZigbeeZclSceneViewScene_t));
 211
 212         /* Update request structure */
 213         req.node_id = node_id;
 214         req.dest_ep = dest_ep;
 215         req.group_id = group_id;
 216         req.scene_id = scene_id;
 217
 218         /* Allocate response callback data */
 219         resp_cb_data =
 220                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 221                         invocation, NULL, 0);
 222         if (NULL == resp_cb_data) {
 223                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 224
 225                 /* Send failure response */
 226                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 227
 228                 return TRUE;
 229         }
 230
 231         /* Dispatch request */
 232         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 233                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 234                 ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE,
 235                 &req, sizeof(req),
 236                 on_zcl_scene_view_scene_resp, resp_cb_data);
 237         if (FALSE == ret) {
 238                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 239
 240                 /* Free response callback data */
 241                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 242
 243                 /* Send failure response */
 244                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 245
 246                 return TRUE;
 247         }
 248
 249         return TRUE;
 250 }
 251
 252 static void on_zcl_scene_remove_scene_resp(ZigBeeServiceInterface *service_interface,
 253         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 254 {
 255         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 256                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 257
 258         ZigbeeZcl_scene *scene_object = NULL;
 259         GDBusMethodInvocation *invocation = NULL;
 260
 261         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 262
 263         NOT_USED(service_interface);
 264         NOT_USED(request_id);
 265
 266         if (NULL == resp_data || 0 == resp_data_len) {
 267                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 268                 g_free(cb_data);
 269                 return;
 270         }
 271
 272         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 273         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 274
 275         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 276         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 277
 278         zigbee_zcl_scene_complete_remove_scene(scene_object, invocation, payload->result);
 279
 280         g_free(cb_data);
 281 }
 282
 283 static gboolean on_zcl_scene_remove_scene(ZigbeeZcl_scene *zcl_scene_object,
 284         GDBusMethodInvocation *invocation,
 285         gshort node_id,
 286         gchar dest_ep,
 287         gshort group_id,
 288         gchar scene_id,
 289         gpointer user_data)
 290 {
 291         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 292         ZigbeeZclSceneRemoveScene_t req;
 293         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 294
 295         gboolean ret;
 296
 297         memset(&req, 0x0, sizeof(ZigbeeZclSceneRemoveScene_t));
 298
 299         /* Update request structure */
 300         req.node_id = node_id;
 301         req.dest_ep = dest_ep;
 302         req.group_id = group_id;
 303         req.scene_id = scene_id;
 304
 305         /* Allocate response callback data */
 306         resp_cb_data =
 307                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 308                         invocation, NULL, 0);
 309         if (NULL == resp_cb_data) {
 310                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 311
 312                 /* Send failure response */
 313                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 314
 315                 return TRUE;
 316         }
 317
 318         /* Dispatch request */
 319         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 320                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 321                 ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE,
 322                 &req, sizeof(req),
 323                 on_zcl_scene_remove_scene_resp, resp_cb_data);
 324         if (FALSE == ret) {
 325                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 326
 327                 /* Free response callback data */
 328                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 329
 330                 /* Send failure response */
 331                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 332
 333                 return TRUE;
 334         }
 335
 336         return TRUE;
 337 }
 338
 339 static void on_zcl_scene_store_scene_resp(ZigBeeServiceInterface *service_interface,
 340         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 341 {
 342         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 343                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 344
 345         ZigbeeZcl_scene *scene_object = NULL;
 346         GDBusMethodInvocation *invocation = NULL;
 347
 348         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 349
 350         NOT_USED(service_interface);
 351         NOT_USED(request_id);
 352
 353         if (NULL == resp_data || 0 == resp_data_len) {
 354                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 355                 g_free(cb_data);
 356                 return;
 357         }
 358
 359         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 360         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 361
 362         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 363         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 364
 365         zigbee_zcl_scene_complete_store_scene(scene_object, invocation, payload->result);
 366
 367         g_free(cb_data);
 368 }
 369
 370 static gboolean on_zcl_scene_store_scene(ZigbeeZcl_scene *zcl_scene_object,
 371         GDBusMethodInvocation *invocation,
 372         gshort node_id,
 373         gchar dest_ep,
 374         gshort group_id,
 375         gchar scene_id,
 376         gpointer user_data)
 377 {
 378         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 379         ZigbeeZclSceneStoreScene_t req;
 380         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 381
 382         gboolean ret;
 383
 384         memset(&req, 0x0, sizeof(ZigbeeZclSceneStoreScene_t));
 385
 386         /* Update request structure */
 387         req.node_id = node_id;
 388         req.dest_ep = dest_ep;
 389         req.group_id = group_id;
 390         req.scene_id = scene_id;
 391
 392         /* Allocate response callback data */
 393         resp_cb_data =
 394                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 395                         invocation, NULL, 0);
 396         if (NULL == resp_cb_data) {
 397                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 398
 399                 /* Send failure response */
 400                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 401
 402                 return TRUE;
 403         }
 404
 405         /* Dispatch request */
 406         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 407                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 408                 ZBLIB_ZCL_SCENE_OPS_STORE_SCENE,
 409                 &req, sizeof(req),
 410                 on_zcl_scene_store_scene_resp, resp_cb_data);
 411         if (FALSE == ret) {
 412                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 413
 414                 /* Free response callback data */
 415                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 416
 417                 /* Send failure response */
 418                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 419
 420                 return TRUE;
 421         }
 422
 423         return TRUE;
 424 }
 425
 426 static void on_zcl_scene_recall_scene_resp(ZigBeeServiceInterface *service_interface,
 427         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 428 {
 429         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 430                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 431
 432         ZigbeeZcl_scene *scene_object = NULL;
 433         GDBusMethodInvocation *invocation = NULL;
 434
 435         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 436
 437         NOT_USED(service_interface);
 438         NOT_USED(request_id);
 439
 440         if (NULL == resp_data || 0 == resp_data_len) {
 441                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 442                 g_free(cb_data);
 443                 return;
 444         }
 445
 446         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 447         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 448
 449         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 450         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 451
 452         zigbee_zcl_scene_complete_recall_scene(scene_object, invocation, payload->result);
 453
 454         g_free(cb_data);
 455 }
 456
 457 static gboolean on_zcl_scene_recall_scene(ZigbeeZcl_scene *zcl_scene_object,
 458         GDBusMethodInvocation *invocation,
 459         gshort node_id,
 460         gchar dest_ep,
 461         gshort group_id,
 462         gchar scene_id,
 463         gpointer user_data)
 464 {
 465         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 466         ZigbeeZclSceneRecallScene_t req;
 467         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 468
 469         gboolean ret;
 470
 471         memset(&req, 0x0, sizeof(ZigbeeZclSceneRecallScene_t));
 472
 473         /* Update request structure */
 474         req.node_id = node_id;
 475         req.dest_ep = dest_ep;
 476         req.group_id = group_id;
 477         req.scene_id = scene_id;
 478
 479         /* Allocate response callback data */
 480         resp_cb_data =
 481                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 482                         invocation, NULL, 0);
 483         if (NULL == resp_cb_data) {
 484                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 485
 486                 /* Send failure response */
 487                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 488
 489                 return TRUE;
 490         }
 491
 492         /* Dispatch request */
 493         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 494                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 495                 ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE,
 496                 &req, sizeof(req),
 497                 on_zcl_scene_recall_scene_resp, resp_cb_data);
 498         if (FALSE == ret) {
 499                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 500
 501                 /* Free response callback data */
 502                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 503
 504                 /* Send failure response */
 505                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 506
 507                 return TRUE;
 508         }
 509
 510         return TRUE;
 511 }
 512
 513 static void on_zcl_scene_remove_all_scene_resp(ZigBeeServiceInterface *service_interface,
 514         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 515 {
 516         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 517                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 518
 519         ZigbeeZcl_scene *scene_object = NULL;
 520         GDBusMethodInvocation *invocation = NULL;
 521
 522         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 523
 524         NOT_USED(service_interface);
 525         NOT_USED(request_id);
 526
 527         if (NULL == resp_data || 0 == resp_data_len) {
 528                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 529                 g_free(cb_data);
 530                 return;
 531         }
 532
 533         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 534         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 535
 536         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 537         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 538
 539         zigbee_zcl_scene_complete_remove_all_scene(scene_object, invocation, payload->result);
 540
 541         g_free(cb_data);
 542 }
 543
 544 static gboolean on_zcl_scene_remove_all_scene(ZigbeeZcl_scene *zcl_scene_object,
 545         GDBusMethodInvocation *invocation,
 546         gshort node_id,
 547         gchar dest_ep,
 548         gshort group_id,
 549         gpointer user_data)
 550 {
 551         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 552         ZigbeeZclSceneRemoveAllScene_t req;
 553         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 554
 555         gboolean ret;
 556
 557         memset(&req, 0x0, sizeof(ZigbeeZclSceneRemoveAllScene_t));
 558
 559         /* Update request structure */
 560         req.node_id = node_id;
 561         req.dest_ep = dest_ep;
 562         req.group_id = group_id;
 563
 564         /* Allocate response callback data */
 565         resp_cb_data =
 566                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 567                         invocation, NULL, 0);
 568         if (NULL == resp_cb_data) {
 569                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 570
 571                 /* Send failure response */
 572                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 573
 574                 return TRUE;
 575         }
 576
 577         /* Dispatch request */
 578         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 579                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 580                 ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE,
 581                 &req, sizeof(req),
 582                 on_zcl_scene_remove_all_scene_resp, resp_cb_data);
 583         if (FALSE == ret) {
 584                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 585
 586                 /* Free response callback data */
 587                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 588
 589                 /* Send failure response */
 590                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 591
 592                 return TRUE;
 593         }
 594
 595         return TRUE;
 596 }
 597
 598 static void on_zcl_scene_get_scene_membership_resp(ZigBeeServiceInterface *service_interface,
 599         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 600 {
 601         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 602                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 603
 604         ZigbeeZcl_scene *scene_object = NULL;
 605         GDBusMethodInvocation *invocation = NULL;
 606
 607         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 608
 609         NOT_USED(service_interface);
 610         NOT_USED(request_id);
 611
 612         if (NULL == resp_data || 0 == resp_data_len) {
 613                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 614                 g_free(cb_data);
 615                 return;
 616         }
 617
 618         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 619         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 620
 621         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 622         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 623
 624         zigbee_zcl_scene_complete_get_scene_membership(scene_object, invocation, payload->result);
 625
 626         g_free(cb_data);
 627 }
 628
 629 static gboolean on_zcl_scene_get_scene_membership(ZigbeeZcl_scene *zcl_scene_object,
 630         GDBusMethodInvocation *invocation,
 631         gshort node_id,
 632         gchar dest_ep,
 633         gshort group_id,
 634         gpointer user_data)
 635 {
 636         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 637         ZigbeeZclSceneGetSceneMembership_t req;
 638         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 639
 640         gboolean ret;
 641
 642         memset(&req, 0x0, sizeof(ZigbeeZclSceneGetSceneMembership_t));
 643
 644         /* Update request structure */
 645         req.node_id = node_id;
 646         req.dest_ep = dest_ep;
 647         req.group_id = group_id;
 648
 649         /* Allocate response callback data */
 650         resp_cb_data =
 651                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 652                         invocation, NULL, 0);
 653         if (NULL == resp_cb_data) {
 654                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 655
 656                 /* Send failure response */
 657                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 658
 659                 return TRUE;
 660         }
 661
 662         /* Dispatch request */
 663         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 664                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 665                 ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP,
 666                 &req, sizeof(req),
 667                 on_zcl_scene_get_scene_membership_resp, resp_cb_data);
 668         if (FALSE == ret) {
 669                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 670
 671                 /* Free response callback data */
 672                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 673
 674                 /* Send failure response */
 675                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 676
 677                 return TRUE;
 678         }
 679
 680         return TRUE;
 681 }
 682
 683 void zigbee_service_dbus_interface_zcl_scene_notification(ZigBeeServiceInterface *service_interface,
 684         guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
 685 {
 686         ZigbeeZcl_scene *scene_object;
 687
 688         zblib_check_null_ret("service_interface", service_interface);
 689
 690         if (NULL == noti_data || 0 == noti_data_len) {
 691                 Z_LOGE("noti_data=%p or noti_data_len=%d is null", noti_data, noti_data_len);
 692                 return;
 693         }
 694
 695         scene_object = _service_interface_ref_zigbee_zcl_scene(service_interface);
 696         zblib_check_null_ret("scene_object", scene_object);
 697
 698         NOT_USED(noti_cb_data);
 699
 700         switch (noti_id) {
 701         case ZBLIB_ZCL_SCENE_NOTI_ADD_SCENE: {
 702                 ZigbeeZclSceneAddSceneResp_t *rsp = (ZigbeeZclSceneAddSceneResp_t*)noti_data;
 703
 704                 Z_LOGD("'add_scene_rsp' from : [0x%X]", rsp->node_id);
 705
 706                 zigbee_zcl_scene_emit_add_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 707                         rsp->status, rsp->group_id, rsp->scene_id);
 708         }
 709         break;
 710         case ZBLIB_ZCL_SCENE_NOTI_VIEW_SCENE: {
 711                 int i;
 712
 713                 GVariant* scene_name = NULL;
 714                 GVariantBuilder *attr_builder = NULL;
 715                 GVariant* ext_field_set = NULL;
 716                 GVariantBuilder *attr_builder1 = NULL;
 717
 718                 ZigbeeZclSceneViewSceneResp_t *rsp = (ZigbeeZclSceneViewSceneResp_t*)noti_data;
 719
 720                 Z_LOGD("'view_scene_rsp' from : [0x%X]", rsp->node_id);
 721
 722                 attr_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 723                 for (i = 0; rsp->scene_name[i] && i < ZIGBEE_ZCL_SCENE_NAME_MAX_LEN; i++)
 724                         g_variant_builder_add(attr_builder, "(y)", rsp->scene_name[i]);
 725                 scene_name = g_variant_builder_end(attr_builder);
 726                 g_variant_builder_unref(attr_builder);
 727
 728
 729                 attr_builder1 = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 730                 for (i = 0; i < rsp->ext_field_set_len; i++)
 731                         g_variant_builder_add(attr_builder1, "(y)", rsp->ext_field_set[i]);
 732                 ext_field_set = g_variant_builder_end(attr_builder1);
 733                 g_variant_builder_unref(attr_builder1);
 734
 735                 zigbee_zcl_scene_emit_view_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 736                         rsp->status, rsp->group_id, rsp->scene_id, rsp->transition_time,
 737                         scene_name, rsp->ext_field_set_len, ext_field_set);
 738         }
 739         break;
 740         case ZBLIB_ZCL_SCENE_NOTI_REMOVE_SCENE: {
 741                 ZigbeeZclSceneRemoveSceneResp_t *rsp = (ZigbeeZclSceneRemoveSceneResp_t*)noti_data;
 742
 743                 Z_LOGD("'remove_scene_rsp' from : [0x%X]", rsp->node_id);
 744
 745                 zigbee_zcl_scene_emit_remove_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 746                         rsp->status, rsp->group_id, rsp->scene_id);
 747         }
 748         break;
 749         case ZBLIB_ZCL_SCENE_NOTI_REMOVE_ALL_SCENE: {
 750                 ZigbeeZclSceneRemoveAllSceneResp_t *rsp =
 751                         (ZigbeeZclSceneRemoveAllSceneResp_t*)noti_data;
 752
 753                 Z_LOGD("'remove_all_scene_rsp' from : [0x%X]", rsp->node_id);
 754
 755                 zigbee_zcl_scene_emit_remove_all_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 756                         rsp->status, rsp->group_id);
 757         }
 758         break;
 759         case ZBLIB_ZCL_SCENE_NOTI_STORE_SCENE: {
 760                 ZigbeeZclSceneStoreSceneResp_t *rsp =
 761                         (ZigbeeZclSceneStoreSceneResp_t*)noti_data;
 762
 763                 Z_LOGD("'store_scene_rsp' from : [0x%X]", rsp->node_id);
 764
 765                 zigbee_zcl_scene_emit_store_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 766                         rsp->status, rsp->group_id, rsp->scene_id);
 767         }
 768         break;
 769         case ZBLIB_ZCL_SCENE_NOTI_GET_SCENE_MEMBERSHIP: {
 770                 int i;
 771                 GVariant* scene_list = NULL;
 772                 GVariantBuilder *attr_builder = NULL;
 773
 774                 ZigbeeZclSceneGetSceneMembershipResp_t *rsp =
 775                         (ZigbeeZclSceneGetSceneMembershipResp_t*)noti_data;
 776
 777                 Z_LOGD("'get_scene_rsp' from : [0x%X]", rsp->node_id);
 778
 779                 attr_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 780                 for (i = 0; i < rsp->scene_count; i++)
 781                         g_variant_builder_add(attr_builder, "(y)", rsp->scene_list[i]);
 782                 scene_list = g_variant_builder_end(attr_builder);
 783                 g_variant_builder_unref(attr_builder);
 784
 785                 zigbee_zcl_scene_emit_get_scene_membership_rsp(scene_object, rsp->node_id, rsp->src_ep,
 786                         rsp->status, rsp->capacity, rsp->group_id, rsp->scene_count, scene_list);
 787         }
 788         break;
 789         default:
 790                 Z_LOGE("Unexpected notification [%x]", noti_id);
 791         break;
 792         }
 793
 794         /* ZigbeeZcl_scene should be dereferenced */
 795         g_object_unref(scene_object);
 796 }
 797
 798 gboolean zigbee_service_dbus_interface_zcl_scene_init(ZigBeeServiceInterface *service_interface,
 799         ZigbeeObjectSkeleton *zigbee_object)
 800 {
 801         ZigbeeZcl_scene *zcl_scene_object;
 802
 803         if (NULL == service_interface) {
 804                 Z_LOGE("service_interface is NULL");
 805                 return FALSE;
 806         }
 807
 808         zcl_scene_object = zigbee_zcl_scene_skeleton_new();
 809         zigbee_object_skeleton_set_zcl_scene(zigbee_object, zcl_scene_object);
 810         g_object_unref(zcl_scene_object);
 811
 812         Z_LOGI("zcl_scene_object: [%p]", zcl_scene_object);
 813
 814         /*
 815          * Register signal handlers for 'zcl_scene' interface
 816          */
 817         g_signal_connect(zcl_scene_object,
 818                 "handle-add-scene",
 819                 G_CALLBACK(on_zcl_scene_add_scene), service_interface);
 820
 821         g_signal_connect(zcl_scene_object,
 822                 "handle-view-scene",
 823                 G_CALLBACK(on_zcl_scene_view_scene), service_interface);
 824
 825         g_signal_connect(zcl_scene_object,
 826                 "handle-remove-scene",
 827                 G_CALLBACK(on_zcl_scene_remove_scene), service_interface);
 828
 829         g_signal_connect(zcl_scene_object,
 830                 "handle-store-scene",
 831                 G_CALLBACK(on_zcl_scene_store_scene), service_interface);
 832
 833         g_signal_connect(zcl_scene_object,
 834                 "handle-recall-scene",
 835                 G_CALLBACK(on_zcl_scene_recall_scene), service_interface);
 836
 837         g_signal_connect(zcl_scene_object,
 838                 "handle-remove-all-scene",
 839                 G_CALLBACK(on_zcl_scene_remove_all_scene), service_interface);
 840
 841         g_signal_connect(zcl_scene_object,
 842                 "handle-get-scene-membership",
 843                 G_CALLBACK(on_zcl_scene_get_scene_membership), service_interface);
 844
 845         return TRUE;
 846 }