2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include <media_filter.h>
19 #include <media_info.h>
20 #include <media_info_private.h>
21 #include <media_playlist.h>
23 #define PLAYLIST_ARRAY_SIZE 20
24 #define PLAYLIST_ARRAY_EXPAND 10
25 #define MAX_TMP_STR 2048
27 static void __media_playlist_item_add(media_playlist_s *playlist, media_playlist_item_s *item_s);
28 static void __media_playlist_item_release(media_playlist_s *playlist);
29 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id);
30 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id);
31 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id);
32 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name);
33 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path);
34 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order);
35 static int __media_playlist_reset_file(const char* playlist_path);
36 static int __media_playlist_append_to_file(const char* playlist_path, const char* path);
37 static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count);
38 static int __media_playlist_destroy_import_item(char** item_list, int item_count);
39 static void __media_playlist_destroy_export_item(gpointer data);
41 static void __media_playlist_item_add(media_playlist_s *playlist, media_playlist_item_s *item_s)
43 playlist->item_list = g_list_append(playlist->item_list, item_s);
46 static void __media_playlist_item_release(media_playlist_s *playlist)
50 media_playlist_item_s *item = NULL;
52 list_cnt = g_list_length(playlist->item_list);
54 media_content_debug("list_cnt : [%d]", list_cnt);
56 for (idx = 0; idx < list_cnt; idx++) {
57 item = (media_playlist_item_s*)g_list_nth_data(playlist->item_list, idx);
59 SAFE_FREE(item->media_id);
60 SAFE_FREE(item->playlist_name);
61 SAFE_FREE(item->thumbnail_path);
66 g_list_free(playlist->item_list);
67 playlist->item_list = NULL;
71 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id)
73 int ret = MEDIA_CONTENT_ERROR_NONE;
74 char *query_str = NULL;
75 char *select_query = NULL;
76 sqlite3_stmt *stmt = NULL;
78 query_str = sqlite3_mprintf(INSERT_PLAYLIST_TO_PLAYLIST, playlist_name);
80 ret = _content_query_sql(query_str);
81 SQLITE3_SAFE_FREE(query_str);
82 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
84 select_query = sqlite3_mprintf(SELECT_PLAYLIST_ID_FROM_PLAYLIST, playlist_name);
86 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
87 SQLITE3_SAFE_FREE(select_query);
88 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
90 while (sqlite3_step(stmt) == SQLITE_ROW) {
91 *playlist_id = (int)sqlite3_column_int(stmt, 0);
94 SQLITE3_FINALIZE(stmt);
96 return MEDIA_CONTENT_ERROR_NONE;
99 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id)
101 int ret = MEDIA_CONTENT_ERROR_NONE;
102 sqlite3_stmt *stmt = NULL;
103 char select_query[DEFAULT_QUERY_SIZE];
104 char *query_str = NULL;
107 memset(select_query, 0x00, sizeof(select_query));
109 snprintf(select_query, sizeof(select_query), SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id);
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);
115 while (sqlite3_step(stmt) == SQLITE_ROW) {
116 play_order = (int)sqlite3_column_int(stmt, 0);
119 SQLITE3_FINALIZE(stmt);
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 = _content_query_sql(query_str);
126 SQLITE3_SAFE_FREE(query_str);
131 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id)
133 int ret = MEDIA_CONTENT_ERROR_NONE;
134 char *query_str = NULL;
136 query_str = sqlite3_mprintf(REMOVE_PLAYLIST_ITEM_FROM_PLAYLIST_MAP, playlist_id, playlist_member_id);
138 ret = _content_query_sql(query_str);
139 SQLITE3_SAFE_FREE(query_str);
144 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name)
146 int ret = MEDIA_CONTENT_ERROR_NONE;
147 char *query_str = NULL;
149 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_NAME_FROM_PLAYLIST, playlist_name, playlist_id);
151 ret = _content_query_sql(query_str);
152 SQLITE3_SAFE_FREE(query_str);
157 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path)
159 int ret = MEDIA_CONTENT_ERROR_NONE;
160 char *query_str = NULL;
162 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST, path, playlist_id);
164 ret = _content_query_sql(query_str);
165 SQLITE3_SAFE_FREE(query_str);
170 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order)
172 int ret = MEDIA_CONTENT_ERROR_NONE;
173 char *query_str = NULL;
175 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP, play_order, playlist_id, playlist_member_id);
177 ret = _content_query_sql(query_str);
178 SQLITE3_SAFE_FREE(query_str);
183 static bool __media_playlist_media_info_cb(media_info_h media, void *user_data)
185 int ret = MEDIA_CONTENT_ERROR_NONE;
186 char **media_id = (char**)user_data;
188 ret = media_info_get_media_id(media, media_id);
189 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_media_id fail");
194 static bool __media_playlist_member_cb(int playlist_member_id, media_info_h media, void *user_data)
196 int ret = MEDIA_CONTENT_ERROR_NONE;
197 GList **list = (GList**)user_data;
200 ret = media_info_get_file_path(media, &path);
201 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_file_path fail");
203 *list = g_list_append(*list, path);
208 static int __media_playlist_reset_file(const char* playlist_path)
212 fp = fopen(playlist_path, "wb");
213 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
215 fputs("", fp); // remove previous playlist
219 return MEDIA_CONTENT_ERROR_NONE;
222 static int __media_playlist_append_to_file(const char* playlist_path, const char* path)
226 fp = fopen(playlist_path, "a"); // append only
227 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
235 return MEDIA_CONTENT_ERROR_NONE;
238 static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count)
240 int current_index = 0; // Current record number
241 int current_max_size = PLAYLIST_ARRAY_SIZE; // Current max number of records in array
242 int tmp_str_len = 0; // Length of the string
244 char *tmp_buf = NULL;
245 char *tmp_str = NULL; // Next line from buffer, this string is used for parsing
248 long int file_size = 0;
250 *item_list = NULL; *item_count = 0;
252 fp = fopen(playlist_path, "rb"); // Open as binary for precise estimation of file length
253 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
255 fseek(fp, 0, SEEK_END); // Move to the end of file
256 file_size = ftell(fp); // Here we can find the size of file
257 fseek(fp, 0 , SEEK_SET); // Return to the beginning of file
259 if (file_size == 0) {
260 media_content_debug("file is empty.");
262 return MEDIA_CONTENT_ERROR_NONE;
264 // Allocate the memory and copy file content there
266 buf = malloc(file_size + 1);
269 media_content_error("Out of Memory");
271 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
276 if (fread(buf, file_size, 1, fp) != 1) {
279 media_content_stderror("fread fail");
280 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
285 // Preliminary memory allocation
286 *item_list = calloc(current_max_size, sizeof(char*));
287 tmp_str = malloc(MAX_TMP_STR);
288 if (tmp_str == NULL || *item_list == NULL) {
289 SAFE_FREE(*item_list);
292 media_content_error("Out of Memory");
293 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
295 // Here we create format string for sscanf(...) that allows to get a line from buffer
297 snprintf(format, 25, "%%%d[^\n]", MAX_TMP_STR);
299 // This cycle gets lines one by one from buffer till the end of buffer. Empty line ("\n") must be treated specifically
300 while ((sscanf(tmp_buf, format, tmp_str) == 1) || (*tmp_buf == '\n')) {
301 if (*tmp_buf == '\n') {// Check if there is an empty line, skip '\n' symbol
304 if (tmp_buf < (buf + file_size))
305 continue; // We are still in buffer
307 break; // Empty line was in the end of buffer
310 tmp_str_len = strlen(tmp_str); // Save the length of line
312 if (tmp_str[0] != '#') { // Check that the line is not a comment
313 if (!(current_index < (current_max_size - 1))) { // Check if we have completely filled record array
314 // Expand array size and relocate the array (records will be copied into new one)
315 current_max_size += PLAYLIST_ARRAY_EXPAND;
316 char **tmp_ptr = calloc(current_max_size, sizeof(char*));
317 if (tmp_ptr == NULL) {
318 __media_playlist_destroy_import_item(*item_list, current_index);
321 media_content_error("Out of Memory");
322 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
324 memmove(tmp_ptr, *item_list, sizeof(char*) * current_index);
325 SAFE_FREE(*item_list);
326 *item_list = tmp_ptr;
329 // Save new file path (current string in tmp_str)
330 (*item_list)[current_index] = malloc(tmp_str_len + 1);
331 if ((*item_list)[current_index] == NULL) {
332 __media_playlist_destroy_import_item(*item_list, current_index);
335 media_content_error("Out of Memory");
336 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
338 memmove((*item_list)[current_index], tmp_str, tmp_str_len + 1);
340 // Increase the index of buffer
344 tmp_buf += (tmp_str_len + 1); // Move position in buffer after the string that was parsed
347 *item_count = current_index; // Now we need to save the number of records in array
350 SAFE_FREE(tmp_str); // Free temporary variables
352 return MEDIA_CONTENT_ERROR_NONE;
355 static int __media_playlist_destroy_import_item(char** item_list, int item_count)
359 for (i = 0; i < item_count; ++i) {
360 SAFE_FREE(item_list[i]);
364 if (item_list != NULL) {
365 SAFE_FREE(item_list);
369 return MEDIA_CONTENT_ERROR_NONE;
372 static void __media_playlist_destroy_export_item(gpointer data)
378 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
380 int ret = MEDIA_CONTENT_ERROR_NONE;
383 if (!STRING_VALID(name)) {
384 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
385 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
388 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
389 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
391 ret = __media_playlist_insert_playlist_record(name, &playlist_id);
393 if (ret != MEDIA_CONTENT_ERROR_NONE) {
394 SAFE_FREE(_playlist);
398 _playlist->playlist_id = playlist_id;
399 _playlist->name = strdup(name);
401 if (_playlist->name == NULL) {
402 SAFE_FREE(_playlist);
403 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
404 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
407 *playlist = (media_playlist_h)_playlist;
412 int media_playlist_delete_from_db(int playlist_id)
414 int ret = MEDIA_CONTENT_ERROR_NONE;
415 char *query_str = NULL;
417 if (playlist_id < 0) {
418 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
419 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
422 query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
424 ret = _content_query_sql(query_str);
426 SQLITE3_SAFE_FREE(query_str);
431 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
433 int ret = MEDIA_CONTENT_ERROR_NONE;
435 if (playlist_count != NULL) {
436 ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
438 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
439 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
445 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
447 int ret = MEDIA_CONTENT_ERROR_NONE;
449 if (callback == NULL) {
450 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
451 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
454 ret = _media_db_get_playlist(filter, callback, user_data);
459 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
461 int ret = MEDIA_CONTENT_ERROR_NONE;
463 if ((playlist_id > 0) && (media_count != NULL)) {
464 ret = _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
466 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
467 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
473 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
475 int ret = MEDIA_CONTENT_ERROR_NONE;
477 if ((playlist_id > 0) && (callback != NULL)) {
478 ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
480 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
481 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
487 int media_playlist_destroy(media_playlist_h playlist)
489 int ret = MEDIA_CONTENT_ERROR_NONE;
490 media_playlist_s *_playlist = (media_playlist_s*)playlist;
493 SAFE_FREE(_playlist->name);
494 SAFE_FREE(_playlist->thumbnail_path);
495 SAFE_FREE(_playlist);
497 ret = MEDIA_CONTENT_ERROR_NONE;
499 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
500 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
506 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
508 int ret = MEDIA_CONTENT_ERROR_NONE;
509 media_playlist_s *_src = (media_playlist_s*)src;
512 media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
513 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
515 _dst->playlist_id = _src->playlist_id;
517 if (STRING_VALID(_src->name)) {
518 _dst->name = strdup(_src->name);
519 if (_dst->name == NULL) {
520 media_playlist_destroy((media_playlist_h)_dst);
521 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
522 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
526 *dst = (media_playlist_h)_dst;
528 ret = MEDIA_CONTENT_ERROR_NONE;
530 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
531 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
537 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
539 int ret = MEDIA_CONTENT_ERROR_NONE;
540 sqlite3_stmt *stmt = NULL;
541 char select_query[DEFAULT_QUERY_SIZE];
543 if (playlist_id > 0) {
544 memset(select_query, 0x00, sizeof(select_query));
546 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
548 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
549 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
551 media_playlist_s *_playlist = NULL;
553 while (sqlite3_step(stmt) == SQLITE_ROW) {
555 media_playlist_destroy((media_playlist_h)_playlist);
557 _playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
558 if (_playlist == NULL) {
559 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
560 SQLITE3_FINALIZE(stmt);
561 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
564 _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
565 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
566 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
568 *playlist = (media_playlist_h)_playlist;
571 SQLITE3_FINALIZE(stmt);
573 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
574 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
580 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
582 int ret = MEDIA_CONTENT_ERROR_NONE;
584 media_playlist_s *_playlist = (media_playlist_s*)playlist;
586 if ((_playlist != NULL) && (playlist_id != NULL)) {
587 *playlist_id = _playlist->playlist_id;
589 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
590 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
596 int media_playlist_get_name(media_playlist_h playlist, char **name)
598 int ret = MEDIA_CONTENT_ERROR_NONE;
599 media_playlist_s *_playlist = (media_playlist_s*)playlist;
601 if (STRING_VALID(_playlist->name)) {
602 *name = strdup(_playlist->name);
603 media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
608 ret = MEDIA_CONTENT_ERROR_NONE;
610 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
611 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
617 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
619 int ret = MEDIA_CONTENT_ERROR_NONE;
620 media_playlist_s *_playlist = (media_playlist_s*)playlist;
622 if (STRING_VALID(_playlist->thumbnail_path)) {
623 *path = strdup(_playlist->thumbnail_path);
624 media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
629 ret = MEDIA_CONTENT_ERROR_NONE;
631 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
632 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
638 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
640 int ret = MEDIA_CONTENT_ERROR_NONE;
641 media_playlist_s *_playlist = (media_playlist_s*)playlist;
643 sqlite3_stmt *stmt = NULL;
644 char select_query[DEFAULT_QUERY_SIZE];
646 if ((_playlist == NULL) || (playlist_member_id < 0) || (play_order == NULL)) {
647 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
648 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
651 playlist_id = _playlist->playlist_id;
653 memset(select_query, 0x00, sizeof(select_query));
655 snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
657 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
658 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
660 while (sqlite3_step(stmt) == SQLITE_ROW) {
661 *play_order = (int)sqlite3_column_int(stmt, 0);
664 SQLITE3_FINALIZE(stmt);
669 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
671 int ret = MEDIA_CONTENT_ERROR_NONE;
672 media_playlist_s *_playlist = (media_playlist_s*)playlist;
674 if (_playlist != NULL && STRING_VALID(playlist_name)) {
675 SAFE_FREE(_playlist->name);
677 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
678 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
680 item->playlist_name = strdup(playlist_name);
681 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
682 if (item->playlist_name == NULL) {
684 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
685 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
688 _playlist->name = strdup(playlist_name);
689 if (_playlist->name == NULL) {
690 SAFE_FREE(item->playlist_name);
692 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
693 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
696 __media_playlist_item_add(_playlist, item);
698 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
699 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
705 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
707 int ret = MEDIA_CONTENT_ERROR_NONE;
708 media_playlist_s *_playlist = (media_playlist_s*)playlist;
710 if (_playlist != NULL && STRING_VALID(path)) {
711 SAFE_FREE(_playlist->thumbnail_path);
713 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
714 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
716 item->thumbnail_path = strdup(path);
717 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
718 if (item->thumbnail_path == NULL) {
720 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
721 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
724 _playlist->thumbnail_path = strdup(path);
725 if (_playlist->thumbnail_path == NULL) {
726 SAFE_FREE(item->thumbnail_path);
728 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
729 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
732 __media_playlist_item_add(_playlist, item);
734 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
735 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
741 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
743 int ret = MEDIA_CONTENT_ERROR_NONE;
744 media_playlist_s *_playlist = (media_playlist_s*)playlist;
746 if ((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0)) {
747 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
748 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
750 item->playlist_member_id = playlist_member_id;
751 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
752 item->play_order = play_order;
754 __media_playlist_item_add(_playlist, item);
756 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
757 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
763 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
765 int ret = MEDIA_CONTENT_ERROR_NONE;
766 media_playlist_s *_playlist = (media_playlist_s*)playlist;
768 if (_playlist != NULL && STRING_VALID(media_id)) {
769 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
770 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
772 item->media_id = strdup(media_id);
773 item->function = MEDIA_PLAYLIST_ADD;
775 if (item->media_id == NULL) {
777 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
778 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
781 __media_playlist_item_add(_playlist, item);
783 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
784 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
791 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
793 int ret = MEDIA_CONTENT_ERROR_NONE;
794 media_playlist_s *_playlist = (media_playlist_s*)playlist;
796 if ((_playlist != NULL) && (playlist_member_id > 0)) {
797 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
798 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
800 item->playlist_member_id = playlist_member_id;
801 item->function = MEDIA_PLAYLIST_REMOVE;
803 __media_playlist_item_add(_playlist, item);
805 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
806 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
812 int media_playlist_update_to_db(media_playlist_h playlist)
814 int ret = MEDIA_CONTENT_ERROR_NONE;
815 media_playlist_s *_playlist = (media_playlist_s*)playlist;
818 media_playlist_item_s *_playlist_item = NULL;
820 if (_playlist == NULL) {
821 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
822 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
825 if (_playlist->item_list != NULL) {
826 length = g_list_length(_playlist->item_list);
828 media_content_debug("operation list length is 0");
829 return MEDIA_CONTENT_ERROR_NONE;
832 for (idx = 0; idx < length; idx++) {
833 _playlist_item = (media_playlist_item_s*)g_list_nth_data(_playlist->item_list, idx);
834 if (_playlist_item != NULL) {
835 switch (_playlist_item->function) {
836 case MEDIA_PLAYLIST_ADD:
838 ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
842 case MEDIA_PLAYLIST_REMOVE:
844 ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
848 case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
850 ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
854 case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
856 ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
860 case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
862 ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
872 __media_playlist_item_release(_playlist);
877 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
879 int ret = MEDIA_CONTENT_ERROR_NONE;
880 char** import_item_list = NULL;
881 int import_item_count = 0;
884 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
885 media_content_retvm_if(!STRING_VALID(playlist_name), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_name");
887 ret = media_playlist_insert_to_db(playlist_name, playlist);
888 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
890 ret = __media_playlist_import_item_from_file(path, &import_item_list, &import_item_count);
891 if (ret != MEDIA_CONTENT_ERROR_NONE) {
892 __media_playlist_destroy_import_item(import_item_list, import_item_count);
893 media_content_error("Fail to get playlist from file");
897 if (import_item_count == 0) {
898 media_content_debug("The playlist from file is empty");
901 for (idx = 0; idx < import_item_count; idx++) {
902 filter_h filter = NULL;
903 char *media_id = NULL;
904 char *condition = NULL;
906 ret = media_filter_create(&filter);
907 if (ret != MEDIA_CONTENT_ERROR_NONE) {
908 __media_playlist_destroy_import_item(import_item_list, import_item_count);
909 media_filter_destroy(filter);
910 media_content_error("error media_filter_create");
913 condition = sqlite3_mprintf("path = '%q'", import_item_list[idx]);
914 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
915 if (ret != MEDIA_CONTENT_ERROR_NONE) {
916 __media_playlist_destroy_import_item(import_item_list, import_item_count);
917 media_filter_destroy(filter);
918 SQLITE3_SAFE_FREE(condition);
919 media_content_error("error media_filter_set_condition");
922 ret = _media_db_get_group_item(NULL, filter, __media_playlist_media_info_cb, &media_id, MEDIA_GROUP_NONE);
923 if (ret != MEDIA_CONTENT_ERROR_NONE) {
924 __media_playlist_destroy_import_item(import_item_list, import_item_count);
925 media_filter_destroy(filter);
927 SQLITE3_SAFE_FREE(condition);
928 media_content_error("error media_info_foreach_media_from_db");
931 ret = media_playlist_add_media((media_playlist_h)*playlist, media_id);
932 if (ret != MEDIA_CONTENT_ERROR_NONE) {
933 __media_playlist_destroy_import_item(import_item_list, import_item_count);
934 media_filter_destroy(filter);
936 SQLITE3_SAFE_FREE(condition);
937 media_content_error("error media_playlist_add_media");
940 media_filter_destroy(filter);
942 SQLITE3_SAFE_FREE(condition);
945 ret = media_playlist_update_to_db(*playlist);
946 if (ret != MEDIA_CONTENT_ERROR_NONE) {
947 __media_playlist_destroy_import_item(import_item_list, import_item_count);
948 media_content_error("Fail to update playlist to db");
951 __media_playlist_destroy_import_item(import_item_list, import_item_count);
956 int media_playlist_export_to_file(media_playlist_h playlist, const char* path)
958 int ret = MEDIA_CONTENT_ERROR_NONE;
959 media_playlist_s *_playlist = (media_playlist_s*)playlist;
960 GList *item_list = NULL;
961 unsigned int idx = 0;
963 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
964 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
965 media_content_retvm_if(_playlist->playlist_id <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_id");
967 ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
968 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
970 ret = __media_playlist_reset_file(path);
971 if (ret != MEDIA_CONTENT_ERROR_NONE) {
972 g_list_free_full(item_list, __media_playlist_destroy_export_item);
973 media_content_error("Fail to init playlist file");
977 for (idx = 0; idx < g_list_length(item_list); idx++) {
978 char *item = g_list_nth_data(item_list, idx);
979 ret = __media_playlist_append_to_file(path, item);
980 if (ret != MEDIA_CONTENT_ERROR_NONE) {
981 g_list_free_full(item_list, __media_playlist_destroy_export_item);
982 media_content_error("Fail to export paths into file");
987 g_list_free_full(item_list, __media_playlist_destroy_export_item);