zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_service.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_service_enable(ZigbeeService *service_object,
  22         GDBusMethodInvocation *invocation,
  23         gpointer user_data)
  24 {
  25         ZigBeeService *service = (ZigBeeService *)user_data;
  26
  27         NOT_USED(service_object);
  28         NOT_USED(invocation);
  29         NOT_USED(service);
  30
  31         /*
  32          * TODO -
  33          * Create and send request for processing
  34          */
  35
  36         return TRUE;
  37 }
  38
  39 static gboolean on_service_disable(ZigbeeService *service_object,
  40         GDBusMethodInvocation *invocation,
  41         gpointer user_data)
  42 {
  43         ZigBeeService *service = (ZigBeeService *)user_data;
  44
  45         NOT_USED(service_object);
  46         NOT_USED(invocation);
  47         NOT_USED(service);
  48
  49         /*
  50          * TODO -
  51          * Create and send request for processing
  52          */
  53
  54         return TRUE;
  55 }
  56
  57 static gboolean on_service_zb_hw_reset(ZigbeeService *service_object,
  58         GDBusMethodInvocation *invocation,
  59         gpointer user_data)
  60 {
  61         ZigBeeService *service = (ZigBeeService *)user_data;
  62
  63         NOT_USED(service_object);
  64         NOT_USED(invocation);
  65         NOT_USED(service);
  66
  67         /*
  68          * TODO -
  69          * Create and send request for processing
  70          */
  71
  72         return TRUE;
  73 }
  74
  75 static gboolean on_service_form_network(ZigbeeService *service_object,
  76         GDBusMethodInvocation *invocation,
  77         gpointer user_data)
  78 {
  79         ZigBeeService *service = (ZigBeeService *)user_data;
  80
  81         NOT_USED(service_object);
  82         NOT_USED(invocation);
  83         NOT_USED(service);
  84
  85         /*
  86          * TODO -
  87          * Create and send request for processing
  88          */
  89
  90         return TRUE;
  91 }
  92
  93 static gboolean on_service_coex_start(ZigbeeService *service_object,
  94         GDBusMethodInvocation *invocation,
  95         gchar channel,
  96         gpointer user_data)
  97 {
  98         ZigBeeService *service = (ZigBeeService *)user_data;
  99
 100         NOT_USED(service_object);
 101         NOT_USED(invocation);
 102         NOT_USED(service);
 103         NOT_USED(channel);
 104
 105         /*
 106          * TODO -
 107          * Create and send request for processing
 108          */
 109
 110         return TRUE;
 111 }
 112
 113 static gboolean on_service_coex_stop(ZigbeeService *service_object,
 114         GDBusMethodInvocation *invocation,
 115         gpointer user_data)
 116 {
 117         ZigBeeService *service = (ZigBeeService *)user_data;
 118
 119         NOT_USED(service_object);
 120         NOT_USED(invocation);
 121         NOT_USED(service);
 122
 123         /*
 124          * TODO -
 125          * Create and send request for processing
 126          */
 127
 128         return TRUE;
 129 }
 130
 131 static gboolean on_service_leave_network(ZigbeeService *service_object,
 132         GDBusMethodInvocation *invocation,
 133         gpointer user_data)
 134 {
 135         ZigBeeService *service = (ZigBeeService *)user_data;
 136
 137         NOT_USED(service_object);
 138         NOT_USED(invocation);
 139         NOT_USED(service);
 140
 141         /*
 142          * TODO -
 143          * Create and send request for processing
 144          */
 145
 146         return TRUE;
 147 }
 148
 149 static gboolean on_service_get_network_info(ZigbeeService *service_object,
 150         GDBusMethodInvocation *invocation,
 151         gpointer user_data)
 152 {
 153         ZigBeeService *service = (ZigBeeService *)user_data;
 154
 155         NOT_USED(service_object);
 156         NOT_USED(invocation);
 157         NOT_USED(service);
 158
 159         /*
 160          * TODO -
 161          * Create and send request for processing
 162          */
 163
 164         return TRUE;
 165 }
 166
 167 static gboolean on_service_permit_join(ZigbeeService *service_object,
 168         GDBusMethodInvocation *invocation,
 169         gint duration,
 170         gboolean broadcast_mgmt_permit_join,
 171         gpointer user_data)
 172 {
 173         ZigBeeService *service = (ZigBeeService *)user_data;
 174
 175         NOT_USED(service_object);
 176         NOT_USED(invocation);
 177         NOT_USED(service);
 178         NOT_USED(duration);
 179         NOT_USED(broadcast_mgmt_permit_join);
 180
 181         /*
 182          * TODO -
 183          * Create and send request for processing
 184          */
 185
 186         return TRUE;
 187 }
 188
 189 static gboolean on_service_leave_request(ZigbeeService *service_object,
 190         GDBusMethodInvocation *invocation,
 191         GVariant *eui64,
 192         gchar remove_child,
 193         gchar rejoin,
 194         gpointer user_data)
 195 {
 196         ZigBeeService *service = (ZigBeeService *)user_data;
 197
 198         NOT_USED(service_object);
 199         NOT_USED(invocation);
 200         NOT_USED(service);
 201         NOT_USED(eui64);
 202         NOT_USED(remove_child);
 203         NOT_USED(rejoin);
 204
 205         /*
 206          * TODO -
 207          * Create and send request for processing
 208          */
 209
 210         return TRUE;
 211 }
 212
 213 static gboolean on_service_get_device_list(ZigbeeService *service_object,
 214         GDBusMethodInvocation *invocation,
 215         gpointer user_data)
 216 {
 217         ZigBeeService *service = (ZigBeeService *)user_data;
 218
 219         NOT_USED(service_object);
 220         NOT_USED(invocation);
 221         NOT_USED(service);
 222
 223         /*
 224          * TODO -
 225          * Create and send request for processing
 226          */
 227
 228         return TRUE;
 229 }
 230
 231 static gboolean on_service_get_mac(ZigbeeService *service_object,
 232         GDBusMethodInvocation *invocation,
 233         gpointer user_data)
 234 {
 235         ZigBeeService *service = (ZigBeeService *)user_data;
 236
 237         NOT_USED(service_object);
 238         NOT_USED(invocation);
 239         NOT_USED(service);
 240
 241         /*
 242          * TODO -
 243          * Create and send request for processing
 244          */
 245
 246         return TRUE;
 247 }
 248
 249 static gboolean on_service_get_device_info(ZigbeeService *service_object,
 250         GDBusMethodInvocation *invocation,
 251         gpointer user_data)
 252 {
 253         ZigBeeService *service = (ZigBeeService *)user_data;
 254
 255         NOT_USED(service_object);
 256         NOT_USED(invocation);
 257         NOT_USED(service);
 258
 259         /*
 260          * TODO -
 261          * Create and send request for processing
 262          */
 263
 264         return TRUE;
 265 }
 266
 267 static gboolean on_service_get_endpoint_list(ZigbeeService *service_object,
 268         GDBusMethodInvocation *invocation,
 269         GVariant *eui64,
 270         gpointer user_data)
 271 {
 272         ZigBeeService *service = (ZigBeeService *)user_data;
 273
 274         NOT_USED(service_object);
 275         NOT_USED(invocation);
 276         NOT_USED(service);
 277         NOT_USED(eui64);
 278
 279         /*
 280          * TODO -
 281          * Create and send request for processing
 282          */
 283
 284         return TRUE;
 285 }
 286
 287 static gboolean on_service_get_cluster_list(ZigbeeService *service_object,
 288         GDBusMethodInvocation *invocation,
 289         GVariant *eui64,
 290         gchar endpoint,
 291         gpointer user_data)
 292 {
 293         ZigBeeService *service = (ZigBeeService *)user_data;
 294
 295         NOT_USED(service_object);
 296         NOT_USED(invocation);
 297         NOT_USED(service);
 298         NOT_USED(eui64);
 299         NOT_USED(endpoint);
 300
 301         /*
 302          * TODO -
 303          * Create and send request for processing
 304          */
 305
 306         return TRUE;
 307 }
 308
 309 static gboolean on_service_get_node_type(ZigbeeService *service_object,
 310         GDBusMethodInvocation *invocation,
 311         GVariant *eui64,
 312         gpointer user_data)
 313 {
 314         ZigBeeService *service = (ZigBeeService *)user_data;
 315
 316         NOT_USED(service_object);
 317         NOT_USED(invocation);
 318         NOT_USED(service);
 319         NOT_USED(eui64);
 320
 321         /*
 322          * TODO -
 323          * Create and send request for processing
 324          */
 325
 326         return TRUE;
 327 }
 328
 329 gboolean zigbee_service_dbus_interface_service_init(ZigBeeService *service,
 330         ZigbeeObjectSkeleton *zigbee_object)
 331 {
 332         ZigbeeService *service_object;
 333
 334         if (NULL == service) {
 335                 Z_LOGE("service is NULL");
 336                 return FALSE;
 337         }
 338
 339         service_object = zigbee_service_skeleton_new();
 340         zigbee_object_skeleton_set_service(zigbee_object, service_object);
 341         g_object_unref(service_object);
 342
 343         Z_LOGI("service_object: [%p]", service_object);
 344
 345         /*
 346          * Register signal handlers for 'service' interface
 347          */
 348         g_signal_connect(service_object,
 349                 "handle-enable",
 350                 G_CALLBACK(on_service_enable), service);
 351
 352         g_signal_connect(service_object,
 353                 "handle-disable",
 354                 G_CALLBACK(on_service_disable), service);
 355
 356         g_signal_connect(service_object,
 357                 "handle-zb-hw-reset",
 358                 G_CALLBACK(on_service_zb_hw_reset), service);
 359
 360         g_signal_connect(service_object,
 361                 "handle-form-network",
 362                 G_CALLBACK(on_service_form_network), service);
 363
 364         g_signal_connect(service_object,
 365                 "handle-coex-start",
 366                 G_CALLBACK(on_service_coex_start), service);
 367
 368         g_signal_connect(service_object,
 369                 "handle-coex-stop",
 370                 G_CALLBACK(on_service_coex_stop), service);
 371
 372         g_signal_connect(service_object,
 373                 "handle-leave-network",
 374                 G_CALLBACK(on_service_leave_network), service);
 375
 376         g_signal_connect(service_object,
 377                 "handle-get-network-info",
 378                 G_CALLBACK(on_service_get_network_info), service);
 379
 380         g_signal_connect(service_object,
 381                 "handle-permit-join",
 382                 G_CALLBACK(on_service_permit_join), service);
 383
 384         g_signal_connect(service_object,
 385                 "handle-leave-request",
 386                 G_CALLBACK(on_service_leave_request), service);
 387
 388         g_signal_connect(service_object,
 389                 "handle-get-device-list",
 390                 G_CALLBACK(on_service_get_device_list), service);
 391
 392         g_signal_connect(service_object,
 393                 "handle-get-mac",
 394                 G_CALLBACK(on_service_get_mac), service);
 395
 396         g_signal_connect(service_object,
 397                 "handle-get-device-info",
 398                 G_CALLBACK(on_service_get_device_info), service);
 399
 400         g_signal_connect(service_object,
 401                 "handle-get-endpoint-list",
 402                 G_CALLBACK(on_service_get_endpoint_list), service);
 403
 404         g_signal_connect(service_object,
 405                 "handle-get-cluster-list",
 406                 G_CALLBACK(on_service_get_cluster_list), service);
 407
 408         g_signal_connect(service_object,
 409                 "handle-get-node-type",
 410                 G_CALLBACK(on_service_get_node_type), service);
 411
 412         return TRUE;
 413 }