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