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