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