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 #include <media_util_private.h>
  20
  21
  22 int media_bookmark_insert_to_db(const char *media_id, time_t time, const char *thumbnail_path)
  23 {
  24         int ret = MEDIA_CONTENT_ERROR_NONE;
  25         char *sql = NULL;
  26         char repl_path[MAX_QUERY_SIZE] = {0, };
  27
  28         if (STRING_VALID(media_id)) {
  29                 if (STRING_VALID(thumbnail_path)) {
  30                         memset(repl_path, 0, sizeof(repl_path));
  31                         ret = _media_content_replace_path(thumbnail_path, repl_path);
  32                         sql = sqlite3_mprintf(INSERT_BOOKMARK_TO_BOOKMARK, media_id, time, repl_path);
  33                 } else {
  34                         sql = sqlite3_mprintf(INSERT_BOOKMARK_TO_BOOKMARK, media_id, time, thumbnail_path);
  35                 }
  36                 ret = _content_query_sql(sql);
  37                 SQLITE3_SAFE_FREE(sql);
  38         } else {
  39                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  40                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  41         }
  42
  43         return ret;
  44 }
  45
  46 int media_bookmark_delete_from_db(int bookmark_id)
  47 {
  48         int ret = MEDIA_CONTENT_ERROR_NONE;
  49         char *query_str = NULL;
  50
  51         if (bookmark_id < 0) {
  52                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  53                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  54         }
  55
  56         query_str = sqlite3_mprintf(DELETE_BOOKMARK_FROM_BOOKMARK, bookmark_id);
  57
  58         ret = _content_query_sql(query_str);
  59
  60         SQLITE3_SAFE_FREE(query_str);
  61
  62         return ret;
  63 }
  64
  65 int media_bookmark_get_bookmark_count_from_db(filter_h filter, int *bookmark_count)
  66 {
  67         int ret = MEDIA_CONTENT_ERROR_NONE;
  68
  69         if (bookmark_count == NULL) {
  70                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  71                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  72         }
  73
  74         ret = _media_db_get_group_count(filter, MEDIA_GROUP_BOOKMARK, bookmark_count);
  75
  76         return ret;
  77 }
  78
  79 int media_bookmark_destroy(media_bookmark_h bookmark)
  80 {
  81         int ret = MEDIA_CONTENT_ERROR_NONE;
  82         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
  83
  84         if (_bookmark) {
  85                 SAFE_FREE(_bookmark->media_id);
  86                 SAFE_FREE(_bookmark->thumbnail_path);
  87                 SAFE_FREE(_bookmark->name);
  88                 free(_bookmark);
  89                 ret = MEDIA_CONTENT_ERROR_NONE;
  90         } else {
  91                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  92                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  93         }
  94
  95         return ret;
  96 }
  97 int media_bookmark_clone(media_bookmark_h *dst, media_bookmark_h src)
  98 {
  99         int ret = MEDIA_CONTENT_ERROR_NONE;
 100
 101         if ((src != NULL)) {
 102                 media_bookmark_s *_src = (media_bookmark_s*)src;
 103                 media_bookmark_s *_dst = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
 104                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 105
 106                 _dst->bookmark_id = _src->bookmark_id;
 107
 108                 if (STRING_VALID(_src->media_id)) {
 109                         _dst->media_id = (char *)strdup(_src->media_id);
 110                         if (_dst->media_id == NULL) {
 111                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 112                                 media_bookmark_destroy((media_bookmark_h)_dst);
 113                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 114                         }
 115                 }
 116
 117                 _dst->marked_time = _src->marked_time;
 118
 119                 if (STRING_VALID(_src->thumbnail_path)) {
 120                         _dst->thumbnail_path = (char*)strdup(_src->thumbnail_path);
 121                         if (_dst->thumbnail_path == NULL) {
 122                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 123                                 media_bookmark_destroy((media_bookmark_h)_dst);
 124                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 125                         }
 126                 }
 127
 128                 if (STRING_VALID(_src->name)) {
 129                         _dst->name = (char*)strdup(_src->name);
 130                         if (_dst->name == NULL) {
 131                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 132                                 media_bookmark_destroy((media_bookmark_h)_dst);
 133                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 134                         }
 135                 }
 136
 137                 *dst = (media_bookmark_h)_dst;
 138
 139                 ret = MEDIA_CONTENT_ERROR_NONE;
 140         } else {
 141                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 142                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 143         }
 144
 145         return ret;
 146 }
 147
 148 int media_bookmark_get_bookmark_id(media_bookmark_h bookmark, int *bookmark_id)
 149 {
 150         int ret = MEDIA_CONTENT_ERROR_NONE;
 151         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 152
 153         if (_bookmark) {
 154                 *bookmark_id = _bookmark->bookmark_id;
 155                 ret = MEDIA_CONTENT_ERROR_NONE;
 156         } else {
 157                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 158                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 159         }
 160
 161         return ret;
 162 }
 163
 164 int media_bookmark_get_marked_time(media_bookmark_h bookmark, time_t* marked_time)
 165 {
 166         int ret = MEDIA_CONTENT_ERROR_NONE;
 167         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 168
 169         if (_bookmark) {
 170                 *marked_time = _bookmark->marked_time;
 171                 ret = MEDIA_CONTENT_ERROR_NONE;
 172         } else {
 173                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 174                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 175         }
 176
 177         return ret;
 178 }
 179
 180 int media_bookmark_get_thumbnail_path(media_bookmark_h bookmark, char **path)
 181 {
 182         int ret = MEDIA_CONTENT_ERROR_NONE;
 183         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 184
 185         if (_bookmark) {
 186                 if (STRING_VALID(_bookmark->thumbnail_path)) {
 187                         *path = strdup(_bookmark->thumbnail_path);
 188                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 189                 } else {
 190                         *path = NULL;
 191                 }
 192
 193                 ret = MEDIA_CONTENT_ERROR_NONE;
 194         } else {
 195                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 196                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 197         }
 198
 199         return ret;
 200 }
 201
 202 int media_bookmark_get_name(media_bookmark_h bookmark, char **name)
 203 {
 204         int ret = MEDIA_CONTENT_ERROR_NONE;
 205         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 206
 207         if (_bookmark) {
 208                 if (STRING_VALID(_bookmark->name)) {
 209                         *name = strdup(_bookmark->name);
 210                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 211                 } else {
 212                         *name = NULL;
 213                 }
 214
 215                 ret = MEDIA_CONTENT_ERROR_NONE;
 216         } else {
 217                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 218                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 219         }
 220
 221         return ret;
 222 }
 223
 224 int media_bookmark_set_name(media_bookmark_h bookmark, const char *name)
 225 {
 226         int ret = MEDIA_CONTENT_ERROR_NONE;
 227         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 228
 229         if (STRING_VALID(name)) {
 230                 _bookmark->name = strdup(name);
 231                 media_content_retvm_if(_bookmark->name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 232         } else {
 233                 _bookmark->name = NULL;
 234         }
 235
 236         return ret;
 237 }
 238
 239 int media_bookmark_update_to_db(media_bookmark_h bookmark)
 240 {
 241         int ret = MEDIA_CONTENT_ERROR_NONE;
 242         media_bookmark_s *_bookmark = (media_bookmark_s*)bookmark;
 243         char *sql = NULL;
 244
 245         if (_bookmark != NULL) {
 246                 sql = sqlite3_mprintf(UPDATE_BOOKMARK_FROM_BOOKMARK, _bookmark->name, _bookmark->bookmark_id);
 247                 ret = _content_query_sql(sql);
 248                 SQLITE3_SAFE_FREE(sql);
 249         } else {
 250                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 251                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 252         }
 253
 254         return ret;
 255 }