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 on_zcl_scene_add_scene_resp(ZigBeeServiceInterface *service_interface,
  24         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
  25 {
  26         ZigbeeServiceInterfaceRespCbData_t *cb_data =
  27                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
  28
  29         NOT_USED(cb_data);
  30         NOT_USED(service_interface);
  31         NOT_USED(request_id);
  32         NOT_USED(resp_data);
  33         NOT_USED(resp_data_len);
  34 }
  35
  36 static gboolean on_zcl_scene_add_scene(ZigbeeZcl_scene *zcl_scene_object,
  37         GDBusMethodInvocation *invocation,
  38         gshort node_id,
  39         gchar dest_ep,
  40         gshort group_id,
  41         gchar scene_id,
  42         gshort transition_time,
  43         gshort ext_length,
  44         GVariant *scene_name,
  45         GVariant *ext_field_set,
  46         gpointer user_data)
  47 {
  48         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  49         ZigbeeZclSceneAddScene_t req;
  50         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  51
  52         GVariantIter *iter = NULL;
  53         gint i = 0;
  54
  55         gboolean ret;
  56
  57         memset(&req, 0x0, sizeof(ZigbeeZclSceneAddScene_t));
  58
  59         /* Update request structure */
  60         req.node_id = node_id;
  61         req.dest_ep = dest_ep;
  62         req.group_id = group_id;
  63         req.scene_id = scene_id;
  64         req.transition_time = transition_time;
  65         g_variant_get(scene_name, "ay", &iter);
  66         while (g_variant_iter_loop(iter, "y", req.scene_name[i])) {
  67                 i++;
  68                 if (i >= ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1)
  69                         break;
  70         }
  71
  72         i = 0;
  73         req.ext_field_set_len = ext_length;
  74         req.ext_field_set = g_malloc0(ext_length);
  75         g_variant_get(ext_field_set, "aq", &iter);
  76         while (g_variant_iter_loop(iter, "q", req.ext_field_set[i])) {
  77                 i++;
  78                 if (i >= ext_length)
  79                         break;
  80         }
  81
  82         /* Allocate response callback data */
  83         resp_cb_data =
  84                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
  85                         invocation, NULL, 0);
  86         if (NULL == resp_cb_data) {
  87                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
  88
  89                 /* Send failure response */
  90                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
  91
  92                 return TRUE;
  93         }
  94
  95         /* Dispatch request */
  96         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
  97                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
  98                 ZBLIB_ZCL_SCENE_OPS_ADD_SCENE,
  99                 &req, sizeof(req),
 100                 on_zcl_scene_add_scene_resp, resp_cb_data);
 101
 102         /* Free resource */
 103         g_free(req.ext_field_set);
 104
 105         if (FALSE == ret) {
 106                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 107
 108                 /* Free response callback data */
 109                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 110
 111                 /* Send failure response */
 112                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 113
 114                 return TRUE;
 115         }
 116
 117         return TRUE;
 118 }
 119
 120 static void on_zcl_scene_view_scene_resp(ZigBeeServiceInterface *service_interface,
 121         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 122 {
 123         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 124                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 125
 126         NOT_USED(cb_data);
 127         NOT_USED(service_interface);
 128         NOT_USED(request_id);
 129         NOT_USED(resp_data);
 130         NOT_USED(resp_data_len);
 131 }
 132
 133 static gboolean on_zcl_scene_view_scene(ZigbeeZcl_scene *zcl_scene_object,
 134         GDBusMethodInvocation *invocation,
 135         gshort node_id,
 136         gchar dest_ep,
 137         gshort group_id,
 138         gchar scene_id,
 139         gpointer user_data)
 140 {
 141         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 142         ZigbeeZclSceneViewScene_t req;
 143         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 144
 145         gboolean ret;
 146
 147         memset(&req, 0x0, sizeof(ZigbeeZclSceneViewScene_t));
 148
 149         /* Update request structure */
 150         req.node_id = node_id;
 151         req.dest_ep = dest_ep;
 152         req.group_id = group_id;
 153         req.scene_id = scene_id;
 154
 155         /* Allocate response callback data */
 156         resp_cb_data =
 157                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 158                         invocation, NULL, 0);
 159         if (NULL == resp_cb_data) {
 160                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 161
 162                 /* Send failure response */
 163                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 164
 165                 return TRUE;
 166         }
 167
 168         /* Dispatch request */
 169         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 170                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 171                 ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE,
 172                 &req, sizeof(req),
 173                 on_zcl_scene_view_scene_resp, resp_cb_data);
 174         if (FALSE == ret) {
 175                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 176
 177                 /* Free response callback data */
 178                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 179
 180                 /* Send failure response */
 181                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 182
 183                 return TRUE;
 184         }
 185
 186         return TRUE;
 187 }
 188
 189 static void on_zcl_scene_remove_scene_resp(ZigBeeServiceInterface *service_interface,
 190         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 191 {
 192         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 193                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 194
 195         NOT_USED(cb_data);
 196         NOT_USED(service_interface);
 197         NOT_USED(request_id);
 198         NOT_USED(resp_data);
 199         NOT_USED(resp_data_len);
 200 }
 201
 202 static gboolean on_zcl_scene_remove_scene(ZigbeeZcl_scene *zcl_scene_object,
 203         GDBusMethodInvocation *invocation,
 204         gshort node_id,
 205         gchar dest_ep,
 206         gshort group_id,
 207         gchar scene_id,
 208         gpointer user_data)
 209 {
 210         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 211         ZigbeeZclSceneRemoveScene_t req;
 212         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 213
 214         gboolean ret;
 215
 216         memset(&req, 0x0, sizeof(ZigbeeZclSceneRemoveScene_t));
 217
 218         /* Update request structure */
 219         req.node_id = node_id;
 220         req.dest_ep = dest_ep;
 221         req.group_id = group_id;
 222         req.scene_id = scene_id;
 223
 224         /* Allocate response callback data */
 225         resp_cb_data =
 226                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 227                         invocation, NULL, 0);
 228         if (NULL == resp_cb_data) {
 229                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 230
 231                 /* Send failure response */
 232                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 233
 234                 return TRUE;
 235         }
 236
 237         /* Dispatch request */
 238         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 239                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 240                 ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE,
 241                 &req, sizeof(req),
 242                 on_zcl_scene_remove_scene_resp, resp_cb_data);
 243         if (FALSE == ret) {
 244                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 245
 246                 /* Free response callback data */
 247                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 248
 249                 /* Send failure response */
 250                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 251
 252                 return TRUE;
 253         }
 254
 255         return TRUE;
 256 }
 257
 258 static void on_zcl_scene_store_scene_resp(ZigBeeServiceInterface *service_interface,
 259         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 260 {
 261         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 262                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 263
 264         NOT_USED(cb_data);
 265         NOT_USED(service_interface);
 266         NOT_USED(request_id);
 267         NOT_USED(resp_data);
 268         NOT_USED(resp_data_len);
 269 }
 270
 271 static gboolean on_zcl_scene_store_scene(ZigbeeZcl_scene *zcl_scene_object,
 272         GDBusMethodInvocation *invocation,
 273         gshort node_id,
 274         gchar dest_ep,
 275         gshort group_id,
 276         gchar scene_id,
 277         gpointer user_data)
 278 {
 279         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 280         ZigbeeZclSceneStoreScene_t req;
 281         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 282
 283         gboolean ret;
 284
 285         memset(&req, 0x0, sizeof(ZigbeeZclSceneStoreScene_t));
 286
 287         /* Update request structure */
 288         req.node_id = node_id;
 289         req.dest_ep = dest_ep;
 290         req.group_id = group_id;
 291         req.scene_id = scene_id;
 292
 293         /* Allocate response callback data */
 294         resp_cb_data =
 295                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 296                         invocation, NULL, 0);
 297         if (NULL == resp_cb_data) {
 298                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 299
 300                 /* Send failure response */
 301                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 302
 303                 return TRUE;
 304         }
 305
 306         /* Dispatch request */
 307         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 308                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 309                 ZBLIB_ZCL_SCENE_OPS_STORE_SCENE,
 310                 &req, sizeof(req),
 311                 on_zcl_scene_store_scene_resp, resp_cb_data);
 312         if (FALSE == ret) {
 313                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 314
 315                 /* Free response callback data */
 316                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 317
 318                 /* Send failure response */
 319                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 320
 321                 return TRUE;
 322         }
 323
 324         return TRUE;
 325 }
 326
 327 static void on_zcl_scene_recall_scene_resp(ZigBeeServiceInterface *service_interface,
 328         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 329 {
 330         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 331                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 332
 333         NOT_USED(cb_data);
 334         NOT_USED(service_interface);
 335         NOT_USED(request_id);
 336         NOT_USED(resp_data);
 337         NOT_USED(resp_data_len);
 338 }
 339
 340 static gboolean on_zcl_scene_recall_scene(ZigbeeZcl_scene *zcl_scene_object,
 341         GDBusMethodInvocation *invocation,
 342         gshort node_id,
 343         gchar dest_ep,
 344         gshort group_id,
 345         gchar scene_id,
 346         gpointer user_data)
 347 {
 348         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 349         ZigbeeZclSceneRecallScene_t req;
 350         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 351
 352         gboolean ret;
 353
 354         memset(&req, 0x0, sizeof(ZigbeeZclSceneRecallScene_t));
 355
 356         /* Update request structure */
 357         req.node_id = node_id;
 358         req.dest_ep = dest_ep;
 359         req.group_id = group_id;
 360         req.scene_id = scene_id;
 361
 362         /* Allocate response callback data */
 363         resp_cb_data =
 364                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 365                         invocation, NULL, 0);
 366         if (NULL == resp_cb_data) {
 367                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 368
 369                 /* Send failure response */
 370                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 371
 372                 return TRUE;
 373         }
 374
 375         /* Dispatch request */
 376         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 377                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 378                 ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE,
 379                 &req, sizeof(req),
 380                 on_zcl_scene_recall_scene_resp, resp_cb_data);
 381         if (FALSE == ret) {
 382                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 383
 384                 /* Free response callback data */
 385                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 386
 387                 /* Send failure response */
 388                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 389
 390                 return TRUE;
 391         }
 392
 393         return TRUE;
 394 }
 395
 396 static void on_zcl_scene_remove_all_scene_resp(ZigBeeServiceInterface *service_interface,
 397         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 398 {
 399         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 400                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 401
 402         NOT_USED(cb_data);
 403         NOT_USED(service_interface);
 404         NOT_USED(request_id);
 405         NOT_USED(resp_data);
 406         NOT_USED(resp_data_len);
 407 }
 408
 409 static gboolean on_zcl_scene_remove_all_scene(ZigbeeZcl_scene *zcl_scene_object,
 410         GDBusMethodInvocation *invocation,
 411         gshort node_id,
 412         gchar dest_ep,
 413         gshort group_id,
 414         gpointer user_data)
 415 {
 416         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 417         ZigbeeZclSceneRemoveAllScene_t req;
 418         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 419
 420         gboolean ret;
 421
 422         memset(&req, 0x0, sizeof(ZigbeeZclSceneRemoveAllScene_t));
 423
 424         /* Update request structure */
 425         req.node_id = node_id;
 426         req.dest_ep = dest_ep;
 427         req.group_id = group_id;
 428
 429         /* Allocate response callback data */
 430         resp_cb_data =
 431                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 432                         invocation, NULL, 0);
 433         if (NULL == resp_cb_data) {
 434                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 435
 436                 /* Send failure response */
 437                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 438
 439                 return TRUE;
 440         }
 441
 442         /* Dispatch request */
 443         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 444                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 445                 ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE,
 446                 &req, sizeof(req),
 447                 on_zcl_scene_remove_all_scene_resp, resp_cb_data);
 448         if (FALSE == ret) {
 449                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 450
 451                 /* Free response callback data */
 452                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 453
 454                 /* Send failure response */
 455                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 456
 457                 return TRUE;
 458         }
 459
 460         return TRUE;
 461 }
 462
 463 static void on_zcl_scene_get_scene_membership_resp(ZigBeeServiceInterface *service_interface,
 464         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 465 {
 466         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 467                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 468
 469         NOT_USED(cb_data);
 470         NOT_USED(service_interface);
 471         NOT_USED(request_id);
 472         NOT_USED(resp_data);
 473         NOT_USED(resp_data_len);
 474 }
 475
 476 static gboolean on_zcl_scene_get_scene_membership(ZigbeeZcl_scene *zcl_scene_object,
 477         GDBusMethodInvocation *invocation,
 478         gshort node_id,
 479         gchar dest_ep,
 480         gshort group_id,
 481         gpointer user_data)
 482 {
 483         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 484         ZigbeeZclSceneGetSceneMembership_t req;
 485         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 486
 487         gboolean ret;
 488
 489         memset(&req, 0x0, sizeof(ZigbeeZclSceneGetSceneMembership_t));
 490
 491         /* Update request structure */
 492         req.node_id = node_id;
 493         req.dest_ep = dest_ep;
 494         req.group_id = group_id;
 495
 496         /* Allocate response callback data */
 497         resp_cb_data =
 498                 zigbee_service_dbus_interface_create_resp_cb_data(zcl_scene_object,
 499                         invocation, NULL, 0);
 500         if (NULL == resp_cb_data) {
 501                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 502
 503                 /* Send failure response */
 504                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 505
 506                 return TRUE;
 507         }
 508
 509         /* Dispatch request */
 510         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 511                 ZBLIB_DRIVER_TYPE_ZCL_SCENE,
 512                 ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP,
 513                 &req, sizeof(req),
 514                 on_zcl_scene_get_scene_membership_resp, resp_cb_data);
 515         if (FALSE == ret) {
 516                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 517
 518                 /* Free response callback data */
 519                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 520
 521                 /* Send failure response */
 522                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 523
 524                 return TRUE;
 525         }
 526
 527         return TRUE;
 528 }
 529
 530 gboolean zigbee_service_dbus_interface_zcl_scene_init(ZigBeeServiceInterface *service_interface,
 531         ZigbeeObjectSkeleton *zigbee_object)
 532 {
 533         ZigbeeZcl_scene *zcl_scene_object;
 534
 535         if (NULL == service_interface) {
 536                 Z_LOGE("service_interface is NULL");
 537                 return FALSE;
 538         }
 539
 540         zcl_scene_object = zigbee_zcl_scene_skeleton_new();
 541         zigbee_object_skeleton_set_zcl_scene(zigbee_object, zcl_scene_object);
 542         g_object_unref(zcl_scene_object);
 543
 544         Z_LOGI("zcl_scene_object: [%p]", zcl_scene_object);
 545
 546         /*
 547          * Register signal handlers for 'zcl_scene' interface
 548          */
 549         g_signal_connect(zcl_scene_object,
 550                 "handle-add-scene",
 551                 G_CALLBACK(on_zcl_scene_add_scene), service_interface);
 552
 553         g_signal_connect(zcl_scene_object,
 554                 "handle-view-scene",
 555                 G_CALLBACK(on_zcl_scene_view_scene), service_interface);
 556
 557         g_signal_connect(zcl_scene_object,
 558                 "handle-remove-scene",
 559                 G_CALLBACK(on_zcl_scene_remove_scene), service_interface);
 560
 561         g_signal_connect(zcl_scene_object,
 562                 "handle-store-scene",
 563                 G_CALLBACK(on_zcl_scene_store_scene), service_interface);
 564
 565         g_signal_connect(zcl_scene_object,
 566                 "handle-recall-scene",
 567                 G_CALLBACK(on_zcl_scene_recall_scene), service_interface);
 568
 569         g_signal_connect(zcl_scene_object,
 570                 "handle-remove-all-scene",
 571                 G_CALLBACK(on_zcl_scene_remove_all_scene), service_interface);
 572
 573         g_signal_connect(zcl_scene_object,
 574                 "handle-get-scene-membership",
 575                 G_CALLBACK(on_zcl_scene_get_scene_membership), service_interface);
 576
 577         return TRUE;
 578 }