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