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("failed 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("failed 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     free(app_id);
 122
 123     return ret;
 124 }
 125
 126 EXPORT_API int sticker_data_destroy(sticker_data_h data_handle)
 127 {
 128     CHECK_STICKER_FEATURE();
 129
 130     if (!data_handle)
 131         return STICKER_ERROR_INVALID_PARAMETER;
 132
 133     if (data_handle->app_id) {
 134         free(data_handle->app_id);
 135         data_handle->app_id = NULL;
 136     }
 137
 138     if (data_handle->uri) {
 139         free(data_handle->uri);
 140         data_handle->uri = NULL;
 141     }
 142
 143     if (data_handle->thumbnail) {
 144         free(data_handle->thumbnail);
 145         data_handle->thumbnail = NULL;
 146     }
 147
 148     if (data_handle->keyword) {
 149         g_list_free_full(data_handle->keyword, free);
 150         data_handle->keyword = NULL;
 151     }
 152
 153     if (data_handle->group) {
 154         free(data_handle->group);
 155         data_handle->group = NULL;
 156     }
 157
 158     if (data_handle->description) {
 159         free(data_handle->description);
 160         data_handle->description = NULL;
 161     }
 162
 163     if (data_handle->date) {
 164         free(data_handle->date);
 165         data_handle->date = NULL;
 166     }
 167
 168     free(data_handle);
 169     data_handle = NULL;
 170
 171     return STICKER_ERROR_NONE;
 172 }
 173
 174 EXPORT_API int sticker_data_clone(sticker_data_h origin_handle, sticker_data_h *target_handle)
 175 {
 176     CHECK_STICKER_FEATURE();
 177
 178     sticker_data_h handle;
 179     if (!origin_handle || !target_handle)
 180         return STICKER_ERROR_INVALID_PARAMETER;
 181
 182     sticker_data_create(&handle);
 183     if (!handle)
 184         return STICKER_ERROR_OUT_OF_MEMORY;
 185
 186     handle->sticker_info_id = origin_handle->sticker_info_id;
 187
 188     if (origin_handle->app_id)
 189         handle->app_id = strdup(origin_handle->app_id);
 190
 191     handle->type = origin_handle->type;
 192
 193     if (origin_handle->uri)
 194         handle->uri = strdup(origin_handle->uri);
 195
 196     if (origin_handle->thumbnail)
 197         handle->thumbnail = strdup(origin_handle->thumbnail);
 198
 199     if (origin_handle->keyword)
 200         handle->keyword = g_list_copy_deep(origin_handle->keyword, (GCopyFunc) g_strdup, NULL);
 201
 202     if (origin_handle->group)
 203         handle->group = strdup(origin_handle->group);
 204
 205     if (origin_handle->description)
 206         handle->description = strdup(origin_handle->description);
 207
 208     if (origin_handle->date)
 209         handle->date = strdup(origin_handle->date);
 210
 211     *target_handle = handle;
 212
 213     return STICKER_ERROR_NONE;
 214 }
 215
 216 EXPORT_API int sticker_data_get_app_id(sticker_data_h data_handle, char **app_id)
 217 {
 218     CHECK_STICKER_FEATURE();
 219
 220     if (!data_handle || !app_id)
 221         return STICKER_ERROR_INVALID_PARAMETER;
 222
 223     if (!data_handle->app_id)
 224         return STICKER_ERROR_OPERATION_FAILED;
 225
 226     *app_id = strdup(data_handle->app_id);
 227
 228     return STICKER_ERROR_NONE;
 229 }
 230
 231 EXPORT_API int sticker_data_set_uri(sticker_data_h data_handle, sticker_data_uri_type_e type, const char *uri)
 232 {
 233     CHECK_STICKER_FEATURE();
 234
 235     char *file_path = NULL;
 236     if (!data_handle || !type || !uri)
 237         return STICKER_ERROR_INVALID_PARAMETER;
 238
 239     if (type == STICKER_DATA_URI_LOCAL_PATH) {
 240         if (access(uri, F_OK) != 0) {
 241             file_path = _make_absolute_path(uri);
 242             if (file_path == NULL) {
 243                 return STICKER_ERROR_INVALID_PARAMETER;
 244             }
 245         } else
 246             file_path = strdup(uri);
 247     }
 248
 249     if (data_handle->uri)
 250         free(data_handle->uri);
 251
 252     data_handle->type = type;
 253     if (type == STICKER_DATA_URI_LOCAL_PATH)
 254         data_handle->uri = file_path;
 255     else
 256         data_handle->uri = strdup(uri);
 257
 258     return STICKER_ERROR_NONE;
 259 }
 260
 261 EXPORT_API int sticker_data_get_uri(sticker_data_h data_handle, sticker_data_uri_type_e *type, char **uri)
 262 {
 263     CHECK_STICKER_FEATURE();
 264
 265     if (!data_handle || !type || !uri)
 266         return STICKER_ERROR_INVALID_PARAMETER;
 267
 268     if (!data_handle->type || !data_handle->uri)
 269         return STICKER_ERROR_OPERATION_FAILED;
 270
 271     *type = data_handle->type;
 272     *uri = strdup(data_handle->uri);
 273
 274     return STICKER_ERROR_NONE;
 275 }
 276
 277 EXPORT_API int sticker_data_foreach_keyword(sticker_data_h data_handle, sticker_data_keyword_foreach_cb callback, void *user_data)
 278 {
 279     CHECK_STICKER_FEATURE();
 280
 281     if (!data_handle || !callback)
 282         return STICKER_ERROR_INVALID_PARAMETER;
 283
 284     if (!data_handle->keyword)
 285         return STICKER_ERROR_OPERATION_FAILED;
 286
 287     GList *list = NULL;
 288     for(list = g_list_first(data_handle->keyword); list != NULL; list=list->next) {
 289         callback(list->data, user_data);
 290     }
 291
 292     return STICKER_ERROR_NONE;
 293 }
 294
 295 EXPORT_API int sticker_data_add_keyword(sticker_data_h data_handle, const char *keyword)
 296 {
 297     CHECK_STICKER_FEATURE();
 298
 299     GList *node;
 300     if (!data_handle || !keyword)
 301         return STICKER_ERROR_INVALID_PARAMETER;
 302
 303     node = g_list_find_custom(data_handle->keyword, keyword, (GCompareFunc) strcmp);
 304
 305     if (node) {
 306         LOGE("keyword already exists");
 307         return STICKER_ERROR_INVALID_PARAMETER;
 308     } else {
 309         data_handle->keyword = g_list_append(data_handle->keyword, strdup(keyword));
 310     }
 311
 312     return STICKER_ERROR_NONE;
 313 }
 314
 315 EXPORT_API int sticker_data_remove_keyword(sticker_data_h data_handle, const char *keyword)
 316 {
 317     CHECK_STICKER_FEATURE();
 318
 319     GList *node;
 320     if (!data_handle || !keyword)
 321         return STICKER_ERROR_INVALID_PARAMETER;
 322
 323     node = g_list_find_custom(data_handle->keyword, keyword, (GCompareFunc) strcmp);
 324
 325     if (node) {
 326         data_handle->keyword = g_list_delete_link(data_handle->keyword, node);
 327     } else {
 328         LOGE("keyword does not exist");
 329         return STICKER_ERROR_INVALID_PARAMETER;
 330     }
 331
 332     return STICKER_ERROR_NONE;
 333 }
 334
 335 EXPORT_API int sticker_data_set_group_name(sticker_data_h data_handle, const char *group)
 336 {
 337     CHECK_STICKER_FEATURE();
 338
 339     if (!data_handle || !group)
 340         return STICKER_ERROR_INVALID_PARAMETER;
 341
 342     if (data_handle->group)
 343         free(data_handle->group);
 344
 345     data_handle->group = strdup(group);
 346
 347     return STICKER_ERROR_NONE;
 348 }
 349
 350 EXPORT_API int sticker_data_get_group_name(sticker_data_h data_handle, char **group)
 351 {
 352     CHECK_STICKER_FEATURE();
 353
 354     if (!data_handle || !group)
 355         return STICKER_ERROR_INVALID_PARAMETER;
 356
 357     if (!data_handle->group)
 358         return STICKER_ERROR_OPERATION_FAILED;
 359
 360     *group = strdup(data_handle->group);
 361
 362     return STICKER_ERROR_NONE;
 363 }
 364
 365 EXPORT_API int sticker_data_set_thumbnail(sticker_data_h data_handle, const char *thumbnail)
 366 {
 367     CHECK_STICKER_FEATURE();
 368
 369     char *file_path = NULL;
 370     if (!data_handle || !thumbnail)
 371         return STICKER_ERROR_INVALID_PARAMETER;
 372
 373     if (access(thumbnail, F_OK) != 0) {
 374         file_path = _make_absolute_path(thumbnail);
 375         if (file_path == NULL)
 376             return STICKER_ERROR_INVALID_PARAMETER;
 377     } else
 378         file_path = strdup(thumbnail);
 379
 380     if (data_handle->thumbnail)
 381         free(data_handle->thumbnail);
 382
 383     data_handle->thumbnail = file_path;
 384
 385     return STICKER_ERROR_NONE;
 386 }
 387
 388 EXPORT_API int sticker_data_get_thumbnail(sticker_data_h data_handle, char **thumbnail)
 389 {
 390     CHECK_STICKER_FEATURE();
 391
 392     if (!data_handle || !thumbnail)
 393         return STICKER_ERROR_INVALID_PARAMETER;
 394
 395     if (!data_handle->thumbnail)
 396         *thumbnail = strdup("");
 397     else
 398         *thumbnail = strdup(data_handle->thumbnail);
 399
 400     return STICKER_ERROR_NONE;
 401 }
 402
 403 EXPORT_API int sticker_data_set_description(sticker_data_h data_handle, const char *description)
 404 {
 405     CHECK_STICKER_FEATURE();
 406
 407     if (!data_handle || !description)
 408         return STICKER_ERROR_INVALID_PARAMETER;
 409
 410     if (data_handle->description)
 411         free(data_handle->description);
 412
 413     data_handle->description = strdup(description);
 414
 415     return STICKER_ERROR_NONE;
 416 }
 417
 418 EXPORT_API int sticker_data_get_description(sticker_data_h data_handle, char **description)
 419 {
 420     CHECK_STICKER_FEATURE();
 421
 422     if (!data_handle || !description)
 423         return STICKER_ERROR_INVALID_PARAMETER;
 424
 425     if (!data_handle->description)
 426         *description = strdup("");
 427     else
 428         *description = strdup(data_handle->description);
 429
 430     return STICKER_ERROR_NONE;
 431 }
 432
 433 EXPORT_API int sticker_data_get_date(sticker_data_h data_handle, char **date)
 434 {
 435     CHECK_STICKER_FEATURE();
 436
 437     if (!data_handle || !date)
 438         return STICKER_ERROR_INVALID_PARAMETER;
 439
 440     if (!data_handle->date)
 441         return STICKER_ERROR_OPERATION_FAILED;
 442
 443     *date = strdup(data_handle->date);
 444
 445     return STICKER_ERROR_NONE;
 446 }