src/mdg_util.c

   1 /*
   2  * Copyright (c) 2018 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  */
  17 #include <glib.h>
  18 #include <stdlib.h>
  19 #include <mdg.h>
  20 #include <mdg_debug.h>
  21 #include <mdg_private.h>
  22
  23 mdg_group_s *mdg_get_group_from_variant(GVariant *va)
  24 {
  25         char *device_id = NULL;
  26         char *group_name = NULL;
  27         mdg_group_type_e type = MDG_GROUP_TYPE_LOCAL;
  28         GVariantIter *iter = NULL;
  29         const gchar *key;
  30         GVariant *key_value = NULL;
  31
  32         mdg_group_s *group = calloc(1, sizeof(mdg_group_s));
  33         if (NULL == group) {
  34                         /* LCOV_EXCL_START */
  35                         _ERR("Memory allocation failed");
  36                         return NULL;
  37                         /* LCOV_EXCL_STOP */
  38         }
  39
  40         g_variant_get(va, "a{sv}", &iter);
  41         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
  42                 if (g_strcmp0(key, "DeviceID") == 0)
  43                         device_id = (char *)g_variant_get_string(key_value, NULL);
  44                 else if (g_strcmp0(key, "GroupName") == 0)
  45                         group_name = (char *)g_variant_get_string(key_value, NULL);
  46                 else if (g_strcmp0(key, "Type") == 0)
  47                         type = g_variant_get_int32(key_value);
  48         }
  49
  50         group->device_id = g_strdup(device_id);
  51         group->group_name = g_strdup(group_name);
  52         group->type = type;
  53
  54         g_variant_iter_free(iter);
  55
  56         return group;
  57 }
  58
  59 mdg_device_s *mdg_get_device_from_variant(GVariant *va)
  60 {
  61         char *device_id = NULL;
  62         char *model_name = NULL;
  63         char *device_name = NULL;
  64         char *platform_ver = NULL;
  65         char *vendor_id = NULL;
  66         char *profile = NULL;
  67         bool is_invited;
  68         int type = MDG_DEVICE_TYPE_LOCAL;
  69         GVariantIter *iter = NULL;
  70         const gchar *key;
  71         GVariant *key_value = NULL;
  72
  73         mdg_device_s *device = calloc(1, sizeof(mdg_device_s));
  74         if (NULL == device) {
  75                         /* LCOV_EXCL_START */
  76                         _ERR("Memory allocation failed");
  77                         return NULL;
  78                         /* LCOV_EXCL_STOP */
  79         }
  80
  81         g_variant_get(va, "a{sv}", &iter);
  82         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
  83                 if (g_strcmp0(key, "DeviceID") == 0)
  84                         device_id = (char *)g_variant_get_string(key_value, NULL);
  85                 else if (g_strcmp0(key, "ModelName") == 0)
  86                         model_name = (char *)g_variant_get_string(key_value, NULL);
  87                 else if (g_strcmp0(key, "DeviceName") == 0)
  88                         device_name = (char *)g_variant_get_string(key_value, NULL);
  89                 else if (g_strcmp0(key, "PlatformVer") == 0)
  90                         platform_ver = (char *)g_variant_get_string(key_value, NULL);
  91                 else if (g_strcmp0(key, "VendorID") == 0)
  92                         vendor_id = (char *)g_variant_get_string(key_value, NULL);
  93                 else if (g_strcmp0(key, "Profile") == 0)
  94                         profile = (char *)g_variant_get_string(key_value, NULL);
  95                 else if (g_strcmp0(key, "IsInvited") == 0)
  96                         is_invited = g_variant_get_int32(key_value);
  97                 else if (g_strcmp0(key, "Type") == 0)
  98                         type = g_variant_get_int32(key_value);
  99         }
 100
 101         device->device_id = g_strdup(device_id);
 102         device->model_name = g_strdup(model_name);
 103         device->device_name = g_strdup(device_name);
 104         device->platform_ver = g_strdup(platform_ver);
 105         device->vendor_id = g_strdup(vendor_id);
 106         device->profile = g_strdup(profile);
 107         device->is_invited = is_invited;
 108         device->type = type;
 109
 110         g_variant_iter_free(iter);
 111
 112         return device;
 113 }
 114
 115 void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id)
 116 {
 117         GVariantIter *iter = NULL;
 118         const gchar *key;
 119         GVariant *key_value = NULL;
 120
 121         g_variant_get(va, "a{sv}", &iter);
 122         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 123                 if (g_strcmp0(key, "DeviceID") == 0)
 124                         *device_id = (char *)g_variant_get_string(key_value, NULL);
 125                 else if (g_strcmp0(key, "ChannelID") == 0)
 126                         *channel_id = (char *)g_variant_get_string(key_value, NULL);
 127         }
 128
 129         g_variant_iter_free(iter);
 130 }
 131
 132 void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id,
 133         unsigned char **data, int *data_len)
 134 {
 135         GVariantIter *iter = NULL;
 136         const gchar *key;
 137         GVariant *key_value = NULL;
 138         GVariant *data_va;
 139         GVariantIter *data_iter = NULL;
 140         unsigned char byte_data;
 141
 142         g_variant_get(va, "a{sv}", &iter);
 143         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 144                 if (g_strcmp0(key, "DeviceID") == 0)
 145                         *device_id = (char *)g_variant_get_string(key_value, NULL);
 146                 else if (g_strcmp0(key, "ChannelID") == 0)
 147                         *channel_id = (char *)g_variant_get_string(key_value, NULL);
 148                 else if (g_strcmp0(key, "Data") == 0)
 149                         data_va = g_variant_get_variant(key_value);
 150                 else if (g_strcmp0(key, "DataLength") == 0)
 151                         *data_len = g_variant_get_int32(key_value);
 152         }
 153
 154         int i = 0;
 155         *data = (unsigned char *)g_try_malloc0(*data_len + 1);
 156
 157         g_variant_get(data_va, "a(y)", &data_iter);
 158         while (g_variant_iter_loop(data_iter, "(y)", &byte_data))
 159                 (*data)[i++] = byte_data;
 160
 161         g_variant_iter_free(iter);
 162 }
 163
 164 void mdg_get_progress_from_variant(GVariant *va, char **file_path,
 165         long *send_size, long *total_size, int *percent)
 166 {
 167         GVariantIter *iter = NULL;
 168         const gchar *key;
 169         GVariant *key_value = NULL;
 170
 171         g_variant_get(va, "a{sv}", &iter);
 172         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 173                 if (g_strcmp0(key, "FilePath") == 0)
 174                         *file_path = (char *)g_variant_get_string(key_value, NULL);
 175                 if (g_strcmp0(key, "SendSize") == 0)
 176                         *send_size = g_variant_get_int64(key_value);
 177                 if (g_strcmp0(key, "TotalSize") == 0)
 178                         *total_size = g_variant_get_int64(key_value);
 179                 if (g_strcmp0(key, "Percent") == 0)
 180                         *percent = g_variant_get_int32(key_value);
 181         }
 182
 183         g_variant_iter_free(iter);
 184 }
 185
 186 void mdg_get_receive_file_from_variant(GVariant *va, char **device_id, char **file_path)
 187 {
 188         GVariantIter *iter = NULL;
 189         const gchar *key;
 190         GVariant *key_value = NULL;
 191
 192         g_variant_get(va, "a{sv}", &iter);
 193         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 194                 if (g_strcmp0(key, "DeviceID") == 0)
 195                         *device_id = (char *)g_variant_get_string(key_value, NULL);
 196                 if (g_strcmp0(key, "FilePath") == 0)
 197                         *file_path = (char *)g_variant_get_string(key_value, NULL);
 198         }
 199
 200         g_variant_iter_free(iter);
 201 }
 202
 203 GVariant *mdg_create_variant_device(mdg_device_s *device)
 204 {
 205         GVariant *va;
 206
 207         GVariantBuilder *builder;
 208
 209         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 210
 211         g_variant_builder_add(builder, "{sv}", "DeviceID",
 212                                                   g_variant_new_string(device->device_id));
 213         g_variant_builder_add(builder, "{sv}", "ModelName",
 214                                                   g_variant_new_string(device->model_name));
 215         g_variant_builder_add(builder, "{sv}", "DeviceName",
 216                                                   g_variant_new_string(device->device_name));
 217         g_variant_builder_add(builder, "{sv}", "PlatformVer",
 218                                                   g_variant_new_string(device->platform_ver));
 219         g_variant_builder_add(builder, "{sv}", "VendorID",
 220                                                   g_variant_new_string(device->vendor_id));
 221         g_variant_builder_add(builder, "{sv}", "Profile",
 222                                                   g_variant_new_string(device->profile));
 223         g_variant_builder_add(builder, "{sv}", "IsInvited",
 224                                                   g_variant_new_int32(device->is_invited));
 225         g_variant_builder_add(builder, "{sv}", "Type",
 226                                                   g_variant_new_int32(device->type));
 227
 228         va = g_variant_builder_end(builder);
 229
 230         g_variant_builder_unref(builder);
 231
 232         return va;
 233 }
 234