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_util_private.h>
  22
  23
  24 #define PLAYLIST_ARRAY_SIZE                             20
  25 #define PLAYLIST_ARRAY_EXPAND                   10
  26 #define MAX_TMP_STR                                             2048
  27
  28 static void __media_playlist_item_add(media_playlist_s *playlist, media_playlist_item_s *item_s);
  29 static void __media_playlist_item_release(media_playlist_s *playlist);
  30 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id);
  31 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id);
  32 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id);
  33 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name);
  34 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path);
  35 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order);
  36 static int __media_playlist_reset_file(const char* playlist_path);
  37 static int __media_playlist_append_to_file(const char* playlist_path, const char* path);
  38 static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count);
  39 static int __media_playlist_destroy_import_item(char** item_list, int item_count);
  40 static void __media_playlist_destroy_export_item(gpointer data);
  41
  42 static void __media_playlist_item_add(media_playlist_s *playlist, media_playlist_item_s *item_s)
  43 {
  44         playlist->item_list = g_list_append(playlist->item_list, item_s);
  45 }
  46
  47 static void __media_playlist_item_release(media_playlist_s *playlist)
  48 {
  49         int idx = 0;
  50         int list_cnt = 0;
  51         media_playlist_item_s *item = NULL;
  52
  53         list_cnt = g_list_length(playlist->item_list);
  54
  55         media_content_debug("list_cnt : [%d]", list_cnt);
  56
  57         for (idx = 0; idx < list_cnt; idx++) {
  58                 item = (media_playlist_item_s*)g_list_nth_data(playlist->item_list, idx);
  59                 if (item != NULL) {
  60                         SAFE_FREE(item->media_id);
  61                         SAFE_FREE(item->playlist_name);
  62                         SAFE_FREE(item->thumbnail_path);
  63                         SAFE_FREE(item);
  64                 }
  65         }
  66
  67         g_list_free(playlist->item_list);
  68         playlist->item_list = NULL;
  69
  70 }
  71
  72 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id)
  73 {
  74         int ret = MEDIA_CONTENT_ERROR_NONE;
  75         char *query_str = NULL;
  76         char *select_query = NULL;
  77         sqlite3_stmt *stmt = NULL;
  78
  79         query_str = sqlite3_mprintf(INSERT_PLAYLIST_TO_PLAYLIST, playlist_name);
  80
  81         ret = _content_query_sql(query_str);
  82         SQLITE3_SAFE_FREE(query_str);
  83         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  84
  85         select_query = sqlite3_mprintf(SELECT_PLAYLIST_ID_FROM_PLAYLIST, playlist_name);
  86
  87         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
  88         SQLITE3_SAFE_FREE(select_query);
  89         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  90
  91         if (sqlite3_step(stmt) == SQLITE_ROW)
  92                 *playlist_id = (int)sqlite3_column_int(stmt, 0);
  93
  94         SQLITE3_FINALIZE(stmt);
  95
  96         return MEDIA_CONTENT_ERROR_NONE;
  97 }
  98
  99 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id)
 100 {
 101         int ret = MEDIA_CONTENT_ERROR_NONE;
 102         sqlite3_stmt *stmt = NULL;
 103         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 104         char *query_str = NULL;
 105         int play_order = 0;
 106
 107         memset(select_query, 0x00, sizeof(select_query));
 108
 109         snprintf(select_query, sizeof(select_query), SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id);
 110
 111         /* get the max play_order */
 112         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 113         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 114
 115         if (sqlite3_step(stmt) == SQLITE_ROW)
 116                 play_order = (int)sqlite3_column_int(stmt, 0);
 117
 118         SQLITE3_FINALIZE(stmt);
 119
 120         ++play_order;
 121
 122         query_str = sqlite3_mprintf("INSERT INTO %q (playlist_id, media_uuid, play_order) values (%d, '%q', %d);",
 123                         DB_TABLE_PLAYLIST_MAP, playlist_id, media_id, play_order);
 124         ret = media_svc_append_query(query_str, _content_get_uid());
 125
 126         return _content_error_capi(MEDIA_CONTENT_TYPE, 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         ret = media_svc_append_query(query_str, _content_get_uid());
 136
 137         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 138 }
 139
 140 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name)
 141 {
 142         int ret = MEDIA_CONTENT_ERROR_NONE;
 143         char *query_str = NULL;
 144
 145         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_NAME_FROM_PLAYLIST, playlist_name, playlist_id);
 146         ret = media_svc_append_query(query_str, _content_get_uid());
 147
 148         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 149 }
 150
 151 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path)
 152 {
 153         int ret = MEDIA_CONTENT_ERROR_NONE;
 154         char *query_str = NULL;
 155
 156         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST, path, playlist_id);
 157         ret = media_svc_append_query(query_str, _content_get_uid());
 158
 159         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 160 }
 161
 162 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order)
 163 {
 164         int ret = MEDIA_CONTENT_ERROR_NONE;
 165         char *query_str = NULL;
 166
 167         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP, play_order, playlist_id, playlist_member_id);
 168         ret = media_svc_append_query(query_str, _content_get_uid());
 169
 170         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 171 }
 172
 173 static bool __media_playlist_media_info_cb(media_info_h media, void *user_data)
 174 {
 175         int ret = MEDIA_CONTENT_ERROR_NONE;
 176         char **media_id = (char**)user_data;
 177
 178         ret = media_info_get_media_id(media, media_id);
 179         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_media_id fail");
 180
 181         return TRUE;
 182 }
 183
 184 static bool __media_playlist_member_cb(int playlist_member_id, media_info_h media, void *user_data)
 185 {
 186         int ret = MEDIA_CONTENT_ERROR_NONE;
 187         GList **list = (GList**)user_data;
 188         char *path = NULL;
 189
 190         ret = media_info_get_file_path(media, &path);
 191         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_file_path fail");
 192
 193         *list = g_list_append(*list, path);
 194
 195         return TRUE;
 196 }
 197
 198 static int __media_playlist_reset_file(const char* playlist_path)
 199 {
 200         FILE *fp = NULL;
 201
 202         fp = fopen(playlist_path, "wb");
 203         media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
 204
 205         fputs("", fp);  /* remove previous playlist */
 206
 207         fclose(fp);
 208
 209         return MEDIA_CONTENT_ERROR_NONE;
 210 }
 211
 212 static int __media_playlist_append_to_file(const char* playlist_path, const char* path)
 213 {
 214         FILE *fp = NULL;
 215
 216         fp = fopen(playlist_path, "a"); /* append only */
 217         media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
 218
 219         fputs(path, fp);
 220
 221         fputs("\n", fp);
 222
 223         fclose(fp);
 224
 225         return MEDIA_CONTENT_ERROR_NONE;
 226 }
 227
 228 static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count)
 229 {
 230         int current_index = 0;
 231         int current_max_size = PLAYLIST_ARRAY_SIZE;
 232         int tmp_str_len = 0;
 233         char *tmp_buf = NULL;
 234         char tmp_str[MAX_QUERY_SIZE] = {0, };
 235         char repl_item[MAX_QUERY_SIZE] = {0, };
 236         FILE *fp = NULL;
 237         long int file_size = 0;
 238
 239         *item_list = NULL; *item_count = 0;
 240
 241         fp = fopen(playlist_path, "rb");
 242         media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
 243
 244         if (fseek(fp, 0, SEEK_END) < 0) {
 245                 media_content_stderror("fseek failed");
 246                 fclose(fp);
 247                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 248         }
 249         file_size = ftell(fp);
 250         if (file_size == 0) {
 251                 media_content_debug("file is empty.");
 252                 fclose(fp);
 253                 return MEDIA_CONTENT_ERROR_NONE;
 254         }
 255
 256         if (fseek(fp, 0, SEEK_SET) < 0) {
 257                 media_content_stderror("fseek failed");
 258                 fclose(fp);
 259                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 260         }
 261
 262         *item_list = calloc(current_max_size, sizeof(char*));
 263         if (*item_list == NULL) {
 264                 fclose(fp);
 265                 SAFE_FREE(*item_list);
 266                 media_content_error("Out of Memory");
 267                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 268         }
 269         memset(tmp_str, 0, sizeof(tmp_str));
 270
 271         while (fgets(tmp_str, MAX_QUERY_SIZE, fp) != NULL) {
 272                 memset(repl_item, 0, sizeof(repl_item));
 273                 _media_content_replace_path(tmp_str, repl_item);
 274                 tmp_str_len = strlen(repl_item);
 275                 if (tmp_str_len > 0 && repl_item[tmp_str_len - 1] == '\n')
 276                         repl_item[tmp_str_len - 1] = '\0';
 277
 278                 tmp_str_len = strlen(repl_item);
 279
 280                 if (tmp_str_len > 0 && repl_item[0] != '#') {
 281                         if (!(current_index < (current_max_size - 1))) {
 282                                 current_max_size += PLAYLIST_ARRAY_EXPAND;
 283                                 char **tmp_ptr = calloc(current_max_size, sizeof(char*));
 284                                 if (tmp_ptr == NULL) {
 285                                         __media_playlist_destroy_import_item(*item_list, current_index);
 286                                         media_content_error("Out of Memory");
 287                                         fclose(fp);
 288                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 289                                 }
 290                                 memmove(tmp_ptr, *item_list, sizeof(char*) * current_index);
 291                                 SAFE_FREE(*item_list);
 292                                 *item_list = tmp_ptr;
 293                         }
 294
 295                         (*item_list)[current_index] = malloc(tmp_str_len + 1);
 296                         if ((*item_list)[current_index] == NULL) {
 297                                 __media_playlist_destroy_import_item(*item_list, current_index);
 298                                 media_content_error("Out of Memory");
 299                                 fclose(fp);
 300                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 301                         }
 302                         memset((*item_list)[current_index], 0, tmp_str_len + 1);
 303                         memmove((*item_list)[current_index], repl_item, tmp_str_len);
 304
 305                         current_index += 1;
 306                 }
 307
 308                 tmp_buf += (tmp_str_len);
 309         }
 310
 311         *item_count = current_index;
 312         fclose(fp);
 313
 314         return MEDIA_CONTENT_ERROR_NONE;
 315 }
 316
 317 static int __media_playlist_destroy_import_item(char** item_list, int item_count)
 318 {
 319         int i = 0;
 320
 321         for (i = 0; i < item_count; ++i) {
 322                 SAFE_FREE(item_list[i]);
 323                 item_list[i] = NULL;
 324         }
 325
 326         if (item_list != NULL) {
 327                 SAFE_FREE(item_list);
 328                 item_list = NULL;
 329         }
 330
 331         return MEDIA_CONTENT_ERROR_NONE;
 332 }
 333
 334 static void __media_playlist_destroy_export_item(gpointer data)
 335 {
 336         SAFE_FREE(data);
 337         data = NULL;
 338 }
 339
 340 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
 341 {
 342         int ret = MEDIA_CONTENT_ERROR_NONE;
 343         int playlist_id = 0;
 344
 345         if (!STRING_VALID(name)) {
 346                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 347                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 348         }
 349
 350         media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 351         media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 352
 353         ret = __media_playlist_insert_playlist_record(name, &playlist_id);
 354
 355         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 356                 SAFE_FREE(_playlist);
 357                 return ret;
 358         }
 359
 360         _playlist->playlist_id = playlist_id;
 361         _playlist->name = strdup(name);
 362
 363         if (_playlist->name == NULL) {
 364                 SAFE_FREE(_playlist);
 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         *playlist = (media_playlist_h)_playlist;
 370
 371         return ret;
 372 }
 373
 374 int media_playlist_delete_from_db(int playlist_id)
 375 {
 376         int ret = MEDIA_CONTENT_ERROR_NONE;
 377         char *query_str = NULL;
 378
 379         if (playlist_id < 0) {
 380                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 381                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 382         }
 383
 384         query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
 385
 386         ret = _content_query_sql(query_str);
 387
 388         SQLITE3_SAFE_FREE(query_str);
 389
 390         return ret;
 391 }
 392
 393 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
 394 {
 395         int ret = MEDIA_CONTENT_ERROR_NONE;
 396
 397         if (playlist_count != NULL) {
 398                 ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
 399         } else {
 400                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 401                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 402         }
 403
 404         return ret;
 405 }
 406
 407 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
 408 {
 409         int ret = MEDIA_CONTENT_ERROR_NONE;
 410
 411         if (callback == NULL) {
 412                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 413                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 414         }
 415
 416         ret = _media_db_get_playlist(filter, callback, user_data);
 417
 418         return ret;
 419 }
 420
 421 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
 422 {
 423         int ret = MEDIA_CONTENT_ERROR_NONE;
 424
 425         if ((playlist_id > 0) && (media_count != NULL)) {
 426                 ret = _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
 427         } else {
 428                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 429                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 430         }
 431
 432         return ret;
 433 }
 434
 435 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
 436 {
 437         int ret = MEDIA_CONTENT_ERROR_NONE;
 438
 439         if ((playlist_id > 0) && (callback != NULL)) {
 440                 ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
 441         } else {
 442                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 443                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 444         }
 445
 446         return ret;
 447 }
 448
 449 int media_playlist_destroy(media_playlist_h playlist)
 450 {
 451         int ret = MEDIA_CONTENT_ERROR_NONE;
 452         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 453
 454         if (_playlist) {
 455                 SAFE_FREE(_playlist->name);
 456                 SAFE_FREE(_playlist->thumbnail_path);
 457                 SAFE_FREE(_playlist);
 458
 459                 ret = MEDIA_CONTENT_ERROR_NONE;
 460         } else {
 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_clone(media_playlist_h *dst, media_playlist_h src)
 469 {
 470         int ret = MEDIA_CONTENT_ERROR_NONE;
 471         media_playlist_s *_src = (media_playlist_s*)src;
 472
 473         if (_src != NULL) {
 474                 media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 475                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 476
 477                 _dst->playlist_id = _src->playlist_id;
 478
 479                 if (STRING_VALID(_src->name)) {
 480                         _dst->name = strdup(_src->name);
 481                         if (_dst->name == NULL) {
 482                                 media_playlist_destroy((media_playlist_h)_dst);
 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
 488                 *dst = (media_playlist_h)_dst;
 489
 490                 ret = MEDIA_CONTENT_ERROR_NONE;
 491         } else {
 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_playlist_from_db(int playlist_id, media_playlist_h *playlist)
 500 {
 501         int ret = MEDIA_CONTENT_ERROR_NONE;
 502         sqlite3_stmt *stmt = NULL;
 503         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 504
 505         if (playlist_id > 0) {
 506                 memset(select_query, 0x00, sizeof(select_query));
 507
 508                 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
 509
 510                 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 511                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 512
 513                 media_playlist_s *_playlist = NULL;
 514
 515                 if (sqlite3_step(stmt) == SQLITE_ROW) {
 516                         _playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 517                         if (_playlist == NULL) {
 518                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 519                                 SQLITE3_FINALIZE(stmt);
 520                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 521                         }
 522
 523                         _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
 524                         _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 525                         _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 526
 527                         *playlist = (media_playlist_h)_playlist;
 528                 } else {
 529                         media_content_error("Nonexistent playlist id[%d]", playlist_id);
 530                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 531                 }
 532
 533                 SQLITE3_FINALIZE(stmt);
 534         } else {
 535                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 536                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 537         }
 538
 539         return ret;
 540 }
 541
 542 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
 543 {
 544         int ret = MEDIA_CONTENT_ERROR_NONE;
 545
 546         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 547
 548         if ((_playlist != NULL) && (playlist_id != NULL)) {
 549                 *playlist_id = _playlist->playlist_id;
 550         } else {
 551                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 552                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 553         }
 554
 555         return ret;
 556 }
 557
 558 int media_playlist_get_name(media_playlist_h playlist, char **name)
 559 {
 560         int ret = MEDIA_CONTENT_ERROR_NONE;
 561         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 562         if (_playlist) {
 563                 if (STRING_VALID(_playlist->name)) {
 564                         *name = strdup(_playlist->name);
 565                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 566                 } else {
 567                         *name = NULL;
 568                 }
 569
 570                 ret = MEDIA_CONTENT_ERROR_NONE;
 571         } else {
 572                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 573                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 574         }
 575
 576         return ret;
 577 }
 578
 579 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
 580 {
 581         int ret = MEDIA_CONTENT_ERROR_NONE;
 582         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 583         if (_playlist) {
 584                 if (STRING_VALID(_playlist->thumbnail_path)) {
 585                         *path = strdup(_playlist->thumbnail_path);
 586                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 587                 } else {
 588                         *path = NULL;
 589                 }
 590
 591                 ret = MEDIA_CONTENT_ERROR_NONE;
 592         } else {
 593                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 594                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 595         }
 596
 597         return ret;
 598 }
 599
 600 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
 601 {
 602         int ret = MEDIA_CONTENT_ERROR_NONE;
 603         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 604         int playlist_id = 0;
 605         sqlite3_stmt *stmt = NULL;
 606         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 607
 608         if ((_playlist == NULL) || (playlist_member_id < 0) || (play_order == NULL)) {
 609                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 610                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 611         }
 612
 613         playlist_id = _playlist->playlist_id;
 614
 615         memset(select_query, 0x00, sizeof(select_query));
 616
 617         snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
 618
 619         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 620         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 621
 622         if (sqlite3_step(stmt) == SQLITE_ROW)
 623                 *play_order = (int)sqlite3_column_int(stmt, 0);
 624
 625         SQLITE3_FINALIZE(stmt);
 626
 627         return ret;
 628 }
 629
 630 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
 631 {
 632         int ret = MEDIA_CONTENT_ERROR_NONE;
 633         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 634
 635         if (_playlist != NULL && STRING_VALID(playlist_name)) {
 636                 SAFE_FREE(_playlist->name);
 637
 638                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 639                 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 640
 641                 item->playlist_name = strdup(playlist_name);
 642                 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
 643                 if (item->playlist_name == NULL) {
 644                         SAFE_FREE(item);
 645                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 646                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 647                 }
 648
 649                 _playlist->name = strdup(playlist_name);
 650                 if (_playlist->name == NULL) {
 651                         SAFE_FREE(item->playlist_name);
 652                         SAFE_FREE(item);
 653                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 654                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 655                 }
 656
 657                 __media_playlist_item_add(_playlist, item);
 658         } else {
 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 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
 667 {
 668         int ret = MEDIA_CONTENT_ERROR_NONE;
 669         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 670
 671         if (_playlist != NULL && STRING_VALID(path)) {
 672                 SAFE_FREE(_playlist->thumbnail_path);
 673
 674                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 675                 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 676
 677                 item->thumbnail_path = g_strdup(path);
 678                 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
 679                 if (item->thumbnail_path == NULL) {
 680                         SAFE_FREE(item);
 681                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 682                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 683                 }
 684
 685                 _playlist->thumbnail_path = strdup(path);
 686                 if (_playlist->thumbnail_path == NULL) {
 687                         SAFE_FREE(item->thumbnail_path);
 688                         SAFE_FREE(item);
 689                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 690                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 691                 }
 692
 693                 __media_playlist_item_add(_playlist, item);
 694         } else {
 695                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 696                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 697         }
 698
 699         return ret;
 700 }
 701
 702 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
 703 {
 704         int ret = MEDIA_CONTENT_ERROR_NONE;
 705         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 706
 707         if ((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0)) {
 708                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 709                 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 710
 711                 item->playlist_member_id = playlist_member_id;
 712                 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
 713                 item->play_order = play_order;
 714
 715                 __media_playlist_item_add(_playlist, item);
 716         } else {
 717                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 718                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 719         }
 720
 721         return ret;
 722 }
 723
 724 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
 725 {
 726         int ret = MEDIA_CONTENT_ERROR_NONE;
 727         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 728
 729         if (_playlist != NULL && STRING_VALID(media_id)) {
 730                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 731                 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 732
 733                 item->media_id = strdup(media_id);
 734                 item->function = MEDIA_PLAYLIST_ADD;
 735
 736                 if (item->media_id == NULL) {
 737                         SAFE_FREE(item);
 738                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 739                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 740                 }
 741
 742                 __media_playlist_item_add(_playlist, item);
 743         } else {
 744                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 745                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 746         }
 747
 748         return ret;
 749 }
 750
 751
 752 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
 753 {
 754         int ret = MEDIA_CONTENT_ERROR_NONE;
 755         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 756
 757         if ((_playlist != NULL) && (playlist_member_id > 0)) {
 758                 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
 759                 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 760
 761                 item->playlist_member_id = playlist_member_id;
 762                 item->function = MEDIA_PLAYLIST_REMOVE;
 763
 764                 __media_playlist_item_add(_playlist, item);
 765         } else {
 766                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 767                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 768         }
 769
 770         return ret;
 771 }
 772
 773 int media_playlist_update_to_db(media_playlist_h playlist)
 774 {
 775         int ret = MEDIA_CONTENT_ERROR_NONE;
 776         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 777         int idx = 0;
 778         int length = 0;
 779         media_playlist_item_s *_playlist_item = NULL;
 780
 781         if (_playlist == NULL) {
 782                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 783                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 784         }
 785
 786         if (_playlist->item_list != NULL) {
 787                 length = g_list_length(_playlist->item_list);
 788         } else {
 789                 media_content_debug("operation list length is 0");
 790                 return MEDIA_CONTENT_ERROR_NONE;
 791         }
 792
 793         for (idx = 0; idx < length; idx++) {
 794                 _playlist_item = (media_playlist_item_s*)g_list_nth_data(_playlist->item_list, idx);
 795                 if (_playlist_item != NULL) {
 796                         switch (_playlist_item->function) {
 797                         case MEDIA_PLAYLIST_ADD:
 798                         {
 799                                 ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
 800                         }
 801                         break;
 802
 803                         case MEDIA_PLAYLIST_REMOVE:
 804                         {
 805                                 ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
 806                         }
 807                         break;
 808
 809                         case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
 810                         {
 811                                 ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
 812                         }
 813                         break;
 814
 815                         case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
 816                         {
 817                                 ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
 818                         }
 819                         break;
 820
 821                         case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
 822                         {
 823                                 ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
 824                         }
 825                         break;
 826
 827                         default:
 828                         break;
 829                         }
 830
 831                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 832                                 media_content_error("Failed some operation[%d]", _playlist_item->function);
 833                 }
 834
 835         }
 836         ret = media_svc_send_query(_content_get_uid());
 837
 838         __media_playlist_item_release(_playlist);
 839
 840         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 841 }
 842
 843 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
 844 {
 845         int ret = MEDIA_CONTENT_ERROR_NONE;
 846         char** import_item_list = NULL;
 847         int import_item_count = 0;
 848         int idx;
 849         char repl_path[MAX_PATH_LEN] = {0, };
 850
 851         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
 852         media_content_retvm_if(!STRING_VALID(playlist_name), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_name");
 853         memset(repl_path, 0, sizeof(repl_path));
 854         ret = _media_content_replace_path(path, repl_path);
 855         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 856
 857         ret = media_playlist_insert_to_db(playlist_name, playlist);
 858         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
 859
 860         ret = __media_playlist_import_item_from_file(repl_path, &import_item_list, &import_item_count);
 861         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 862                 __media_playlist_destroy_import_item(import_item_list, import_item_count);
 863                 media_content_error("Fail to get playlist from file");
 864                 return ret;
 865         }
 866
 867         if (import_item_count == 0)
 868                 media_content_debug("The playlist from file is empty");
 869
 870         for (idx = 0; idx < import_item_count; idx++) {
 871                 filter_h filter = NULL;
 872                 char *media_id = NULL;
 873                 char *condition = NULL;
 874
 875                 ret = media_filter_create(&filter);
 876                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 877                         __media_playlist_destroy_import_item(import_item_list, import_item_count);
 878                         media_filter_destroy(filter);
 879                         media_content_error("error media_filter_create");
 880                         return ret;
 881                 }
 882                 condition = sqlite3_mprintf("path = '%q'", import_item_list[idx]);
 883                 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
 884                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 885                         __media_playlist_destroy_import_item(import_item_list, import_item_count);
 886                         media_filter_destroy(filter);
 887                         SQLITE3_SAFE_FREE(condition);
 888                         media_content_error("error media_filter_set_condition");
 889                         return ret;
 890                 }
 891                 ret = _media_db_get_group_item(NULL, filter, __media_playlist_media_info_cb, &media_id, MEDIA_GROUP_NONE);
 892                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 893                         __media_playlist_destroy_import_item(import_item_list, import_item_count);
 894                         media_filter_destroy(filter);
 895                         SAFE_FREE(media_id);
 896                         SQLITE3_SAFE_FREE(condition);
 897                         media_content_error("error media_info_foreach_media_from_db");
 898                         return ret;
 899                 }
 900                 ret = media_playlist_add_media((media_playlist_h)*playlist, media_id);
 901                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 902                         __media_playlist_destroy_import_item(import_item_list, import_item_count);
 903                         media_filter_destroy(filter);
 904                         SAFE_FREE(media_id);
 905                         SQLITE3_SAFE_FREE(condition);
 906                         media_content_error("error media_playlist_add_media");
 907                         return ret;
 908                 }
 909                 media_filter_destroy(filter);
 910                 SAFE_FREE(media_id);
 911                 SQLITE3_SAFE_FREE(condition);
 912         }
 913
 914         ret = media_playlist_update_to_db(*playlist);
 915         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 916                 __media_playlist_destroy_import_item(import_item_list, import_item_count);
 917                 media_content_error("Fail to update playlist to db");
 918                 return ret;
 919         }
 920         __media_playlist_destroy_import_item(import_item_list, import_item_count);
 921
 922         return ret;
 923 }
 924
 925 int media_playlist_export_to_file(media_playlist_h playlist, const char* path)
 926 {
 927         int ret = MEDIA_CONTENT_ERROR_NONE;
 928         media_playlist_s *_playlist = (media_playlist_s*)playlist;
 929         GList *item_list = NULL;
 930         unsigned int idx = 0;
 931         char repl_path[MAX_PATH_LEN] = {0, };
 932
 933         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
 934         media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
 935         media_content_retvm_if(_playlist->playlist_id <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_id");
 936         memset(repl_path, 0, sizeof(repl_path));
 937         ret = _media_content_replace_path(path, repl_path);
 938         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 939
 940         ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
 941         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
 942
 943         ret = __media_playlist_reset_file(repl_path);
 944         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 945                 g_list_free_full(item_list, __media_playlist_destroy_export_item);
 946                 media_content_error("Fail to init playlist file");
 947                 return ret;
 948         }
 949
 950         for (idx = 0; idx < g_list_length(item_list); idx++) {
 951                 char *item = g_list_nth_data(item_list, idx);
 952                 if (STRING_VALID(item)) {
 953                         ret = __media_playlist_append_to_file(repl_path, item);
 954                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 955                                 g_list_free_full(item_list, __media_playlist_destroy_export_item);
 956                                 media_content_error("Fail to export paths into file");
 957                                 return ret;
 958                         }
 959                 }
 960         }
 961
 962         g_list_free_full(item_list, __media_playlist_destroy_export_item);
 963
 964         return ret;
 965 }
 966
 967 int media_playlist_create(media_playlist_h *playlist)
 968 {
 969         int ret = MEDIA_CONTENT_ERROR_NONE;
 970
 971         media_content_retvm_if(playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid playlist");
 972
 973         media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 974         media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 975
 976         _playlist->playlist_id = -1;
 977         _playlist->name = NULL;
 978         _playlist->thumbnail_path = NULL;
 979         _playlist->item_list = NULL;
 980
 981         *playlist = (media_playlist_h)_playlist;
 982
 983         return ret;
 984 }
 985
 986 int media_playlist_get_play_order_v2(int playlist_id, int playlist_member_id, int *play_order)
 987 {
 988         int ret = MEDIA_CONTENT_ERROR_NONE;
 989         sqlite3_stmt *stmt = NULL;
 990         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 991
 992         if ((playlist_id < 0) || (playlist_member_id < 0) || (play_order == NULL)) {
 993                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 994                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 995         }
 996
 997         memset(select_query, 0x00, sizeof(select_query));
 998
 999         snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
1000
1001         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
1002         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1003
1004         if (sqlite3_step(stmt) == SQLITE_ROW)
1005                 *play_order = (int)sqlite3_column_int(stmt, 0);
1006
1007         SQLITE3_FINALIZE(stmt);
1008
1009         return ret;
1010 }
1011
1012 int media_playlist_insert_to_db_v2(media_playlist_h playlist)
1013 {
1014         int ret = MEDIA_CONTENT_ERROR_NONE;
1015         media_playlist_s *_playlist = (media_playlist_s*)playlist;
1016         int playlist_id = 0;
1017
1018         media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
1019         media_content_retvm_if(_playlist->playlist_id != -1, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid playlist insert");
1020
1021         ret = __media_playlist_insert_playlist_record(_playlist->name, &playlist_id);
1022         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1023                 __media_playlist_item_release(_playlist);
1024                 media_content_error("Insert playlist Fail");
1025                 return ret;
1026         }
1027
1028         _playlist->playlist_id = playlist_id;
1029
1030         ret = media_playlist_update_to_db(playlist);
1031
1032         return ret;
1033 }
1034
1035 int media_playlist_update_to_db_v2(int playlist_id, media_playlist_h playlist)
1036 {
1037         media_playlist_s *_playlist = (media_playlist_s*)playlist;
1038
1039         media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
1040
1041         _playlist->playlist_id = playlist_id;
1042
1043         return media_playlist_update_to_db(playlist);
1044 }