zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zcl_fan_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_zcl_fan_control.h>
  22
  23 static void on_fan_control_set_fan_mode_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_fan_control_set_fan_mode(ZigbeeZcl_fan_control *fan_control_object,
  37         GDBusMethodInvocation *invocation,
  38         GVariant *eui64,
  39         gchar endpoint,
  40         gpointer user_data)
  41 {
  42         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  43         ZigbeeFanControlSetFanMode_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(ZigbeeFanControlSetFanMode_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(fan_control_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_FAN_CONTROL,
  78                 ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE,
  79                 &req, sizeof(req),
  80                 on_fan_control_set_fan_mode_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_fan_control_get_fan_mode_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_fan_control_get_fan_mode(ZigbeeZcl_fan_control *fan_control_object,
 110         GDBusMethodInvocation *invocation,
 111         GVariant *eui64,
 112         gchar endpoint,
 113         gpointer user_data)
 114 {
 115         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 116         ZigbeeFanControlGetFanMode_t req;
 117         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 118
 119         GVariantIter *iter = NULL;
 120         guint i = 0;
 121
 122         gboolean ret;
 123
 124         memset(&req, 0x0, sizeof(ZigbeeFanControlGetFanMode_t));
 125
 126         /* Update request structure */
 127         g_variant_get(eui64, "ay", &iter);
 128         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
 129                 i++;
 130                 if (i >= ZIGBEE_EUI64_SIZE)
 131                         break;
 132         }
 133         req.endpoint = endpoint;
 134
 135         /* Allocate response callback data */
 136         resp_cb_data =
 137                 zigbee_service_dbus_interface_create_resp_cb_data(fan_control_object,
 138                         invocation, NULL, 0);
 139         if (NULL == resp_cb_data) {
 140                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 141
 142                 /* Send failure response */
 143                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 144
 145                 return TRUE;
 146         }
 147
 148         /* Dispatch request */
 149         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 150                 ZBLIB_DRIVER_TYPE_FAN_CONTROL,
 151                 ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE,
 152                 &req, sizeof(req),
 153                 on_fan_control_get_fan_mode_resp, resp_cb_data);
 154         if (FALSE == ret) {
 155                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 156
 157                 /* Free response callback data */
 158                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 159
 160                 /* Send failure response */
 161                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 162
 163                 return TRUE;
 164         }
 165
 166         return TRUE;
 167 }
 168
 169 static void on_fan_control_set_fan_mode_sequence_resp(ZigBeeServiceInterface *service_interface,
 170         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 171 {
 172         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 173                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 174
 175         NOT_USED(cb_data);
 176         NOT_USED(service_interface);
 177         NOT_USED(request_id);
 178         NOT_USED(resp_data);
 179         NOT_USED(resp_data_len);
 180 }
 181
 182 static gboolean on_fan_control_set_fan_mode_sequence(
 183         ZigbeeZcl_fan_control *fan_control_object,
 184         GDBusMethodInvocation *invocation,
 185         GVariant *eui64,
 186         gchar endpoint,
 187         gpointer user_data)
 188 {
 189         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 190         ZigbeeFanControlSetFanModeSequence_t req;
 191         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 192
 193         GVariantIter *iter = NULL;
 194         guint i = 0;
 195
 196         gboolean ret;
 197
 198         memset(&req, 0x0, sizeof(ZigbeeFanControlSetFanModeSequence_t));
 199
 200         /* Update request structure */
 201         g_variant_get(eui64, "ay", &iter);
 202         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
 203                 i++;
 204                 if (i >= ZIGBEE_EUI64_SIZE)
 205                         break;
 206         }
 207         req.endpoint = endpoint;
 208
 209         /* Allocate response callback data */
 210         resp_cb_data =
 211                 zigbee_service_dbus_interface_create_resp_cb_data(fan_control_object,
 212                         invocation, NULL, 0);
 213         if (NULL == resp_cb_data) {
 214                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 215
 216                 /* Send failure response */
 217                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 218
 219                 return TRUE;
 220         }
 221
 222         /* Dispatch request */
 223         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 224                 ZBLIB_DRIVER_TYPE_FAN_CONTROL,
 225                 ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE,
 226                 &req, sizeof(req),
 227                 on_fan_control_set_fan_mode_sequence_resp, resp_cb_data);
 228         if (FALSE == ret) {
 229                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 230
 231                 /* Free response callback data */
 232                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 233
 234                 /* Send failure response */
 235                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 236
 237                 return TRUE;
 238         }
 239
 240         return TRUE;
 241 }
 242
 243 static void on_fan_control_get_fan_mode_sequence_resp(ZigBeeServiceInterface *service_interface,
 244         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 245 {
 246         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 247                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 248
 249         NOT_USED(cb_data);
 250         NOT_USED(service_interface);
 251         NOT_USED(request_id);
 252         NOT_USED(resp_data);
 253         NOT_USED(resp_data_len);
 254 }
 255
 256 static gboolean on_fan_control_get_fan_mode_sequence(
 257         ZigbeeZcl_fan_control *fan_control_object,
 258         GDBusMethodInvocation *invocation,
 259         GVariant *eui64,
 260         gchar endpoint,
 261         gpointer user_data)
 262 {
 263         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 264         ZigbeeFanControlGetFanModeSequence_t req;
 265         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 266
 267         GVariantIter *iter = NULL;
 268         guint i = 0;
 269
 270         gboolean ret;
 271
 272         memset(&req, 0x0, sizeof(ZigbeeFanControlGetFanModeSequence_t));
 273
 274         /* Update request structure */
 275         g_variant_get(eui64, "ay", &iter);
 276         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
 277                 i++;
 278                 if (i >= ZIGBEE_EUI64_SIZE)
 279                         break;
 280         }
 281         req.endpoint = endpoint;
 282
 283         /* Allocate response callback data */
 284         resp_cb_data =
 285                 zigbee_service_dbus_interface_create_resp_cb_data(fan_control_object,
 286                         invocation, NULL, 0);
 287         if (NULL == resp_cb_data) {
 288                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 289
 290                 /* Send failure response */
 291                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 292
 293                 return TRUE;
 294         }
 295
 296         /* Dispatch request */
 297         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 298                 ZBLIB_DRIVER_TYPE_FAN_CONTROL,
 299                 ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE,
 300                 &req, sizeof(req),
 301                 on_fan_control_get_fan_mode_sequence_resp, resp_cb_data);
 302         if (FALSE == ret) {
 303                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 304
 305                 /* Free response callback data */
 306                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 307
 308                 /* Send failure response */
 309                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 310
 311                 return TRUE;
 312         }
 313
 314         return TRUE;
 315 }
 316
 317 gboolean zigbee_service_dbus_interface_zcl_fan_control_init(ZigBeeServiceInterface *service_interface,
 318         ZigbeeObjectSkeleton *zigbee_object)
 319 {
 320         ZigbeeZcl_fan_control *fan_control_object;
 321
 322         if (NULL == service_interface) {
 323                 Z_LOGE("service_interface is NULL");
 324                 return FALSE;
 325         }
 326
 327         fan_control_object = zigbee_zcl_fan_control_skeleton_new();
 328         zigbee_object_skeleton_set_zcl_fan_control(zigbee_object, fan_control_object);
 329         g_object_unref(fan_control_object);
 330
 331         Z_LOGI("fan_control_object: [%p]", fan_control_object);
 332
 333         /*
 334          * Register signal handlers for 'fan_control' interface
 335          */
 336         g_signal_connect(fan_control_object,
 337                 "handle-set-fan-mode",
 338                 G_CALLBACK(on_fan_control_set_fan_mode), service_interface);
 339
 340         g_signal_connect(fan_control_object,
 341                 "handle-get-fan-mode",
 342                 G_CALLBACK(on_fan_control_get_fan_mode), service_interface);
 343
 344         g_signal_connect(fan_control_object,
 345                 "handle-set-fan-mode-sequence",
 346                 G_CALLBACK(on_fan_control_set_fan_mode_sequence), service_interface);
 347
 348         g_signal_connect(fan_control_object,
 349                 "handle-get-fan-mode-sequence",
 350                 G_CALLBACK(on_fan_control_get_fan_mode_sequence), service_interface);
 351
 352         return TRUE;
 353 }