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