client/sticker_data.c

   1 /*
   2  * Copyright (c) 2019 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 <stdio.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <dlog.h>
  21 #include <app_common.h>
  22 #include <package_manager.h>
  23
  24 #include "sticker_data.h"
  25 #include "sticker_dbus.h"
  26
  27 #ifdef LOG_TAG
  28 #undef LOG_TAG
  29 #endif
  30 #define LOG_TAG "STICKER_DATA"
  31
  32 static char* _make_absolute_path(const char *relative_path)
  33 {
  34     int ret = STICKER_ERROR_NONE;
  35     char *app_id = NULL;
  36     package_info_h package_info = NULL;
  37     char *app_path = NULL;
  38     char *file_path = NULL;
  39
  40     ret = app_get_id(&app_id);
  41     if (ret != APP_ERROR_NONE) {
  42         LOGE("Failed to get app_id : %d", ret);
  43         ret = STICKER_ERROR_OPERATION_FAILED;
  44         goto cleanup;
  45     }
  46
  47     ret = package_info_create(app_id, &package_info);
  48     if (ret != PACKAGE_MANAGER_ERROR_NONE || package_info == NULL) {
  49         LOGE("faild to create package_info. ret: %d", ret);
  50         ret = STICKER_ERROR_OPERATION_FAILED;
  51         goto cleanup;
  52     }
  53
  54     ret = package_info_get_root_path(package_info, &app_path);
  55     if (ret != PACKAGE_MANAGER_ERROR_NONE || app_path == NULL) {
  56         LOGE("faild to create package_info. ret: %d", ret);
  57         ret = STICKER_ERROR_OPERATION_FAILED;
  58         goto cleanup;
  59     }
  60
  61     int path_len = strlen(app_path) + strlen(relative_path) + 2;
  62     file_path = (char *)calloc(path_len, sizeof(char));
  63     if (!file_path) {
  64         LOGE("failed to alloc memory");
  65         ret = STICKER_ERROR_OPERATION_FAILED;
  66         goto cleanup;
  67     }
  68
  69     if(relative_path[0] == '/')
  70         snprintf(file_path, path_len, "%s%s",app_path, relative_path);
  71     else
  72         snprintf(file_path, path_len, "%s%s%s",app_path, "/", relative_path);
  73
  74     if (access(file_path, F_OK) != 0) {
  75         LOGE("%s does not exist", file_path);
  76         ret = STICKER_ERROR_OPERATION_FAILED;
  77         free(file_path);
  78     }
  79
  80 cleanup:
  81     if (app_id)
  82         free(app_id);
  83
  84     if (package_info)
  85         package_info_destroy(package_info);
  86
  87     if (app_path)
  88         free(app_path);
  89
  90     if (ret == STICKER_ERROR_NONE)
  91         return file_path;
  92     else
  93         return NULL;
  94 }
  95
  96 EXPORT_API int sticker_data_create(sticker_data_h *data_handle)
  97 {
  98     CHECK_STICKER_FEATURE();
  99
 100     if (!data_handle)
 101         return STICKER_ERROR_INVALID_PARAMETER;
 102
 103     sticker_data_h data_struct = (sticker_data_h)calloc(1, sizeof(struct sticker_data_s));
 104
 105     if (!data_struct)
 106         return STICKER_ERROR_OUT_OF_MEMORY;
 107
 108     char *app_id = NULL;
 109     int ret = app_get_id(&app_id);
 110     if (ret != APP_ERROR_NONE) {
 111         LOGE("Failed to get app_id : %d", ret);
 112         free(data_struct);
 113         ret = STICKER_ERROR_OPERATION_FAILED;
 114         goto cleanup;
 115     }
 116
 117     data_struct->app_id = strdup(app_id);
 118     *data_handle = data_struct;
 119
 120 cleanup:
 121     if (app_id)
 122         free(app_id);
 123
 124     return ret;
 125 }
 126
 127 EXPORT_API int sticker_data_destroy(sticker_data_h data_handle)
 128 {
 129     CHECK_STICKER_FEATURE();
 130
 131     if (!data_handle)
 132         return STICKER_ERROR_INVALID_PARAMETER;
 133
 134     if (data_handle->app_id) {
 135         free(data_handle->app_id);
 136         data_handle->app_id = NULL;
 137     }
 138
 139     if (data_handle->uri) {
 140         free(data_handle->uri);
 141         data_handle->uri = NULL;
 142     }
 143
 144     if (data_handle->thumbnail) {
 145         free(data_handle->thumbnail);
 146         data_handle->thumbnail = NULL;
 147     }
 148
 149     if (data_handle->keyword) {
 150         g_list_free_full(data_handle->keyword, free);
 151         data_handle->keyword = NULL;
 152     }
 153
 154     if (data_handle->group) {
 155         free(data_handle->group);
 156         data_handle->group = NULL;
 157     }
 158
 159     if (data_handle->description) {
 160         free(data_handle->description);
 161         data_handle->description = NULL;
 162     }
 163
 164     if (data_handle->date) {
 165         free(data_handle->date);
 166         data_handle->date = NULL;
 167     }
 168
 169     free(data_handle);
 170     data_handle = NULL;
 171
 172     return STICKER_ERROR_NONE;
 173 }
 174
 175 EXPORT_API int sticker_data_clone(sticker_data_h origin_handle, sticker_data_h *target_handle)
 176 {
 177     CHECK_STICKER_FEATURE();
 178
 179     sticker_data_h handle;
 180     if (!origin_handle || !target_handle)
 181         return STICKER_ERROR_INVALID_PARAMETER;
 182
 183     sticker_data_create(&handle);
 184     if (!handle)
 185         return STICKER_ERROR_OUT_OF_MEMORY;
 186
 187     handle->sticker_info_id = origin_handle->sticker_info_id;
 188
 189     if (origin_handle->app_id)
 190         handle->app_id = strdup(origin_handle->app_id);
 191
 192     handle->type = origin_handle->type;
 193
 194     if (origin_handle->uri)
 195         handle->uri = strdup(origin_handle->uri);
 196
 197     if (origin_handle->thumbnail)
 198         handle->thumbnail = strdup(origin_handle->thumbnail);
 199
 200     if (origin_handle->keyword)
 201         handle->keyword = g_list_copy_deep(origin_handle->keyword, (GCopyFunc) g_strdup, NULL);
 202
 203     if (origin_handle->group)
 204         handle->group = strdup(origin_handle->group);
 205
 206     if (origin_handle->description)
 207         handle->description = strdup(origin_handle->description);
 208
 209     if (origin_handle->date)
 210         handle->date = strdup(origin_handle->date);
 211
 212     *target_handle = handle;
 213
 214     return STICKER_ERROR_NONE;
 215 }
 216
 217 EXPORT_API int sticker_data_get_app_id(sticker_data_h data_handle, char **app_id)
 218 {
 219     CHECK_STICKER_FEATURE();
 220
 221     if (!data_handle || !app_id)
 222         return STICKER_ERROR_INVALID_PARAMETER;
 223
 224     if (!data_handle->app_id)
 225         return STICKER_ERROR_OPERATION_FAILED;
 226
 227     *app_id = strdup(data_handle->app_id);
 228
 229     return STICKER_ERROR_NONE;
 230 }
 231
 232 EXPORT_API int sticker_data_set_uri(sticker_data_h data_handle, sticker_data_uri_type_e type, const char *uri)
 233 {
 234     CHECK_STICKER_FEATURE();
 235
 236     char *file_path = NULL;
 237     if (!data_handle || !type || !uri)
 238         return STICKER_ERROR_INVALID_PARAMETER;
 239
 240     if (type == STICKER_DATA_URI_LOCAL_PATH) {
 241         if (access(uri, F_OK) != 0) {
 242             file_path = _make_absolute_path(uri);
 243             if (file_path == NULL) {
 244                 return STICKER_ERROR_INVALID_PARAMETER;
 245             }
 246         } else
 247             file_path = strdup(uri);
 248     }
 249
 250     if (data_handle->uri)
 251         free(data_handle->uri);
 252
 253     data_handle->type = type;
 254     if (type == STICKER_DATA_URI_LOCAL_PATH)
 255         data_handle->uri = file_path;
 256     else
 257         data_handle->uri = strdup(uri);
 258
 259     return STICKER_ERROR_NONE;
 260 }
 261
 262 EXPORT_API int sticker_data_get_uri(sticker_data_h data_handle, sticker_data_uri_type_e *type, char **uri)
 263 {
 264     CHECK_STICKER_FEATURE();
 265
 266     if (!data_handle || !type || !uri)
 267         return STICKER_ERROR_INVALID_PARAMETER;
 268
 269     if (!data_handle->type || !data_handle->uri)
 270         return STICKER_ERROR_OPERATION_FAILED;
 271
 272     *type = data_handle->type;
 273     *uri = strdup(data_handle->uri);
 274
 275     return STICKER_ERROR_NONE;
 276 }
 277
 278 EXPORT_API int sticker_data_foreach_keyword(sticker_data_h data_handle, sticker_data_keyword_foreach_cb callback, void *user_data)
 279 {
 280     CHECK_STICKER_FEATURE();
 281
 282     if (!data_handle || !callback)
 283         return STICKER_ERROR_INVALID_PARAMETER;
 284
 285     if (!data_handle->keyword)
 286         return STICKER_ERROR_OPERATION_FAILED;
 287
 288     GList *list = NULL;
 289     for(list = g_list_first(data_handle->keyword); list != NULL; list=list->next) {
 290         callback(list->data, user_data);
 291     }
 292
 293     return STICKER_ERROR_NONE;
 294 }
 295
 296 EXPORT_API int sticker_data_add_keyword(sticker_data_h data_handle, const char *keyword)
 297 {
 298     CHECK_STICKER_FEATURE();
 299
 300     GList *node;
 301     if (!data_handle || !keyword)
 302         return STICKER_ERROR_INVALID_PARAMETER;
 303
 304     node = g_list_find_custom(data_handle->keyword, keyword, (GCompareFunc) strcmp);
 305
 306     if (node) {
 307         LOGE("keyword already exists");
 308         return STICKER_ERROR_INVALID_PARAMETER;
 309     } else {
 310         data_handle->keyword = g_list_append(data_handle->keyword, strdup(keyword));
 311     }
 312
 313     return STICKER_ERROR_NONE;
 314 }
 315
 316 EXPORT_API int sticker_data_remove_keyword(sticker_data_h data_handle, const char *keyword)
 317 {
 318     CHECK_STICKER_FEATURE();
 319
 320     GList *node;
 321     if (!data_handle || !keyword)
 322         return STICKER_ERROR_INVALID_PARAMETER;
 323
 324     node = g_list_find_custom(data_handle->keyword, keyword, (GCompareFunc) strcmp);
 325
 326     if (node) {
 327         data_handle->keyword = g_list_delete_link(data_handle->keyword, node);
 328     } else {
 329         LOGE("keyword does not exist");
 330         return STICKER_ERROR_INVALID_PARAMETER;
 331     }
 332
 333     return STICKER_ERROR_NONE;
 334 }
 335
 336 EXPORT_API int sticker_data_set_group_name(sticker_data_h data_handle, const char *group)
 337 {
 338     CHECK_STICKER_FEATURE();
 339
 340     if (!data_handle || !group)
 341         return STICKER_ERROR_INVALID_PARAMETER;
 342
 343     if (data_handle->group)
 344         free(data_handle->group);
 345
 346     data_handle->group = strdup(group);
 347
 348     return STICKER_ERROR_NONE;
 349 }
 350
 351 EXPORT_API int sticker_data_get_group_name(sticker_data_h data_handle, char **group)
 352 {
 353     CHECK_STICKER_FEATURE();
 354
 355     if (!data_handle || !group)
 356         return STICKER_ERROR_INVALID_PARAMETER;
 357
 358     if (!data_handle->group)
 359         return STICKER_ERROR_OPERATION_FAILED;
 360
 361     *group = strdup(data_handle->group);
 362
 363     return STICKER_ERROR_NONE;
 364 }
 365
 366 EXPORT_API int sticker_data_set_thumbnail(sticker_data_h data_handle, const char *thumbnail)
 367 {
 368     CHECK_STICKER_FEATURE();
 369
 370     char *file_path = NULL;
 371     if (!data_handle || !thumbnail)
 372         return STICKER_ERROR_INVALID_PARAMETER;
 373
 374     if (access(thumbnail, F_OK) != 0) {
 375         file_path = _make_absolute_path(thumbnail);
 376         if (file_path == NULL)
 377             return STICKER_ERROR_INVALID_PARAMETER;
 378     } else
 379         file_path = strdup(thumbnail);
 380
 381     if (data_handle->thumbnail)
 382         free(data_handle->thumbnail);
 383
 384     data_handle->thumbnail = file_path;
 385
 386     return STICKER_ERROR_NONE;
 387 }
 388
 389 EXPORT_API int sticker_data_get_thumbnail(sticker_data_h data_handle, char **thumbnail)
 390 {
 391     CHECK_STICKER_FEATURE();
 392
 393     if (!data_handle || !thumbnail)
 394         return STICKER_ERROR_INVALID_PARAMETER;
 395
 396     if (!data_handle->thumbnail)
 397         *thumbnail = strdup("");
 398     else
 399         *thumbnail = strdup(data_handle->thumbnail);
 400
 401     return STICKER_ERROR_NONE;
 402 }
 403
 404 EXPORT_API int sticker_data_set_description(sticker_data_h data_handle, const char *description)
 405 {
 406     CHECK_STICKER_FEATURE();
 407
 408     if (!data_handle || !description)
 409         return STICKER_ERROR_INVALID_PARAMETER;
 410
 411     if (data_handle->description)
 412         free(data_handle->description);
 413
 414     data_handle->description = strdup(description);
 415
 416     return STICKER_ERROR_NONE;
 417 }
 418
 419 EXPORT_API int sticker_data_get_description(sticker_data_h data_handle, char **description)
 420 {
 421     CHECK_STICKER_FEATURE();
 422
 423     if (!data_handle || !description)
 424         return STICKER_ERROR_INVALID_PARAMETER;
 425
 426     if (!data_handle->description)
 427         *description = strdup("");
 428     else
 429         *description = strdup(data_handle->description);
 430
 431     return STICKER_ERROR_NONE;
 432 }
 433
 434 EXPORT_API int sticker_data_get_date(sticker_data_h data_handle, char **date)
 435 {
 436     CHECK_STICKER_FEATURE();
 437
 438     if (!data_handle || !date)
 439         return STICKER_ERROR_INVALID_PARAMETER;
 440
 441     if (!data_handle->date)
 442         return STICKER_ERROR_OPERATION_FAILED;
 443
 444     *date = strdup(data_handle->date);
 445
 446     return STICKER_ERROR_NONE;
 447 }