src/media_playlist.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
  18 #include <media_filter.h>
  19 #include <media_info.h>
  20 #include <media_info_private.h>
  21 #include <media_playlist.h>
  22
  23
  24 static __thread GList *g_playlist_item_list = NULL;
  25
  26 static void __media_playlist_item_add(media_playlist_item_s *item_s);
  27 static void __media_playlist_item_release(void);
  28 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id);
  29 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id);
  30 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id);
  31 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name);
  32 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path);
  33 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order);
  34
  35 static void __media_playlist_item_add(media_playlist_item_s *item_s)
  36 {
  37         g_playlist_item_list = g_list_append(g_playlist_item_list, item_s);
  38 }
  39
  40 static void __media_playlist_item_release(void)
  41 {
  42         int idx = 0;
  43         int list_cnt = 0;
  44         media_playlist_item_s *item = NULL;
  45
  46         list_cnt = g_list_length(g_playlist_item_list);
  47
  48         media_content_debug("list_cnt : [%d]", list_cnt);
  49
  50         for(idx = 0; idx < list_cnt; idx++)
  51         {
  52                 item = (media_playlist_item_s*)g_list_nth_data(g_playlist_item_list, idx);
  53                 if(item != NULL)
  54                 {
  55                         SAFE_FREE(item->media_id);
  56                         SAFE_FREE(item->playlist_name);
  57                         SAFE_FREE(item->thumbnail_path);
  58                         SAFE_FREE(item);
  59                 }
  60         }
  61
  62         g_list_free(g_playlist_item_list);
  63         g_playlist_item_list = NULL;
  64
  65 }
  66
  67 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id)
  68 {
  69         int ret = MEDIA_CONTENT_ERROR_NONE;
  70         char *query_str = NULL;
  71         char *select_query = NULL;
  72         sqlite3_stmt *stmt = NULL;
  73
  74         query_str = sqlite3_mprintf(INSERT_PLAYLIST_TO_PLAYLIST, playlist_name);
  75
  76         ret = _content_query_sql(query_str);
  77         sqlite3_free(query_str);
  78         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  79
  80         select_query = sqlite3_mprintf(SELECT_PLAYLIST_ID_FROM_PLAYLIST, playlist_name);
  81
  82         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
  83         sqlite3_free(select_query);
  84         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  85
  86         while(sqlite3_step(stmt) == SQLITE_ROW)
  87         {
  88                 *playlist_id = (int)sqlite3_column_int(stmt,0);
  89         }
  90
  91         SQLITE3_FINALIZE(stmt);
  92
  93         return MEDIA_CONTENT_ERROR_NONE;
  94 }
  95
  96 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id)
  97 {
  98         int ret = MEDIA_CONTENT_ERROR_NONE;
  99         sqlite3_stmt *stmt = NULL;
 100         char select_query[DEFAULT_QUERY_SIZE];
 101         char *query_str = NULL;
 102         int play_order = 0;
 103
 104         memset(select_query, 0x00, sizeof(select_query));
 105
 106         snprintf(select_query, sizeof(select_query), SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id);
 107
 108         /* get the max play_order */
 109         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 110         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 111
 112         while(sqlite3_step(stmt) == SQLITE_ROW)
 113         {
 114                 play_order = (int)sqlite3_column_int(stmt, 0);
 115         }
 116
 117         SQLITE3_FINALIZE(stmt);
 118
 119         ++play_order;
 120
 121         query_str = sqlite3_mprintf("INSERT INTO %q (playlist_id, media_uuid, play_order) values (%d, '%q', %d)",
 122                         DB_TABLE_PLAYLIST_MAP, playlist_id, media_id, play_order);
 123         ret = _content_query_sql(query_str);
 124         sqlite3_free(query_str);
 125
 126         return ret;
 127 }
 128
 129 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id)
 130 {
 131         int ret = MEDIA_CONTENT_ERROR_NONE;
 132         char *query_str = NULL;
 133
 134         query_str = sqlite3_mprintf(REMOVE_PLAYLIST_ITEM_FROM_PLAYLIST_MAP, playlist_id, playlist_member_id);
 135
 136         ret = _content_query_sql(query_str);
 137         sqlite3_free(query_str);
 138
 139         return ret;
 140 }
 141
 142 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name)
 143 {
 144         int ret = MEDIA_CONTENT_ERROR_NONE;
 145         char *query_str = NULL;
 146
 147         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_NAME_FROM_PLAYLIST, playlist_name, playlist_id);
 148
 149         ret = _content_query_sql(query_str);
 150         sqlite3_free(query_str);
 151
 152         return ret;
 153 }
 154
 155 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path)
 156 {
 157         int ret = MEDIA_CONTENT_ERROR_NONE;
 158         char *query_str = NULL;
 159
 160         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST, path, playlist_id);
 161
 162         ret = _content_query_sql(query_str);
 163         sqlite3_free(query_str);
 164
 165         return ret;
 166 }
 167
 168 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order)
 169 {
 170         int ret = MEDIA_CONTENT_ERROR_NONE;
 171         char *query_str = NULL;
 172
 173         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP, play_order, playlist_id, playlist_member_id);
 174
 175         ret = _content_query_sql(query_str);
 176         sqlite3_free(query_str);
 177
 178         return ret;
 179 }
 180
 181 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
 182 {
 183         int ret = MEDIA_CONTENT_ERROR_NONE;
 184         int playlist_id = 0;
 185
 186         if(!STRING_VALID(name))
 187         {
 188                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 189                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 190         }
 191
 192         media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 193
 194         if(_playlist == NULL)
 195         {
 196                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 197                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 198         }
 199
 200         ret = __media_playlist_insert_playlist_record(name, &playlist_id);
 201
 202         if(ret != MEDIA_CONTENT_ERROR_NONE)
 203         {
 204                 SAFE_FREE(_playlist);
 205                 return ret;
 206         }
 207
 208         _playlist->playlist_id = playlist_id;
 209         _playlist->name = strdup(name);
 210
 211         if(_playlist->name == NULL)
 212         {
 213                 SAFE_FREE(_playlist);
 214                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 215                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 216         }
 217
 218         *playlist = (media_playlist_h)_playlist;
 219
 220         return ret;
 221 }
 222
 223 int media_playlist_delete_from_db(int playlist_id)
 224 {
 225         int ret = MEDIA_CONTENT_ERROR_NONE;
 226         char *query_str = NULL;
 227
 228         if(playlist_id < 0)
 229         {
 230                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 231                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 232         }
 233
 234         query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
 235
 236         ret = _content_query_sql(query_str);
 237
 238         sqlite3_free(query_str);
 239
 240         return ret;
 241 }
 242
 243 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
 244 {
 245         int ret = MEDIA_CONTENT_ERROR_NONE;
 246
 247         media_content_debug_func();
 248
 249         if(playlist_count != NULL)
 250         {
 251                 ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
 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_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
 263 {
 264         int ret = MEDIA_CONTENT_ERROR_NONE;
 265
 266         media_content_debug_func();
 267
 268         if(callback == NULL)
 269         {
 270                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 271                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 272         }
 273
 274         ret = _media_db_get_playlist(filter, callback, user_data);
 275
 276         return ret;
 277 }
 278
 279 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
 280 {
 281         int ret = MEDIA_CONTENT_ERROR_NONE;
 282
 283         media_content_debug_func();
 284
 285         if((playlist_id > 0) && (media_count != NULL))
 286         {
 287                 ret = _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
 288         }
 289         else
 290         {
 291                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 292                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 293         }
 294
 295         return ret;
 296 }
 297
 298 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
 299 {
 300         int ret = MEDIA_CONTENT_ERROR_NONE;
 301
 302         media_content_debug_func();
 303
 304         if((playlist_id > 0) && (callback != NULL))
 305         {
 306                 //ret = _media_db_get_group_item_by_id(playlist_id, filter, callback, user_data, MEDIA_GROUP_PLAYLIST);
 307                 ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
 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_playlist_destroy(media_playlist_h playlist)
 319 {
 320         int ret = MEDIA_CONTENT_ERROR_NONE;
 321         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 322
 323         if(_playlist)
 324         {
 325                 SAFE_FREE(_playlist->name);
 326                 SAFE_FREE(_playlist);
 327
 328                 ret = MEDIA_CONTENT_ERROR_NONE;
 329         }
 330         else
 331         {
 332                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 333                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 334         }
 335
 336         return ret;
 337 }
 338
 339 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
 340 {
 341         int ret = MEDIA_CONTENT_ERROR_NONE;
 342         media_playlist_s *_src = (media_playlist_s*)src;
 343
 344         if(_src != NULL)
 345         {
 346                 media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 347                 if(_dst == NULL)
 348                 {
 349                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 350                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 351                 }
 352
 353                 _dst->playlist_id = _src->playlist_id;
 354
 355                 if(STRING_VALID(_src->name))
 356                 {
 357                         _dst->name = strdup(_src->name);
 358                         if(_dst->name == NULL)
 359                         {
 360                                 media_playlist_destroy((media_playlist_h)_dst);
 361                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 362                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 363                         }
 364                 }
 365
 366                 *dst = (media_playlist_h)_dst;
 367
 368                 ret = MEDIA_CONTENT_ERROR_NONE;
 369         }
 370         else
 371         {
 372                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 373                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 374         }
 375
 376         return ret;
 377 }
 378
 379 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
 380 {
 381         int ret = MEDIA_CONTENT_ERROR_NONE;
 382         sqlite3_stmt *stmt = NULL;
 383         char select_query[DEFAULT_QUERY_SIZE];
 384
 385         if(playlist_id > 0)
 386         {
 387                 memset(select_query, 0x00, sizeof(select_query));
 388
 389                 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
 390
 391                 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 392                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 393
 394                 while(sqlite3_step(stmt) == SQLITE_ROW)
 395                 {
 396                         media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 397
 398                         _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
 399                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 400                                 _playlist->name = strdup((const char *)sqlite3_column_text(stmt, 1));
 401                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
 402                                 _playlist->thumbnail_path = strdup((const char *)sqlite3_column_text(stmt, 2));
 403
 404                         *playlist = (media_playlist_h)_playlist;
 405                 }
 406
 407                 SQLITE3_FINALIZE(stmt);
 408         }
 409         else
 410         {
 411                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 412                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 413         }
 414
 415         return ret;
 416 }
 417
 418 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
 419 {
 420         int ret = MEDIA_CONTENT_ERROR_NONE;
 421
 422         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 423
 424         if((_playlist != NULL) && (playlist_id != NULL))
 425         {
 426                 *playlist_id = _playlist->playlist_id;
 427         }
 428         else
 429         {
 430                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 431                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 432         }
 433
 434         return ret;
 435 }
 436
 437 int media_playlist_get_name(media_playlist_h playlist, char **name)
 438 {
 439         int ret = MEDIA_CONTENT_ERROR_NONE;
 440         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 441         if(_playlist)
 442         {
 443                 if(STRING_VALID(_playlist->name))
 444                 {
 445                         *name = strdup(_playlist->name);
 446                         if(*name == NULL)
 447                         {
 448                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 449                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 450                         }
 451                 }
 452                 else
 453                 {
 454                         *name = NULL;
 455                 }
 456
 457                 ret = MEDIA_CONTENT_ERROR_NONE;
 458         }
 459         else
 460         {
 461                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 462                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 463         }
 464
 465         return ret;
 466 }
 467
 468 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
 469 {
 470         int ret = MEDIA_CONTENT_ERROR_NONE;
 471         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 472         if(_playlist)
 473         {
 474                 if(STRING_VALID(_playlist->thumbnail_path))
 475                 {
 476                         *path = strdup(_playlist->thumbnail_path);
 477                         if(*path == NULL)
 478                         {
 479                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 480                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 481                         }
 482                 }
 483                 else
 484                 {
 485                         *path = NULL;
 486                 }
 487
 488                 ret = MEDIA_CONTENT_ERROR_NONE;
 489         }
 490         else
 491         {
 492                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 493                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 494         }
 495
 496         return ret;
 497 }
 498
 499 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
 500 {
 501         int ret = MEDIA_CONTENT_ERROR_NONE;
 502         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 503         int playlist_id = 0;
 504         sqlite3_stmt *stmt = NULL;
 505         char select_query[DEFAULT_QUERY_SIZE];
 506
 507         if((_playlist == NULL) || (playlist_member_id < 0) || (play_order == NULL))
 508         {
 509                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 510                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 511         }
 512
 513         playlist_id = _playlist->playlist_id;
 514
 515         memset(select_query, 0x00, sizeof(select_query));
 516
 517         snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
 518
 519         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 520         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 521
 522         while(sqlite3_step(stmt) == SQLITE_ROW)
 523         {
 524                 *play_order = (int)sqlite3_column_int(stmt, 0);
 525         }
 526
 527         SQLITE3_FINALIZE(stmt);
 528
 529         return ret;
 530 }
 531
 532 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
 533 {
 534         int ret = MEDIA_CONTENT_ERROR_NONE;
 535         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 536
 537         if(_playlist != NULL && STRING_VALID(playlist_name))
 538         {
 539                 SAFE_FREE(_playlist->name);
 540
 541                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 542
 543                 item->playlist_name = strdup(playlist_name);
 544                 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
 545                 if(item->playlist_name == NULL)
 546                 {
 547                         SAFE_FREE(item);
 548                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 549                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 550                 }
 551
 552                 _playlist->name = strdup(playlist_name);
 553                 if(_playlist->name == NULL)
 554                 {
 555                         SAFE_FREE(item->playlist_name);
 556                         SAFE_FREE(item);
 557                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 558                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 559                 }
 560
 561                 __media_playlist_item_add(item);
 562         }
 563         else
 564         {
 565                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 566                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 567         }
 568
 569         return ret;
 570 }
 571
 572 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
 573 {
 574         int ret = MEDIA_CONTENT_ERROR_NONE;
 575         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 576
 577         if(_playlist != NULL && STRING_VALID(path))
 578         {
 579                 SAFE_FREE(_playlist->thumbnail_path);
 580
 581                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 582
 583                 item->thumbnail_path = strdup(path);
 584                 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
 585                 if(item->thumbnail_path == NULL)
 586                 {
 587                         SAFE_FREE(item);
 588                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 589                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 590                 }
 591
 592                 _playlist->thumbnail_path = strdup(path);
 593                 if(_playlist->thumbnail_path == NULL)
 594                 {
 595                         SAFE_FREE(item->thumbnail_path);
 596                         SAFE_FREE(item);
 597                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 598                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 599                 }
 600
 601                 __media_playlist_item_add(item);
 602         }
 603         else
 604         {
 605                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 606                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 607         }
 608
 609         return ret;
 610 }
 611
 612 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
 613 {
 614         int ret = MEDIA_CONTENT_ERROR_NONE;
 615         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 616
 617         if((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0))
 618         {
 619                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 620
 621                 item->playlist_member_id = playlist_member_id;
 622                 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
 623                 item->play_order = play_order;
 624
 625                 __media_playlist_item_add(item);
 626         }
 627         else
 628         {
 629                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 630                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 631         }
 632
 633         return ret;
 634 }
 635
 636 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
 637 {
 638         int ret = MEDIA_CONTENT_ERROR_NONE;
 639         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 640
 641         if(_playlist != NULL && STRING_VALID(media_id))
 642         {
 643                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 644
 645                 item->media_id = strdup(media_id);
 646                 item->function = MEDIA_PLAYLIST_ADD;
 647
 648                 if(item->media_id == NULL)
 649                 {
 650                         SAFE_FREE(item);
 651                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 652                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 653                 }
 654
 655                 __media_playlist_item_add(item);
 656         }
 657         else
 658         {
 659                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 660                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 661         }
 662
 663         return ret;
 664 }
 665
 666
 667 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
 668 {
 669         int ret = MEDIA_CONTENT_ERROR_NONE;
 670         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 671
 672         if((_playlist != NULL) && (playlist_member_id > 0))
 673         {
 674                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 675
 676                 item->playlist_member_id = playlist_member_id;
 677                 item->function = MEDIA_PLAYLIST_REMOVE;
 678
 679                 __media_playlist_item_add(item);
 680         }
 681         else
 682         {
 683                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 684                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 685         }
 686
 687         return ret;
 688 }
 689
 690 int media_playlist_update_to_db(media_playlist_h playlist)
 691 {
 692         int ret = MEDIA_CONTENT_ERROR_NONE;
 693         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 694         int idx = 0;
 695         int length = 0;
 696         media_playlist_item_s *_playlist_item = NULL;
 697
 698         if(_playlist == NULL)
 699         {
 700                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 701                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 702         }
 703
 704         length = g_list_length(g_playlist_item_list);
 705
 706         for (idx = 0; idx < length; idx++) {
 707                 _playlist_item = (media_playlist_item_s*)g_list_nth_data(g_playlist_item_list, idx);
 708                 if(_playlist_item != NULL) {
 709                         switch(_playlist_item->function) {
 710                                 case MEDIA_PLAYLIST_ADD:
 711                                 {
 712                                         ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
 713                                 }
 714                                 break;
 715
 716                                 case MEDIA_PLAYLIST_REMOVE:
 717                                 {
 718                                         ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
 719                                 }
 720                                 break;
 721
 722                                 case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
 723                                 {
 724                                         ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
 725                                 }
 726                                 break;
 727
 728                                 case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
 729                                 {
 730                                         ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
 731                                 }
 732                                 break;
 733
 734                                 case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
 735                                 {
 736                                         ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
 737                                 }
 738                                 break;
 739                         }
 740                 }
 741         }
 742
 743         __media_playlist_item_release();
 744
 745         return ret;
 746 }