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 #include <media_filter.h>
  18 #include <media_info.h>
  19 #include <media_info_private.h>
  20 #include <media_group.h>
  21
  22
  23 int media_album_get_album_count_from_db(filter_h filter, int *album_count)
  24 {
  25         int ret = MEDIA_CONTENT_ERROR_NONE;
  26
  27         if (album_count != NULL)
  28         {
  29                 ret = _media_db_get_group_count(filter, MEDIA_GROUP_ALBUM, album_count);
  30         }
  31         else
  32         {
  33                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  34                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  35         }
  36
  37         return ret;
  38 }
  39
  40 int media_album_foreach_album_from_db(filter_h filter, media_album_cb callback, void *user_data)
  41 {
  42         int ret = MEDIA_CONTENT_ERROR_NONE;
  43
  44         if (callback == NULL)
  45         {
  46                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  47                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  48         }
  49
  50         ret = _media_db_get_album(filter, callback, user_data);
  51
  52         return ret;
  53 }
  54
  55 int media_album_get_media_count_from_db(int album_id, filter_h filter, int *media_count)
  56 {
  57         int ret = MEDIA_CONTENT_ERROR_NONE;
  58
  59         if ((album_id > 0) && (media_count != NULL))
  60         {
  61                 ret = _media_db_get_group_item_count_by_id(album_id, filter, MEDIA_GROUP_ALBUM, media_count);
  62         }
  63         else
  64         {
  65                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  66                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  67         }
  68
  69         return ret;
  70 }
  71
  72 int media_album_foreach_media_from_db(int album_id, filter_h filter, media_info_cb callback, void *user_data)
  73 {
  74         int ret = MEDIA_CONTENT_ERROR_NONE;
  75
  76         if ((album_id > 0) && (callback != NULL))
  77         {
  78                 ret = _media_db_get_group_item_by_id(album_id, filter, callback, user_data, MEDIA_GROUP_ALBUM);
  79         }
  80         else
  81         {
  82                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  83                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  84         }
  85
  86         return ret;
  87 }
  88
  89 int media_album_get_album_from_db(int album_id, media_album_h *album)
  90 {
  91         int ret = MEDIA_CONTENT_ERROR_NONE;
  92         sqlite3_stmt *stmt = NULL;
  93         char select_query[DEFAULT_QUERY_SIZE];
  94
  95         if (album_id < 0)
  96         {
  97                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  98                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  99         }
 100
 101         memset(select_query, 0x00, sizeof(select_query));
 102
 103         snprintf(select_query, sizeof(select_query), SELECT_ALBUM_FROM_ALBUM, album_id);
 104
 105         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 106         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 107
 108         while(sqlite3_step(stmt) == SQLITE_ROW)
 109         {
 110                 media_album_s *_album = (media_album_s*)calloc(1, sizeof(media_album_s));
 111                 if (_album == NULL)
 112                 {
 113                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 114                         SQLITE3_FINALIZE(stmt);
 115                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 116                 }
 117
 118                 _album->album_id = (int)sqlite3_column_int(stmt, 0);
 119                 _album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 120                 _album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 121
 122                 *album = (media_album_h)_album;
 123         }
 124
 125         SQLITE3_FINALIZE(stmt);
 126
 127         return ret;
 128 }
 129
 130 int media_album_destroy(media_album_h album)
 131 {
 132         int ret = MEDIA_CONTENT_ERROR_NONE;
 133         media_album_s *_album = (media_album_s*)album;
 134
 135         if (_album)
 136         {
 137                 SAFE_FREE(_album->name);
 138                 SAFE_FREE(_album->artist);
 139                 SAFE_FREE(_album->album_art_path);
 140                 SAFE_FREE(_album);
 141
 142                 ret = MEDIA_CONTENT_ERROR_NONE;
 143         }
 144         else
 145         {
 146                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 147                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 148         }
 149
 150         return ret;
 151 }
 152
 153 int media_album_clone(media_album_h *dst, media_album_h src)
 154 {
 155         int ret = MEDIA_CONTENT_ERROR_NONE;
 156         media_album_s *_src = (media_album_s*)src;
 157
 158         if (_src != NULL)
 159         {
 160                 media_album_s *_dst = (media_album_s*)calloc(1, sizeof(media_album_s));
 161                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 162
 163                 _dst->album_id = _src->album_id;
 164
 165                 if(STRING_VALID(_src->name))
 166                 {
 167                         _dst->name = strdup(_src->name);
 168                         if (_dst->name == NULL)
 169                         {
 170                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 171                                 media_album_destroy((media_album_h)_dst);
 172                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 173                         }
 174                 }
 175
 176                 if(STRING_VALID(_src->artist))
 177                 {
 178                         _dst->artist = strdup(_src->artist);
 179                         if (_dst->artist == NULL)
 180                         {
 181                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 182                                 media_album_destroy((media_album_h)_dst);
 183                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 184                         }
 185                 }
 186
 187                 if(STRING_VALID(_src->album_art_path))
 188                 {
 189                         _dst->album_art_path = strdup(_src->album_art_path);
 190                         if (_dst->album_art_path == NULL)
 191                         {
 192                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 193                                 media_album_destroy((media_album_h)_dst);
 194                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 195                         }
 196                 }
 197
 198                 *dst = (media_album_h)_dst;
 199
 200                 ret = MEDIA_CONTENT_ERROR_NONE;
 201         }
 202         else
 203         {
 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_album_get_album_id(media_album_h album, int *album_id)
 212 {
 213         int ret = MEDIA_CONTENT_ERROR_NONE;
 214         media_album_s *_album = (media_album_s*)album;
 215
 216         if (_album && album_id)
 217         {
 218                 *album_id = _album->album_id;
 219                 ret = MEDIA_CONTENT_ERROR_NONE;
 220         }
 221         else
 222         {
 223                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 224                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 225         }
 226
 227         return ret;
 228 }
 229
 230 int media_album_get_name(media_album_h album, char **name)
 231 {
 232         int ret = MEDIA_CONTENT_ERROR_NONE;
 233         media_album_s *_album = (media_album_s*)album;
 234
 235         if (_album)
 236         {
 237                 if (STRING_VALID(_album->name))
 238                 {
 239                         *name = strdup(_album->name);
 240                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 241                 }
 242                 else
 243                 {
 244                         *name = NULL;
 245                 }
 246
 247                 ret = MEDIA_CONTENT_ERROR_NONE;
 248         }
 249         else
 250         {
 251                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 252                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 253         }
 254
 255         return ret;
 256 }
 257
 258 int media_album_get_artist(media_album_h album, char **artist)
 259 {
 260         int ret = MEDIA_CONTENT_ERROR_NONE;
 261         media_album_s *_album = (media_album_s*)album;
 262
 263         if (_album)
 264         {
 265                 if (STRING_VALID(_album->artist))
 266                 {
 267                         *artist = strdup(_album->artist);
 268                         media_content_retvm_if(*artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 269                 }
 270                 else
 271                 {
 272                         *artist = NULL;
 273                 }
 274
 275                 ret = MEDIA_CONTENT_ERROR_NONE;
 276         }
 277         else
 278         {
 279                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 280                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 281         }
 282
 283         return ret;
 284 }
 285
 286 int media_album_get_album_art(media_album_h album, char **album_art)
 287 {
 288         int ret = MEDIA_CONTENT_ERROR_NONE;
 289         media_album_s *_album = (media_album_s*)album;
 290
 291         if (_album)
 292         {
 293                 if(STRING_VALID(_album->album_art_path))
 294                 {
 295                         *album_art = strdup(_album->album_art_path);
 296                         media_content_retvm_if(*album_art == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 297                 }
 298                 else
 299                 {
 300                         *album_art = NULL;
 301                 }
 302
 303                 ret = MEDIA_CONTENT_ERROR_NONE;
 304         }
 305         else
 306         {
 307                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 308                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 309         }
 310
 311         return ret;
 312 }
 313
 314 int media_group_get_group_count_from_db(filter_h filter, media_group_e group, int *group_count)
 315 {
 316         int ret = MEDIA_CONTENT_ERROR_NONE;
 317
 318         if ((group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX) || (group_count == NULL))
 319         {
 320                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 321                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 322         }
 323         else
 324         {
 325                 ret = _media_db_get_media_group_count(group, filter, group_count);
 326         }
 327
 328         return ret;
 329 }
 330
 331 int media_group_foreach_group_from_db(filter_h filter, media_group_e group, media_group_cb callback, void *user_data)
 332 {
 333         int ret = MEDIA_CONTENT_ERROR_NONE;
 334
 335         if ((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX))
 336         {
 337                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 338                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 339         }
 340         else
 341         {
 342                 ret = _media_db_get_media_group(group, filter, callback, user_data);
 343         }
 344
 345         return ret;
 346 }
 347
 348 int media_group_get_media_count_from_db(const char *group_name, media_group_e group, filter_h filter, int *media_count)
 349 {
 350         int ret = MEDIA_CONTENT_ERROR_NONE;
 351
 352         if ((media_count == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX))
 353         {
 354                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 355                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 356         }
 357         else
 358         {
 359                 ret = _media_db_get_media_group_item_count(group_name, filter, group, media_count);
 360         }
 361
 362         return ret;
 363 }
 364
 365 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)
 366 {
 367         int ret = MEDIA_CONTENT_ERROR_NONE;
 368
 369         if ((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX))
 370         {
 371                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 372                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 373         }
 374         else
 375         {
 376                 ret = _media_db_get_media_group_item(group_name, filter, group, callback, user_data);
 377         }
 378
 379         return ret;
 380 }