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