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);
93 SQLITE3_FINALIZE(stmt);
95 return MEDIA_CONTENT_ERROR_NONE;
98 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id)
100 int ret = MEDIA_CONTENT_ERROR_NONE;
101 sqlite3_stmt *stmt = NULL;
102 char select_query[DEFAULT_QUERY_SIZE];
103 char *query_str = NULL;
106 memset(select_query, 0x00, sizeof(select_query));
108 snprintf(select_query, sizeof(select_query), SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id);
110 /* get the max play_order */
111 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
112 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
114 while (sqlite3_step(stmt) == SQLITE_ROW)
115 play_order = (int)sqlite3_column_int(stmt, 0);
117 SQLITE3_FINALIZE(stmt);
121 query_str = sqlite3_mprintf("INSERT INTO %q (playlist_id, media_uuid, play_order) values (%d, '%q', %d);",
122 DB_TABLE_PLAYLIST_MAP, playlist_id, media_id, play_order);
123 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
125 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
128 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id)
130 int ret = MEDIA_CONTENT_ERROR_NONE;
131 char *query_str = NULL;
133 query_str = sqlite3_mprintf(REMOVE_PLAYLIST_ITEM_FROM_PLAYLIST_MAP, playlist_id, playlist_member_id);
134 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
136 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
139 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name)
141 int ret = MEDIA_CONTENT_ERROR_NONE;
142 char *query_str = NULL;
144 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_NAME_FROM_PLAYLIST, playlist_name, playlist_id);
145 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
147 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
150 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path)
152 int ret = MEDIA_CONTENT_ERROR_NONE;
153 char *query_str = NULL;
155 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST, path, playlist_id);
156 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
158 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
161 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order)
163 int ret = MEDIA_CONTENT_ERROR_NONE;
164 char *query_str = NULL;
166 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP, play_order, playlist_id, playlist_member_id);
167 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
169 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
172 static bool __media_playlist_media_info_cb(media_info_h media, void *user_data)
174 int ret = MEDIA_CONTENT_ERROR_NONE;
175 char **media_id = (char**)user_data;
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");
183 static bool __media_playlist_member_cb(int playlist_member_id, media_info_h media, void *user_data)
185 int ret = MEDIA_CONTENT_ERROR_NONE;
186 GList **list = (GList**)user_data;
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");
192 *list = g_list_append(*list, path);
197 static int __media_playlist_reset_file(const char* playlist_path)
201 fp = fopen(playlist_path, "wb");
202 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
204 fputs("", fp); /* remove previous playlist */
208 return MEDIA_CONTENT_ERROR_NONE;
211 static int __media_playlist_append_to_file(const char* playlist_path, const char* path)
215 fp = fopen(playlist_path, "a"); /* append only */
216 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
224 return MEDIA_CONTENT_ERROR_NONE;
227 static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count)
229 int current_index = 0;
230 int current_max_size = PLAYLIST_ARRAY_SIZE;
233 char *tmp_buf = NULL;
234 char *tmp_str = NULL;
237 long int file_size = 0;
239 *item_list = NULL; *item_count = 0;
241 fp = fopen(playlist_path, "rb");
242 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
244 fseek(fp, 0, SEEK_END);
245 file_size = ftell(fp);
246 fseek(fp, 0 , SEEK_SET);
248 if (file_size == 0) {
249 media_content_debug("file is empty.");
251 return MEDIA_CONTENT_ERROR_NONE;
255 buf = malloc(file_size + 1);
258 media_content_error("Out of Memory");
260 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
265 if (fread(buf, file_size, 1, fp) != 1) {
268 media_content_stderror("fread fail");
269 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
274 *item_list = calloc(current_max_size, sizeof(char*));
275 tmp_str = malloc(MAX_TMP_STR);
276 if (tmp_str == NULL || *item_list == NULL) {
277 SAFE_FREE(*item_list);
280 media_content_error("Out of Memory");
281 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
285 snprintf(format, 25, "%%%d[^\n]", MAX_TMP_STR - 1);
287 while ((sscanf(tmp_buf, format, tmp_str) == 1) || (*tmp_buf == '\n')) {
288 if (*tmp_buf == '\n') {
291 if (tmp_buf < (buf + file_size))
297 tmp_str_len = strlen(tmp_str);
299 if (tmp_str[0] != '#') {
300 if (!(current_index < (current_max_size - 1))) {
301 current_max_size += PLAYLIST_ARRAY_EXPAND;
302 char **tmp_ptr = calloc(current_max_size, sizeof(char*));
303 if (tmp_ptr == NULL) {
304 __media_playlist_destroy_import_item(*item_list, current_index);
307 media_content_error("Out of Memory");
308 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
310 memmove(tmp_ptr, *item_list, sizeof(char*) * current_index);
311 SAFE_FREE(*item_list);
312 *item_list = tmp_ptr;
315 (*item_list)[current_index] = malloc(tmp_str_len + 1);
316 if ((*item_list)[current_index] == NULL) {
317 __media_playlist_destroy_import_item(*item_list, current_index);
320 media_content_error("Out of Memory");
321 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
323 memset((*item_list)[current_index], 0, tmp_str_len + 1);
324 memmove((*item_list)[current_index], tmp_str, tmp_str_len);
329 tmp_buf += (tmp_str_len);
332 *item_count = current_index;
337 return MEDIA_CONTENT_ERROR_NONE;
340 static int __media_playlist_destroy_import_item(char** item_list, int item_count)
344 for (i = 0; i < item_count; ++i) {
345 SAFE_FREE(item_list[i]);
349 if (item_list != NULL) {
350 SAFE_FREE(item_list);
354 return MEDIA_CONTENT_ERROR_NONE;
357 static void __media_playlist_destroy_export_item(gpointer data)
363 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
365 int ret = MEDIA_CONTENT_ERROR_NONE;
368 if (!STRING_VALID(name)) {
369 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
370 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
373 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
374 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
376 ret = __media_playlist_insert_playlist_record(name, &playlist_id);
378 if (ret != MEDIA_CONTENT_ERROR_NONE) {
379 SAFE_FREE(_playlist);
383 _playlist->playlist_id = playlist_id;
384 _playlist->name = strdup(name);
386 if (_playlist->name == NULL) {
387 SAFE_FREE(_playlist);
388 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
389 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
392 *playlist = (media_playlist_h)_playlist;
397 int media_playlist_delete_from_db(int playlist_id)
399 int ret = MEDIA_CONTENT_ERROR_NONE;
400 char *query_str = NULL;
402 if (playlist_id < 0) {
403 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
404 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
407 query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
409 ret = _content_query_sql(query_str);
411 SQLITE3_SAFE_FREE(query_str);
416 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
418 int ret = MEDIA_CONTENT_ERROR_NONE;
420 if (playlist_count != NULL) {
421 ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
423 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
424 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
430 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
432 int ret = MEDIA_CONTENT_ERROR_NONE;
434 if (callback == NULL) {
435 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
436 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
439 ret = _media_db_get_playlist(filter, callback, user_data);
444 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
446 int ret = MEDIA_CONTENT_ERROR_NONE;
448 if ((playlist_id > 0) && (media_count != NULL)) {
449 ret = _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
451 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
452 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
458 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
460 int ret = MEDIA_CONTENT_ERROR_NONE;
462 if ((playlist_id > 0) && (callback != NULL)) {
463 ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
465 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
466 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
472 int media_playlist_destroy(media_playlist_h playlist)
474 int ret = MEDIA_CONTENT_ERROR_NONE;
475 media_playlist_s *_playlist = (media_playlist_s*)playlist;
478 SAFE_FREE(_playlist->name);
479 SAFE_FREE(_playlist->thumbnail_path);
480 SAFE_FREE(_playlist);
482 ret = MEDIA_CONTENT_ERROR_NONE;
484 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
485 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
491 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
493 int ret = MEDIA_CONTENT_ERROR_NONE;
494 media_playlist_s *_src = (media_playlist_s*)src;
497 media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
498 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
500 _dst->playlist_id = _src->playlist_id;
502 if (STRING_VALID(_src->name)) {
503 _dst->name = strdup(_src->name);
504 if (_dst->name == NULL) {
505 media_playlist_destroy((media_playlist_h)_dst);
506 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
507 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
511 *dst = (media_playlist_h)_dst;
513 ret = MEDIA_CONTENT_ERROR_NONE;
515 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
516 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
522 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
524 int ret = MEDIA_CONTENT_ERROR_NONE;
525 sqlite3_stmt *stmt = NULL;
526 char select_query[DEFAULT_QUERY_SIZE];
528 if (playlist_id > 0) {
529 memset(select_query, 0x00, sizeof(select_query));
531 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
533 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
534 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
536 media_playlist_s *_playlist = NULL;
538 while (sqlite3_step(stmt) == SQLITE_ROW) {
540 media_playlist_destroy((media_playlist_h)_playlist);
542 _playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
543 if (_playlist == NULL) {
544 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
545 SQLITE3_FINALIZE(stmt);
546 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
549 _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
550 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
551 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
553 *playlist = (media_playlist_h)_playlist;
556 SQLITE3_FINALIZE(stmt);
558 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
559 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
565 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
567 int ret = MEDIA_CONTENT_ERROR_NONE;
569 media_playlist_s *_playlist = (media_playlist_s*)playlist;
571 if ((_playlist != NULL) && (playlist_id != NULL)) {
572 *playlist_id = _playlist->playlist_id;
574 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
575 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
581 int media_playlist_get_name(media_playlist_h playlist, char **name)
583 int ret = MEDIA_CONTENT_ERROR_NONE;
584 media_playlist_s *_playlist = (media_playlist_s*)playlist;
586 if (STRING_VALID(_playlist->name)) {
587 *name = strdup(_playlist->name);
588 media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
593 ret = MEDIA_CONTENT_ERROR_NONE;
595 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
596 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
602 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
604 int ret = MEDIA_CONTENT_ERROR_NONE;
605 media_playlist_s *_playlist = (media_playlist_s*)playlist;
607 if (STRING_VALID(_playlist->thumbnail_path)) {
608 *path = strdup(_playlist->thumbnail_path);
609 media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
614 ret = MEDIA_CONTENT_ERROR_NONE;
616 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
617 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
623 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
625 int ret = MEDIA_CONTENT_ERROR_NONE;
626 media_playlist_s *_playlist = (media_playlist_s*)playlist;
628 sqlite3_stmt *stmt = NULL;
629 char select_query[DEFAULT_QUERY_SIZE];
631 if ((_playlist == NULL) || (playlist_member_id < 0) || (play_order == NULL)) {
632 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
633 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
636 playlist_id = _playlist->playlist_id;
638 memset(select_query, 0x00, sizeof(select_query));
640 snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
642 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
643 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
645 while (sqlite3_step(stmt) == SQLITE_ROW)
646 *play_order = (int)sqlite3_column_int(stmt, 0);
648 SQLITE3_FINALIZE(stmt);
653 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
655 int ret = MEDIA_CONTENT_ERROR_NONE;
656 media_playlist_s *_playlist = (media_playlist_s*)playlist;
658 if (_playlist != NULL && STRING_VALID(playlist_name)) {
659 SAFE_FREE(_playlist->name);
661 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
662 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
664 item->playlist_name = strdup(playlist_name);
665 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
666 if (item->playlist_name == NULL) {
668 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
669 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
672 _playlist->name = strdup(playlist_name);
673 if (_playlist->name == NULL) {
674 SAFE_FREE(item->playlist_name);
676 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
677 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
680 __media_playlist_item_add(_playlist, item);
682 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
683 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
689 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
691 int ret = MEDIA_CONTENT_ERROR_NONE;
692 media_playlist_s *_playlist = (media_playlist_s*)playlist;
694 if (_playlist != NULL && STRING_VALID(path)) {
695 SAFE_FREE(_playlist->thumbnail_path);
697 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
698 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
700 item->thumbnail_path = strdup(path);
701 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
702 if (item->thumbnail_path == NULL) {
704 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
705 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
708 _playlist->thumbnail_path = strdup(path);
709 if (_playlist->thumbnail_path == NULL) {
710 SAFE_FREE(item->thumbnail_path);
712 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
713 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
716 __media_playlist_item_add(_playlist, item);
718 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
719 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
725 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
727 int ret = MEDIA_CONTENT_ERROR_NONE;
728 media_playlist_s *_playlist = (media_playlist_s*)playlist;
730 if ((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0)) {
731 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
732 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
734 item->playlist_member_id = playlist_member_id;
735 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
736 item->play_order = play_order;
738 __media_playlist_item_add(_playlist, item);
740 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
741 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
747 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
749 int ret = MEDIA_CONTENT_ERROR_NONE;
750 media_playlist_s *_playlist = (media_playlist_s*)playlist;
752 if (_playlist != NULL && STRING_VALID(media_id)) {
753 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
754 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
756 item->media_id = strdup(media_id);
757 item->function = MEDIA_PLAYLIST_ADD;
759 if (item->media_id == NULL) {
761 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
762 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
765 __media_playlist_item_add(_playlist, item);
767 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
768 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
775 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
777 int ret = MEDIA_CONTENT_ERROR_NONE;
778 media_playlist_s *_playlist = (media_playlist_s*)playlist;
780 if ((_playlist != NULL) && (playlist_member_id > 0)) {
781 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
782 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
784 item->playlist_member_id = playlist_member_id;
785 item->function = MEDIA_PLAYLIST_REMOVE;
787 __media_playlist_item_add(_playlist, item);
789 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
790 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
796 int media_playlist_update_to_db(media_playlist_h playlist)
798 int ret = MEDIA_CONTENT_ERROR_NONE;
799 media_playlist_s *_playlist = (media_playlist_s*)playlist;
802 media_playlist_item_s *_playlist_item = NULL;
804 if (_playlist == NULL) {
805 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
806 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
809 if (_playlist->item_list != NULL) {
810 length = g_list_length(_playlist->item_list);
812 media_content_debug("operation list length is 0");
813 return MEDIA_CONTENT_ERROR_NONE;
816 for (idx = 0; idx < length; idx++) {
817 _playlist_item = (media_playlist_item_s*)g_list_nth_data(_playlist->item_list, idx);
818 if (_playlist_item != NULL) {
819 switch (_playlist_item->function) {
820 case MEDIA_PLAYLIST_ADD:
822 ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
826 case MEDIA_PLAYLIST_REMOVE:
828 ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
832 case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
834 ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
838 case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
840 ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
844 case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
846 ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
855 ret = media_svc_send_query(tzplatform_getuid(TZ_USER_NAME));
857 __media_playlist_item_release(_playlist);
859 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
862 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
864 int ret = MEDIA_CONTENT_ERROR_NONE;
865 char** import_item_list = NULL;
866 int import_item_count = 0;
869 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
870 media_content_retvm_if(!STRING_VALID(playlist_name), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_name");
872 ret = media_playlist_insert_to_db(playlist_name, playlist);
873 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
875 ret = __media_playlist_import_item_from_file(path, &import_item_list, &import_item_count);
876 if (ret != MEDIA_CONTENT_ERROR_NONE) {
877 __media_playlist_destroy_import_item(import_item_list, import_item_count);
878 media_content_error("Fail to get playlist from file");
882 if (import_item_count == 0)
883 media_content_debug("The playlist from file is empty");
885 for (idx = 0; idx < import_item_count; idx++) {
886 filter_h filter = NULL;
887 char *media_id = NULL;
888 char *condition = NULL;
890 ret = media_filter_create(&filter);
891 if (ret != MEDIA_CONTENT_ERROR_NONE) {
892 __media_playlist_destroy_import_item(import_item_list, import_item_count);
893 media_filter_destroy(filter);
894 media_content_error("error media_filter_create");
897 condition = sqlite3_mprintf("path = '%q'", import_item_list[idx]);
898 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
899 if (ret != MEDIA_CONTENT_ERROR_NONE) {
900 __media_playlist_destroy_import_item(import_item_list, import_item_count);
901 media_filter_destroy(filter);
902 SQLITE3_SAFE_FREE(condition);
903 media_content_error("error media_filter_set_condition");
906 ret = _media_db_get_group_item(NULL, filter, __media_playlist_media_info_cb, &media_id, MEDIA_GROUP_NONE);
907 if (ret != MEDIA_CONTENT_ERROR_NONE) {
908 __media_playlist_destroy_import_item(import_item_list, import_item_count);
909 media_filter_destroy(filter);
911 SQLITE3_SAFE_FREE(condition);
912 media_content_error("error media_info_foreach_media_from_db");
915 ret = media_playlist_add_media((media_playlist_h)*playlist, media_id);
916 if (ret != MEDIA_CONTENT_ERROR_NONE) {
917 __media_playlist_destroy_import_item(import_item_list, import_item_count);
918 media_filter_destroy(filter);
920 SQLITE3_SAFE_FREE(condition);
921 media_content_error("error media_playlist_add_media");
924 media_filter_destroy(filter);
926 SQLITE3_SAFE_FREE(condition);
929 ret = media_playlist_update_to_db(*playlist);
930 if (ret != MEDIA_CONTENT_ERROR_NONE) {
931 __media_playlist_destroy_import_item(import_item_list, import_item_count);
932 media_content_error("Fail to update playlist to db");
935 __media_playlist_destroy_import_item(import_item_list, import_item_count);
940 int media_playlist_export_to_file(media_playlist_h playlist, const char* path)
942 int ret = MEDIA_CONTENT_ERROR_NONE;
943 media_playlist_s *_playlist = (media_playlist_s*)playlist;
944 GList *item_list = NULL;
945 unsigned int idx = 0;
947 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
948 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
949 media_content_retvm_if(_playlist->playlist_id <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_id");
951 ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
952 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
954 ret = __media_playlist_reset_file(path);
955 if (ret != MEDIA_CONTENT_ERROR_NONE) {
956 g_list_free_full(item_list, __media_playlist_destroy_export_item);
957 media_content_error("Fail to init playlist file");
961 for (idx = 0; idx < g_list_length(item_list); idx++) {
962 char *item = g_list_nth_data(item_list, idx);
963 ret = __media_playlist_append_to_file(path, item);
964 if (ret != MEDIA_CONTENT_ERROR_NONE) {
965 g_list_free_full(item_list, __media_playlist_destroy_export_item);
966 media_content_error("Fail to export paths into file");
971 g_list_free_full(item_list, __media_playlist_destroy_export_item);