src/media_playlist.c

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