zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zcl_alarm.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_alarm.h>
  22
  23 /* LCOV_EXCL_START */
  24 static void *_service_interface_ref_zigbee_zcl_alarm(ZigBeeServiceInterface *service_interface)
  25 {
  26         ZigbeeObjectSkeleton *zigbee_object = NULL;
  27         ZigbeeCustomData_t *custom_data = NULL;
  28         ZigbeeZcl_alarm *alarm_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         alarm_object = zigbee_object_get_zcl_alarm(ZIGBEE_OBJECT(zigbee_object));
  44         return alarm_object;
  45 }
  46
  47 static void on_alarm_get_alarm_count_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_alarm *zcl_alarm_object = NULL;
  54         GDBusMethodInvocation *invocation = NULL;
  55
  56         ZigbeeZclAlarmGetAlarmCountResp_t *payload =
  57                 (ZigbeeZclAlarmGetAlarmCountResp_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 is null");
  64                 g_free(cb_data);
  65                 return;
  66         }
  67
  68         zcl_alarm_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
  69         zblib_check_null_free_and_ret("zcl_alarm_object", zcl_alarm_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_alarm_complete_get_alarm_count(zcl_alarm_object, invocation,
  75                 payload->result, payload->status);
  76
  77         g_free(cb_data);
  78 }
  79
  80 static gboolean on_alarm_get_alarm_count(ZigbeeZcl_alarm *alarm_object,
  81         GDBusMethodInvocation *invocation,
  82         GVariant *eui64,
  83         gchar endpoint,
  84         gpointer user_data)
  85 {
  86         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  87         ZigbeeZclAlarmGetAlarmCount_t req;
  88         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  89
  90         GVariantIter *iter = NULL;
  91         guint i = 0;
  92
  93         gboolean ret;
  94
  95         memset(&req, 0x0, sizeof(ZigbeeZclAlarmGetAlarmCount_t));
  96
  97         /* Update request structure */
  98         g_variant_get(eui64, "a(y)", &iter);
  99         while (g_variant_iter_loop(iter, "(y)", &(req.eui64[i]))) {
 100                 i++;
 101                 if (i >= ZIGBEE_EUI64_SIZE)
 102                         break;
 103         }
 104         req.endpoint = endpoint;
 105
 106         /* Allocate response callback data */
 107         resp_cb_data =
 108                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 109                         invocation, NULL, 0);
 110         if (NULL == resp_cb_data) {
 111                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 112
 113                 /* Send failure response */
 114                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 115
 116                 return TRUE;
 117         }
 118
 119         /* Dispatch request */
 120         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 121                 ZBLIB_DRIVER_TYPE_ZCL_ALARM,
 122                 ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT,
 123                 &req, sizeof(req),
 124                 on_alarm_get_alarm_count_resp, resp_cb_data);
 125         if (FALSE == ret) {
 126                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 127
 128                 /* Free response callback data */
 129                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 130
 131                 /* Send failure response */
 132                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 133
 134                 return TRUE;
 135         }
 136
 137         return TRUE;
 138 }
 139
 140 static void on_alarm_reset_alarm_resp(ZigBeeServiceInterface *service_interface,
 141         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 142 {
 143         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 144                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 145
 146         ZigbeeZcl_alarm *zcl_alarm_object = NULL;
 147         GDBusMethodInvocation *invocation = NULL;
 148
 149         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 150
 151         NOT_USED(service_interface);
 152         NOT_USED(request_id);
 153
 154         if (NULL == resp_data || 0 == resp_data_len) {
 155                 Z_LOGE("resp_data is null");
 156                 g_free(cb_data);
 157                 return;
 158         }
 159
 160         zcl_alarm_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 161         zblib_check_null_free_and_ret("zcl_alarm_object", zcl_alarm_object, cb_data);
 162
 163         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 164         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 165
 166         zigbee_zcl_alarm_complete_reset_alarm(zcl_alarm_object, invocation,
 167                 payload->result);
 168
 169         g_free(cb_data);
 170 }
 171
 172 static gboolean on_alarm_reset_alarm(ZigbeeZcl_alarm *alarm_object,
 173         GDBusMethodInvocation *invocation,
 174         gshort node_id,
 175         gchar endpoint,
 176         gchar alarmcode,
 177         gshort cluster_id,
 178         gpointer user_data)
 179 {
 180         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 181         ZigbeeZclAlarmResetAlarm_t req;
 182         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 183
 184         gboolean ret;
 185
 186         memset(&req, 0x0, sizeof(ZigbeeZclAlarmResetAlarm_t));
 187
 188         /* Update request structure */
 189         req.node_id = node_id;
 190         req.endpoint = endpoint;
 191         req.alarm_code = alarmcode;
 192         req.cluster_id = cluster_id;
 193
 194         /* Allocate response callback data */
 195         resp_cb_data =
 196                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 197                         invocation, &req, sizeof(req));
 198         if (NULL == resp_cb_data) {
 199                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 200
 201                 /* Send failure response */
 202                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 203
 204                 return TRUE;
 205         }
 206
 207         /* Dispatch request */
 208         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 209                 ZBLIB_DRIVER_TYPE_ZCL_ALARM,
 210                 ZBLIB_ZCL_ALARM_OPS_RESET_ALARM,
 211                 &req, sizeof(req),
 212                 on_alarm_reset_alarm_resp, resp_cb_data);
 213         if (FALSE == ret) {
 214                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 215
 216                 /* Free response callback data */
 217                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 218
 219                 /* Send failure response */
 220                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 221
 222                 return TRUE;
 223         }
 224
 225         return TRUE;
 226 }
 227
 228 static void on_alarm_reset_all_alarm_resp(ZigBeeServiceInterface *service_interface,
 229         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 230 {
 231         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 232                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 233
 234         ZigbeeZcl_alarm *zcl_alarm_object = NULL;
 235         GDBusMethodInvocation *invocation = NULL;
 236
 237         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 238
 239         NOT_USED(service_interface);
 240         NOT_USED(request_id);
 241
 242         if (NULL == resp_data || 0 == resp_data_len) {
 243                 Z_LOGE("resp_data is null");
 244                 g_free(cb_data);
 245                 return;
 246         }
 247
 248         zcl_alarm_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 249         zblib_check_null_free_and_ret("zcl_alarm_object", zcl_alarm_object, cb_data);
 250
 251         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 252         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 253
 254         zigbee_zcl_alarm_complete_reset_all_alarm(zcl_alarm_object, invocation,
 255                 payload->result);
 256
 257         g_free(cb_data);
 258 }
 259
 260 static gboolean on_alarm_reset_all_alarm(ZigbeeZcl_alarm *alarm_object,
 261         GDBusMethodInvocation *invocation,
 262         gshort node_id,
 263         gchar endpoint,
 264         gpointer user_data)
 265 {
 266         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 267         ZigbeeZclAlarmResetAllAlarm_t req;
 268         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 269
 270         gboolean ret;
 271
 272         memset(&req, 0x0, sizeof(ZigbeeZclAlarmResetAllAlarm_t));
 273
 274         /* Update request structure */
 275         req.node_id = node_id;
 276         req.endpoint = endpoint;
 277
 278         /* Allocate response callback data */
 279         resp_cb_data =
 280                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 281                         invocation, NULL, 0);
 282         if (NULL == resp_cb_data) {
 283                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 284
 285                 /* Send failure response */
 286                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 287
 288                 return TRUE;
 289         }
 290
 291         /* Dispatch request */
 292         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 293                 ZBLIB_DRIVER_TYPE_ZCL_ALARM,
 294                 ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM,
 295                 &req, sizeof(req),
 296                 on_alarm_reset_all_alarm_resp, resp_cb_data);
 297         if (FALSE == ret) {
 298                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 299
 300                 /* Free response callback data */
 301                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 302
 303                 /* Send failure response */
 304                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 305
 306                 return TRUE;
 307         }
 308
 309         return TRUE;
 310 }
 311
 312 static void on_alarm_alarm_resp(ZigBeeServiceInterface *service_interface,
 313         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 314 {
 315         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 316                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 317
 318         ZigbeeZcl_alarm *zcl_alarm_object = NULL;
 319         GDBusMethodInvocation *invocation = NULL;
 320
 321         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 322
 323         NOT_USED(service_interface);
 324         NOT_USED(request_id);
 325
 326         if (NULL == resp_data || 0 == resp_data_len) {
 327                 Z_LOGE("resp_data is null");
 328                 g_free(cb_data);
 329                 return;
 330         }
 331
 332         zcl_alarm_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 333         zblib_check_null_free_and_ret("zcl_alarm_object", zcl_alarm_object, cb_data);
 334
 335         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 336         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 337
 338         zigbee_zcl_alarm_complete_alarm(zcl_alarm_object, invocation,
 339                 payload->result);
 340
 341         g_free(cb_data);
 342 }
 343
 344 static gboolean on_alarm_alarm(ZigbeeZcl_alarm *alarm_object,
 345         GDBusMethodInvocation *invocation,
 346         GVariant *eui64,
 347         gchar endpoint,
 348         gchar alarmcode,
 349         gshort cluster_id,
 350         gpointer user_data)
 351 {
 352         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 353         ZigbeeZclAlarmAlarm_t req;
 354         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 355
 356         GVariantIter *iter = NULL;
 357         guint i = 0;
 358
 359         gboolean ret;
 360
 361         memset(&req, 0x0, sizeof(ZigbeeZclAlarmAlarm_t));
 362
 363         /* Update request structure */
 364         g_variant_get(eui64, "a(y)", &iter);
 365         while (g_variant_iter_loop(iter, "(y)", &(req.eui64[i]))) {
 366                 i++;
 367                 if (i >= ZIGBEE_EUI64_SIZE)
 368                         break;
 369         }
 370         req.endpoint = endpoint;
 371         req.alarm_code = alarmcode;
 372         req.cluster_id = cluster_id;
 373
 374         /* Allocate response callback data */
 375         resp_cb_data =
 376                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 377                         invocation, NULL, 0);
 378         if (NULL == resp_cb_data) {
 379                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 380
 381                 /* Send failure response */
 382                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 383
 384                 return TRUE;
 385         }
 386
 387         /* Dispatch request */
 388         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 389                 ZBLIB_DRIVER_TYPE_ZCL_ALARM,
 390                 ZBLIB_ZCL_ALARM_OPS_ALARM,
 391                 &req, sizeof(req),
 392                 on_alarm_alarm_resp, resp_cb_data);
 393         if (FALSE == ret) {
 394                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 395
 396                 /* Free response callback data */
 397                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 398
 399                 /* Send failure response */
 400                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 401
 402                 return TRUE;
 403         }
 404
 405         return TRUE;
 406 }
 407
 408 static void on_alarm_reset_alarm_log_resp(ZigBeeServiceInterface *service_interface,
 409         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 410 {
 411         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 412                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 413
 414         ZigbeeZcl_alarm *zcl_alarm_object = NULL;
 415         GDBusMethodInvocation *invocation = NULL;
 416
 417         ZigbeeGeneralResp_t *payload =
 418                 (ZigbeeGeneralResp_t *)resp_data;
 419
 420         NOT_USED(service_interface);
 421         NOT_USED(request_id);
 422
 423         if (NULL == resp_data || 0 == resp_data_len) {
 424                 Z_LOGE("resp_data is null");
 425                 g_free(cb_data);
 426                 return;
 427         }
 428
 429         zcl_alarm_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 430         zblib_check_null_free_and_ret("zcl_alarm_object", zcl_alarm_object, cb_data);
 431
 432         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 433         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 434
 435         zigbee_zcl_alarm_complete_reset_alarm_log(zcl_alarm_object, invocation,
 436                 payload->result);
 437
 438         g_free(cb_data);
 439 }
 440
 441 static gboolean on_alarm_reset_alarm_log(ZigbeeZcl_alarm *alarm_object,
 442         GDBusMethodInvocation *invocation,
 443         gshort node_id,
 444         gchar endpoint,
 445         gpointer user_data)
 446 {
 447         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 448         ZigbeeZclAlarmResetAlarmLogs_t req;
 449         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 450
 451         gboolean ret;
 452
 453         memset(&req, 0x0, sizeof(ZigbeeZclAlarmResetAlarmLogs_t));
 454
 455         /* Update request structure */
 456         req.node_id = node_id;
 457         req.endpoint = endpoint;
 458
 459         /* Allocate response callback data */
 460         resp_cb_data =
 461                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 462                         invocation, NULL, 0);
 463         if (NULL == resp_cb_data) {
 464                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 465
 466                 /* Send failure response */
 467                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 468
 469                 return TRUE;
 470         }
 471
 472         /* Dispatch request */
 473         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 474                 ZBLIB_DRIVER_TYPE_ZCL_ALARM,
 475                 ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG,
 476                 &req, sizeof(req),
 477                 on_alarm_reset_alarm_log_resp, resp_cb_data);
 478         if (FALSE == ret) {
 479                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 480
 481                 /* Free response callback data */
 482                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 483
 484                 /* Send failure response */
 485                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 486
 487                 return TRUE;
 488         }
 489
 490         return TRUE;
 491 }
 492
 493 static void on_alarm_get_alarm_resp(ZigBeeServiceInterface *service_interface,
 494         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 495 {
 496         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 497                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 498
 499         ZigbeeZcl_alarm *zcl_alarm_object = NULL;
 500         GDBusMethodInvocation *invocation = NULL;
 501
 502         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t *)resp_data;
 503
 504         NOT_USED(service_interface);
 505         NOT_USED(request_id);
 506
 507         if (NULL == resp_data || 0 == resp_data_len) {
 508                 Z_LOGE("resp_data is null");
 509                 g_free(cb_data);
 510                 return;
 511         }
 512
 513         zcl_alarm_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 514         zblib_check_null_free_and_ret("zcl_alarm_object", zcl_alarm_object, cb_data);
 515
 516         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 517         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 518
 519         zigbee_zcl_alarm_complete_get_alarm(zcl_alarm_object, invocation,
 520                 payload->result);
 521
 522         g_free(cb_data);
 523 }
 524
 525 static gboolean on_alarm_get_alarm(ZigbeeZcl_alarm *alarm_object,
 526         GDBusMethodInvocation *invocation,
 527         gshort node_id,
 528         gchar endpoint,
 529         gpointer user_data)
 530 {
 531         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 532         ZigbeeZclAlarmGetAlarm_t req;
 533         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 534
 535         gboolean ret;
 536
 537         memset(&req, 0x0, sizeof(ZigbeeZclAlarmGetAlarm_t));
 538
 539         /* Update request structure */
 540         req.node_id = node_id;
 541         req.endpoint = endpoint;
 542
 543         /* Allocate response callback data */
 544         resp_cb_data =
 545                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 546                         invocation, NULL, 0);
 547         if (NULL == resp_cb_data) {
 548                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 549
 550                 /* Send failure response */
 551                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 552
 553                 return TRUE;
 554         }
 555
 556         /* Dispatch request */
 557         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 558                 ZBLIB_DRIVER_TYPE_ZCL_ALARM,
 559                 ZBLIB_ZCL_ALARM_OPS_GET_ALARM,
 560                 &req, sizeof(req),
 561                 on_alarm_get_alarm_resp, resp_cb_data);
 562         if (FALSE == ret) {
 563                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 564
 565                 /* Free response callback data */
 566                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 567
 568                 /* Send failure response */
 569                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 570
 571                 return TRUE;
 572         }
 573
 574         return TRUE;
 575 }
 576
 577 void zigbee_service_dbus_interface_zcl_alarm_notification(ZigBeeServiceInterface *service_interface,
 578         guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
 579 {
 580         ZigbeeZcl_alarm *alarm_object;
 581
 582         zblib_check_null_ret("service_interface", service_interface);
 583
 584         if (NULL == noti_data || 0 == noti_data_len) {
 585                 Z_LOGE("noti_data is NULL");
 586                 return;
 587         }
 588
 589         alarm_object = _service_interface_ref_zigbee_zcl_alarm(service_interface);
 590         zblib_check_null_ret("alarm_object", alarm_object);
 591
 592         NOT_USED(noti_cb_data);
 593
 594         switch (noti_id) {
 595         case ZBLIB_ZCL_ALARM_NOTI_GET_ALARM_RSP: {
 596                 ZigbeeZclAlarmGetAlarmRsp_t *rsp =
 597                         (ZigbeeZclAlarmGetAlarmRsp_t*)noti_data;
 598
 599                 Z_LOGD("get_alarm_rsp from : [0x%X]", rsp->node_id);
 600
 601                 zigbee_zcl_alarm_emit_get_alarm_rsp(alarm_object, rsp->node_id, rsp->endpoint,
 602                         rsp->status, rsp->alarm_code, rsp->clusterid, rsp->timestamp);
 603         }
 604         break;
 605         default:
 606                 Z_LOGE("Unexpected notification [%x]", noti_id);
 607         break;
 608         }
 609
 610         /* ZigbeeZcl_alarm should be dereferenced */
 611         g_object_unref(alarm_object);
 612 }
 613 /* LCOV_EXCL_STOP */
 614
 615 gboolean zigbee_service_dbus_interface_zcl_alarm_init(ZigBeeServiceInterface *service_interface,
 616         ZigbeeObjectSkeleton *zigbee_object)
 617 {
 618         ZigbeeZcl_alarm *alarm_object;
 619
 620         if (NULL == service_interface) {
 621                 /* LCOV_EXCL_START */
 622                 Z_LOGE("service_interface is NULL");
 623                 return FALSE;
 624                 /* LCOV_EXCL_STOP */
 625         }
 626
 627         alarm_object = zigbee_zcl_alarm_skeleton_new();
 628         zigbee_object_skeleton_set_zcl_alarm(zigbee_object, alarm_object);
 629         g_object_unref(alarm_object);
 630
 631         Z_LOGI("alarm_object: [%p]", alarm_object);
 632
 633         /*
 634          * Register signal handlers for 'alarm' interface
 635          */
 636         g_signal_connect(alarm_object,
 637                 "handle-get-alarm-count",
 638                 G_CALLBACK(on_alarm_get_alarm_count), service_interface);
 639
 640         g_signal_connect(alarm_object,
 641                 "handle-reset-alarm",
 642                 G_CALLBACK(on_alarm_reset_alarm), service_interface);
 643
 644         g_signal_connect(alarm_object,
 645                 "handle-reset-all-alarm",
 646                 G_CALLBACK(on_alarm_reset_all_alarm), service_interface);
 647
 648         g_signal_connect(alarm_object,
 649                 "handle-alarm",
 650                 G_CALLBACK(on_alarm_alarm), service_interface);
 651
 652         g_signal_connect(alarm_object,
 653                 "handle-reset-alarm-log",
 654                 G_CALLBACK(on_alarm_reset_alarm_log), service_interface);
 655
 656         g_signal_connect(alarm_object,
 657                 "handle-get-alarm",
 658                 G_CALLBACK(on_alarm_get_alarm), service_interface);
 659
 660         return TRUE;
 661 }