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         media_content_debug_func();
 324
 325         if(_playlist)
 326         {
 327                 SAFE_FREE(_playlist->name);
 328                 SAFE_FREE(_playlist);
 329
 330                 ret = MEDIA_CONTENT_ERROR_NONE;
 331         }
 332         else
 333         {
 334                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 335                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 336         }
 337
 338         return ret;
 339 }
 340
 341 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
 342 {
 343         int ret = MEDIA_CONTENT_ERROR_NONE;
 344         media_playlist_s *_src = (media_playlist_s*)src;
 345
 346         media_content_debug_func();
 347
 348         if(_src != NULL)
 349         {
 350                 media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 351                 if(_dst == NULL)
 352                 {
 353                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 354                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 355                 }
 356
 357                 _dst->playlist_id = _src->playlist_id;
 358
 359                 if(STRING_VALID(_src->name))
 360                 {
 361                         _dst->name = strdup(_src->name);
 362                         if(_dst->name == NULL)
 363                         {
 364                                 media_playlist_destroy((media_playlist_h)_dst);
 365                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 366                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 367                         }
 368                 }
 369
 370                 *dst = (media_playlist_h)_dst;
 371
 372                 ret = MEDIA_CONTENT_ERROR_NONE;
 373         }
 374         else
 375         {
 376                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 377                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 378         }
 379
 380         return ret;
 381 }
 382
 383 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
 384 {
 385         int ret = MEDIA_CONTENT_ERROR_NONE;
 386         sqlite3_stmt *stmt = NULL;
 387         char select_query[DEFAULT_QUERY_SIZE];
 388
 389         if(playlist_id > 0)
 390         {
 391                 memset(select_query, 0x00, sizeof(select_query));
 392
 393                 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
 394
 395                 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 396                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 397
 398                 while(sqlite3_step(stmt) == SQLITE_ROW)
 399                 {
 400                         media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 401
 402                         _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
 403                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 404                                 _playlist->name = strdup((const char *)sqlite3_column_text(stmt, 1));
 405                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
 406                                 _playlist->thumbnail_path = strdup((const char *)sqlite3_column_text(stmt, 2));
 407
 408                         *playlist = (media_playlist_h)_playlist;
 409                 }
 410
 411                 SQLITE3_FINALIZE(stmt);
 412         }
 413         else
 414         {
 415                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 416                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 417         }
 418
 419         return ret;
 420 }
 421
 422 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
 423 {
 424         int ret = MEDIA_CONTENT_ERROR_NONE;
 425
 426         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 427
 428         if((_playlist != NULL) && (playlist_id != NULL))
 429         {
 430                 *playlist_id = _playlist->playlist_id;
 431         }
 432         else
 433         {
 434                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 435                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 436         }
 437
 438         return ret;
 439 }
 440
 441 int media_playlist_get_name(media_playlist_h playlist, char **name)
 442 {
 443         int ret = MEDIA_CONTENT_ERROR_NONE;
 444         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 445         if(_playlist)
 446         {
 447                 if(STRING_VALID(_playlist->name))
 448                 {
 449                         *name = strdup(_playlist->name);
 450                         if(*name == NULL)
 451                         {
 452                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 453                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 454                         }
 455                 }
 456                 else
 457                 {
 458                         *name = NULL;
 459                 }
 460
 461                 ret = MEDIA_CONTENT_ERROR_NONE;
 462         }
 463         else
 464         {
 465                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 466                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 467         }
 468
 469         return ret;
 470 }
 471
 472 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
 473 {
 474         int ret = MEDIA_CONTENT_ERROR_NONE;
 475         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 476         if(_playlist)
 477         {
 478                 if(STRING_VALID(_playlist->thumbnail_path))
 479                 {
 480                         *path = strdup(_playlist->thumbnail_path);
 481                         if(*path == NULL)
 482                         {
 483                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 484                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 485                         }
 486                 }
 487                 else
 488                 {
 489                         *path = NULL;
 490                 }
 491
 492                 ret = MEDIA_CONTENT_ERROR_NONE;
 493         }
 494         else
 495         {
 496                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 497                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 498         }
 499
 500         return ret;
 501 }
 502
 503 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
 504 {
 505         int ret = MEDIA_CONTENT_ERROR_NONE;
 506         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 507         int playlist_id = 0;
 508         sqlite3_stmt *stmt = NULL;
 509         char select_query[DEFAULT_QUERY_SIZE];
 510
 511         if((_playlist == NULL) || (playlist_member_id < 0) || (play_order == NULL))
 512         {
 513                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 514                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 515         }
 516
 517         playlist_id = _playlist->playlist_id;
 518
 519         memset(select_query, 0x00, sizeof(select_query));
 520
 521         snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
 522
 523         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 524         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 525
 526         while(sqlite3_step(stmt) == SQLITE_ROW)
 527         {
 528                 *play_order = (int)sqlite3_column_int(stmt, 0);
 529         }
 530
 531         SQLITE3_FINALIZE(stmt);
 532
 533         return ret;
 534 }
 535
 536 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
 537 {
 538         int ret = MEDIA_CONTENT_ERROR_NONE;
 539         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 540
 541         if(_playlist != NULL && STRING_VALID(playlist_name))
 542         {
 543                 SAFE_FREE(_playlist->name);
 544
 545                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 546
 547                 item->playlist_name = strdup(playlist_name);
 548                 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
 549                 if(item->playlist_name == NULL)
 550                 {
 551                         SAFE_FREE(item);
 552                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 553                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 554                 }
 555
 556                 _playlist->name = strdup(playlist_name);
 557                 if(_playlist->name == NULL)
 558                 {
 559                         SAFE_FREE(item->playlist_name);
 560                         SAFE_FREE(item);
 561                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 562                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 563                 }
 564
 565                 __media_playlist_item_add(item);
 566         }
 567         else
 568         {
 569                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 570                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 571         }
 572
 573         return ret;
 574 }
 575
 576 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
 577 {
 578         int ret = MEDIA_CONTENT_ERROR_NONE;
 579         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 580
 581         if(_playlist != NULL && STRING_VALID(path))
 582         {
 583                 SAFE_FREE(_playlist->thumbnail_path);
 584
 585                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 586
 587                 item->thumbnail_path = strdup(path);
 588                 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
 589                 if(item->thumbnail_path == NULL)
 590                 {
 591                         SAFE_FREE(item);
 592                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 593                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 594                 }
 595
 596                 _playlist->thumbnail_path = strdup(path);
 597                 if(_playlist->thumbnail_path == NULL)
 598                 {
 599                         SAFE_FREE(item->thumbnail_path);
 600                         SAFE_FREE(item);
 601                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 602                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 603                 }
 604
 605                 __media_playlist_item_add(item);
 606         }
 607         else
 608         {
 609                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 610                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 611         }
 612
 613         return ret;
 614 }
 615
 616 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
 617 {
 618         int ret = MEDIA_CONTENT_ERROR_NONE;
 619         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 620
 621         if((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0))
 622         {
 623                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 624
 625                 item->playlist_member_id = playlist_member_id;
 626                 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
 627                 item->play_order = play_order;
 628
 629                 __media_playlist_item_add(item);
 630         }
 631         else
 632         {
 633                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 634                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 635         }
 636
 637         return ret;
 638 }
 639
 640 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
 641 {
 642         int ret = MEDIA_CONTENT_ERROR_NONE;
 643         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 644
 645         if(_playlist != NULL && STRING_VALID(media_id))
 646         {
 647                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 648
 649                 item->media_id = strdup(media_id);
 650                 item->function = MEDIA_PLAYLIST_ADD;
 651
 652                 if(item->media_id == NULL)
 653                 {
 654                         SAFE_FREE(item);
 655                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 656                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 657                 }
 658
 659                 __media_playlist_item_add(item);
 660         }
 661         else
 662         {
 663                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 664                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 665         }
 666
 667         return ret;
 668 }
 669
 670
 671 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
 672 {
 673         int ret = MEDIA_CONTENT_ERROR_NONE;
 674         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 675
 676         if((_playlist != NULL) && (playlist_member_id > 0))
 677         {
 678                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 679
 680                 item->playlist_member_id = playlist_member_id;
 681                 item->function = MEDIA_PLAYLIST_REMOVE;
 682
 683                 __media_playlist_item_add(item);
 684         }
 685         else
 686         {
 687                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 688                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 689         }
 690
 691         return ret;
 692 }
 693
 694 int media_playlist_update_to_db(media_playlist_h playlist)
 695 {
 696         int ret = MEDIA_CONTENT_ERROR_NONE;
 697         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 698         int idx = 0;
 699         int length = 0;
 700         media_playlist_item_s *_playlist_item = NULL;
 701
 702         if(_playlist == NULL)
 703         {
 704                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 705                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 706         }
 707
 708         length = g_list_length(g_playlist_item_list);
 709
 710         for (idx = 0; idx < length; idx++) {
 711                 _playlist_item = (media_playlist_item_s*)g_list_nth_data(g_playlist_item_list, idx);
 712                 if(_playlist_item != NULL) {
 713                         switch(_playlist_item->function) {
 714                                 case MEDIA_PLAYLIST_ADD:
 715                                 {
 716                                         ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
 717                                 }
 718                                 break;
 719
 720                                 case MEDIA_PLAYLIST_REMOVE:
 721                                 {
 722                                         ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
 723                                 }
 724                                 break;
 725
 726                                 case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
 727                                 {
 728                                         ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
 729                                 }
 730                                 break;
 731
 732                                 case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
 733                                 {
 734                                         ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
 735                                 }
 736                                 break;
 737
 738                                 case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
 739                                 {
 740                                         ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
 741                                 }
 742                                 break;
 743                         }
 744                 }
 745         }
 746
 747         __media_playlist_item_release();
 748
 749         return ret;
 750 }