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