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