zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_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_alarm.h>
  22
  23 static void on_alarm_get_alarm_count_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_alarm_get_alarm_count(ZigbeeAlarm *alarm_object,
  37         GDBusMethodInvocation *invocation,
  38         GVariant *eui64,
  39         gchar endpoint,
  40         gpointer user_data)
  41 {
  42         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  43         ZigbeeAlarmGetAlarmCount_t req;
  44         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  45
  46         GVariantIter *iter = NULL;
  47         guint i = 0;
  48
  49         gboolean ret;
  50
  51         memset(&req, 0x0, sizeof(ZigbeeAlarmGetAlarmCount_t));
  52
  53         /* Update request structure */
  54         g_variant_get(eui64, "ay", &iter);
  55         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
  56                 i++;
  57                 if (i >= ZIGBEE_EUI64_SIZE)
  58                         break;
  59         }
  60         req.endpoint = endpoint;
  61
  62         /* Allocate response callback data */
  63         resp_cb_data =
  64                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
  65                         invocation, NULL, 0);
  66         if (NULL == resp_cb_data) {
  67                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
  68
  69                 /* Send failure response */
  70                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
  71
  72                 return TRUE;
  73         }
  74
  75         /* Dispatch request */
  76         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
  77                 ZBLIB_DRIVER_TYPE_ALARM,
  78                 ZBLIB_ALARM_OPS_GET_ALARM_COUNT,
  79                 &req, sizeof(req),
  80                 on_alarm_get_alarm_count_resp, resp_cb_data);
  81         if (FALSE == ret) {
  82                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
  83
  84                 /* Free response callback data */
  85                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
  86
  87                 /* Send failure response */
  88                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
  89
  90                 return TRUE;
  91         }
  92
  93         return TRUE;
  94 }
  95
  96 static void on_alarm_reset_alarm_resp(ZigBeeServiceInterface *service_interface,
  97         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
  98 {
  99         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 100                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 101
 102         NOT_USED(cb_data);
 103         NOT_USED(service_interface);
 104         NOT_USED(request_id);
 105         NOT_USED(resp_data);
 106         NOT_USED(resp_data_len);
 107 }
 108
 109 static gboolean on_alarm_reset_alarm(ZigbeeAlarm *alarm_object,
 110         GDBusMethodInvocation *invocation,
 111         gshort node_id,
 112         gchar endpoint,
 113         gchar alarmcode,
 114         gshort cluster_id,
 115         gpointer user_data)
 116 {
 117         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 118         ZigbeeAlarmResetAlarm_t req;
 119         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 120
 121         gboolean ret;
 122
 123         memset(&req, 0x0, sizeof(ZigbeeAlarmResetAlarm_t));
 124
 125         /* Update request structure */
 126         req.node_id = node_id;
 127         req.endpoint = endpoint;
 128         req.alarm_code = alarmcode;
 129         req.cluster_id = cluster_id;
 130
 131         /* Allocate response callback data */
 132         resp_cb_data =
 133                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 134                         invocation, NULL, 0);
 135         if (NULL == resp_cb_data) {
 136                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 137
 138                 /* Send failure response */
 139                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 140
 141                 return TRUE;
 142         }
 143
 144         /* Dispatch request */
 145         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 146                 ZBLIB_DRIVER_TYPE_ALARM,
 147                 ZBLIB_ALARM_OPS_RESET_ALARM,
 148                 &req, sizeof(req),
 149                 on_alarm_reset_alarm_resp, resp_cb_data);
 150         if (FALSE == ret) {
 151                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 152
 153                 /* Free response callback data */
 154                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 155
 156                 /* Send failure response */
 157                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 158
 159                 return TRUE;
 160         }
 161
 162         return TRUE;
 163 }
 164
 165 static void on_alarm_reset_all_alarm_resp(ZigBeeServiceInterface *service_interface,
 166         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 167 {
 168         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 169                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 170
 171         NOT_USED(cb_data);
 172         NOT_USED(service_interface);
 173         NOT_USED(request_id);
 174         NOT_USED(resp_data);
 175         NOT_USED(resp_data_len);
 176 }
 177
 178 static gboolean on_alarm_reset_all_alarm(ZigbeeAlarm *alarm_object,
 179         GDBusMethodInvocation *invocation,
 180         gshort node_id,
 181         gchar endpoint,
 182         gpointer user_data)
 183 {
 184         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 185         ZigbeeAlarmResetAllAlarm_t req;
 186         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 187
 188         gboolean ret;
 189
 190         memset(&req, 0x0, sizeof(ZigbeeAlarmResetAllAlarm_t));
 191
 192         /* Update request structure */
 193         req.node_id = node_id;
 194         req.endpoint = endpoint;
 195
 196         /* Allocate response callback data */
 197         resp_cb_data =
 198                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 199                         invocation, NULL, 0);
 200         if (NULL == resp_cb_data) {
 201                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 202
 203                 /* Send failure response */
 204                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 205
 206                 return TRUE;
 207         }
 208
 209         /* Dispatch request */
 210         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 211                 ZBLIB_DRIVER_TYPE_ALARM,
 212                 ZBLIB_ALARM_OPS_RESET_ALL_ALARM,
 213                 &req, sizeof(req),
 214                 on_alarm_reset_all_alarm_resp, resp_cb_data);
 215         if (FALSE == ret) {
 216                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 217
 218                 /* Free response callback data */
 219                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 220
 221                 /* Send failure response */
 222                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 223
 224                 return TRUE;
 225         }
 226
 227         return TRUE;
 228 }
 229
 230 static void on_alarm_alarm_resp(ZigBeeServiceInterface *service_interface,
 231         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 232 {
 233         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 234                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 235
 236         NOT_USED(cb_data);
 237         NOT_USED(service_interface);
 238         NOT_USED(request_id);
 239         NOT_USED(resp_data);
 240         NOT_USED(resp_data_len);
 241 }
 242
 243 static gboolean on_alarm_alarm(ZigbeeAlarm *alarm_object,
 244         GDBusMethodInvocation *invocation,
 245         GVariant *eui64,
 246         gchar endpoint,
 247         gchar alarmcode,
 248         gshort cluster_id,
 249         gpointer user_data)
 250 {
 251         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 252         ZigbeeAlarmAlarm_t req;
 253         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 254
 255         GVariantIter *iter = NULL;
 256         guint i = 0;
 257
 258         gboolean ret;
 259
 260         memset(&req, 0x0, sizeof(ZigbeeAlarmAlarm_t));
 261
 262         /* Update request structure */
 263         g_variant_get(eui64, "ay", &iter);
 264         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
 265                 i++;
 266                 if (i >= ZIGBEE_EUI64_SIZE)
 267                         break;
 268         }
 269         req.endpoint = endpoint;
 270         req.alarm_code = alarmcode;
 271         req.cluster_id = cluster_id;
 272
 273         /* Allocate response callback data */
 274         resp_cb_data =
 275                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 276                         invocation, NULL, 0);
 277         if (NULL == resp_cb_data) {
 278                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 279
 280                 /* Send failure response */
 281                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 282
 283                 return TRUE;
 284         }
 285
 286         /* Dispatch request */
 287         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 288                 ZBLIB_DRIVER_TYPE_ALARM,
 289                 ZBLIB_ALARM_OPS_ALARM,
 290                 &req, sizeof(req),
 291                 on_alarm_alarm_resp, resp_cb_data);
 292         if (FALSE == ret) {
 293                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 294
 295                 /* Free response callback data */
 296                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 297
 298                 /* Send failure response */
 299                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 300
 301                 return TRUE;
 302         }
 303
 304         return TRUE;
 305 }
 306
 307 static void on_alarm_reset_alarm_log_resp(ZigBeeServiceInterface *service_interface,
 308         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 309 {
 310         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 311                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 312
 313         NOT_USED(cb_data);
 314         NOT_USED(service_interface);
 315         NOT_USED(request_id);
 316         NOT_USED(resp_data);
 317         NOT_USED(resp_data_len);
 318 }
 319
 320 static gboolean on_alarm_reset_alarm_log(ZigbeeAlarm *alarm_object,
 321         GDBusMethodInvocation *invocation,
 322         gshort node_id,
 323         gchar endpoint,
 324         gpointer user_data)
 325 {
 326         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 327         ZigbeeAlarmResetAlarmLogs_t req;
 328         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 329
 330         gboolean ret;
 331
 332         memset(&req, 0x0, sizeof(ZigbeeAlarmResetAlarmLogs_t));
 333
 334         /* Update request structure */
 335         req.node_id = node_id;
 336         req.endpoint = endpoint;
 337
 338         /* Allocate response callback data */
 339         resp_cb_data =
 340                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_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_ALARM,
 354                 ZBLIB_ALARM_OPS_RESET_ALARM_LOG,
 355                 &req, sizeof(req),
 356                 on_alarm_reset_alarm_log_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_alarm_get_alarm_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_alarm_get_alarm(ZigbeeAlarm *alarm_object,
 386         GDBusMethodInvocation *invocation,
 387         gshort node_id,
 388         gchar endpoint,
 389         gpointer user_data)
 390 {
 391         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 392         ZigbeeAlarmGetAlarm_t req;
 393         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 394
 395         gboolean ret;
 396
 397         memset(&req, 0x0, sizeof(ZigbeeAlarmGetAlarm_t));
 398
 399         /* Update request structure */
 400         req.node_id = node_id;
 401         req.endpoint = endpoint;
 402
 403         /* Allocate response callback data */
 404         resp_cb_data =
 405                 zigbee_service_dbus_interface_create_resp_cb_data(alarm_object,
 406                         invocation, NULL, 0);
 407         if (NULL == resp_cb_data) {
 408                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 409
 410                 /* Send failure response */
 411                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 412
 413                 return TRUE;
 414         }
 415
 416         /* Dispatch request */
 417         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 418                 ZBLIB_DRIVER_TYPE_ALARM,
 419                 ZBLIB_ALARM_OPS_GET_ALARM,
 420                 &req, sizeof(req),
 421                 on_alarm_get_alarm_resp, resp_cb_data);
 422         if (FALSE == ret) {
 423                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 424
 425                 /* Free response callback data */
 426                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 427
 428                 /* Send failure response */
 429                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 430
 431                 return TRUE;
 432         }
 433
 434         return TRUE;
 435 }
 436
 437 gboolean zigbee_service_dbus_interface_alarm_init(ZigBeeServiceInterface *service_interface,
 438         ZigbeeObjectSkeleton *zigbee_object)
 439 {
 440         ZigbeeAlarm *alarm_object;
 441
 442         if (NULL == service_interface) {
 443                 Z_LOGE("service_interface is NULL");
 444                 return FALSE;
 445         }
 446
 447         alarm_object = zigbee_alarm_skeleton_new();
 448         zigbee_object_skeleton_set_alarm(zigbee_object, alarm_object);
 449         g_object_unref(alarm_object);
 450
 451         Z_LOGI("alarm_object: [%p]", alarm_object);
 452
 453         /*
 454          * Register signal handlers for 'alarm' interface
 455          */
 456         g_signal_connect(alarm_object,
 457                 "handle-get-alarm-count",
 458                 G_CALLBACK(on_alarm_get_alarm_count), service_interface);
 459
 460         g_signal_connect(alarm_object,
 461                 "handle-reset-alarm",
 462                 G_CALLBACK(on_alarm_reset_alarm), service_interface);
 463
 464         g_signal_connect(alarm_object,
 465                 "handle-reset-all-alarm",
 466                 G_CALLBACK(on_alarm_reset_all_alarm), service_interface);
 467
 468         g_signal_connect(alarm_object,
 469                 "handle-alarm",
 470                 G_CALLBACK(on_alarm_alarm), service_interface);
 471
 472         g_signal_connect(alarm_object,
 473                 "handle-reset-alarm-log",
 474                 G_CALLBACK(on_alarm_reset_alarm_log), service_interface);
 475
 476         g_signal_connect(alarm_object,
 477                 "handle-get-alarm",
 478                 G_CALLBACK(on_alarm_get_alarm), service_interface);
 479
 480         return TRUE;
 481 }