src/media_group.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
  21 int media_album_get_album_count_from_db(filter_h filter, int *album_count)
  22 {
  23         int ret = MEDIA_CONTENT_ERROR_NONE;
  24
  25         if (album_count != NULL)
  26                 ret = _media_db_get_group_count(filter, MEDIA_GROUP_ALBUM, album_count);
  27         else {
  28                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  29                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  30         }
  31
  32         return ret;
  33 }
  34
  35 int media_album_foreach_album_from_db(filter_h filter, media_album_cb callback, void *user_data)
  36 {
  37         int ret = MEDIA_CONTENT_ERROR_NONE;
  38
  39         if (callback == NULL) {
  40                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  41                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  42         }
  43
  44         ret = _media_db_get_album(filter, callback, user_data);
  45
  46         return ret;
  47 }
  48
  49 int media_album_get_media_count_from_db(int album_id, filter_h filter, int *media_count)
  50 {
  51         int ret = MEDIA_CONTENT_ERROR_NONE;
  52
  53         if ((album_id > 0) && (media_count != NULL))
  54                 ret = _media_db_get_group_item_count_by_id(album_id, filter, MEDIA_GROUP_ALBUM, media_count);
  55         else {
  56                 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_album_foreach_media_from_db(int album_id, filter_h filter, media_info_cb callback, void *user_data)
  64 {
  65         int ret = MEDIA_CONTENT_ERROR_NONE;
  66
  67         if ((album_id > 0) && (callback != NULL))
  68                 ret = _media_db_get_group_item_by_id(album_id, filter, callback, user_data, MEDIA_GROUP_ALBUM);
  69         else {
  70                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  71                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  72         }
  73
  74         return ret;
  75 }
  76
  77 int media_album_get_album_from_db(int album_id, media_album_h *album)
  78 {
  79         int ret = MEDIA_CONTENT_ERROR_NONE;
  80         sqlite3_stmt *stmt = NULL;
  81         char select_query[DEFAULT_QUERY_SIZE] = {0, };
  82
  83         content_retipm_if_fail(album_id > 0, "album_id [%d]", album_id);
  84         content_retip_if_fail(album);
  85
  86         snprintf(select_query, sizeof(select_query), SELECT_ALBUM_FROM_ALBUM, album_id);
  87
  88         ret = _content_get_result(select_query, &stmt);
  89         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  90
  91         if (sqlite3_step(stmt) == SQLITE_ROW) {
  92                 media_album_s *_album = g_new0(media_album_s, 1);
  93
  94                 _album->album_id = album_id;
  95                 _album->name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
  96                 _album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 1));
  97                 _album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
  98
  99                 *album = (media_album_h)_album;
 100         }
 101
 102         SQLITE3_FINALIZE(stmt);
 103
 104         return ret;
 105 }
 106
 107 int media_album_destroy(media_album_h album)
 108 {
 109         int ret = MEDIA_CONTENT_ERROR_NONE;
 110         media_album_s *_album = (media_album_s*)album;
 111
 112         if (_album) {
 113                 g_free(_album->name);
 114                 g_free(_album->artist);
 115                 g_free(_album->album_art_path);
 116                 g_free(_album);
 117
 118                 ret = MEDIA_CONTENT_ERROR_NONE;
 119         } else {
 120                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 121                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 122         }
 123
 124         return ret;
 125 }
 126
 127 int media_album_clone(media_album_h *dst, media_album_h src)
 128 {
 129         media_album_s *_src = (media_album_s*)src;
 130
 131         content_retip_if_fail(dst);
 132         content_retip_if_fail(src);
 133
 134         media_album_s *_dst = g_new0(media_album_s, 1);
 135
 136         _dst->album_id = _src->album_id;
 137         _dst->name = g_strdup(_src->name);
 138         _dst->artist = g_strdup(_src->artist);
 139         _dst->album_art_path = g_strdup(_src->album_art_path);
 140
 141         *dst = (media_album_h)_dst;
 142
 143         return MEDIA_CONTENT_ERROR_NONE;
 144 }
 145
 146 int media_album_get_album_id(media_album_h album, int *album_id)
 147 {
 148         int ret = MEDIA_CONTENT_ERROR_NONE;
 149         media_album_s *_album = (media_album_s*)album;
 150
 151         if (_album && album_id) {
 152                 *album_id = _album->album_id;
 153                 ret = MEDIA_CONTENT_ERROR_NONE;
 154         } else {
 155                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 156                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 157         }
 158
 159         return ret;
 160 }
 161
 162 int media_album_get_name(media_album_h album, char **name)
 163 {
 164         media_album_s *_album = (media_album_s*)album;
 165
 166         content_retip_if_fail(album);
 167         content_retip_if_fail(name);
 168
 169         *name = g_strdup(_album->name);
 170
 171         return MEDIA_CONTENT_ERROR_NONE;
 172 }
 173
 174 int media_album_get_artist(media_album_h album, char **artist)
 175 {
 176         media_album_s *_album = (media_album_s*)album;
 177
 178         content_retip_if_fail(album);
 179         content_retip_if_fail(artist);
 180
 181         *artist = g_strdup(_album->artist);
 182
 183         return MEDIA_CONTENT_ERROR_NONE;
 184 }
 185
 186 int media_album_get_album_art(media_album_h album, char **album_art)
 187 {
 188         media_album_s *_album = (media_album_s*)album;
 189
 190         content_retip_if_fail(album);
 191         content_retip_if_fail(album_art);
 192
 193         *album_art = g_strdup(_album->album_art_path);
 194
 195         return MEDIA_CONTENT_ERROR_NONE;
 196 }
 197
 198 int media_group_get_group_count_from_db(filter_h filter, media_group_e group, int *group_count)
 199 {
 200         int ret = MEDIA_CONTENT_ERROR_NONE;
 201 #ifdef _USE_TVPD_MODE
 202         if ((group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_GROUP_MAX) || (group_count == NULL)) {
 203 #else
 204         if ((group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX) || (group_count == NULL)) {
 205 #endif
 206                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 207                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 208         } else {
 209                 ret = _media_db_get_media_group_count(group, filter, group_count);
 210         }
 211
 212         return ret;
 213 }
 214 #ifdef _USE_TVPD_MODE
 215 int media_group_foreach_group_and_count_from_db(filter_h filter, media_group_e group, media_group_and_count_cb callback, void *user_data)
 216 {
 217         int ret = MEDIA_CONTENT_ERROR_NONE;
 218
 219         if ((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_GROUP_MAX)) {
 220                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 221                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 222         } else {
 223                 ret = _media_db_get_media_group_and_count(group, filter, callback, user_data);
 224         }
 225
 226         return ret;
 227 }
 228 #endif
 229
 230 int media_group_foreach_group_from_db(filter_h filter, media_group_e group, media_group_cb callback, void *user_data)
 231 {
 232         int ret = MEDIA_CONTENT_ERROR_NONE;
 233 #ifdef _USE_TVPD_MODE
 234         if ((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_GROUP_MAX)) {
 235 #else
 236         if ((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX)) {
 237 #endif
 238                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 239                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 240         } else {
 241                 ret = _media_db_get_media_group(group, filter, callback, user_data);
 242         }
 243
 244         return ret;
 245 }
 246
 247 int media_group_get_media_count_from_db(const char *group_name, media_group_e group, filter_h filter, int *media_count)
 248 {
 249         int ret = MEDIA_CONTENT_ERROR_NONE;
 250 #ifdef _USE_TVPD_MODE
 251         if ((media_count == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_GROUP_MAX)) {
 252 #else
 253         if ((media_count == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX)) {
 254 #endif
 255                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 256                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 257         } else {
 258                 ret = _media_db_get_media_group_item_count(group_name, filter, group, media_count);
 259         }
 260
 261         return ret;
 262 }
 263
 264 int media_group_foreach_media_from_db(const char *group_name, media_group_e group, filter_h filter, media_info_cb callback, void *user_data)
 265 {
 266         int ret = MEDIA_CONTENT_ERROR_NONE;
 267 #ifdef _USE_TVPD_MODE
 268         if ((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_GROUP_MAX)) {
 269 #else
 270         if ((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX)) {
 271 #endif
 272                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 273                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 274         } else {
 275                 ret = _media_db_get_media_group_item(group_name, filter, group, callback, user_data);
 276         }
 277
 278         return ret;
 279 }