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