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         if(_album)
 147         {
 148                 SAFE_FREE(_album->name);
 149                 SAFE_FREE(_album->artist);
 150                 SAFE_FREE(_album->album_art_path);
 151                 SAFE_FREE(_album);
 152
 153                 ret = MEDIA_CONTENT_ERROR_NONE;
 154         }
 155         else
 156         {
 157                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 158                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 159         }
 160
 161         return ret;
 162 }
 163
 164 int media_album_clone(media_album_h *dst, media_album_h src)
 165 {
 166         int ret = MEDIA_CONTENT_ERROR_NONE;
 167         media_album_s *_src = (media_album_s*)src;
 168
 169         if(_src != NULL)
 170         {
 171                 media_album_s *_dst = (media_album_s*)calloc(1, sizeof(media_album_s));
 172
 173                 if(_dst == NULL)
 174                 {
 175                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 176                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 177                 }
 178
 179                 _dst->album_id = _src->album_id;
 180
 181                 if(STRING_VALID(_src->name))
 182                 {
 183                         _dst->name = strdup(_src->name);
 184                         if(_dst->name == NULL)
 185                         {
 186                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 187                                 media_album_destroy((media_album_h)_dst);
 188                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 189                         }
 190                 }
 191
 192                 if(STRING_VALID(_src->artist))
 193                 {
 194                         _dst->artist = strdup(_src->artist);
 195                         if(_dst->artist == NULL)
 196                         {
 197                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 198                                 media_album_destroy((media_album_h)_dst);
 199                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 200                         }
 201                 }
 202
 203                 if(STRING_VALID(_src->album_art_path))
 204                 {
 205                         _dst->album_art_path = strdup(_src->album_art_path);
 206                         if(_dst->album_art_path == NULL)
 207                         {
 208                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 209                                 media_album_destroy((media_album_h)_dst);
 210                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 211                         }
 212                 }
 213
 214                 *dst = (media_album_h)_dst;
 215
 216                 ret = MEDIA_CONTENT_ERROR_NONE;
 217         }
 218         else
 219         {
 220                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 221                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 222         }
 223
 224         return ret;
 225 }
 226
 227 int media_album_get_album_id(media_album_h album, int *album_id)
 228 {
 229         int ret = MEDIA_CONTENT_ERROR_NONE;
 230         media_album_s *_album = (media_album_s*)album;
 231
 232         if(_album && album_id)
 233         {
 234                 *album_id = _album->album_id;
 235                 ret = MEDIA_CONTENT_ERROR_NONE;
 236         }
 237         else
 238         {
 239                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 240                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 241         }
 242
 243         return ret;
 244 }
 245
 246 int media_album_get_name(media_album_h album, char **name)
 247 {
 248         int ret = MEDIA_CONTENT_ERROR_NONE;
 249         media_album_s *_album = (media_album_s*)album;
 250
 251         if(_album)
 252         {
 253                 if(STRING_VALID(_album->name))
 254                 {
 255                         *name = strdup(_album->name);
 256                         if(*name == NULL)
 257                         {
 258                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 259                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 260                         }
 261                 }
 262                 else
 263                 {
 264                         *name = NULL;
 265                 }
 266
 267                 ret = MEDIA_CONTENT_ERROR_NONE;
 268         }
 269         else
 270         {
 271                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 272                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 273         }
 274
 275         return ret;
 276 }
 277
 278 int media_album_get_artist(media_album_h album, char **artist)
 279 {
 280         int ret = MEDIA_CONTENT_ERROR_NONE;
 281         media_album_s *_album = (media_album_s*)album;
 282
 283         if(_album)
 284         {
 285                 if(STRING_VALID(_album->artist))
 286                 {
 287                         *artist = strdup(_album->artist);
 288                         if(*artist == NULL)
 289                         {
 290                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 291                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 292                         }
 293                 }
 294                 else
 295                 {
 296                         *artist = NULL;
 297                 }
 298
 299                 ret = MEDIA_CONTENT_ERROR_NONE;
 300         }
 301         else
 302         {
 303                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 304                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 305         }
 306
 307         return ret;
 308 }
 309
 310 int media_album_get_album_art(media_album_h album, char **album_art)
 311 {
 312         int ret = MEDIA_CONTENT_ERROR_NONE;
 313         media_album_s *_album = (media_album_s*)album;
 314
 315         if(_album)
 316         {
 317                 if(STRING_VALID(_album->album_art_path))
 318                 {
 319                         *album_art = strdup(_album->album_art_path);
 320                         if(*album_art == NULL)
 321                         {
 322                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 323                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 324                         }
 325                 }
 326                 else
 327                 {
 328                         *album_art = NULL;
 329                 }
 330
 331                 ret = MEDIA_CONTENT_ERROR_NONE;
 332         }
 333         else
 334         {
 335                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 336                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 337         }
 338
 339         return ret;
 340 }
 341
 342 int media_group_get_group_count_from_db(filter_h filter, media_group_e group, int *group_count)
 343 {
 344         int ret = MEDIA_CONTENT_ERROR_NONE;
 345
 346         media_content_debug_func();
 347
 348         if((group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group > MEDIA_CONTENT_GROUP_KEYWORD) || (group_count == NULL))
 349         {
 350                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 351                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 352         }
 353         else
 354         {
 355                 ret = _media_db_get_media_group_count(group, filter, group_count);
 356         }
 357
 358         return ret;
 359 }
 360
 361 int media_group_foreach_group_from_db(filter_h filter, media_group_e group, media_group_cb callback, void *user_data)
 362 {
 363         int ret = MEDIA_CONTENT_ERROR_NONE;
 364
 365         media_content_debug_func();
 366
 367         if((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group > MEDIA_CONTENT_GROUP_KEYWORD))
 368         {
 369                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 370                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 371         }
 372         else
 373         {
 374                 ret = _media_db_get_media_group(group, filter, callback, user_data);
 375         }
 376
 377         return ret;
 378 }
 379
 380 int media_group_get_media_count_from_db(const char *group_name, media_group_e group, filter_h filter, int *media_count)
 381 {
 382         int ret = MEDIA_CONTENT_ERROR_NONE;
 383
 384         media_content_debug_func();
 385
 386         if((media_count == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group > MEDIA_CONTENT_GROUP_KEYWORD))
 387         {
 388                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 389                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 390         }
 391         else
 392         {
 393                 ret = _media_db_get_media_group_item_count(group_name, group, filter, media_count);
 394         }
 395
 396         return ret;
 397 }
 398
 399 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)
 400 {
 401         int ret = MEDIA_CONTENT_ERROR_NONE;
 402
 403         media_content_debug_func();
 404
 405         if((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group > MEDIA_CONTENT_GROUP_KEYWORD))
 406         {
 407                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 408                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 409         }
 410         else
 411         {
 412                 ret = _media_db_get_media_group_item(group_name, group, filter, callback, user_data);
 413         }
 414
 415         return ret;
 416 }