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