zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_alarm.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_alarm_get_alarm_count(ZigbeeAlarm *alarm_object,
  22         GDBusMethodInvocation *invocation,
  23         GVariant *eui64,
  24         gchar endpoint,
  25         gpointer user_data)
  26 {
  27         ZigBeeService *service = (ZigBeeService *)user_data;
  28
  29         NOT_USED(alarm_object);
  30         NOT_USED(invocation);
  31         NOT_USED(service);
  32         NOT_USED(eui64);
  33         NOT_USED(endpoint);
  34
  35         /*
  36          * TODO -
  37          * Create and send request for processing
  38          */
  39
  40         return TRUE;
  41 }
  42
  43 static gboolean on_alarm_reset_alarm(ZigbeeAlarm *alarm_object,
  44         GDBusMethodInvocation *invocation,
  45         gshort node_id,
  46         gchar endpoint,
  47         gchar alarmcode,
  48         gshort cluster_id,
  49         gpointer user_data)
  50 {
  51         ZigBeeService *service = (ZigBeeService *)user_data;
  52
  53         NOT_USED(alarm_object);
  54         NOT_USED(invocation);
  55         NOT_USED(service);
  56         NOT_USED(node_id);
  57         NOT_USED(endpoint);
  58         NOT_USED(alarmcode);
  59         NOT_USED(cluster_id);
  60
  61         /*
  62          * TODO -
  63          * Create and send request for processing
  64          */
  65
  66         return TRUE;
  67 }
  68
  69 static gboolean on_alarm_reset_all_alarm(ZigbeeAlarm *alarm_object,
  70         GDBusMethodInvocation *invocation,
  71         gshort node_id,
  72         gchar endpoint,
  73         gpointer user_data)
  74 {
  75         ZigBeeService *service = (ZigBeeService *)user_data;
  76
  77         NOT_USED(alarm_object);
  78         NOT_USED(invocation);
  79         NOT_USED(service);
  80         NOT_USED(node_id);
  81         NOT_USED(endpoint);
  82
  83         /*
  84          * TODO -
  85          * Create and send request for processing
  86          */
  87
  88         return TRUE;
  89 }
  90
  91 static gboolean on_alarm_alarm(ZigbeeAlarm *alarm_object,
  92         GDBusMethodInvocation *invocation,
  93         GVariant *eui64,
  94         gchar endpoint,
  95         gchar alarmcode,
  96         gshort cluster_id,
  97         gpointer user_data)
  98 {
  99         ZigBeeService *service = (ZigBeeService *)user_data;
 100
 101         NOT_USED(alarm_object);
 102         NOT_USED(invocation);
 103         NOT_USED(service);
 104         NOT_USED(eui64);
 105         NOT_USED(endpoint);
 106         NOT_USED(alarmcode);
 107         NOT_USED(cluster_id);
 108
 109         /*
 110          * TODO -
 111          * Create and send request for processing
 112          */
 113
 114         return TRUE;
 115 }
 116
 117 static gboolean on_alarm_reset_alarm_log(ZigbeeAlarm *alarm_object,
 118         GDBusMethodInvocation *invocation,
 119         gshort node_id,
 120         gchar endpoint,
 121         gpointer user_data)
 122 {
 123         ZigBeeService *service = (ZigBeeService *)user_data;
 124
 125         NOT_USED(alarm_object);
 126         NOT_USED(invocation);
 127         NOT_USED(service);
 128         NOT_USED(node_id);
 129         NOT_USED(endpoint);
 130
 131         /*
 132          * TODO -
 133          * Create and send request for processing
 134          */
 135
 136         return TRUE;
 137 }
 138
 139 static gboolean on_alarm_get_alarm(ZigbeeAlarm *alarm_object,
 140         GDBusMethodInvocation *invocation,
 141         gshort node_id,
 142         gchar endpoint,
 143         gpointer user_data)
 144 {
 145         ZigBeeService *service = (ZigBeeService *)user_data;
 146
 147         NOT_USED(alarm_object);
 148         NOT_USED(invocation);
 149         NOT_USED(service);
 150         NOT_USED(node_id);
 151         NOT_USED(endpoint);
 152
 153         /*
 154          * TODO -
 155          * Create and send request for processing
 156          */
 157
 158         return TRUE;
 159 }
 160
 161 gboolean zigbee_service_dbus_interface_alarm_init(ZigBeeService *service,
 162         ZigbeeObjectSkeleton *zigbee_object)
 163 {
 164         ZigbeeAlarm *alarm_object;
 165
 166         if (NULL == service) {
 167                 Z_LOGE("service is NULL");
 168                 return FALSE;
 169         }
 170
 171         alarm_object = zigbee_alarm_skeleton_new();
 172         zigbee_object_skeleton_set_alarm(zigbee_object, alarm_object);
 173         g_object_unref(alarm_object);
 174
 175         Z_LOGI("alarm_object: [%p]", alarm_object);
 176
 177         /*
 178          * Register signal handlers for 'alarm' interface
 179          */
 180         g_signal_connect(alarm_object,
 181                 "handle-get-alarm-count",
 182                 G_CALLBACK(on_alarm_get_alarm_count), service);
 183
 184         g_signal_connect(alarm_object,
 185                 "handle-reset-alarm",
 186                 G_CALLBACK(on_alarm_reset_alarm), service);
 187
 188         g_signal_connect(alarm_object,
 189                 "handle-reset-all-alarm",
 190                 G_CALLBACK(on_alarm_reset_all_alarm), service);
 191
 192         g_signal_connect(alarm_object,
 193                 "handle-alarm",
 194                 G_CALLBACK(on_alarm_alarm), service);
 195
 196         g_signal_connect(alarm_object,
 197                 "handle-reset-alarm-log",
 198                 G_CALLBACK(on_alarm_reset_alarm_log), service);
 199
 200         g_signal_connect(alarm_object,
 201                 "handle-get-alarm",
 202                 G_CALLBACK(on_alarm_get_alarm), service);
 203
 204         return TRUE;
 205 }