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