src/media_bookmark.c

   1 /*
   2 * Copyright (c) 2011 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
  18 #include <media_info_private.h>
  19
  20 static int __media_bookmark_check_media_id(const char *media_id);
  21
  22 static int __media_bookmark_check_media_id(const char *media_id)
  23 {
  24         int ret = MEDIA_CONTENT_ERROR_NONE;
  25         char *query_str = NULL;
  26         sqlite3_stmt *stmt = NULL;
  27         int item_count = 0;
  28
  29         media_content_retvm_if(!STRING_VALID(media_id), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media_id");
  30
  31         query_str = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_MEDIA_BY_ID, media_id);
  32         ret = _content_query_prepare(&stmt, query_str, NULL, NULL);
  33         SQLITE3_SAFE_FREE(query_str);
  34         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  35
  36         if (sqlite3_step(stmt) == SQLITE_ROW)
  37                 item_count = (int)sqlite3_column_int(stmt, 0);
  38
  39         SQLITE3_FINALIZE(stmt);
  40
  41         media_content_retvm_if(item_count == 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_id");
  42
  43         return MEDIA_CONTENT_ERROR_NONE;
  44 }
  45
  46 int media_bookmark_insert_to_db(const char *media_id, time_t time, const char *thumbnail_path)
  47 {
  48         int ret = MEDIA_CONTENT_ERROR_NONE;
  49         char *sql = NULL;
  50
  51         if (STRING_VALID(media_id)) {
  52                 sql = sqlite3_mprintf(INSERT_BOOKMARK_TO_BOOKMARK, media_id, time, thumbnail_path, MEDIA_CONTENT_EMPTY_STRING);
  53                 ret = _content_query_sql(sql);
  54                 SQLITE3_SAFE_FREE(sql);
  55         } else {
  56                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  57                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  58         }
  59
  60         return ret;
  61 }
  62
  63 int media_bookmark_delete_from_db(int bookmark_id)
  64 {
  65         int ret = MEDIA_CONTENT_ERROR_NONE;
  66         char *query_str = NULL;
  67
  68         if (bookmark_id < 0) {
  69                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  70                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  71         }
  72
  73         query_str = sqlite3_mprintf(DELETE_BOOKMARK_FROM_BOOKMARK, bookmark_id);
  74
  75         ret = _content_query_sql(query_str);
  76
  77         SQLITE3_SAFE_FREE(query_str);
  78
  79         return ret;
  80 }
  81
  82 int media_bookmark_get_bookmark_count_from_db(filter_h filter, int *bookmark_count)
  83 {
  84         int ret = MEDIA_CONTENT_ERROR_NONE;
  85
  86         if (bookmark_count == NULL) {
  87                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  88                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  89         }
  90
  91         ret = _media_db_get_group_count(filter, MEDIA_GROUP_BOOKMARK, bookmark_count);
  92
  93         return ret;
  94 }
  95
  96 int media_bookmark_foreach_bookmark_from_db(filter_h filter, media_bookmark_cb callback, void *user_data)
  97 {
  98         int ret = MEDIA_CONTENT_ERROR_NONE;
  99
 100         media_content_retvm_if(callback == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid paramter");
 101
 102         ret = _media_db_get_bookmark(NULL, filter, callback, user_data);
 103
 104         return ret;
 105 }
 106
 107 int media_bookmark_destroy(media_bookmark_h bookmark)
 108 {
 109         int ret = MEDIA_CONTENT_ERROR_NONE;
 110         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 111
 112         if (_bookmark) {
 113                 SAFE_FREE(_bookmark->media_id);
 114                 SAFE_FREE(_bookmark->thumbnail_path);
 115                 SAFE_FREE(_bookmark->name);
 116                 SAFE_FREE(_bookmark);
 117                 ret = MEDIA_CONTENT_ERROR_NONE;
 118         } else {
 119                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 120                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 121         }
 122
 123         return ret;
 124 }
 125 int media_bookmark_clone(media_bookmark_h *dst, media_bookmark_h src)
 126 {
 127         int ret = MEDIA_CONTENT_ERROR_NONE;
 128
 129         if ((src != NULL)) {
 130                 media_bookmark_s *_src = (media_bookmark_s*)src;
 131                 media_bookmark_s *_dst = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
 132                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 133
 134                 _dst->bookmark_id = _src->bookmark_id;
 135
 136                 if (STRING_VALID(_src->media_id)) {
 137                         _dst->media_id = (char *)strdup(_src->media_id);
 138                         if (_dst->media_id == NULL) {
 139                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 140                                 media_bookmark_destroy((media_bookmark_h)_dst);
 141                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 142                         }
 143                 }
 144
 145                 _dst->marked_time = _src->marked_time;
 146
 147                 if (STRING_VALID(_src->thumbnail_path)) {
 148                         _dst->thumbnail_path = (char*)strdup(_src->thumbnail_path);
 149                         if (_dst->thumbnail_path == NULL) {
 150                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 151                                 media_bookmark_destroy((media_bookmark_h)_dst);
 152                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 153                         }
 154                 }
 155
 156                 if (STRING_VALID(_src->name)) {
 157                         _dst->name = (char*)strdup(_src->name);
 158                         if (_dst->name == NULL) {
 159                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 160                                 media_bookmark_destroy((media_bookmark_h)_dst);
 161                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 162                         }
 163                 }
 164
 165                 *dst = (media_bookmark_h)_dst;
 166
 167                 ret = MEDIA_CONTENT_ERROR_NONE;
 168         } else {
 169                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 170                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 171         }
 172
 173         return ret;
 174 }
 175
 176 int media_bookmark_get_bookmark_id(media_bookmark_h bookmark, int *bookmark_id)
 177 {
 178         int ret = MEDIA_CONTENT_ERROR_NONE;
 179         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 180
 181         if (_bookmark) {
 182                 *bookmark_id = _bookmark->bookmark_id;
 183                 ret = MEDIA_CONTENT_ERROR_NONE;
 184         } else {
 185                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 186                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 187         }
 188
 189         return ret;
 190 }
 191
 192 int media_bookmark_get_marked_time(media_bookmark_h bookmark, time_t* marked_time)
 193 {
 194         int ret = MEDIA_CONTENT_ERROR_NONE;
 195         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 196
 197         if (_bookmark) {
 198                 *marked_time = _bookmark->marked_time;
 199                 ret = MEDIA_CONTENT_ERROR_NONE;
 200         } else {
 201                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 202                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 203         }
 204
 205         return ret;
 206 }
 207
 208 int media_bookmark_get_thumbnail_path(media_bookmark_h bookmark, char **path)
 209 {
 210         int ret = MEDIA_CONTENT_ERROR_NONE;
 211         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 212
 213         if (_bookmark) {
 214                 if (STRING_VALID(_bookmark->thumbnail_path)) {
 215                         *path = strdup(_bookmark->thumbnail_path);
 216                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 217                 } else {
 218                         *path = NULL;
 219                 }
 220
 221                 ret = MEDIA_CONTENT_ERROR_NONE;
 222         } else {
 223                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 224                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 225         }
 226
 227         return ret;
 228 }
 229
 230 int media_bookmark_get_name(media_bookmark_h bookmark, char **name)
 231 {
 232         int ret = MEDIA_CONTENT_ERROR_NONE;
 233         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 234
 235         if (_bookmark) {
 236                 *name = g_strdup(_bookmark->name);
 237                 media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 238         } else {
 239                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 240                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 241         }
 242
 243         return ret;
 244 }
 245
 246 int media_bookmark_set_name(media_bookmark_h bookmark, const char *name)
 247 {
 248         int ret = MEDIA_CONTENT_ERROR_NONE;
 249         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 250
 251         if (_bookmark != NULL) {
 252                 if (STRING_VALID(name))
 253                         _bookmark->name = g_strdup(name);
 254                 else
 255                         _bookmark->name = g_strdup(MEDIA_CONTENT_EMPTY_STRING);
 256
 257                 media_content_retvm_if(_bookmark->name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 258         } else {
 259                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 260                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 261         }
 262
 263         return ret;
 264 }
 265
 266 int media_bookmark_update_to_db(media_bookmark_h bookmark)
 267 {
 268         int ret = MEDIA_CONTENT_ERROR_NONE;
 269         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 270         char *sql = NULL;
 271
 272         if (_bookmark != NULL) {
 273                 sql = sqlite3_mprintf(UPDATE_BOOKMARK_FROM_BOOKMARK, _bookmark->name, _bookmark->bookmark_id);
 274                 ret = _content_query_sql(sql);
 275                 SQLITE3_SAFE_FREE(sql);
 276         } else {
 277                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 278                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 279         }
 280
 281         return ret;
 282 }
 283
 284 int media_bookmark_create(const char *media_id, time_t time, media_bookmark_h *bookmark)
 285 {
 286         int ret = MEDIA_CONTENT_ERROR_NONE;
 287
 288         media_content_retvm_if(!STRING_VALID(media_id), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media_id");
 289         media_content_retvm_if(bookmark == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid bookmark");
 290
 291         ret = __media_bookmark_check_media_id(media_id);
 292         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Not exist media_id");
 293
 294         media_bookmark_s *_bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
 295         media_content_retvm_if(_bookmark == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 296
 297         _bookmark->media_id = g_strdup(media_id);
 298         if (!STRING_VALID(_bookmark->media_id)) {
 299                 media_content_error("MEDIA_CONTENT_ERROR_OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 300                 SAFE_FREE(_bookmark->media_id);
 301                 SAFE_FREE(_bookmark);
 302                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 303         }
 304
 305         _bookmark->bookmark_id = -1;
 306         _bookmark->marked_time = time;
 307
 308         *bookmark = (media_bookmark_h)_bookmark;
 309
 310         return ret;
 311 }
 312
 313 int media_bookmark_set_thumbnail_path(media_bookmark_h bookmark, const char *path)
 314 {
 315         int ret = MEDIA_CONTENT_ERROR_NONE;
 316         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 317
 318         media_content_retvm_if(_bookmark == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid bookmark");
 319
 320         if (STRING_VALID(path))
 321                 _bookmark->thumbnail_path = g_strdup(path);
 322         else
 323                 _bookmark->thumbnail_path = g_strdup(MEDIA_CONTENT_EMPTY_STRING);
 324
 325         media_content_retvm_if(_bookmark->thumbnail_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 326
 327         return ret;
 328 }
 329
 330 int media_bookmark_insert_to_db_v2(media_bookmark_h bookmark)
 331 {
 332         int ret = MEDIA_CONTENT_ERROR_NONE;
 333         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 334         char *sql = NULL;
 335         char *select_query = NULL;
 336         sqlite3_stmt *stmt = NULL;
 337         int bookmark_id = -1;
 338
 339         media_content_retvm_if(_bookmark == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid bookmark");
 340         media_content_retvm_if(_bookmark->bookmark_id != -1, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid bookmark insert");
 341
 342         sql = sqlite3_mprintf(INSERT_BOOKMARK_TO_BOOKMARK, _bookmark->media_id, _bookmark->marked_time, _bookmark->thumbnail_path, _bookmark->name);
 343         ret = _content_query_sql(sql);
 344         SQLITE3_SAFE_FREE(sql);
 345         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 346
 347         select_query = sqlite3_mprintf(SELECT_BOOKMARK_ID_FROM_BOOKMARK, _bookmark->media_id, _bookmark->marked_time);
 348
 349         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 350         SQLITE3_SAFE_FREE(select_query);
 351         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 352
 353         if (sqlite3_step(stmt) == SQLITE_ROW)
 354                 bookmark_id = (int)sqlite3_column_int(stmt, 0);
 355
 356         SQLITE3_FINALIZE(stmt);
 357
 358         _bookmark->bookmark_id = bookmark_id;
 359
 360         return ret;
 361 }