zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_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_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(ZigbeeLevel_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         ZigbeeLevelControlMoveToLevel_t req;
  46         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  47
  48         gboolean ret;
  49
  50         memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveToLevel_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_LEVEL_CONTROL,
  74                 ZBLIB_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(ZigbeeLevel_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         ZigbeeLevelControlMove_t req;
 115         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 116
 117         gboolean ret;
 118
 119         memset(&req, 0x0, sizeof(ZigbeeLevelControlMove_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_LEVEL_CONTROL,
 143                 ZBLIB_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(ZigbeeLevel_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         ZigbeeLevelControlStep_t req;
 185         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 186
 187         gboolean ret;
 188
 189         memset(&req, 0x0, sizeof(ZigbeeLevelControlStep_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_LEVEL_CONTROL,
 214                 ZBLIB_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(ZigbeeLevel_control *level_control_object,
 246         GDBusMethodInvocation *invocation,
 247         gshort node_id,
 248         gchar endpoint,
 249         gchar level,
 250         gshort transition,
 251         gpointer user_data)
 252 {
 253         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 254         ZigbeeLevelControlMoveToLevelWithOnOff_t req;
 255         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 256
 257         gboolean ret;
 258
 259         memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveToLevelWithOnOff_t));
 260
 261         /* Update request structure */
 262         req.node_id = node_id;
 263         req.endpoint = endpoint;
 264         req.level = level;
 265         req.transition = transition;
 266
 267         /* Allocate response callback data */
 268         resp_cb_data =
 269                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 270                         invocation, NULL, 0);
 271         if (NULL == resp_cb_data) {
 272                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 273
 274                 /* Send failure response */
 275                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 276
 277                 return TRUE;
 278         }
 279
 280         /* Dispatch request */
 281         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 282                 ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
 283                 ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF,
 284                 &req, sizeof(req),
 285                 on_level_control_move_to_level_with_on_off_resp, resp_cb_data);
 286         if (FALSE == ret) {
 287                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 288
 289                 /* Free response callback data */
 290                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 291
 292                 /* Send failure response */
 293                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 294
 295                 return TRUE;
 296         }
 297
 298         return TRUE;
 299 }
 300
 301 static void on_level_control_move_with_on_off_resp(ZigBeeServiceInterface *service_interface,
 302         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 303 {
 304         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 305                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 306
 307         NOT_USED(cb_data);
 308         NOT_USED(service_interface);
 309         NOT_USED(request_id);
 310         NOT_USED(resp_data);
 311         NOT_USED(resp_data_len);
 312 }
 313
 314 static gboolean on_level_control_move_with_on_off(ZigbeeLevel_control *level_control_object,
 315         GDBusMethodInvocation *invocation,
 316         gshort node_id,
 317         gchar endpoint,
 318         gchar move_mode,
 319         gchar rate,
 320         gpointer user_data)
 321 {
 322         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 323         ZigbeeLevelControlMoveWithOnOff_t req;
 324         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 325
 326         gboolean ret;
 327
 328         memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveWithOnOff_t));
 329
 330         /* Update request structure */
 331         req.node_id = node_id;
 332         req.endpoint = endpoint;
 333         req.move_mode = move_mode;
 334         req.rate = rate;
 335
 336         /* Allocate response callback data */
 337         resp_cb_data =
 338                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 339                         invocation, NULL, 0);
 340         if (NULL == resp_cb_data) {
 341                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 342
 343                 /* Send failure response */
 344                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 345
 346                 return TRUE;
 347         }
 348
 349         /* Dispatch request */
 350         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 351                 ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
 352                 ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF,
 353                 &req, sizeof(req),
 354                 on_level_control_move_with_on_off_resp, resp_cb_data);
 355         if (FALSE == ret) {
 356                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 357
 358                 /* Free response callback data */
 359                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 360
 361                 /* Send failure response */
 362                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 363
 364                 return TRUE;
 365         }
 366
 367         return TRUE;
 368 }
 369
 370 static void on_level_control_step_with_on_off_resp(ZigBeeServiceInterface *service_interface,
 371         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 372 {
 373         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 374                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 375
 376         NOT_USED(cb_data);
 377         NOT_USED(service_interface);
 378         NOT_USED(request_id);
 379         NOT_USED(resp_data);
 380         NOT_USED(resp_data_len);
 381 }
 382
 383 static gboolean on_level_control_step_with_on_off(ZigbeeLevel_control *level_control_object,
 384         GDBusMethodInvocation *invocation,
 385         gshort node_id,
 386         gchar endpoint,
 387         gchar step_mode,
 388         gchar move_mode,
 389         gshort transition_time,
 390         gpointer user_data)
 391 {
 392         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 393         ZigbeeLevelControlStepWithOnOff_t req;
 394         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 395
 396         gboolean ret;
 397
 398         memset(&req, 0x0, sizeof(ZigbeeLevelControlStepWithOnOff_t));
 399
 400         /* Update request structure */
 401         req.node_id = node_id;
 402         req.endpoint = endpoint;
 403         req.step_mode = step_mode;
 404         req.move_mode = move_mode;
 405         req.transition_time = transition_time;
 406
 407         /* Allocate response callback data */
 408         resp_cb_data =
 409                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 410                         invocation, NULL, 0);
 411         if (NULL == resp_cb_data) {
 412                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 413
 414                 /* Send failure response */
 415                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 416
 417                 return TRUE;
 418         }
 419
 420         /* Dispatch request */
 421         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 422                 ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
 423                 ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF,
 424                 &req, sizeof(req),
 425                 on_level_control_step_with_on_off_resp, resp_cb_data);
 426         if (FALSE == ret) {
 427                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 428
 429                 /* Free response callback data */
 430                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 431
 432                 /* Send failure response */
 433                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 434
 435                 return TRUE;
 436         }
 437
 438         return TRUE;
 439 }
 440
 441 static void on_level_control_stop_resp(ZigBeeServiceInterface *service_interface,
 442         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 443 {
 444         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 445                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 446
 447         NOT_USED(cb_data);
 448         NOT_USED(service_interface);
 449         NOT_USED(request_id);
 450         NOT_USED(resp_data);
 451         NOT_USED(resp_data_len);
 452 }
 453
 454 static gboolean on_level_control_stop(ZigbeeLevel_control *level_control_object,
 455         GDBusMethodInvocation *invocation,
 456         gshort node_id,
 457         gchar endpoint,
 458         gpointer user_data)
 459 {
 460         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 461         ZigbeeLevelControlStop_t req;
 462         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 463
 464         gboolean ret;
 465
 466         memset(&req, 0x0, sizeof(ZigbeeLevelControlStop_t));
 467
 468         /* Update request structure */
 469         req.node_id = node_id;
 470         req.endpoint = endpoint;
 471
 472         /* Allocate response callback data */
 473         resp_cb_data =
 474                 zigbee_service_dbus_interface_create_resp_cb_data(level_control_object,
 475                         invocation, NULL, 0);
 476         if (NULL == resp_cb_data) {
 477                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 478
 479                 /* Send failure response */
 480                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 481
 482                 return TRUE;
 483         }
 484
 485         /* Dispatch request */
 486         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 487                 ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
 488                 ZBLIB_LEVEL_CONTROL_OPS_STOP,
 489                 &req, sizeof(req),
 490                 on_level_control_stop_resp, resp_cb_data);
 491         if (FALSE == ret) {
 492                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 493
 494                 /* Free response callback data */
 495                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 496
 497                 /* Send failure response */
 498                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 499
 500                 return TRUE;
 501         }
 502
 503         return TRUE;
 504 }
 505
 506 gboolean zigbee_service_dbus_interface_level_control_init(ZigBeeServiceInterface *service_interface,
 507         ZigbeeObjectSkeleton *zigbee_object)
 508 {
 509         ZigbeeLevel_control *level_control_object;
 510
 511         if (NULL == service_interface) {
 512                 Z_LOGE("service_interface is NULL");
 513                 return FALSE;
 514         }
 515
 516         level_control_object = zigbee_level_control_skeleton_new();
 517         zigbee_object_skeleton_set_level_control(zigbee_object, level_control_object);
 518         g_object_unref(level_control_object);
 519
 520         Z_LOGI("level_control_object: [%p]", level_control_object);
 521
 522         /*
 523          * Register signal handlers for 'level_control' interface
 524          */
 525         g_signal_connect(level_control_object,
 526                 "handle-move-to-level",
 527                 G_CALLBACK(on_level_control_move_to_level), service_interface);
 528
 529         g_signal_connect(level_control_object,
 530                 "handle-move",
 531                 G_CALLBACK(on_level_control_move), service_interface);
 532
 533         g_signal_connect(level_control_object,
 534                 "handle-step",
 535                 G_CALLBACK(on_level_control_step), service_interface);
 536
 537         g_signal_connect(level_control_object,
 538                 "handle-move-to-level-with-on-off",
 539                 G_CALLBACK(on_level_control_move_to_level_with_on_off), service_interface);
 540
 541         g_signal_connect(level_control_object,
 542                 "handle-move-with-on-off",
 543                 G_CALLBACK(on_level_control_move_with_on_off), service_interface);
 544
 545         g_signal_connect(level_control_object,
 546                 "handle-step-with-on-off",
 547                 G_CALLBACK(on_level_control_step_with_on_off), service_interface);
 548
 549         g_signal_connect(level_control_object,
 550                 "handle-stop",
 551                 G_CALLBACK(on_level_control_stop), service_interface);
 552
 553         return TRUE;
 554 }