lib/icl-device.c

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <errno.h>
  20 #include <glib.h>
  21
  22 #include "iotcon.h"
  23 #include "ic-utils.h"
  24 #include "icl.h"
  25 #include "icl-repr.h"
  26 #include "icl-dbus.h"
  27 #include "icl-dbus-type.h"
  28
  29 /**
  30  * @brief The maximum length which can be held in a manufacturer name.
  31  *
  32  * @since_tizen 3.0
  33  */
  34 #define ICL_MANUFACTURER_NAME_LENGTH_MAX 15
  35
  36 /**
  37  * @brief The maximum length which can be held in a manufacturer url.
  38  *
  39  * @since_tizen 3.0
  40  */
  41 #define ICL_MANUFACTURER_URL_LENGTH_MAX 32
  42
  43
  44 typedef struct {
  45         iotcon_device_info_cb cb;
  46         void *user_data;
  47         unsigned int id;
  48 } icl_device_info_s;
  49
  50 typedef struct {
  51         iotcon_platform_info_cb cb;
  52         void *user_data;
  53         unsigned int id;
  54 } icl_platform_info_s;
  55
  56
  57 API int iotcon_register_device_info(const char *device_name)
  58 {
  59         int ret, error_code;
  60         GError *error = NULL;
  61         GVariant *arg_info;
  62
  63         RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS);
  64         RETV_IF(NULL == device_name, IOTCON_ERROR_INVALID_PARAMETER);
  65
  66         arg_info = icl_dbus_device_info_to_gvariant(device_name);
  67         ic_dbus_call_register_device_info_sync(icl_dbus_get_object(), arg_info, &ret,
  68                         NULL, &error);
  69         if (error) {
  70                 ERR("ic_dbus_call_register_device_info_sync() Fail(%s)", error->message);
  71                 error_code = icl_dbus_convert_dbus_error(error->code);
  72                 g_error_free(error);
  73                 g_variant_unref(arg_info);
  74                 return error_code;
  75         }
  76
  77         if (IOTCON_ERROR_NONE != ret) {
  78                 ERR("iotcon-daemon Fail(%d)", ret);
  79                 return icl_dbus_convert_daemon_error(ret);
  80         }
  81
  82         return ret;
  83 }
  84
  85
  86 static void _icl_device_info_cb(GDBusConnection *connection,
  87                 const gchar *sender_name,
  88                 const gchar *object_path,
  89                 const gchar *interface_name,
  90                 const gchar *signal_name,
  91                 GVariant *parameters,
  92                 gpointer user_data)
  93 {
  94         icl_device_info_s *cb_container = user_data;
  95         iotcon_device_info_cb cb = cb_container->cb;
  96         char *device_name, *sid, *spec_version, *data_model_version;
  97
  98         g_variant_get(parameters, "(&s&s&s&s)", &device_name, &sid, &spec_version,
  99                         &data_model_version);
 100
 101         if (cb)
 102                 cb(device_name, sid, spec_version, data_model_version, cb_container->user_data);
 103 }
 104
 105
 106 API int iotcon_get_device_info(const char *host_address, iotcon_device_info_cb cb,
 107                 void *user_data)
 108 {
 109         GError *error = NULL;
 110         unsigned int sub_id;
 111         int ret, signal_number, error_code;
 112         char signal_name[IC_DBUS_SIGNAL_LENGTH] = {0};
 113         icl_device_info_s *cb_container;
 114
 115         RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS);
 116         RETV_IF(NULL == host_address, IOTCON_ERROR_INVALID_PARAMETER);
 117         RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER);
 118
 119         signal_number = icl_dbus_generate_signal_number();
 120
 121         ic_dbus_call_get_device_info_sync(icl_dbus_get_object(), host_address,
 122                         signal_number, &ret, NULL, &error);
 123         if (error) {
 124                 ERR("ic_dbus_call_get_device_info_sync() Fail(%s)", error->message);
 125                 error_code = icl_dbus_convert_dbus_error(error->code);
 126                 g_error_free(error);
 127                 return error_code;
 128         }
 129
 130         if (IOTCON_ERROR_NONE != ret) {
 131                 ERR("iotcon-daemon Fail(%d)", ret);
 132                 return icl_dbus_convert_daemon_error(ret);
 133         }
 134
 135         snprintf(signal_name, sizeof(signal_name), "%s_%u", IC_DBUS_SIGNAL_DEVICE,
 136                         signal_number);
 137
 138         cb_container = calloc(1, sizeof(icl_device_info_s));
 139         if (NULL == cb_container) {
 140                 ERR("calloc() Fail(%d)", errno);
 141                 return IOTCON_ERROR_OUT_OF_MEMORY;
 142         }
 143
 144         cb_container->cb = cb;
 145         cb_container->user_data = user_data;
 146
 147         sub_id = icl_dbus_subscribe_signal(signal_name, cb_container, free,
 148                         _icl_device_info_cb);
 149         if (0 == sub_id) {
 150                 ERR("icl_dbus_subscribe_signal() Fail");
 151                 return IOTCON_ERROR_DBUS;
 152         }
 153
 154         cb_container->id = sub_id;
 155
 156         return ret;
 157 }
 158
 159
 160 /* The length of manufacturer_name should be less than and equal to 16.
 161  * The length of manufacturer_url should be less than and equal to 32. */
 162 API int iotcon_register_platform_info(iotcon_platform_info_s *platform_info)
 163 {
 164         int ret, error_code;
 165         GError *error = NULL;
 166         GVariant *arg_info;
 167
 168         RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS);
 169
 170         if (NULL == platform_info->platform_id
 171                         || NULL == platform_info->manuf_name
 172                         || NULL == platform_info->manuf_url
 173                         || NULL == platform_info->model_number
 174                         || NULL == platform_info->date_of_manufacture
 175                         || NULL == platform_info->platform_ver
 176                         || NULL == platform_info->os_ver
 177                         || NULL == platform_info->hardware_ver
 178                         || NULL == platform_info->firmware_ver
 179                         || NULL == platform_info->support_url
 180                         || NULL == platform_info->system_time) {
 181                 ERR("one of parameter is NULL");
 182                 return IOTCON_ERROR_INVALID_PARAMETER;
 183         }
 184
 185         if (platform_info->manuf_name
 186                         && (ICL_MANUFACTURER_NAME_LENGTH_MAX < strlen(platform_info->manuf_name))) {
 187                 ERR("The length of manufacturer_name(%s) is invalid.", platform_info->manuf_name);
 188                 return IOTCON_ERROR_INVALID_PARAMETER;
 189         }
 190
 191         if (platform_info->manuf_url
 192                         && (ICL_MANUFACTURER_URL_LENGTH_MAX < strlen(platform_info->manuf_url))) {
 193                 ERR("The length of manufacturer_url(%s) is invalid.", platform_info->manuf_url);
 194                 return IOTCON_ERROR_INVALID_PARAMETER;
 195         }
 196
 197         arg_info = icl_dbus_platform_info_to_gvariant(platform_info);
 198         ic_dbus_call_register_platform_info_sync(icl_dbus_get_object(), arg_info, &ret,
 199                         NULL, &error);
 200         if (error) {
 201                 ERR("ic_dbus_call_register_platform_info_sync() Fail(%s)", error->message);
 202                 error_code = icl_dbus_convert_dbus_error(error->code);
 203                 g_error_free(error);
 204                 g_variant_unref(arg_info);
 205                 return error_code;
 206         }
 207
 208         if (IOTCON_ERROR_NONE != ret) {
 209                 ERR("iotcon-daemon Fail(%d)", ret);
 210                 return icl_dbus_convert_daemon_error(ret);
 211         }
 212
 213         return ret;
 214 }
 215
 216
 217 static void _icl_platform_info_cb(GDBusConnection *connection,
 218                 const gchar *sender_name,
 219                 const gchar *object_path,
 220                 const gchar *interface_name,
 221                 const gchar *signal_name,
 222                 GVariant *parameters,
 223                 gpointer user_data)
 224 {
 225         char *uri_path;
 226         iotcon_platform_info_s *info = NULL;
 227         icl_platform_info_s *cb_container = user_data;
 228         iotcon_platform_info_cb cb = cb_container->cb;
 229
 230         info = calloc(1, sizeof(iotcon_platform_info_s));
 231         if (NULL == info) {
 232                 ERR("calloc(client) Fail(%d)", errno);
 233                 return;
 234         }
 235
 236         g_variant_get(parameters, "(&s&s&s&s&s&s&s&s&s&s&s&s)",
 237                         &uri_path,
 238                         &info->platform_id,
 239                         &info->manuf_name,
 240                         &info->manuf_url,
 241                         &info->model_number,
 242                         &info->date_of_manufacture,
 243                         &info->platform_ver,
 244                         &info->os_ver,
 245                         &info->hardware_ver,
 246                         &info->firmware_ver,
 247                         &info->support_url,
 248                         &info->system_time);
 249
 250         /* From iotivity, we can get uri_path. But, the value is always "/oic/p". */
 251
 252         if (cb)
 253                 cb(info, cb_container->user_data);
 254
 255         free(info);
 256 }
 257
 258
 259 API int iotcon_get_platform_info(const char *host_address, iotcon_platform_info_cb cb,
 260                 void *user_data)
 261 {
 262         GError *error = NULL;
 263         unsigned int sub_id;
 264         int ret, signal_number, error_code;
 265         char signal_name[IC_DBUS_SIGNAL_LENGTH] = {0};
 266         icl_platform_info_s *cb_container;
 267
 268         RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS);
 269         RETV_IF(NULL == host_address, IOTCON_ERROR_INVALID_PARAMETER);
 270         RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER);
 271
 272         signal_number = icl_dbus_generate_signal_number();
 273
 274         ic_dbus_call_get_platform_info_sync(icl_dbus_get_object(), host_address,
 275                         signal_number, &ret, NULL, &error);
 276         if (error) {
 277                 ERR("ic_dbus_call_get_platform_info_sync() Fail(%s)", error->message);
 278                 error_code = icl_dbus_convert_dbus_error(error->code);
 279                 g_error_free(error);
 280                 return error_code;
 281         }
 282
 283         if (IOTCON_ERROR_NONE != ret) {
 284                 ERR("iotcon-daemon Fail(%d)", ret);
 285                 return icl_dbus_convert_daemon_error(ret);
 286         }
 287
 288         snprintf(signal_name, sizeof(signal_name), "%s_%u", IC_DBUS_SIGNAL_PLATFORM,
 289                         signal_number);
 290
 291         cb_container = calloc(1, sizeof(icl_platform_info_s));
 292         if (NULL == cb_container) {
 293                 ERR("calloc() Fail(%d)", errno);
 294                 return IOTCON_ERROR_OUT_OF_MEMORY;
 295         }
 296
 297         cb_container->cb = cb;
 298         cb_container->user_data = user_data;
 299
 300         sub_id = icl_dbus_subscribe_signal(signal_name, cb_container, free,
 301                         _icl_platform_info_cb);
 302         if (0 == sub_id) {
 303                 ERR("icl_dbus_subscribe_signal() Fail");
 304                 return IOTCON_ERROR_DBUS;
 305         }
 306
 307         cb_container->id = sub_id;
 308
 309         return ret;
 310 }
 311