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