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                 return TRUE;
 137         }
 138
 139         /* Dispatch request */
 140         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 141                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 142                 ZBLIB_ZCL_SCENE_OPS_ADD_SCENE,
 143                 &req, sizeof(req),
 144                 on_zcl_scene_add_scene_resp, resp_cb_data);
 145
 146         /* Free resource */
 147         g_free(req.ext_field_set);
 148
 149         if (FALSE == ret) {
 150                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 151
 152                 /* Free response callback data */
 153                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 154
 155                 /* Send failure response */
 156                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 157
 158                 return TRUE;
 159         }
 160
 161         return TRUE;
 162 }
 163
 164 static void on_zcl_scene_view_scene_resp(ZigBeeServiceInterface *service_interface,
 165         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 166 {
 167         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 168                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 169
 170         ZigbeeZcl_scene *scene_object = NULL;
 171         GDBusMethodInvocation *invocation = NULL;
 172
 173         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 174
 175         NOT_USED(service_interface);
 176         NOT_USED(request_id);
 177
 178         if (NULL == resp_data || 0 == resp_data_len) {
 179                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 180                 g_free(cb_data);
 181                 return;
 182         }
 183
 184         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 185         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 186
 187         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 188         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 189
 190         zigbee_zcl_scene_complete_view_scene(scene_object, invocation, payload->result);
 191
 192         g_free(cb_data);
 193 }
 194
 195 static gboolean on_zcl_scene_view_scene(ZigbeeZcl_scene *zcl_scene_object,
 196         GDBusMethodInvocation *invocation,
 197         gshort node_id,
 198         gchar dest_ep,
 199         gshort group_id,
 200         gchar scene_id,
 201         gpointer user_data)
 202 {
 203         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 204         ZigbeeZclSceneViewScene_t req;
 205         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 206
 207         gboolean ret;
 208
 209         memset(&req, 0x0, sizeof(ZigbeeZclSceneViewScene_t));
 210
 211         /* Update request structure */
 212         req.node_id = node_id;
 213         req.dest_ep = dest_ep;
 214         req.group_id = group_id;
 215         req.scene_id = scene_id;
 216
 217         /* Allocate response callback data */
 218         resp_cb_data =
 219                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 220                         invocation, NULL, 0);
 221         if (NULL == resp_cb_data) {
 222                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 223
 224                 /* Send failure response */
 225                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 226
 227                 return TRUE;
 228         }
 229
 230         /* Dispatch request */
 231         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 232                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 233                 ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE,
 234                 &req, sizeof(req),
 235                 on_zcl_scene_view_scene_resp, resp_cb_data);
 236         if (FALSE == ret) {
 237                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 238
 239                 /* Free response callback data */
 240                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 241
 242                 /* Send failure response */
 243                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 244
 245                 return TRUE;
 246         }
 247
 248         return TRUE;
 249 }
 250
 251 static void on_zcl_scene_remove_scene_resp(ZigBeeServiceInterface *service_interface,
 252         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 253 {
 254         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 255                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 256
 257         ZigbeeZcl_scene *scene_object = NULL;
 258         GDBusMethodInvocation *invocation = NULL;
 259
 260         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 261
 262         NOT_USED(service_interface);
 263         NOT_USED(request_id);
 264
 265         if (NULL == resp_data || 0 == resp_data_len) {
 266                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 267                 g_free(cb_data);
 268                 return;
 269         }
 270
 271         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 272         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 273
 274         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 275         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 276
 277         zigbee_zcl_scene_complete_remove_scene(scene_object, invocation, payload->result);
 278
 279         g_free(cb_data);
 280 }
 281
 282 static gboolean on_zcl_scene_remove_scene(ZigbeeZcl_scene *zcl_scene_object,
 283         GDBusMethodInvocation *invocation,
 284         gshort node_id,
 285         gchar dest_ep,
 286         gshort group_id,
 287         gchar scene_id,
 288         gpointer user_data)
 289 {
 290         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 291         ZigbeeZclSceneRemoveScene_t req;
 292         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 293
 294         gboolean ret;
 295
 296         memset(&req, 0x0, sizeof(ZigbeeZclSceneRemoveScene_t));
 297
 298         /* Update request structure */
 299         req.node_id = node_id;
 300         req.dest_ep = dest_ep;
 301         req.group_id = group_id;
 302         req.scene_id = scene_id;
 303
 304         /* Allocate response callback data */
 305         resp_cb_data =
 306                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 307                         invocation, NULL, 0);
 308         if (NULL == resp_cb_data) {
 309                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 310
 311                 /* Send failure response */
 312                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 313
 314                 return TRUE;
 315         }
 316
 317         /* Dispatch request */
 318         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 319                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 320                 ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE,
 321                 &req, sizeof(req),
 322                 on_zcl_scene_remove_scene_resp, resp_cb_data);
 323         if (FALSE == ret) {
 324                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 325
 326                 /* Free response callback data */
 327                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 328
 329                 /* Send failure response */
 330                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 331
 332                 return TRUE;
 333         }
 334
 335         return TRUE;
 336 }
 337
 338 static void on_zcl_scene_store_scene_resp(ZigBeeServiceInterface *service_interface,
 339         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 340 {
 341         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 342                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 343
 344         ZigbeeZcl_scene *scene_object = NULL;
 345         GDBusMethodInvocation *invocation = NULL;
 346
 347         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 348
 349         NOT_USED(service_interface);
 350         NOT_USED(request_id);
 351
 352         if (NULL == resp_data || 0 == resp_data_len) {
 353                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 354                 g_free(cb_data);
 355                 return;
 356         }
 357
 358         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 359         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 360
 361         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 362         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 363
 364         zigbee_zcl_scene_complete_store_scene(scene_object, invocation, payload->result);
 365
 366         g_free(cb_data);
 367 }
 368
 369 static gboolean on_zcl_scene_store_scene(ZigbeeZcl_scene *zcl_scene_object,
 370         GDBusMethodInvocation *invocation,
 371         gshort node_id,
 372         gchar dest_ep,
 373         gshort group_id,
 374         gchar scene_id,
 375         gpointer user_data)
 376 {
 377         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 378         ZigbeeZclSceneStoreScene_t req;
 379         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 380
 381         gboolean ret;
 382
 383         memset(&req, 0x0, sizeof(ZigbeeZclSceneStoreScene_t));
 384
 385         /* Update request structure */
 386         req.node_id = node_id;
 387         req.dest_ep = dest_ep;
 388         req.group_id = group_id;
 389         req.scene_id = scene_id;
 390
 391         /* Allocate response callback data */
 392         resp_cb_data =
 393                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 394                         invocation, NULL, 0);
 395         if (NULL == resp_cb_data) {
 396                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 397
 398                 /* Send failure response */
 399                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 400
 401                 return TRUE;
 402         }
 403
 404         /* Dispatch request */
 405         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 406                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 407                 ZBLIB_ZCL_SCENE_OPS_STORE_SCENE,
 408                 &req, sizeof(req),
 409                 on_zcl_scene_store_scene_resp, resp_cb_data);
 410         if (FALSE == ret) {
 411                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 412
 413                 /* Free response callback data */
 414                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 415
 416                 /* Send failure response */
 417                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 418
 419                 return TRUE;
 420         }
 421
 422         return TRUE;
 423 }
 424
 425 static void on_zcl_scene_recall_scene_resp(ZigBeeServiceInterface *service_interface,
 426         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 427 {
 428         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 429                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 430
 431         ZigbeeZcl_scene *scene_object = NULL;
 432         GDBusMethodInvocation *invocation = NULL;
 433
 434         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 435
 436         NOT_USED(service_interface);
 437         NOT_USED(request_id);
 438
 439         if (NULL == resp_data || 0 == resp_data_len) {
 440                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 441                 g_free(cb_data);
 442                 return;
 443         }
 444
 445         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 446         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 447
 448         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 449         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 450
 451         zigbee_zcl_scene_complete_recall_scene(scene_object, invocation, payload->result);
 452
 453         g_free(cb_data);
 454 }
 455
 456 static gboolean on_zcl_scene_recall_scene(ZigbeeZcl_scene *zcl_scene_object,
 457         GDBusMethodInvocation *invocation,
 458         gshort node_id,
 459         gchar dest_ep,
 460         gshort group_id,
 461         gchar scene_id,
 462         gpointer user_data)
 463 {
 464         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 465         ZigbeeZclSceneRecallScene_t req;
 466         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 467
 468         gboolean ret;
 469
 470         memset(&req, 0x0, sizeof(ZigbeeZclSceneRecallScene_t));
 471
 472         /* Update request structure */
 473         req.node_id = node_id;
 474         req.dest_ep = dest_ep;
 475         req.group_id = group_id;
 476         req.scene_id = scene_id;
 477
 478         /* Allocate response callback data */
 479         resp_cb_data =
 480                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 481                         invocation, NULL, 0);
 482         if (NULL == resp_cb_data) {
 483                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 484
 485                 /* Send failure response */
 486                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 487
 488                 return TRUE;
 489         }
 490
 491         /* Dispatch request */
 492         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 493                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 494                 ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE,
 495                 &req, sizeof(req),
 496                 on_zcl_scene_recall_scene_resp, resp_cb_data);
 497         if (FALSE == ret) {
 498                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 499
 500                 /* Free response callback data */
 501                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 502
 503                 /* Send failure response */
 504                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 505
 506                 return TRUE;
 507         }
 508
 509         return TRUE;
 510 }
 511
 512 static void on_zcl_scene_remove_all_scene_resp(ZigBeeServiceInterface *service_interface,
 513         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 514 {
 515         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 516                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 517
 518         ZigbeeZcl_scene *scene_object = NULL;
 519         GDBusMethodInvocation *invocation = NULL;
 520
 521         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 522
 523         NOT_USED(service_interface);
 524         NOT_USED(request_id);
 525
 526         if (NULL == resp_data || 0 == resp_data_len) {
 527                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 528                 g_free(cb_data);
 529                 return;
 530         }
 531
 532         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 533         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 534
 535         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 536         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 537
 538         zigbee_zcl_scene_complete_remove_all_scene(scene_object, invocation, payload->result);
 539
 540         g_free(cb_data);
 541 }
 542
 543 static gboolean on_zcl_scene_remove_all_scene(ZigbeeZcl_scene *zcl_scene_object,
 544         GDBusMethodInvocation *invocation,
 545         gshort node_id,
 546         gchar dest_ep,
 547         gshort group_id,
 548         gpointer user_data)
 549 {
 550         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 551         ZigbeeZclSceneRemoveAllScene_t req;
 552         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 553
 554         gboolean ret;
 555
 556         memset(&req, 0x0, sizeof(ZigbeeZclSceneRemoveAllScene_t));
 557
 558         /* Update request structure */
 559         req.node_id = node_id;
 560         req.dest_ep = dest_ep;
 561         req.group_id = group_id;
 562
 563         /* Allocate response callback data */
 564         resp_cb_data =
 565                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 566                         invocation, NULL, 0);
 567         if (NULL == resp_cb_data) {
 568                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 569
 570                 /* Send failure response */
 571                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 572
 573                 return TRUE;
 574         }
 575
 576         /* Dispatch request */
 577         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 578                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 579                 ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE,
 580                 &req, sizeof(req),
 581                 on_zcl_scene_remove_all_scene_resp, resp_cb_data);
 582         if (FALSE == ret) {
 583                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 584
 585                 /* Free response callback data */
 586                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 587
 588                 /* Send failure response */
 589                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 590
 591                 return TRUE;
 592         }
 593
 594         return TRUE;
 595 }
 596
 597 static void on_zcl_scene_get_scene_membership_resp(ZigBeeServiceInterface *service_interface,
 598         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 599 {
 600         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 601                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 602
 603         ZigbeeZcl_scene *scene_object = NULL;
 604         GDBusMethodInvocation *invocation = NULL;
 605
 606         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 607
 608         NOT_USED(service_interface);
 609         NOT_USED(request_id);
 610
 611         if (NULL == resp_data || 0 == resp_data_len) {
 612                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 613                 g_free(cb_data);
 614                 return;
 615         }
 616
 617         scene_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 618         zblib_check_null_free_and_ret("scene_object", scene_object, cb_data);
 619
 620         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 621         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 622
 623         zigbee_zcl_scene_complete_get_scene_membership(scene_object, invocation, payload->result);
 624
 625         g_free(cb_data);
 626 }
 627
 628 static gboolean on_zcl_scene_get_scene_membership(ZigbeeZcl_scene *zcl_scene_object,
 629         GDBusMethodInvocation *invocation,
 630         gshort node_id,
 631         gchar dest_ep,
 632         gshort group_id,
 633         gpointer user_data)
 634 {
 635         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 636         ZigbeeZclSceneGetSceneMembership_t req;
 637         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 638
 639         gboolean ret;
 640
 641         memset(&req, 0x0, sizeof(ZigbeeZclSceneGetSceneMembership_t));
 642
 643         /* Update request structure */
 644         req.node_id = node_id;
 645         req.dest_ep = dest_ep;
 646         req.group_id = group_id;
 647
 648         /* Allocate response callback data */
 649         resp_cb_data =
 650                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 651                         invocation, NULL, 0);
 652         if (NULL == resp_cb_data) {
 653                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 654
 655                 /* Send failure response */
 656                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 657
 658                 return TRUE;
 659         }
 660
 661         /* Dispatch request */
 662         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 663                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 664                 ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP,
 665                 &req, sizeof(req),
 666                 on_zcl_scene_get_scene_membership_resp, resp_cb_data);
 667         if (FALSE == ret) {
 668                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 669
 670                 /* Free response callback data */
 671                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 672
 673                 /* Send failure response */
 674                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 675
 676                 return TRUE;
 677         }
 678
 679         return TRUE;
 680 }
 681
 682 void zigbee_service_dbus_interface_zcl_scene_notification(ZigBeeServiceInterface *service_interface,
 683         guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
 684 {
 685         ZigbeeZcl_scene *scene_object;
 686
 687         zblib_check_null_ret("service_interface", service_interface);
 688
 689         if (NULL == noti_data || 0 == noti_data_len) {
 690                 Z_LOGE("noti_data=%p or noti_data_len=%d is null", noti_data, noti_data_len);
 691                 return;
 692         }
 693
 694         scene_object = _service_interface_ref_zigbee_zcl_scene(service_interface);
 695         zblib_check_null_ret("scene_object", scene_object);
 696
 697         NOT_USED(noti_cb_data);
 698
 699         switch (noti_id) {
 700         case ZBLIB_ZCL_SCENE_NOTI_ADD_SCENE: {
 701                 ZigbeeZclSceneAddSceneResp_t *rsp = (ZigbeeZclSceneAddSceneResp_t*)noti_data;
 702
 703                 Z_LOGD("'add_scene_rsp' from : [0x%X]", rsp->node_id);
 704
 705                 zigbee_zcl_scene_emit_add_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 706                         rsp->status, rsp->group_id, rsp->scene_id);
 707         }
 708         break;
 709         case ZBLIB_ZCL_SCENE_NOTI_VIEW_SCENE: {
 710                 int i;
 711
 712                 GVariant* scene_name = NULL;
 713                 GVariantBuilder *attr_builder = NULL;
 714                 GVariant* ext_field_set = NULL;
 715                 GVariantBuilder *attr_builder1 = NULL;
 716
 717                 ZigbeeZclSceneViewSceneResp_t *rsp = (ZigbeeZclSceneViewSceneResp_t*)noti_data;
 718
 719                 Z_LOGD("'view_scene_rsp' from : [0x%X]", rsp->node_id);
 720
 721                 attr_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 722                 for (i = 0; rsp->scene_name[i] && i < ZIGBEE_ZCL_SCENE_NAME_MAX_LEN; i++)
 723                         g_variant_builder_add(attr_builder, "(y)", rsp->scene_name[i]);
 724                 scene_name = g_variant_builder_end(attr_builder);
 725                 g_variant_builder_unref(attr_builder);
 726
 727
 728                 attr_builder1 = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 729                 for (i = 0; i < rsp->ext_field_set_len; i++)
 730                         g_variant_builder_add(attr_builder1, "(y)", rsp->ext_field_set[i]);
 731                 ext_field_set = g_variant_builder_end(attr_builder1);
 732                 g_variant_builder_unref(attr_builder1);
 733
 734                 zigbee_zcl_scene_emit_view_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 735                         rsp->status, rsp->group_id, rsp->scene_id, rsp->transition_time,
 736                         scene_name, rsp->ext_field_set_len, ext_field_set);
 737         }
 738         break;
 739         case ZBLIB_ZCL_SCENE_NOTI_REMOVE_SCENE: {
 740                 ZigbeeZclSceneRemoveSceneResp_t *rsp = (ZigbeeZclSceneRemoveSceneResp_t*)noti_data;
 741
 742                 Z_LOGD("'remove_scene_rsp' from : [0x%X]", rsp->node_id);
 743
 744                 zigbee_zcl_scene_emit_remove_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 745                         rsp->status, rsp->group_id, rsp->scene_id);
 746         }
 747         break;
 748         case ZBLIB_ZCL_SCENE_NOTI_REMOVE_ALL_SCENE: {
 749                 ZigbeeZclSceneRemoveAllSceneResp_t *rsp =
 750                         (ZigbeeZclSceneRemoveAllSceneResp_t*)noti_data;
 751
 752                 Z_LOGD("'remove_all_scene_rsp' from : [0x%X]", rsp->node_id);
 753
 754                 zigbee_zcl_scene_emit_remove_all_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 755                         rsp->status, rsp->group_id);
 756         }
 757         break;
 758         case ZBLIB_ZCL_SCENE_NOTI_STORE_SCENE: {
 759                 ZigbeeZclSceneStoreSceneResp_t *rsp =
 760                         (ZigbeeZclSceneStoreSceneResp_t*)noti_data;
 761
 762                 Z_LOGD("'store_scene_rsp' from : [0x%X]", rsp->node_id);
 763
 764                 zigbee_zcl_scene_emit_store_scene_rsp(scene_object, rsp->node_id, rsp->src_ep,
 765                         rsp->status, rsp->group_id, rsp->scene_id);
 766         }
 767         break;
 768         case ZBLIB_ZCL_SCENE_NOTI_GET_SCENE_MEMBERSHIP: {
 769                 int i;
 770                 GVariant* scene_list = NULL;
 771                 GVariantBuilder *attr_builder = NULL;
 772
 773                 ZigbeeZclSceneGetSceneMembershipResp_t *rsp =
 774                         (ZigbeeZclSceneGetSceneMembershipResp_t*)noti_data;
 775
 776                 Z_LOGD("'get_scene_rsp' from : [0x%X]", rsp->node_id);
 777
 778                 attr_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
 779                 for (i = 0; i < rsp->scene_count; i++)
 780                         g_variant_builder_add(attr_builder, "(y)", rsp->scene_list[i]);
 781                 scene_list = g_variant_builder_end(attr_builder);
 782                 g_variant_builder_unref(attr_builder);
 783
 784                 zigbee_zcl_scene_emit_get_scene_membership_rsp(scene_object, rsp->node_id, rsp->src_ep,
 785                         rsp->status, rsp->capacity, rsp->group_id, rsp->scene_count, scene_list);
 786         }
 787         break;
 788         default:
 789                 Z_LOGE("Unexpected notification [%x]", noti_id);
 790         break;
 791         }
 792
 793         /* ZigbeeZcl_scene should be dereferenced */
 794         g_object_unref(scene_object);
 795 }
 796
 797 gboolean zigbee_service_dbus_interface_zcl_scene_init(ZigBeeServiceInterface *service_interface,
 798         ZigbeeObjectSkeleton *zigbee_object)
 799 {
 800         ZigbeeZcl_scene *zcl_scene_object;
 801
 802         if (NULL == service_interface) {
 803                 Z_LOGE("service_interface is NULL");
 804                 return FALSE;
 805         }
 806
 807         zcl_scene_object = zigbee_zcl_scene_skeleton_new();
 808         zigbee_object_skeleton_set_zcl_scene(zigbee_object, zcl_scene_object);
 809         g_object_unref(zcl_scene_object);
 810
 811         Z_LOGI("zcl_scene_object: [%p]", zcl_scene_object);
 812
 813         /*
 814          * Register signal handlers for 'zcl_scene' interface
 815          */
 816         g_signal_connect(zcl_scene_object,
 817                 "handle-add-scene",
 818                 G_CALLBACK(on_zcl_scene_add_scene), service_interface);
 819
 820         g_signal_connect(zcl_scene_object,
 821                 "handle-view-scene",
 822                 G_CALLBACK(on_zcl_scene_view_scene), service_interface);
 823
 824         g_signal_connect(zcl_scene_object,
 825                 "handle-remove-scene",
 826                 G_CALLBACK(on_zcl_scene_remove_scene), service_interface);
 827
 828         g_signal_connect(zcl_scene_object,
 829                 "handle-store-scene",
 830                 G_CALLBACK(on_zcl_scene_store_scene), service_interface);
 831
 832         g_signal_connect(zcl_scene_object,
 833                 "handle-recall-scene",
 834                 G_CALLBACK(on_zcl_scene_recall_scene), service_interface);
 835
 836         g_signal_connect(zcl_scene_object,
 837                 "handle-remove-all-scene",
 838                 G_CALLBACK(on_zcl_scene_remove_all_scene), service_interface);
 839
 840         g_signal_connect(zcl_scene_object,
 841                 "handle-get-scene-membership",
 842                 G_CALLBACK(on_zcl_scene_get_scene_membership), service_interface);
 843
 844         return TRUE;
 845 }