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