zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zcl_thermostat.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_thermostat.h>
  22
  23 static void on_thermostat_get_local_temp_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_thermostat_get_local_temp(ZigbeeZcl_thermostat *thermostat_object,
  37         GDBusMethodInvocation *invocation,
  38         GVariant *eui64,
  39         gchar endpoint,
  40         gpointer user_data)
  41 {
  42         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  43         ZigbeeZclThermostatGetLocalTemp_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(ZigbeeZclThermostatGetLocalTemp_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(thermostat_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_ZCL_THERMOSTAT,
  78                 ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP,
  79                 &req, sizeof(req),
  80                 on_thermostat_get_local_temp_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_thermostat_get_weekly_schedule_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_thermostat_get_weekly_schedule(ZigbeeZcl_thermostat *thermostat_object,
 110         GDBusMethodInvocation *invocation,
 111         GVariant *eui64,
 112         gchar endpoint,
 113         gchar no_of_days,
 114         gchar mode,
 115         gpointer user_data)
 116 {
 117         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 118         ZigbeeZclThermostatGetWeeklySchedule_t req;
 119         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 120
 121         GVariantIter *iter = NULL;
 122         guint i = 0;
 123
 124         gboolean ret;
 125
 126         memset(&req, 0x0, sizeof(ZigbeeZclThermostatGetWeeklySchedule_t));
 127
 128         /* Update request structure */
 129         g_variant_get(eui64, "ay", &iter);
 130         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
 131                 i++;
 132                 if (i >= ZIGBEE_EUI64_SIZE)
 133                         break;
 134         }
 135         req.endpoint = endpoint;
 136         req.num_of_days = no_of_days;
 137         req.mode = mode;
 138
 139         /* Allocate response callback data */
 140         resp_cb_data =
 141                 zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
 142                         invocation, NULL, 0);
 143         if (NULL == resp_cb_data) {
 144                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 145
 146                 /* Send failure response */
 147                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 148
 149                 return TRUE;
 150         }
 151
 152         /* Dispatch request */
 153         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 154                 ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
 155                 ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE,
 156                 &req, sizeof(req),
 157                 on_thermostat_get_weekly_schedule_resp, resp_cb_data);
 158         if (FALSE == ret) {
 159                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 160
 161                 /* Free response callback data */
 162                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 163
 164                 /* Send failure response */
 165                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 166
 167                 return TRUE;
 168         }
 169
 170         return TRUE;
 171 }
 172
 173 static void on_thermostat_set_weekly_schedule_resp(ZigBeeServiceInterface *service_interface,
 174         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 175 {
 176         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 177                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 178
 179         NOT_USED(cb_data);
 180         NOT_USED(service_interface);
 181         NOT_USED(request_id);
 182         NOT_USED(resp_data);
 183         NOT_USED(resp_data_len);
 184 }
 185
 186 static gboolean on_thermostat_set_weekly_schedule(ZigbeeZcl_thermostat *thermostat_object,
 187         GDBusMethodInvocation *invocation,
 188         GVariant *eui64,
 189         gchar endpoint,
 190         gchar no_of_transitions,
 191         gchar no_of_days,
 192         gchar mode,
 193         GVariant *payload,
 194         gchar payload_len,
 195         gpointer user_data)
 196 {
 197         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 198         ZigbeeZclThermostatSetWeeklySchedule_t req;
 199         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 200
 201         GVariantIter *iter = NULL;
 202         guint i = 0;
 203
 204         gboolean ret;
 205
 206         memset(&req, 0x0, sizeof(ZigbeeZclThermostatSetWeeklySchedule_t));
 207
 208         /* Update request structure */
 209         g_variant_get(eui64, "ay", &iter);
 210         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
 211                 i++;
 212                 if (i >= ZIGBEE_EUI64_SIZE)
 213                         break;
 214         }
 215         req.endpoint = endpoint;
 216         req.no_of_transitions = no_of_transitions;
 217         req.num_of_days = no_of_days;
 218         req.mode = mode;
 219
 220         i = 0;
 221         g_variant_get(payload, "ay", &iter);
 222         while (g_variant_iter_loop(iter, "y", req.payload[i])) {
 223                 i++;
 224                 if (i >= (guint)payload_len)
 225                         break;
 226         }
 227         req.payload_len = payload_len;
 228
 229         /* Allocate response callback data */
 230         resp_cb_data =
 231                 zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
 232                         invocation, NULL, 0);
 233         if (NULL == resp_cb_data) {
 234                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 235
 236                 /* Send failure response */
 237                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 238
 239                 return TRUE;
 240         }
 241
 242         /* Dispatch request */
 243         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 244                 ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
 245                 ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE,
 246                 &req, sizeof(req),
 247                 on_thermostat_set_weekly_schedule_resp, resp_cb_data);
 248         if (FALSE == ret) {
 249                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 250
 251                 /* Free response callback data */
 252                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 253
 254                 /* Send failure response */
 255                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 256
 257                 return TRUE;
 258         }
 259
 260         return TRUE;
 261 }
 262
 263 static void on_thermostat_clear_weekly_schedule_resp(ZigBeeServiceInterface *service_interface,
 264         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 265 {
 266         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 267                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 268
 269         NOT_USED(cb_data);
 270         NOT_USED(service_interface);
 271         NOT_USED(request_id);
 272         NOT_USED(resp_data);
 273         NOT_USED(resp_data_len);
 274 }
 275
 276 static gboolean on_thermostat_clear_weekly_schedule(ZigbeeZcl_thermostat *thermostat_object,
 277         GDBusMethodInvocation *invocation,
 278         GVariant *eui64,
 279         gchar endpoint,
 280         gpointer user_data)
 281 {
 282         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 283         ZigbeeZclThermostatClearWeeklySchedule_t req;
 284         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 285
 286         GVariantIter *iter = NULL;
 287         guint i = 0;
 288
 289         gboolean ret;
 290
 291         memset(&req, 0x0, sizeof(ZigbeeZclThermostatClearWeeklySchedule_t));
 292
 293         /* Update request structure */
 294         g_variant_get(eui64, "ay", &iter);
 295         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
 296                 i++;
 297                 if (i >= ZIGBEE_EUI64_SIZE)
 298                         break;
 299         }
 300         req.endpoint = endpoint;
 301
 302         /* Allocate response callback data */
 303         resp_cb_data =
 304                 zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
 305                         invocation, NULL, 0);
 306         if (NULL == resp_cb_data) {
 307                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 308
 309                 /* Send failure response */
 310                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 311
 312                 return TRUE;
 313         }
 314
 315         /* Dispatch request */
 316         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 317                 ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
 318                 ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE,
 319                 &req, sizeof(req),
 320                 on_thermostat_clear_weekly_schedule_resp, resp_cb_data);
 321         if (FALSE == ret) {
 322                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 323
 324                 /* Free response callback data */
 325                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 326
 327                 /* Send failure response */
 328                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 329
 330                 return TRUE;
 331         }
 332
 333         return TRUE;
 334 }
 335
 336 static void on_thermostat_setpoint_raise_lower_resp(ZigBeeServiceInterface *service_interface,
 337         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 338 {
 339         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 340                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 341
 342         NOT_USED(cb_data);
 343         NOT_USED(service_interface);
 344         NOT_USED(request_id);
 345         NOT_USED(resp_data);
 346         NOT_USED(resp_data_len);
 347 }
 348
 349 static gboolean on_thermostat_setpoint_raise_lower(ZigbeeZcl_thermostat *thermostat_object,
 350         GDBusMethodInvocation *invocation,
 351         gshort node_id,
 352         gchar endpoint,
 353         gchar mode,
 354         gchar amount,
 355         gpointer user_data)
 356 {
 357         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 358         ZigbeeZclThermostatSetpointRaiseLower_t req;
 359         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 360
 361         gboolean ret;
 362
 363         memset(&req, 0x0, sizeof(ZigbeeZclThermostatSetpointRaiseLower_t));
 364
 365         /* Update request structure */
 366         req.node_id = node_id;
 367         req.endpoint = endpoint;
 368         req.mode = mode;
 369         req.amount = amount;
 370
 371         /* Allocate response callback data */
 372         resp_cb_data =
 373                 zigbee_service_dbus_interface_create_resp_cb_data(thermostat_object,
 374                         invocation, NULL, 0);
 375         if (NULL == resp_cb_data) {
 376                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 377
 378                 /* Send failure response */
 379                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 380
 381                 return TRUE;
 382         }
 383
 384         /* Dispatch request */
 385         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 386                 ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
 387                 ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER,
 388                 &req, sizeof(req),
 389                 on_thermostat_setpoint_raise_lower_resp, resp_cb_data);
 390         if (FALSE == ret) {
 391                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 392
 393                 /* Free response callback data */
 394                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 395
 396                 /* Send failure response */
 397                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 398
 399                 return TRUE;
 400         }
 401
 402         return TRUE;
 403 }
 404
 405 void zigbee_service_dbus_interface_zcl_thermostat_notification(ZigBeeServiceInterface *service_interface,
 406         guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
 407 {
 408         if (NULL == service_interface) {
 409                 Z_LOGE("service_interface is NULL");
 410                 return;
 411         }
 412
 413         NOT_USED(noti_id);
 414         NOT_USED(noti_data);
 415         NOT_USED(noti_data_len);
 416         NOT_USED(noti_cb_data);
 417 }
 418
 419 gboolean zigbee_service_dbus_interface_zcl_thermostat_init(ZigBeeServiceInterface *service_interface,
 420         ZigbeeObjectSkeleton *zigbee_object)
 421 {
 422         ZigbeeZcl_thermostat *thermostat_object;
 423
 424         if (NULL == service_interface) {
 425                 Z_LOGE("service_interface is NULL");
 426                 return FALSE;
 427         }
 428
 429         thermostat_object = zigbee_zcl_thermostat_skeleton_new();
 430         zigbee_object_skeleton_set_zcl_thermostat(zigbee_object, thermostat_object);
 431         g_object_unref(thermostat_object);
 432
 433         Z_LOGI("thermostat_object: [%p]", thermostat_object);
 434
 435         /*
 436          * Register signal handlers for 'thermostat' interface
 437          */
 438         g_signal_connect(thermostat_object,
 439                 "handle-get-local-temp",
 440                 G_CALLBACK(on_thermostat_get_local_temp), service_interface);
 441
 442         g_signal_connect(thermostat_object,
 443                 "handle-get-weekly-schedule",
 444                 G_CALLBACK(on_thermostat_get_weekly_schedule), service_interface);
 445
 446         g_signal_connect(thermostat_object,
 447                 "handle-set-weekly-schedule",
 448                 G_CALLBACK(on_thermostat_set_weekly_schedule), service_interface);
 449
 450         g_signal_connect(thermostat_object,
 451                 "handle-clear-weekly-schedule",
 452                 G_CALLBACK(on_thermostat_clear_weekly_schedule), service_interface);
 453
 454         g_signal_connect(thermostat_object,
 455                 "handle-setpoint-raise-lower",
 456                 G_CALLBACK(on_thermostat_setpoint_raise_lower), service_interface);
 457
 458         return TRUE;
 459 }