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 = calloc(1, sizeof(iotcon_platform_info_s));
 227         icl_platform_info_s *cb_container = user_data;
 228         iotcon_platform_info_cb cb = cb_container->cb;
 229
 230         g_variant_get(parameters, "(&s&s&s&s&s&s&s&s&s&s&s&s)",
 231                         &uri_path,
 232                         &info->platform_id,
 233                         &info->manuf_name,
 234                         &info->manuf_url,
 235                         &info->model_number,
 236                         &info->date_of_manufacture,
 237                         &info->platform_ver,
 238                         &info->os_ver,
 239                         &info->hardware_ver,
 240                         &info->firmware_ver,
 241                         &info->support_url,
 242                         &info->system_time);
 243
 244         /* From iotivity, we can get uri_path. But, the value is always "/oic/p". */
 245
 246         if (cb)
 247                 cb(info, cb_container->user_data);
 248 }
 249
 250
 251 API int iotcon_get_platform_info(const char *host_address, iotcon_platform_info_cb cb,
 252                 void *user_data)
 253 {
 254         GError *error = NULL;
 255         unsigned int sub_id;
 256         int ret, signal_number, error_code;
 257         char signal_name[IC_DBUS_SIGNAL_LENGTH] = {0};
 258         icl_platform_info_s *cb_container;
 259
 260         RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS);
 261         RETV_IF(NULL == host_address, IOTCON_ERROR_INVALID_PARAMETER);
 262         RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER);
 263
 264         signal_number = icl_dbus_generate_signal_number();
 265
 266         ic_dbus_call_get_platform_info_sync(icl_dbus_get_object(), host_address,
 267                         signal_number, &ret, NULL, &error);
 268         if (error) {
 269                 ERR("ic_dbus_call_get_platform_info_sync() Fail(%s)", error->message);
 270                 error_code = icl_dbus_convert_dbus_error(error->code);
 271                 g_error_free(error);
 272                 return error_code;
 273         }
 274
 275         if (IOTCON_ERROR_NONE != ret) {
 276                 ERR("iotcon-daemon Fail(%d)", ret);
 277                 return icl_dbus_convert_daemon_error(ret);
 278         }
 279
 280         snprintf(signal_name, sizeof(signal_name), "%s_%u", IC_DBUS_SIGNAL_PLATFORM,
 281                         signal_number);
 282
 283         cb_container = calloc(1, sizeof(icl_platform_info_s));
 284         if (NULL == cb_container) {
 285                 ERR("calloc() Fail(%d)", errno);
 286                 return IOTCON_ERROR_OUT_OF_MEMORY;
 287         }
 288
 289         cb_container->cb = cb;
 290         cb_container->user_data = user_data;
 291
 292         sub_id = icl_dbus_subscribe_signal(signal_name, cb_container, free,
 293                         _icl_platform_info_cb);
 294         if (0 == sub_id) {
 295                 ERR("icl_dbus_subscribe_signal() Fail");
 296                 return IOTCON_ERROR_DBUS;
 297         }
 298
 299         cb_container->id = sub_id;
 300
 301         return ret;
 302 }
 303