zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zcl_level_control.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_level_control.h>
  22
  23 /* LCOV_EXCL_START */
  24 static void *_service_interface_ref_zigbee_zcl_level_control(
  25         ZigBeeServiceInterface *service_interface)
  26 {
  27         ZigbeeObjectSkeleton *zigbee_object = NULL;
  28         ZigbeeCustomData_t *custom_data = NULL;
  29         ZigbeeZcl_level_control *level_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!");
  41                 return NULL;
  42         }
  43
  44         level_object = zigbee_object_get_zcl_level_control(ZIGBEE_OBJECT(zigbee_object));
  45         return level_object;
  46 }
  47
  48 static void on_level_control_move_to_level_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_level_control *level_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         level_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
  69         zblib_check_null_free_and_ret("level_object", level_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_level_control_complete_move_to_level(level_object, invocation, payload->result);
  75
  76         g_free(cb_data);
  77 }
  78
  79 static gboolean on_level_control_move_to_level(ZigbeeZcl_level_control *level_control_object,
  80         GDBusMethodInvocation *invocation,
  81         gshort node_id,
  82         gchar endpoint,
  83         gchar level,
  84         gshort transition,
  85         gpointer user_data)
  86 {
  87         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  88         ZigbeeZclLevelControlMoveToLevel_t req;
  89         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  90
  91         gboolean ret;
  92
  93         memset(&req, 0x0, sizeof(ZigbeeZclLevelControlMoveToLevel_t));
  94
  95         /* Update request structure */
  96         req.node_id = node_id;
  97         req.endpoint = endpoint;
  98         req.level = level;
  99         req.transition = transition;
 100
 101         /* Allocate response callback data */
 102         resp_cb_data =
 103                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 104                         invocation, NULL, 0);
 105         if (NULL == resp_cb_data) {
 106                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 107
 108                 /* Send failure response */
 109                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 110
 111                 return TRUE;
 112         }
 113
 114         /* Dispatch request */
 115         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 116                 ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
 117                 ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL,
 118                 &req, sizeof(req),
 119                 on_level_control_move_to_level_resp, resp_cb_data);
 120         if (FALSE == ret) {
 121                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 122
 123                 /* Free response callback data */
 124                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 125
 126                 /* Send failure response */
 127                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 128
 129                 return TRUE;
 130         }
 131
 132         return TRUE;
 133 }
 134
 135 static void on_level_control_move_resp(ZigBeeServiceInterface *service_interface,
 136         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 137 {
 138         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 139                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 140
 141         ZigbeeZcl_level_control *level_object = NULL;
 142         GDBusMethodInvocation *invocation = NULL;
 143
 144         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 145
 146         NOT_USED(service_interface);
 147         NOT_USED(request_id);
 148
 149         if (NULL == resp_data || 0 == resp_data_len) {
 150                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 151                 g_free(cb_data);
 152                 return;
 153         }
 154
 155         level_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 156         zblib_check_null_free_and_ret("level_object", level_object, cb_data);
 157
 158         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 159         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 160
 161         zigbee_zcl_level_control_complete_move(level_object, invocation, payload->result);
 162
 163         g_free(cb_data);
 164 }
 165
 166 static gboolean on_level_control_move(ZigbeeZcl_level_control *level_control_object,
 167         GDBusMethodInvocation *invocation,
 168         gshort node_id,
 169         gchar endpoint,
 170         gchar move_mode,
 171         gchar rate,
 172         gpointer user_data)
 173 {
 174         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 175         ZigbeeZclLevelControlMove_t req;
 176         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 177
 178         gboolean ret;
 179
 180         memset(&req, 0x0, sizeof(ZigbeeZclLevelControlMove_t));
 181
 182         /* Update request structure */
 183         req.node_id = node_id;
 184         req.endpoint = endpoint;
 185         req.move_mode = move_mode;
 186         req.rate = rate;
 187
 188         /* Allocate response callback data */
 189         resp_cb_data =
 190                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 191                         invocation, NULL, 0);
 192         if (NULL == resp_cb_data) {
 193                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 194
 195                 /* Send failure response */
 196                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 197
 198                 return TRUE;
 199         }
 200
 201         /* Dispatch request */
 202         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 203                 ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
 204                 ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE,
 205                 &req, sizeof(req),
 206                 on_level_control_move_resp, resp_cb_data);
 207         if (FALSE == ret) {
 208                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 209
 210                 /* Free response callback data */
 211                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 212
 213                 /* Send failure response */
 214                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 215
 216                 return TRUE;
 217         }
 218
 219         return TRUE;
 220 }
 221
 222 static void on_level_control_step_resp(ZigBeeServiceInterface *service_interface,
 223         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 224 {
 225         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 226                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 227
 228         ZigbeeZcl_level_control *level_object = NULL;
 229         GDBusMethodInvocation *invocation = NULL;
 230
 231         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 232
 233         NOT_USED(service_interface);
 234         NOT_USED(request_id);
 235
 236         if (NULL == resp_data || 0 == resp_data_len) {
 237                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 238                 g_free(cb_data);
 239                 return;
 240         }
 241
 242         level_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 243         zblib_check_null_free_and_ret("level_object", level_object, cb_data);
 244
 245         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 246         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 247
 248         zigbee_zcl_level_control_complete_step(level_object, invocation, payload->result);
 249
 250         g_free(cb_data);
 251 }
 252
 253 static gboolean on_level_control_step(ZigbeeZcl_level_control *level_control_object,
 254         GDBusMethodInvocation *invocation,
 255         gshort node_id,
 256         gchar endpoint,
 257         gchar step_mode,
 258         gchar step_size,
 259         gshort transition_time,
 260         gpointer user_data)
 261 {
 262         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 263         ZigbeeZclLevelControlStep_t req;
 264         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 265
 266         gboolean ret;
 267
 268         memset(&req, 0x0, sizeof(ZigbeeZclLevelControlStep_t));
 269
 270         /* Update request structure */
 271         req.node_id = node_id;
 272         req.endpoint = endpoint;
 273         req.step_mode = step_mode;
 274         req.step_size = step_size;
 275         req.transition_time = transition_time;
 276
 277         /* Allocate response callback data */
 278         resp_cb_data =
 279                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 280                         invocation, NULL, 0);
 281         if (NULL == resp_cb_data) {
 282                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 283
 284                 /* Send failure response */
 285                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 286
 287                 return TRUE;
 288         }
 289
 290         /* Dispatch request */
 291         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 292                 ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
 293                 ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP,
 294                 &req, sizeof(req),
 295                 on_level_control_step_resp, resp_cb_data);
 296         if (FALSE == ret) {
 297                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 298
 299                 /* Free response callback data */
 300                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 301
 302                 /* Send failure response */
 303                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 304
 305                 return TRUE;
 306         }
 307
 308         return TRUE;
 309 }
 310
 311 static void on_level_control_move_to_level_with_on_off_resp(ZigBeeServiceInterface *service_interface,
 312         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 313 {
 314         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 315                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 316
 317         ZigbeeZcl_level_control *level_object = NULL;
 318         GDBusMethodInvocation *invocation = NULL;
 319
 320         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 321
 322         NOT_USED(service_interface);
 323         NOT_USED(request_id);
 324
 325         if (NULL == resp_data || 0 == resp_data_len) {
 326                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 327                 g_free(cb_data);
 328                 return;
 329         }
 330
 331         level_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 332         zblib_check_null_free_and_ret("level_object", level_object, cb_data);
 333
 334         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 335         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 336
 337         zigbee_zcl_level_control_complete_move_to_level_with_on_off(level_object, invocation,
 338                 payload->result);
 339
 340         g_free(cb_data);
 341 }
 342
 343 static gboolean on_level_control_move_to_level_with_on_off(
 344         ZigbeeZcl_level_control *level_control_object,
 345         GDBusMethodInvocation *invocation,
 346         gshort node_id,
 347         gchar endpoint,
 348         gchar level,
 349         gshort transition,
 350         gpointer user_data)
 351 {
 352         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 353         ZigbeeZclLevelControlMoveToLevelWithOnOff_t req;
 354         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 355
 356         gboolean ret;
 357
 358         memset(&req, 0x0, sizeof(ZigbeeZclLevelControlMoveToLevelWithOnOff_t));
 359
 360         /* Update request structure */
 361         req.node_id = node_id;
 362         req.endpoint = endpoint;
 363         req.level = level;
 364         req.transition = transition;
 365
 366         /* Allocate response callback data */
 367         resp_cb_data =
 368                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 369                         invocation, NULL, 0);
 370         if (NULL == resp_cb_data) {
 371                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 372
 373                 /* Send failure response */
 374                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 375
 376                 return TRUE;
 377         }
 378
 379         /* Dispatch request */
 380         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 381                 ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
 382                 ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF,
 383                 &req, sizeof(req),
 384                 on_level_control_move_to_level_with_on_off_resp, resp_cb_data);
 385         if (FALSE == ret) {
 386                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 387
 388                 /* Free response callback data */
 389                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 390
 391                 /* Send failure response */
 392                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 393
 394                 return TRUE;
 395         }
 396
 397         return TRUE;
 398 }
 399
 400 static void on_level_control_move_with_on_off_resp(ZigBeeServiceInterface *service_interface,
 401         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 402 {
 403         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 404                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 405
 406         ZigbeeZcl_level_control *level_object = NULL;
 407         GDBusMethodInvocation *invocation = NULL;
 408
 409         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 410
 411         NOT_USED(service_interface);
 412         NOT_USED(request_id);
 413
 414         if (NULL == resp_data || 0 == resp_data_len) {
 415                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 416                 g_free(cb_data);
 417                 return;
 418         }
 419
 420         level_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 421         zblib_check_null_free_and_ret("level_object", level_object, cb_data);
 422
 423         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 424         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 425
 426         zigbee_zcl_level_control_complete_move_with_on_off(level_object, invocation,
 427                 payload->result);
 428
 429         g_free(cb_data);
 430 }
 431
 432 static gboolean on_level_control_move_with_on_off(
 433         ZigbeeZcl_level_control *level_control_object,
 434         GDBusMethodInvocation *invocation,
 435         gshort node_id,
 436         gchar endpoint,
 437         gchar move_mode,
 438         gchar rate,
 439         gpointer user_data)
 440 {
 441         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 442         ZigbeeZclLevelControlMoveWithOnOff_t req;
 443         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 444
 445         gboolean ret;
 446
 447         memset(&req, 0x0, sizeof(ZigbeeZclLevelControlMoveWithOnOff_t));
 448
 449         /* Update request structure */
 450         req.node_id = node_id;
 451         req.endpoint = endpoint;
 452         req.move_mode = move_mode;
 453         req.rate = rate;
 454
 455         /* Allocate response callback data */
 456         resp_cb_data =
 457                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 458                         invocation, NULL, 0);
 459         if (NULL == resp_cb_data) {
 460                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 461
 462                 /* Send failure response */
 463                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 464
 465                 return TRUE;
 466         }
 467
 468         /* Dispatch request */
 469         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 470                 ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
 471                 ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF,
 472                 &req, sizeof(req),
 473                 on_level_control_move_with_on_off_resp, resp_cb_data);
 474         if (FALSE == ret) {
 475                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 476
 477                 /* Free response callback data */
 478                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 479
 480                 /* Send failure response */
 481                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 482
 483                 return TRUE;
 484         }
 485
 486         return TRUE;
 487 }
 488
 489 static void on_level_control_step_with_on_off_resp(ZigBeeServiceInterface *service_interface,
 490         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 491 {
 492         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 493                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 494
 495         ZigbeeZcl_level_control *level_object = NULL;
 496         GDBusMethodInvocation *invocation = NULL;
 497
 498         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 499
 500         NOT_USED(service_interface);
 501         NOT_USED(request_id);
 502
 503         if (NULL == resp_data || 0 == resp_data_len) {
 504                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 505                 g_free(cb_data);
 506                 return;
 507         }
 508
 509         level_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 510         zblib_check_null_free_and_ret("level_object", level_object, cb_data);
 511
 512         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 513         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 514
 515         zigbee_zcl_level_control_complete_step_with_on_off(level_object, invocation,
 516                 payload->result);
 517
 518         g_free(cb_data);
 519 }
 520
 521 static gboolean on_level_control_step_with_on_off(
 522         ZigbeeZcl_level_control *level_control_object,
 523         GDBusMethodInvocation *invocation,
 524         gshort node_id,
 525         gchar endpoint,
 526         gchar step_mode,
 527         gchar step_size,
 528         gshort transition_time,
 529         gpointer user_data)
 530 {
 531         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 532         ZigbeeZclLevelControlStepWithOnOff_t req;
 533         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 534
 535         gboolean ret;
 536
 537         memset(&req, 0x0, sizeof(ZigbeeZclLevelControlStepWithOnOff_t));
 538
 539         /* Update request structure */
 540         req.node_id = node_id;
 541         req.endpoint = endpoint;
 542         req.step_mode = step_mode;
 543         req.step_size = step_size;
 544         req.transition_time = transition_time;
 545
 546         /* Allocate response callback data */
 547         resp_cb_data =
 548                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 549                         invocation, NULL, 0);
 550         if (NULL == resp_cb_data) {
 551                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 552
 553                 /* Send failure response */
 554                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 555
 556                 return TRUE;
 557         }
 558
 559         /* Dispatch request */
 560         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 561                 ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
 562                 ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF,
 563                 &req, sizeof(req),
 564                 on_level_control_step_with_on_off_resp, resp_cb_data);
 565         if (FALSE == ret) {
 566                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 567
 568                 /* Free response callback data */
 569                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 570
 571                 /* Send failure response */
 572                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 573
 574                 return TRUE;
 575         }
 576
 577         return TRUE;
 578 }
 579
 580 static void on_level_control_stop_resp(ZigBeeServiceInterface *service_interface,
 581         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 582 {
 583         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 584                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 585
 586         ZigbeeZcl_level_control *level_object = NULL;
 587         GDBusMethodInvocation *invocation = NULL;
 588
 589         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 590
 591         NOT_USED(service_interface);
 592         NOT_USED(request_id);
 593
 594         if (NULL == resp_data || 0 == resp_data_len) {
 595                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 596                 g_free(cb_data);
 597                 return;
 598         }
 599
 600         level_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 601         zblib_check_null_free_and_ret("level_object", level_object, cb_data);
 602
 603         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 604         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 605
 606         zigbee_zcl_level_control_complete_stop(level_object, invocation, payload->result);
 607
 608         g_free(cb_data);
 609 }
 610
 611 static gboolean on_level_control_stop(ZigbeeZcl_level_control *level_control_object,
 612         GDBusMethodInvocation *invocation,
 613         gshort node_id,
 614         gchar endpoint,
 615         gpointer user_data)
 616 {
 617         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 618         ZigbeeZclLevelControlStop_t req;
 619         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 620
 621         gboolean ret;
 622
 623         memset(&req, 0x0, sizeof(ZigbeeZclLevelControlStop_t));
 624
 625         /* Update request structure */
 626         req.node_id = node_id;
 627         req.endpoint = endpoint;
 628
 629         /* Allocate response callback data */
 630         resp_cb_data =
 631                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 632                         invocation, NULL, 0);
 633         if (NULL == resp_cb_data) {
 634                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 635
 636                 /* Send failure response */
 637                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 638
 639                 return TRUE;
 640         }
 641
 642         /* Dispatch request */
 643         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 644                 ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
 645                 ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP,
 646                 &req, sizeof(req),
 647                 on_level_control_stop_resp, resp_cb_data);
 648         if (FALSE == ret) {
 649                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 650
 651                 /* Free response callback data */
 652                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 653
 654                 /* Send failure response */
 655                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 656
 657                 return TRUE;
 658         }
 659
 660         return TRUE;
 661 }
 662
 663 void zigbee_service_dbus_interface_zcl_level_control_notification(ZigBeeServiceInterface *service_interface,
 664         guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
 665 {
 666         ZigbeeZcl_level_control *level_object;
 667
 668         zblib_check_null_ret("service_interface", service_interface);
 669
 670         if (NULL == noti_data || 0 == noti_data_len) {
 671                 Z_LOGE("noti_data=%p or noti_data_len=%d is null", noti_data, noti_data_len);
 672                 return;
 673         }
 674
 675         level_object = _service_interface_ref_zigbee_zcl_level_control(service_interface);
 676         zblib_check_null_ret("level_object", level_object);
 677
 678         NOT_USED(noti_cb_data);
 679
 680         switch (noti_id) {
 681         default:
 682                 Z_LOGE("Unexpected notification [%x]", noti_id);
 683         break;
 684         }
 685
 686         /* ZigbeeZcl_level_control should be dereferenced */
 687         g_object_unref(level_object);
 688 }
 689 /* LCOV_EXCL_STOP */
 690
 691 gboolean zigbee_service_dbus_interface_zcl_level_control_init(ZigBeeServiceInterface *service_interface,
 692         ZigbeeObjectSkeleton *zigbee_object)
 693 {
 694         ZigbeeZcl_level_control *level_control_object;
 695
 696         if (NULL == service_interface) {
 697                 /* LCOV_EXCL_START */
 698                 Z_LOGE("service_interface is NULL");
 699                 return FALSE;
 700                 /* LCOV_EXCL_STOP */
 701         }
 702
 703         level_control_object = zigbee_zcl_level_control_skeleton_new();
 704         zigbee_object_skeleton_set_zcl_level_control(zigbee_object, level_control_object);
 705         g_object_unref(level_control_object);
 706
 707         Z_LOGI("level_control_object: [%p]", level_control_object);
 708
 709         /*
 710          * Register signal handlers for 'level_control' interface
 711          */
 712         g_signal_connect(level_control_object,
 713                 "handle-move-to-level",
 714                 G_CALLBACK(on_level_control_move_to_level), service_interface);
 715
 716         g_signal_connect(level_control_object,
 717                 "handle-move",
 718                 G_CALLBACK(on_level_control_move), service_interface);
 719
 720         g_signal_connect(level_control_object,
 721                 "handle-step",
 722                 G_CALLBACK(on_level_control_step), service_interface);
 723
 724         g_signal_connect(level_control_object,
 725                 "handle-move-to-level-with-on-off",
 726                 G_CALLBACK(on_level_control_move_to_level_with_on_off), service_interface);
 727
 728         g_signal_connect(level_control_object,
 729                 "handle-move-with-on-off",
 730                 G_CALLBACK(on_level_control_move_with_on_off), service_interface);
 731
 732         g_signal_connect(level_control_object,
 733                 "handle-step-with-on-off",
 734                 G_CALLBACK(on_level_control_step_with_on_off), service_interface);
 735
 736         g_signal_connect(level_control_object,
 737                 "handle-stop",
 738                 G_CALLBACK(on_level_control_stop), service_interface);
 739
 740         return TRUE;
 741 }