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