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