zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zclglobal_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 static gboolean on_zclglobal_control_read_attributes_req(ZigbeeZclglobal_control *zclglobal_control_object,
  22         GDBusMethodInvocation *invocation,
  23         GVariant *attribute_id,
  24         gint attribute_ids_length,
  25         gshort node_id,
  26         gshort cluster_id,
  27         gchar zcl_frame_ctrl,
  28         gchar dest_ep,
  29         gpointer user_data)
  30 {
  31         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  32
  33         NOT_USED(zclglobal_control_object);
  34         NOT_USED(invocation);
  35         NOT_USED(service_interface);
  36         NOT_USED(attribute_id);
  37         NOT_USED(attribute_ids_length);
  38         NOT_USED(node_id);
  39         NOT_USED(cluster_id);
  40         NOT_USED(zcl_frame_ctrl);
  41         NOT_USED(dest_ep);
  42
  43         /*
  44          * TODO -
  45          * Create and send request for processing
  46          */
  47
  48         return TRUE;
  49 }
  50
  51 static gboolean on_zclglobal_control_write_attributes_req(ZigbeeZclglobal_control *zclglobal_control_object,
  52         GDBusMethodInvocation *invocation,
  53         GVariant *write_attribute,
  54         gint records_length,
  55         gshort node_id,
  56         gshort cluster_id,
  57         gchar zcl_frame_ctrl,
  58         gchar dest_ep,
  59         gpointer user_data)
  60 {
  61         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  62
  63         NOT_USED(zclglobal_control_object);
  64         NOT_USED(invocation);
  65         NOT_USED(service_interface);
  66         NOT_USED(write_attribute);
  67         NOT_USED(records_length);
  68         NOT_USED(node_id);
  69         NOT_USED(cluster_id);
  70         NOT_USED(zcl_frame_ctrl);
  71         NOT_USED(dest_ep);
  72
  73         /*
  74          * TODO -
  75          * Create and send request for processing
  76          */
  77
  78         return TRUE;
  79 }
  80
  81 static gboolean on_zclglobal_control_write_attributes_undivided_req(ZigbeeZclglobal_control *zclglobal_control_object,
  82         GDBusMethodInvocation *invocation,
  83         GVariant *write_attribute,
  84         gint records_length,
  85         gshort node_id,
  86         gshort cluster_id,
  87         gchar zcl_frame_ctrl,
  88         gchar src_ep,
  89         gchar dest_ep,
  90         gpointer user_data)
  91 {
  92         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  93
  94         NOT_USED(zclglobal_control_object);
  95         NOT_USED(invocation);
  96         NOT_USED(service_interface);
  97         NOT_USED(write_attribute);
  98         NOT_USED(records_length);
  99         NOT_USED(node_id);
 100         NOT_USED(cluster_id);
 101         NOT_USED(zcl_frame_ctrl);
 102         NOT_USED(src_ep);
 103         NOT_USED(dest_ep);
 104
 105         /*
 106          * TODO -
 107          * Create and send request for processing
 108          */
 109
 110         return TRUE;
 111 }
 112
 113 static gboolean on_zclglobal_control_write_attributes_no_resp(ZigbeeZclglobal_control *zclglobal_control_object,
 114         GDBusMethodInvocation *invocation,
 115         GVariant *write_attribute,
 116         gint records_length,
 117         gshort node_id,
 118         gshort cluster_id,
 119         gchar zcl_frame_ctrl,
 120         gchar src_ep,
 121         gchar dest_ep,
 122         gpointer user_data)
 123 {
 124         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 125
 126         NOT_USED(zclglobal_control_object);
 127         NOT_USED(invocation);
 128         NOT_USED(service_interface);
 129         NOT_USED(write_attribute);
 130         NOT_USED(records_length);
 131         NOT_USED(node_id);
 132         NOT_USED(cluster_id);
 133         NOT_USED(zcl_frame_ctrl);
 134         NOT_USED(src_ep);
 135         NOT_USED(dest_ep);
 136
 137         /*
 138          * TODO -
 139          * Create and send request for processing
 140          */
 141
 142         return TRUE;
 143 }
 144
 145 static gboolean on_zclglobal_control_write_attributes_structured(ZigbeeZclglobal_control *zclglobal_control_object,
 146         GDBusMethodInvocation *invocation,
 147         GVariant *write_attribute,
 148         gint records_length,
 149         gshort node_id,
 150         gshort cluster_id,
 151         gchar zcl_frame_ctrl,
 152         gchar src_ep,
 153         gchar dest_ep,
 154         gpointer user_data)
 155 {
 156         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 157
 158         NOT_USED(zclglobal_control_object);
 159         NOT_USED(invocation);
 160         NOT_USED(service_interface);
 161         NOT_USED(write_attribute);
 162         NOT_USED(records_length);
 163         NOT_USED(node_id);
 164         NOT_USED(cluster_id);
 165         NOT_USED(zcl_frame_ctrl);
 166         NOT_USED(src_ep);
 167         NOT_USED(dest_ep);
 168
 169         /*
 170          * TODO -
 171          * Create and send request for processing
 172          */
 173
 174         return TRUE;
 175 }
 176
 177 static gboolean on_zclglobal_control_read_attributes_structured(ZigbeeZclglobal_control *zclglobal_control_object,
 178         GDBusMethodInvocation *invocation,
 179         GVariant *read_attribute,
 180         gint records_length,
 181         gshort node_id,
 182         gshort cluster_id,
 183         gchar zcl_frame_ctrl,
 184         gchar src_ep,
 185         gchar dest_ep,
 186         gpointer user_data)
 187 {
 188         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 189
 190         NOT_USED(zclglobal_control_object);
 191         NOT_USED(invocation);
 192         NOT_USED(service_interface);
 193         NOT_USED(read_attribute);
 194         NOT_USED(records_length);
 195         NOT_USED(node_id);
 196         NOT_USED(cluster_id);
 197         NOT_USED(zcl_frame_ctrl);
 198         NOT_USED(src_ep);
 199         NOT_USED(dest_ep);
 200
 201         /*
 202          * TODO -
 203          * Create and send request for processing
 204          */
 205
 206         return TRUE;
 207 }
 208
 209 static gboolean on_zclglobal_control_configure_reporting_req(ZigbeeZclglobal_control *zclglobal_control_object,
 210         GDBusMethodInvocation *invocation,
 211         GVariant *read_attribute,
 212         gint records_length,
 213         gshort node_id,
 214         gshort cluster_id,
 215         gchar zcl_frame_ctrl,
 216         gchar src_ep,
 217         gchar dest_ep,
 218         gpointer user_data)
 219 {
 220         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 221
 222         NOT_USED(zclglobal_control_object);
 223         NOT_USED(invocation);
 224         NOT_USED(service_interface);
 225         NOT_USED(read_attribute);
 226         NOT_USED(records_length);
 227         NOT_USED(node_id);
 228         NOT_USED(cluster_id);
 229         NOT_USED(zcl_frame_ctrl);
 230         NOT_USED(src_ep);
 231         NOT_USED(dest_ep);
 232
 233         /*
 234          * TODO -
 235          * Create and send request for processing
 236          */
 237
 238         return TRUE;
 239 }
 240
 241 static gboolean on_zclglobal_control_read_configure_reporting(ZigbeeZclglobal_control *zclglobal_control_object,
 242         GDBusMethodInvocation *invocation,
 243         GVariant *read_attribute,
 244         gint records_length,
 245         gshort node_id,
 246         gshort cluster_id,
 247         gchar zcl_frame_ctrl,
 248         gchar src_ep,
 249         gchar dest_ep,
 250         gpointer user_data)
 251 {
 252         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 253
 254         NOT_USED(zclglobal_control_object);
 255         NOT_USED(invocation);
 256         NOT_USED(service_interface);
 257         NOT_USED(read_attribute);
 258         NOT_USED(records_length);
 259         NOT_USED(node_id);
 260         NOT_USED(cluster_id);
 261         NOT_USED(zcl_frame_ctrl);
 262         NOT_USED(src_ep);
 263         NOT_USED(dest_ep);
 264
 265         /*
 266          * TODO -
 267          * Create and send request for processing
 268          */
 269
 270         return TRUE;
 271 }
 272
 273 static gboolean on_zclglobal_control_discover_attributes(ZigbeeZclglobal_control *zclglobal_control_object,
 274         GDBusMethodInvocation *invocation,
 275         gshort node_id,
 276         gchar dest_ep,
 277         gchar zcl_frame_ctrl,
 278         gshort cluster_id,
 279         gshort start_attr,
 280         gchar max,
 281         gpointer user_data)
 282 {
 283         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 284
 285         NOT_USED(zclglobal_control_object);
 286         NOT_USED(invocation);
 287         NOT_USED(service_interface);
 288         NOT_USED(node_id);
 289         NOT_USED(dest_ep);
 290         NOT_USED(zcl_frame_ctrl);
 291         NOT_USED(cluster_id);
 292         NOT_USED(start_attr);
 293         NOT_USED(max);
 294
 295         /*
 296          * TODO -
 297          * Create and send request for processing
 298          */
 299
 300         return TRUE;
 301 }
 302
 303 static gboolean on_zclglobal_control_discover_attributes_extended(ZigbeeZclglobal_control *zclglobal_control_object,
 304         GDBusMethodInvocation *invocation,
 305         gshort node_id,
 306         gchar dest_ep,
 307         gchar zcl_frame_ctrl,
 308         gshort cluster_id,
 309         gshort start_attr,
 310         gchar max,
 311         gpointer user_data)
 312 {
 313         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 314
 315         NOT_USED(zclglobal_control_object);
 316         NOT_USED(invocation);
 317         NOT_USED(service_interface);
 318         NOT_USED(node_id);
 319         NOT_USED(dest_ep);
 320         NOT_USED(zcl_frame_ctrl);
 321         NOT_USED(cluster_id);
 322         NOT_USED(start_attr);
 323         NOT_USED(max);
 324
 325         /*
 326          * TODO -
 327          * Create and send request for processing
 328          */
 329
 330         return TRUE;
 331 }
 332
 333 static gboolean on_zclglobal_control_discover_commands_received(ZigbeeZclglobal_control *zclglobal_control_object,
 334         GDBusMethodInvocation *invocation,
 335         gshort node_id,
 336         gchar dest_ep,
 337         gchar zcl_frame_ctrl,
 338         gshort cluster_id,
 339         gshort start_attr,
 340         gchar max,
 341         gpointer user_data)
 342 {
 343         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 344
 345         NOT_USED(zclglobal_control_object);
 346         NOT_USED(invocation);
 347         NOT_USED(service_interface);
 348         NOT_USED(node_id);
 349         NOT_USED(dest_ep);
 350         NOT_USED(zcl_frame_ctrl);
 351         NOT_USED(cluster_id);
 352         NOT_USED(start_attr);
 353         NOT_USED(max);
 354
 355         /*
 356          * TODO -
 357          * Create and send request for processing
 358          */
 359
 360         return TRUE;
 361 }
 362
 363 static gboolean on_zclglobal_control_discover_commands_generated(ZigbeeZclglobal_control *zclglobal_control_object,
 364         GDBusMethodInvocation *invocation,
 365         gshort node_id,
 366         gchar dest_ep,
 367         gchar zcl_frame_ctrl,
 368         gshort cluster_id,
 369         gshort start_attr,
 370         gchar max,
 371         gpointer user_data)
 372 {
 373         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 374
 375         NOT_USED(zclglobal_control_object);
 376         NOT_USED(invocation);
 377         NOT_USED(service_interface);
 378         NOT_USED(node_id);
 379         NOT_USED(dest_ep);
 380         NOT_USED(zcl_frame_ctrl);
 381         NOT_USED(cluster_id);
 382         NOT_USED(start_attr);
 383         NOT_USED(max);
 384
 385         /*
 386          * TODO -
 387          * Create and send request for processing
 388          */
 389
 390         return TRUE;
 391 }
 392
 393 gboolean zigbee_service_dbus_interface_zclglobal_control_init(ZigBeeServiceInterface *service_interface,
 394         ZigbeeObjectSkeleton *zigbee_object)
 395 {
 396         ZigbeeZclglobal_control *zclglobal_control_object;
 397
 398         if (NULL == service_interface) {
 399                 Z_LOGE("service_interface is NULL");
 400                 return FALSE;
 401         }
 402
 403         zclglobal_control_object = zigbee_zclglobal_control_skeleton_new();
 404         zigbee_object_skeleton_set_zclglobal_control(zigbee_object, zclglobal_control_object);
 405         g_object_unref(zclglobal_control_object);
 406
 407         Z_LOGI("zclglobal_control_object: [%p]", zclglobal_control_object);
 408
 409         /*
 410          * Register signal handlers for 'zclglobal_control' interface
 411          */
 412         g_signal_connect(zclglobal_control_object,
 413                 "handle-read-attributes-req",
 414                 G_CALLBACK(on_zclglobal_control_read_attributes_req), service_interface);
 415
 416         g_signal_connect(zclglobal_control_object,
 417                 "handle-write-attributes-req",
 418                 G_CALLBACK(on_zclglobal_control_write_attributes_req), service_interface);
 419
 420         g_signal_connect(zclglobal_control_object,
 421                 "handle-write-attributes-undivided-req",
 422                 G_CALLBACK(on_zclglobal_control_write_attributes_undivided_req), service_interface);
 423
 424         g_signal_connect(zclglobal_control_object,
 425                 "handle-write-attributes-no-resp",
 426                 G_CALLBACK(on_zclglobal_control_write_attributes_no_resp), service_interface);
 427
 428         g_signal_connect(zclglobal_control_object,
 429                 "handle-write-attributes-structured",
 430                 G_CALLBACK(on_zclglobal_control_write_attributes_structured), service_interface);
 431
 432         g_signal_connect(zclglobal_control_object,
 433                 "handle-read-attributes-structured",
 434                 G_CALLBACK(on_zclglobal_control_read_attributes_structured), service_interface);
 435
 436         g_signal_connect(zclglobal_control_object,
 437                 "handle-configure-reporting-req",
 438                 G_CALLBACK(on_zclglobal_control_configure_reporting_req), service_interface);
 439
 440         g_signal_connect(zclglobal_control_object,
 441                 "handle-read-configure-reporting",
 442                 G_CALLBACK(on_zclglobal_control_read_configure_reporting), service_interface);
 443
 444         g_signal_connect(zclglobal_control_object,
 445                 "handle-discover-attributes",
 446                 G_CALLBACK(on_zclglobal_control_discover_attributes), service_interface);
 447
 448         g_signal_connect(zclglobal_control_object,
 449                 "handle-discover-attributes-extended",
 450                 G_CALLBACK(on_zclglobal_control_discover_attributes_extended), service_interface);
 451
 452         g_signal_connect(zclglobal_control_object,
 453                 "handle-discover-commands-received",
 454                 G_CALLBACK(on_zclglobal_control_discover_commands_received), service_interface);
 455
 456         g_signal_connect(zclglobal_control_object,
 457                 "handle-discover-commands-generated",
 458                 G_CALLBACK(on_zclglobal_control_discover_commands_generated), service_interface);
 459
 460         return TRUE;
 461 }