client/src/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     int path_len = 0;
  40
  41     ret = app_get_id(&app_id);
  42     if (ret != APP_ERROR_NONE) {
  43         LOGE("Failed to get app_id : %d", ret); //LCOV_EXCL_LINE
  44         ret = STICKER_ERROR_OPERATION_FAILED;
  45         goto cleanup;
  46     }
  47
  48     ret = package_info_create(app_id, &package_info);
  49     if (ret != PACKAGE_MANAGER_ERROR_NONE || package_info == NULL) {
  50         LOGE("failed to create package_info. ret: %d", ret); //LCOV_EXCL_LINE
  51         ret = STICKER_ERROR_OPERATION_FAILED;
  52         goto cleanup;
  53     }
  54
  55     ret = package_info_get_root_path(package_info, &app_path);
  56     if (ret != PACKAGE_MANAGER_ERROR_NONE || app_path == NULL) {
  57         LOGE("failed to create package_info. ret: %d", ret); //LCOV_EXCL_LINE
  58         ret = STICKER_ERROR_OPERATION_FAILED;
  59         goto cleanup;
  60     }
  61
  62     path_len = strlen(app_path) + strlen(relative_path) + 2;
  63     file_path = (char *)calloc(path_len, sizeof(char));
  64     if (!file_path) {
  65         LOGE("failed to alloc memory"); //LCOV_EXCL_LINE
  66         ret = STICKER_ERROR_OPERATION_FAILED;
  67         goto cleanup;
  68     }
  69
  70     if (relative_path[0] == '/')
  71         snprintf(file_path, path_len, "%s%s",app_path, relative_path);
  72     else
  73         snprintf(file_path, path_len, "%s%s%s",app_path, "/", relative_path); //LCOV_EXCL_LINE
  74
  75     if (access(file_path, F_OK) != 0) {
  76         LOGE("%s does not exist", file_path);
  77         ret = STICKER_ERROR_OPERATION_FAILED;
  78         free(file_path);
  79     }
  80
  81 cleanup:
  82     if (app_id)
  83         free(app_id);
  84
  85     if (package_info)
  86         package_info_destroy(package_info);
  87
  88     if (app_path)
  89         free(app_path);
  90
  91     if (ret == STICKER_ERROR_NONE)
  92         return file_path;
  93     else
  94         return NULL;
  95 }
  96
  97 EXPORT_API int sticker_data_create(sticker_data_h *data_handle)
  98 {
  99     CHECK_STICKER_FEATURE();
 100
 101     if (!data_handle)
 102         return STICKER_ERROR_INVALID_PARAMETER;
 103
 104     sticker_data_h data_struct = (sticker_data_h)calloc(1, sizeof(struct sticker_data_s));
 105
 106     if (!data_struct)
 107         return STICKER_ERROR_OUT_OF_MEMORY;
 108
 109     char *app_id = NULL;
 110     int ret = app_get_id(&app_id);
 111     if (ret != APP_ERROR_NONE) {
 112         //LCOV_EXCL_START
 113         LOGE("Failed to get app_id : %d", ret);
 114         free(data_struct);
 115         ret = STICKER_ERROR_OPERATION_FAILED;
 116         goto cleanup;
 117         //LCOV_EXCL_STOP
 118     }
 119
 120     data_struct->app_id = strdup(app_id);
 121     *data_handle = data_struct;
 122
 123 cleanup:
 124     free(app_id);
 125
 126     return ret;
 127 }
 128
 129 EXPORT_API int sticker_data_destroy(sticker_data_h data_handle)
 130 {
 131     CHECK_STICKER_FEATURE();
 132
 133     if (!data_handle)
 134         return STICKER_ERROR_INVALID_PARAMETER;
 135
 136     if (data_handle->app_id) {
 137         free(data_handle->app_id);
 138         data_handle->app_id = NULL;
 139     }
 140
 141     if (data_handle->uri) {
 142         free(data_handle->uri);
 143         data_handle->uri = NULL;
 144     }
 145
 146     if (data_handle->thumbnail) {
 147         free(data_handle->thumbnail);
 148         data_handle->thumbnail = NULL;
 149     }
 150
 151     if (data_handle->keyword) {
 152         g_list_free_full(data_handle->keyword, free);
 153         data_handle->keyword = NULL;
 154     }
 155
 156     if (data_handle->group) {
 157         free(data_handle->group);
 158         data_handle->group = NULL;
 159     }
 160
 161     if (data_handle->description) {
 162         free(data_handle->description);
 163         data_handle->description = NULL;
 164     }
 165
 166     if (data_handle->date) {
 167         free(data_handle->date);
 168         data_handle->date = NULL;
 169     }
 170
 171     free(data_handle);
 172     data_handle = NULL;
 173
 174     return STICKER_ERROR_NONE;
 175 }
 176
 177 EXPORT_API int sticker_data_clone(sticker_data_h origin_handle, sticker_data_h *target_handle)
 178 {
 179     CHECK_STICKER_FEATURE();
 180
 181     sticker_data_h handle;
 182     if (!origin_handle || !target_handle)
 183         return STICKER_ERROR_INVALID_PARAMETER;
 184
 185     sticker_data_create(&handle);
 186     if (!handle)
 187         return STICKER_ERROR_OUT_OF_MEMORY;
 188
 189     handle->sticker_info_id = origin_handle->sticker_info_id;
 190
 191     if (origin_handle->app_id)
 192         handle->app_id = strdup(origin_handle->app_id);
 193
 194     handle->type = origin_handle->type;
 195
 196     if (origin_handle->uri)
 197         handle->uri = strdup(origin_handle->uri);
 198
 199     if (origin_handle->thumbnail)
 200         handle->thumbnail = strdup(origin_handle->thumbnail);
 201
 202     if (origin_handle->keyword)
 203         handle->keyword = g_list_copy_deep(origin_handle->keyword, (GCopyFunc) g_strdup, NULL);
 204
 205     if (origin_handle->group)
 206         handle->group = strdup(origin_handle->group);
 207
 208     if (origin_handle->description)
 209         handle->description = strdup(origin_handle->description);
 210
 211     if (origin_handle->date)
 212         handle->date = strdup(origin_handle->date);
 213
 214     handle->disp_type = origin_handle->disp_type;
 215
 216     *target_handle = handle;
 217
 218     return STICKER_ERROR_NONE;
 219 }
 220
 221 EXPORT_API int sticker_data_get_handle(const char* uri, sticker_data_h *data_handle)
 222 {
 223     CHECK_STICKER_FEATURE();
 224
 225     int ret;
 226     GDBusConnection *gdbus_connection = NULL;
 227     int server_watcher_id = 0;
 228     int monitor_id = 0;
 229     int server_monitor_id = 0;
 230     int is_exist = 0;
 231
 232     if (!uri || uri[0] == '\0' || !data_handle)
 233         return STICKER_ERROR_INVALID_PARAMETER;
 234
 235     struct sticker_data_s *handle = (sticker_data_h)calloc(1, sizeof(struct sticker_data_s));
 236     if (!handle)
 237         return STICKER_ERROR_OUT_OF_MEMORY;
 238
 239     ret = sticker_dbus_init(&gdbus_connection, &server_watcher_id, &monitor_id, &server_monitor_id, STICKER_CLIENT_LIB_PROVIDER, NULL);
 240     if (ret != STICKER_ERROR_NONE) {
 241         LOGE("Failed to initialize dbus : %d", ret);
 242         ret = STICKER_ERROR_OPERATION_FAILED;
 243         goto cleanup;
 244     }
 245
 246     ret = sticker_dbus_check_file_exists(gdbus_connection, uri, &is_exist);
 247     if (ret != STICKER_ERROR_NONE) {
 248         LOGE("Failed to check file exists : %d", ret);
 249         ret = STICKER_ERROR_OPERATION_FAILED;
 250         goto cleanup;
 251     }
 252
 253     if (!is_exist) {
 254         LOGE("Sticker does not exist. URI : %s", uri);
 255         ret = STICKER_ERROR_NO_SUCH_FILE;
 256         goto cleanup;
 257     }
 258
 259     ret = sticker_dbus_get_sticker_info_by_uri(gdbus_connection, handle, uri);
 260     if (ret != STICKER_ERROR_NONE) {
 261         LOGE("Failed to get sticker information : %d", ret);
 262         goto cleanup;
 263     }
 264
 265     *data_handle = handle;
 266
 267     ret = sticker_dbus_shutdown(gdbus_connection, &server_watcher_id, &server_monitor_id, &monitor_id, STICKER_CLIENT_LIB_PROVIDER);
 268     if (ret != STICKER_ERROR_NONE)
 269         LOGE("Failed to finalize dbus : %d", ret);
 270
 271     g_object_unref(gdbus_connection);
 272
 273     return STICKER_ERROR_NONE;
 274
 275 cleanup:
 276     if (handle)
 277         sticker_data_destroy(handle);
 278
 279     if (gdbus_connection) {
 280         int ret_err = sticker_dbus_shutdown(gdbus_connection, &server_watcher_id, &server_monitor_id, &monitor_id, STICKER_CLIENT_LIB_PROVIDER);
 281         if (ret_err != STICKER_ERROR_NONE)
 282             LOGE("Failed to finalize dbus : %d", ret_err);
 283
 284         g_object_unref(gdbus_connection);
 285     }
 286
 287     return ret;
 288 }
 289
 290 EXPORT_API int sticker_data_get_app_id(sticker_data_h data_handle, char **app_id)
 291 {
 292     CHECK_STICKER_FEATURE();
 293
 294     if (!data_handle || !app_id)
 295         return STICKER_ERROR_INVALID_PARAMETER;
 296
 297     if (!data_handle->app_id)
 298         return STICKER_ERROR_NO_DATA;
 299
 300     *app_id = strdup(data_handle->app_id);
 301
 302     return STICKER_ERROR_NONE;
 303 }
 304
 305 EXPORT_API int sticker_data_set_uri(sticker_data_h data_handle, sticker_data_uri_type_e type, const char *uri)
 306 {
 307     CHECK_STICKER_FEATURE();
 308
 309     char *file_path = NULL;
 310     if (!data_handle || !type || !uri || uri[0] == '\0')
 311         return STICKER_ERROR_INVALID_PARAMETER;
 312
 313     if (type == STICKER_DATA_URI_LOCAL_PATH) {
 314         if (access(uri, F_OK) != 0) {
 315             file_path = _make_absolute_path(uri);
 316             if (file_path == NULL) {
 317                 return STICKER_ERROR_INVALID_PARAMETER;
 318             }
 319         } else
 320             file_path = strdup(uri);
 321     }
 322
 323     if (data_handle->uri)
 324         free(data_handle->uri);
 325
 326     data_handle->type = type;
 327     if (type == STICKER_DATA_URI_LOCAL_PATH)
 328         data_handle->uri = file_path;
 329     else
 330         data_handle->uri = strdup(uri);
 331
 332     return STICKER_ERROR_NONE;
 333 }
 334
 335 EXPORT_API int sticker_data_get_uri(sticker_data_h data_handle, sticker_data_uri_type_e *type, char **uri)
 336 {
 337     CHECK_STICKER_FEATURE();
 338
 339     if (!data_handle || !type || !uri)
 340         return STICKER_ERROR_INVALID_PARAMETER;
 341
 342     if (!data_handle->type || !data_handle->uri)
 343         return STICKER_ERROR_NO_DATA;
 344
 345     *type = data_handle->type;
 346     *uri = strdup(data_handle->uri);
 347
 348     return STICKER_ERROR_NONE;
 349 }
 350
 351 EXPORT_API int sticker_data_foreach_keyword(sticker_data_h data_handle, sticker_data_keyword_foreach_cb callback, void *user_data)
 352 {
 353     CHECK_STICKER_FEATURE();
 354
 355     if (!data_handle || !callback)
 356         return STICKER_ERROR_INVALID_PARAMETER;
 357
 358     if (!data_handle->keyword)
 359         return STICKER_ERROR_NO_DATA;
 360
 361     GList *list = NULL;
 362     for(list = g_list_first(data_handle->keyword); list != NULL; list=list->next) {
 363         callback(list->data, user_data);
 364     }
 365
 366     return STICKER_ERROR_NONE;
 367 }
 368
 369 EXPORT_API int sticker_data_add_keyword(sticker_data_h data_handle, const char *keyword)
 370 {
 371     CHECK_STICKER_FEATURE();
 372
 373     GList *node;
 374     if (!data_handle || !keyword)
 375         return STICKER_ERROR_INVALID_PARAMETER;
 376
 377     node = g_list_find_custom(data_handle->keyword, keyword, (GCompareFunc) strcmp);
 378
 379     if (node) {
 380         LOGE("keyword already exists");
 381         return STICKER_ERROR_INVALID_PARAMETER;
 382     } else {
 383         data_handle->keyword = g_list_append(data_handle->keyword, strdup(keyword));
 384     }
 385
 386     return STICKER_ERROR_NONE;
 387 }
 388
 389 EXPORT_API int sticker_data_remove_keyword(sticker_data_h data_handle, const char *keyword)
 390 {
 391     CHECK_STICKER_FEATURE();
 392
 393     GList *node;
 394     if (!data_handle || !keyword)
 395         return STICKER_ERROR_INVALID_PARAMETER;
 396
 397     node = g_list_find_custom(data_handle->keyword, keyword, (GCompareFunc) strcmp);
 398
 399     if (node) {
 400         data_handle->keyword = g_list_delete_link(data_handle->keyword, node);
 401     } else {
 402         LOGE("keyword does not exist");
 403         return STICKER_ERROR_INVALID_PARAMETER;
 404     }
 405
 406     return STICKER_ERROR_NONE;
 407 }
 408
 409 EXPORT_API int sticker_data_set_group_name(sticker_data_h data_handle, const char *group)
 410 {
 411     CHECK_STICKER_FEATURE();
 412
 413     if (!data_handle || !group)
 414         return STICKER_ERROR_INVALID_PARAMETER;
 415
 416     if (data_handle->group)
 417         free(data_handle->group);
 418
 419     data_handle->group = strdup(group);
 420
 421     return STICKER_ERROR_NONE;
 422 }
 423
 424 EXPORT_API int sticker_data_get_group_name(sticker_data_h data_handle, char **group)
 425 {
 426     CHECK_STICKER_FEATURE();
 427
 428     if (!data_handle || !group)
 429         return STICKER_ERROR_INVALID_PARAMETER;
 430
 431     if (!data_handle->group)
 432         return STICKER_ERROR_NO_DATA;
 433
 434     *group = strdup(data_handle->group);
 435
 436     return STICKER_ERROR_NONE;
 437 }
 438
 439 EXPORT_API int sticker_data_set_thumbnail(sticker_data_h data_handle, const char *thumbnail)
 440 {
 441     CHECK_STICKER_FEATURE();
 442
 443     char *file_path = NULL;
 444     if (!data_handle || !thumbnail || thumbnail[0] == '\0')
 445         return STICKER_ERROR_INVALID_PARAMETER;
 446
 447     if (access(thumbnail, F_OK) != 0) {
 448         file_path = _make_absolute_path(thumbnail);
 449         if (file_path == NULL)
 450             return STICKER_ERROR_INVALID_PARAMETER;
 451     } else
 452         file_path = strdup(thumbnail);
 453
 454     if (data_handle->thumbnail)
 455         free(data_handle->thumbnail);
 456
 457     data_handle->thumbnail = file_path;
 458
 459     return STICKER_ERROR_NONE;
 460 }
 461
 462 EXPORT_API int sticker_data_get_thumbnail(sticker_data_h data_handle, char **thumbnail)
 463 {
 464     CHECK_STICKER_FEATURE();
 465
 466     if (!data_handle || !thumbnail)
 467         return STICKER_ERROR_INVALID_PARAMETER;
 468
 469     if (!data_handle->thumbnail)
 470         *thumbnail = strdup("");
 471     else
 472         *thumbnail = strdup(data_handle->thumbnail);
 473
 474     return STICKER_ERROR_NONE;
 475 }
 476
 477 EXPORT_API int sticker_data_set_description(sticker_data_h data_handle, const char *description)
 478 {
 479     CHECK_STICKER_FEATURE();
 480
 481     if (!data_handle || !description)
 482         return STICKER_ERROR_INVALID_PARAMETER;
 483
 484     if (data_handle->description)
 485         free(data_handle->description);
 486
 487     data_handle->description = strdup(description);
 488
 489     return STICKER_ERROR_NONE;
 490 }
 491
 492 EXPORT_API int sticker_data_get_description(sticker_data_h data_handle, char **description)
 493 {
 494     CHECK_STICKER_FEATURE();
 495
 496     if (!data_handle || !description)
 497         return STICKER_ERROR_INVALID_PARAMETER;
 498
 499     if (!data_handle->description)
 500         *description = strdup("");
 501     else
 502         *description = strdup(data_handle->description);
 503
 504     return STICKER_ERROR_NONE;
 505 }
 506
 507 EXPORT_API int sticker_data_get_date(sticker_data_h data_handle, char **date)
 508 {
 509     CHECK_STICKER_FEATURE();
 510
 511     if (!data_handle || !date)
 512         return STICKER_ERROR_INVALID_PARAMETER;
 513
 514     if (!data_handle->date)
 515         return STICKER_ERROR_NO_DATA;
 516
 517     *date = strdup(data_handle->date);
 518
 519     return STICKER_ERROR_NONE;
 520 }
 521
 522 EXPORT_API int sticker_data_set_display_type(sticker_data_h data_handle, sticker_data_display_type_e type)
 523 {
 524     CHECK_STICKER_FEATURE();
 525
 526     if (!data_handle || !type || type < STICKER_DATA_DISP_EMOJI || type > STICKER_DATA_DISP_WALLPAPER)
 527         return STICKER_ERROR_INVALID_PARAMETER;
 528
 529     data_handle->disp_type = type;
 530
 531     return STICKER_ERROR_NONE;
 532 }
 533
 534 EXPORT_API int sticker_data_get_display_type(sticker_data_h data_handle, sticker_data_display_type_e *type)
 535 {
 536     CHECK_STICKER_FEATURE();
 537
 538     if (!data_handle || !type)
 539         return STICKER_ERROR_INVALID_PARAMETER;
 540
 541     *type = data_handle->disp_type;
 542
 543     return STICKER_ERROR_NONE;
 544 }