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         while (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_destroy(media_bookmark_h bookmark)
  97 {
  98         int ret = MEDIA_CONTENT_ERROR_NONE;
  99         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 100
 101         if (_bookmark) {
 102                 SAFE_FREE(_bookmark->media_id);
 103                 SAFE_FREE(_bookmark->thumbnail_path);
 104                 SAFE_FREE(_bookmark->name);
 105                 free(_bookmark);
 106                 ret = MEDIA_CONTENT_ERROR_NONE;
 107         } else {
 108                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 109                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 110         }
 111
 112         return ret;
 113 }
 114 int media_bookmark_clone(media_bookmark_h *dst, media_bookmark_h src)
 115 {
 116         int ret = MEDIA_CONTENT_ERROR_NONE;
 117
 118         if ((src != NULL)) {
 119                 media_bookmark_s *_src = (media_bookmark_s*)src;
 120                 media_bookmark_s *_dst = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
 121                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 122
 123                 _dst->bookmark_id = _src->bookmark_id;
 124
 125                 if (STRING_VALID(_src->media_id)) {
 126                         _dst->media_id = (char *)strdup(_src->media_id);
 127                         if (_dst->media_id == NULL) {
 128                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 129                                 media_bookmark_destroy((media_bookmark_h)_dst);
 130                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 131                         }
 132                 }
 133
 134                 _dst->marked_time = _src->marked_time;
 135
 136                 if (STRING_VALID(_src->thumbnail_path)) {
 137                         _dst->thumbnail_path = (char*)strdup(_src->thumbnail_path);
 138                         if (_dst->thumbnail_path == 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                 if (STRING_VALID(_src->name)) {
 146                         _dst->name = (char*)strdup(_src->name);
 147                         if (_dst->name == 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                 *dst = (media_bookmark_h)_dst;
 155
 156                 ret = MEDIA_CONTENT_ERROR_NONE;
 157         } else {
 158                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 159                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 160         }
 161
 162         return ret;
 163 }
 164
 165 int media_bookmark_get_bookmark_id(media_bookmark_h bookmark, int *bookmark_id)
 166 {
 167         int ret = MEDIA_CONTENT_ERROR_NONE;
 168         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 169
 170         if (_bookmark) {
 171                 *bookmark_id = _bookmark->bookmark_id;
 172                 ret = MEDIA_CONTENT_ERROR_NONE;
 173         } else {
 174                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 175                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 176         }
 177
 178         return ret;
 179 }
 180
 181 int media_bookmark_get_marked_time(media_bookmark_h bookmark, time_t* marked_time)
 182 {
 183         int ret = MEDIA_CONTENT_ERROR_NONE;
 184         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 185
 186         if (_bookmark) {
 187                 *marked_time = _bookmark->marked_time;
 188                 ret = MEDIA_CONTENT_ERROR_NONE;
 189         } else {
 190                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 191                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 192         }
 193
 194         return ret;
 195 }
 196
 197 int media_bookmark_get_thumbnail_path(media_bookmark_h bookmark, char **path)
 198 {
 199         int ret = MEDIA_CONTENT_ERROR_NONE;
 200         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 201
 202         if (_bookmark) {
 203                 if (STRING_VALID(_bookmark->thumbnail_path)) {
 204                         *path = strdup(_bookmark->thumbnail_path);
 205                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 206                 } else {
 207                         *path = NULL;
 208                 }
 209
 210                 ret = MEDIA_CONTENT_ERROR_NONE;
 211         } else {
 212                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 213                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 214         }
 215
 216         return ret;
 217 }
 218
 219 int media_bookmark_get_name(media_bookmark_h bookmark, char **name)
 220 {
 221         int ret = MEDIA_CONTENT_ERROR_NONE;
 222         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 223
 224         if (_bookmark) {
 225                 *name = g_strdup(_bookmark->name);
 226                 media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 227         } else {
 228                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 229                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 230         }
 231
 232         return ret;
 233 }
 234
 235 int media_bookmark_set_name(media_bookmark_h bookmark, const char *name)
 236 {
 237         int ret = MEDIA_CONTENT_ERROR_NONE;
 238         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 239
 240         if (_bookmark != NULL) {
 241                 if (STRING_VALID(name))
 242                         _bookmark->name = g_strdup(name);
 243                 else
 244                         _bookmark->name = g_strdup(MEDIA_CONTENT_EMPTY_STRING);
 245
 246                 media_content_retvm_if(_bookmark->name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 247         } else {
 248                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 249                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 250         }
 251
 252         return ret;
 253 }
 254
 255 int media_bookmark_update_to_db(media_bookmark_h bookmark)
 256 {
 257         int ret = MEDIA_CONTENT_ERROR_NONE;
 258         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 259         char *sql = NULL;
 260
 261         if (_bookmark != NULL) {
 262                 sql = sqlite3_mprintf(UPDATE_BOOKMARK_FROM_BOOKMARK, _bookmark->name, _bookmark->bookmark_id);
 263                 ret = _content_query_sql(sql);
 264                 SQLITE3_SAFE_FREE(sql);
 265         } else {
 266                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 267                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 268         }
 269
 270         return ret;
 271 }
 272
 273 int media_bookmark_create(const char *media_id, time_t time, media_bookmark_h *bookmark)
 274 {
 275         int ret = MEDIA_CONTENT_ERROR_NONE;
 276
 277         media_content_retvm_if(!STRING_VALID(media_id), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media_id");
 278         media_content_retvm_if(bookmark == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid bookmark");
 279
 280         ret = __media_bookmark_check_media_id(media_id);
 281         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Not exist media_id");
 282
 283         media_bookmark_s *_bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
 284         media_content_retvm_if(_bookmark == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 285
 286         _bookmark->media_id = g_strdup(media_id);
 287         if (!STRING_VALID(_bookmark->media_id)) {
 288                 media_content_error("MEDIA_CONTENT_ERROR_OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 289                 SAFE_FREE(_bookmark->media_id);
 290                 SAFE_FREE(_bookmark);
 291                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 292         }
 293
 294         _bookmark->bookmark_id = -1;
 295         _bookmark->marked_time = time;
 296
 297         *bookmark = (media_bookmark_h)_bookmark;
 298
 299         return ret;
 300 }
 301
 302 int media_bookmark_set_thumbnail_path(media_bookmark_h bookmark, const char *path)
 303 {
 304         int ret = MEDIA_CONTENT_ERROR_NONE;
 305         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 306
 307         media_content_retvm_if(_bookmark == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid bookmark");
 308
 309         if (STRING_VALID(path))
 310                 _bookmark->thumbnail_path = g_strdup(path);
 311         else
 312                 _bookmark->thumbnail_path = g_strdup(MEDIA_CONTENT_EMPTY_STRING);
 313
 314         media_content_retvm_if(_bookmark->thumbnail_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 315
 316         return ret;
 317 }
 318
 319 int media_bookmark_insert_to_db_v2(media_bookmark_h bookmark)
 320 {
 321         int ret = MEDIA_CONTENT_ERROR_NONE;
 322         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 323         char *sql = NULL;
 324         char *select_query = NULL;
 325         sqlite3_stmt *stmt = NULL;
 326         int bookmark_id = -1;
 327
 328         media_content_retvm_if(_bookmark == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid bookmark");
 329         media_content_retvm_if(_bookmark->bookmark_id != -1, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid bookmark insert");
 330
 331         sql = sqlite3_mprintf(INSERT_BOOKMARK_TO_BOOKMARK, _bookmark->media_id, _bookmark->marked_time, _bookmark->thumbnail_path, _bookmark->name);
 332         ret = _content_query_sql(sql);
 333         SQLITE3_SAFE_FREE(sql);
 334
 335         select_query = sqlite3_mprintf(SELECT_BOOKMARK_ID_FROM_BOOKMARK, _bookmark->media_id, _bookmark->marked_time);
 336
 337         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 338         SQLITE3_SAFE_FREE(select_query);
 339         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 340
 341         while (sqlite3_step(stmt) == SQLITE_ROW)
 342                 bookmark_id = (int)sqlite3_column_int(stmt, 0);
 343
 344         SQLITE3_FINALIZE(stmt);
 345
 346         _bookmark->bookmark_id = bookmark_id;
 347
 348         return ret;
 349 }