zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zcl_color.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_zcl_color_move_to_hue(ZigbeeZcl_color *zcl_color_object,
  22         GDBusMethodInvocation *invocation,
  23         gshort node_id,
  24         gchar endpoint,
  25         gchar move_mode,
  26         gchar rate,
  27         gpointer user_data)
  28 {
  29         ZigBeeService *service = (ZigBeeService *)user_data;
  30
  31         NOT_USED(zcl_color_object);
  32         NOT_USED(invocation);
  33         NOT_USED(service);
  34         NOT_USED(node_id);
  35         NOT_USED(endpoint);
  36         NOT_USED(move_mode);
  37         NOT_USED(rate);
  38
  39         /*
  40          * TODO -
  41          * Create and send request for processing
  42          */
  43
  44         return TRUE;
  45 }
  46
  47 static gboolean on_zcl_color_move_hue(ZigbeeZcl_color *zcl_color_object,
  48         GDBusMethodInvocation *invocation,
  49         gshort node_id,
  50         gchar endpoint,
  51         gchar hue,
  52         gchar direction,
  53         gpointer user_data)
  54 {
  55         ZigBeeService *service = (ZigBeeService *)user_data;
  56
  57         NOT_USED(zcl_color_object);
  58         NOT_USED(invocation);
  59         NOT_USED(service);
  60         NOT_USED(node_id);
  61         NOT_USED(endpoint);
  62         NOT_USED(hue);
  63         NOT_USED(direction);
  64
  65         /*
  66          * TODO -
  67          * Create and send request for processing
  68          */
  69
  70         return TRUE;
  71 }
  72
  73 static gboolean on_zcl_color_step_hue(ZigbeeZcl_color *zcl_color_object,
  74         GDBusMethodInvocation *invocation,
  75         gshort node_id,
  76         gchar endpoint,
  77         gchar step_mode,
  78         gchar step_size,
  79         gchar transition_time,
  80         gpointer user_data)
  81 {
  82         ZigBeeService *service = (ZigBeeService *)user_data;
  83
  84         NOT_USED(zcl_color_object);
  85         NOT_USED(invocation);
  86         NOT_USED(service);
  87         NOT_USED(node_id);
  88         NOT_USED(endpoint);
  89         NOT_USED(step_mode);
  90         NOT_USED(step_size);
  91         NOT_USED(transition_time);
  92
  93         /*
  94          * TODO -
  95          * Create and send request for processing
  96          */
  97
  98         return TRUE;
  99 }
 100
 101 static gboolean on_zcl_color_move_to_saturation(ZigbeeZcl_color *zcl_color_object,
 102         GDBusMethodInvocation *invocation,
 103         gshort node_id,
 104         gchar endpoint,
 105         gchar saturation,
 106         gshort transition_time,
 107         gpointer user_data)
 108 {
 109         ZigBeeService *service = (ZigBeeService *)user_data;
 110
 111         NOT_USED(zcl_color_object);
 112         NOT_USED(invocation);
 113         NOT_USED(service);
 114         NOT_USED(node_id);
 115         NOT_USED(endpoint);
 116         NOT_USED(saturation);
 117         NOT_USED(transition_time);
 118
 119         /*
 120          * TODO -
 121          * Create and send request for processing
 122          */
 123
 124         return TRUE;
 125 }
 126
 127 static gboolean on_zcl_color_move_saturation(ZigbeeZcl_color *zcl_color_object,
 128         GDBusMethodInvocation *invocation,
 129         gshort node_id,
 130         gchar endpoint,
 131         gchar move_mode,
 132         gchar rate,
 133         gpointer user_data)
 134 {
 135         ZigBeeService *service = (ZigBeeService *)user_data;
 136
 137         NOT_USED(zcl_color_object);
 138         NOT_USED(invocation);
 139         NOT_USED(service);
 140         NOT_USED(node_id);
 141         NOT_USED(endpoint);
 142         NOT_USED(move_mode);
 143         NOT_USED(rate);
 144
 145         /*
 146          * TODO -
 147          * Create and send request for processing
 148          */
 149
 150         return TRUE;
 151 }
 152
 153 static gboolean on_zcl_color_step_saturation(ZigbeeZcl_color *zcl_color_object,
 154         GDBusMethodInvocation *invocation,
 155         gshort node_id,
 156         gchar endpoint,
 157         gchar step_mode,
 158         gchar step_size,
 159         gchar transition_time,
 160         gpointer user_data)
 161 {
 162         ZigBeeService *service = (ZigBeeService *)user_data;
 163
 164         NOT_USED(zcl_color_object);
 165         NOT_USED(invocation);
 166         NOT_USED(service);
 167         NOT_USED(node_id);
 168         NOT_USED(endpoint);
 169         NOT_USED(step_mode);
 170         NOT_USED(step_size);
 171         NOT_USED(transition_time);
 172
 173         /*
 174          * TODO -
 175          * Create and send request for processing
 176          */
 177
 178         return TRUE;
 179 }
 180
 181 static gboolean on_zcl_color_move_to_hue_and_saturation(ZigbeeZcl_color *zcl_color_object,
 182         GDBusMethodInvocation *invocation,
 183         gshort node_id,
 184         gchar endpoint,
 185         gchar hue,
 186         gchar saturation,
 187         gshort transition_time,
 188         gpointer user_data)
 189 {
 190         ZigBeeService *service = (ZigBeeService *)user_data;
 191
 192         NOT_USED(zcl_color_object);
 193         NOT_USED(invocation);
 194         NOT_USED(service);
 195         NOT_USED(node_id);
 196         NOT_USED(endpoint);
 197         NOT_USED(hue);
 198         NOT_USED(saturation);
 199         NOT_USED(transition_time);
 200
 201         /*
 202          * TODO -
 203          * Create and send request for processing
 204          */
 205
 206         return TRUE;
 207 }
 208
 209 static gboolean on_zcl_color_move_to_color(ZigbeeZcl_color *zcl_color_object,
 210         GDBusMethodInvocation *invocation,
 211         gshort node_id,
 212         gchar endpoint,
 213         gshort start_x,
 214         gshort start_y,
 215         gshort transition_time,
 216         gpointer user_data)
 217 {
 218         ZigBeeService *service = (ZigBeeService *)user_data;
 219
 220         NOT_USED(zcl_color_object);
 221         NOT_USED(invocation);
 222         NOT_USED(service);
 223         NOT_USED(node_id);
 224         NOT_USED(endpoint);
 225         NOT_USED(start_x);
 226         NOT_USED(start_y);
 227         NOT_USED(transition_time);
 228
 229         /*
 230          * TODO -
 231          * Create and send request for processing
 232          */
 233
 234         return TRUE;
 235 }
 236
 237 static gboolean on_zcl_color_move_color(ZigbeeZcl_color *zcl_color_object,
 238         GDBusMethodInvocation *invocation,
 239         gshort node_id,
 240         gchar endpoint,
 241         gshort rate_x,
 242         gshort rate_y,
 243         gpointer user_data)
 244 {
 245         ZigBeeService *service = (ZigBeeService *)user_data;
 246
 247         NOT_USED(zcl_color_object);
 248         NOT_USED(invocation);
 249         NOT_USED(service);
 250         NOT_USED(node_id);
 251         NOT_USED(endpoint);
 252         NOT_USED(rate_x);
 253         NOT_USED(rate_y);
 254
 255         /*
 256          * TODO -
 257          * Create and send request for processing
 258          */
 259
 260         return TRUE;
 261 }
 262
 263 static gboolean on_zcl_color_step_color(ZigbeeZcl_color *zcl_color_object,
 264         GDBusMethodInvocation *invocation,
 265         gshort node_id,
 266         gchar endpoint,
 267         gshort rate_x,
 268         gshort rate_y,
 269         gshort transition_time,
 270         gpointer user_data)
 271 {
 272         ZigBeeService *service = (ZigBeeService *)user_data;
 273
 274         NOT_USED(zcl_color_object);
 275         NOT_USED(invocation);
 276         NOT_USED(service);
 277         NOT_USED(node_id);
 278         NOT_USED(endpoint);
 279         NOT_USED(rate_x);
 280         NOT_USED(rate_y);
 281         NOT_USED(transition_time);
 282
 283         /*
 284          * TODO -
 285          * Create and send request for processing
 286          */
 287
 288         return TRUE;
 289 }
 290
 291 static gboolean on_zcl_color_move_color_temperature(ZigbeeZcl_color *zcl_color_object,
 292         GDBusMethodInvocation *invocation,
 293         gshort node_id,
 294         gchar endpoint,
 295         gshort color_temperature,
 296         gshort transition_time,
 297         gpointer user_data)
 298 {
 299         ZigBeeService *service = (ZigBeeService *)user_data;
 300
 301         NOT_USED(zcl_color_object);
 302         NOT_USED(invocation);
 303         NOT_USED(service);
 304         NOT_USED(node_id);
 305         NOT_USED(endpoint);
 306         NOT_USED(color_temperature);
 307         NOT_USED(transition_time);
 308
 309         /*
 310          * TODO -
 311          * Create and send request for processing
 312          */
 313
 314         return TRUE;
 315 }
 316
 317 gboolean zigbee_service_dbus_interface_zcl_color_init(ZigBeeService *service,
 318         ZigbeeObjectSkeleton *zigbee_object)
 319 {
 320         ZigbeeZcl_color *zcl_color_object;
 321
 322         if (NULL == service) {
 323                 Z_LOGE("service is NULL");
 324                 return FALSE;
 325         }
 326
 327         zcl_color_object = zigbee_zcl_color_skeleton_new();
 328         zigbee_object_skeleton_set_zcl_color(zigbee_object, zcl_color_object);
 329         g_object_unref(zcl_color_object);
 330
 331         Z_LOGI("zcl_color_object: [%p]", zcl_color_object);
 332
 333         /*
 334          * Register signal handlers for 'zcl_color' interface
 335          */
 336         g_signal_connect(zcl_color_object,
 337                 "handle-move-to-hue",
 338                 G_CALLBACK(on_zcl_color_move_to_hue), service);
 339
 340         g_signal_connect(zcl_color_object,
 341                 "handle-move-hue",
 342                 G_CALLBACK(on_zcl_color_move_hue), service);
 343
 344         g_signal_connect(zcl_color_object,
 345                 "handle-step-hue",
 346                 G_CALLBACK(on_zcl_color_step_hue), service);
 347
 348         g_signal_connect(zcl_color_object,
 349                 "handle-move-to-saturation",
 350                 G_CALLBACK(on_zcl_color_move_to_saturation), service);
 351
 352         g_signal_connect(zcl_color_object,
 353                 "handle-move-saturation",
 354                 G_CALLBACK(on_zcl_color_move_saturation), service);
 355
 356         g_signal_connect(zcl_color_object,
 357                 "handle-step-saturation",
 358                 G_CALLBACK(on_zcl_color_step_saturation), service);
 359
 360         g_signal_connect(zcl_color_object,
 361                 "handle-move-to-hue-and-saturation",
 362                 G_CALLBACK(on_zcl_color_move_to_hue_and_saturation), service);
 363
 364         g_signal_connect(zcl_color_object,
 365                 "handle-move-to-color",
 366                 G_CALLBACK(on_zcl_color_move_to_color), service);
 367
 368         g_signal_connect(zcl_color_object,
 369                 "handle-move-color",
 370                 G_CALLBACK(on_zcl_color_move_color), service);
 371
 372         g_signal_connect(zcl_color_object,
 373                 "handle-step-color",
 374                 G_CALLBACK(on_zcl_color_step_color), service);
 375
 376         g_signal_connect(zcl_color_object,
 377                 "handle-move-color-temperature",
 378                 G_CALLBACK(on_zcl_color_move_color_temperature), service);
 379
 380         return TRUE;
 381 }