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_util_private.h>
24 #define PLAYLIST_ARRAY_SIZE 20
25 #define PLAYLIST_ARRAY_EXPAND 10
26 #define MAX_TMP_STR 2048
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);
42 static void __media_playlist_item_add(media_playlist_s *playlist, media_playlist_item_s *item_s)
44 playlist->item_list = g_list_append(playlist->item_list, item_s);
47 static void __media_playlist_item_release(media_playlist_s *playlist)
51 media_playlist_item_s *item = NULL;
53 list_cnt = g_list_length(playlist->item_list);
55 media_content_debug("list_cnt : [%d]", list_cnt);
57 for (idx = 0; idx < list_cnt; idx++) {
58 item = (media_playlist_item_s*)g_list_nth_data(playlist->item_list, idx);
60 SAFE_FREE(item->media_id);
61 SAFE_FREE(item->playlist_name);
62 SAFE_FREE(item->thumbnail_path);
67 g_list_free(playlist->item_list);
68 playlist->item_list = NULL;
72 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id)
74 int ret = MEDIA_CONTENT_ERROR_NONE;
75 char *query_str = NULL;
76 char *select_query = NULL;
77 sqlite3_stmt *stmt = NULL;
79 query_str = sqlite3_mprintf(INSERT_PLAYLIST_TO_PLAYLIST, playlist_name);
81 ret = _content_query_sql(query_str);
82 SQLITE3_SAFE_FREE(query_str);
83 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
85 select_query = sqlite3_mprintf(SELECT_PLAYLIST_ID_FROM_PLAYLIST, playlist_name);
87 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
88 SQLITE3_SAFE_FREE(select_query);
89 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
91 if (sqlite3_step(stmt) == SQLITE_ROW)
92 *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] = {0, };
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 if (sqlite3_step(stmt) == SQLITE_ROW)
116 play_order = (int)sqlite3_column_int(stmt, 0);
118 SQLITE3_FINALIZE(stmt);
122 query_str = sqlite3_mprintf("INSERT INTO %q (playlist_id, media_uuid, play_order) values (%d, '%q', %d);",
123 DB_TABLE_PLAYLIST_MAP, playlist_id, media_id, play_order);
124 ret = media_svc_append_query(query_str, _content_get_uid());
126 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
129 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id)
131 int ret = MEDIA_CONTENT_ERROR_NONE;
132 char *query_str = NULL;
134 query_str = sqlite3_mprintf(REMOVE_PLAYLIST_ITEM_FROM_PLAYLIST_MAP, playlist_id, playlist_member_id);
135 ret = media_svc_append_query(query_str, _content_get_uid());
137 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
140 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name)
142 int ret = MEDIA_CONTENT_ERROR_NONE;
143 char *query_str = NULL;
145 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_NAME_FROM_PLAYLIST, playlist_name, playlist_id);
146 ret = media_svc_append_query(query_str, _content_get_uid());
148 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
151 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path)
153 int ret = MEDIA_CONTENT_ERROR_NONE;
154 char *query_str = NULL;
156 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST, path, playlist_id);
157 ret = media_svc_append_query(query_str, _content_get_uid());
159 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
162 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order)
164 int ret = MEDIA_CONTENT_ERROR_NONE;
165 char *query_str = NULL;
167 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP, play_order, playlist_id, playlist_member_id);
168 ret = media_svc_append_query(query_str, _content_get_uid());
170 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
173 static bool __media_playlist_media_info_cb(media_info_h media, void *user_data)
175 int ret = MEDIA_CONTENT_ERROR_NONE;
176 char **media_id = (char**)user_data;
178 ret = media_info_get_media_id(media, media_id);
179 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_media_id fail");
184 static bool __media_playlist_member_cb(int playlist_member_id, media_info_h media, void *user_data)
186 int ret = MEDIA_CONTENT_ERROR_NONE;
187 GList **list = (GList**)user_data;
190 ret = media_info_get_file_path(media, &path);
191 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_file_path fail");
193 *list = g_list_append(*list, path);
198 static int __media_playlist_reset_file(const char* playlist_path)
202 fp = fopen(playlist_path, "wb");
203 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
205 fputs("", fp); /* remove previous playlist */
209 return MEDIA_CONTENT_ERROR_NONE;
212 static int __media_playlist_append_to_file(const char* playlist_path, const char* path)
216 fp = fopen(playlist_path, "a"); /* append only */
217 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
225 return MEDIA_CONTENT_ERROR_NONE;
228 static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count)
230 int current_index = 0;
231 int current_max_size = PLAYLIST_ARRAY_SIZE;
233 char *tmp_buf = NULL;
234 char tmp_str[MAX_QUERY_SIZE] = {0, };
235 char repl_item[MAX_QUERY_SIZE] = {0, };
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;
254 *item_list = calloc(current_max_size, sizeof(char*));
255 if (*item_list == NULL) {
257 SAFE_FREE(*item_list);
258 media_content_error("Out of Memory");
259 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
261 memset(tmp_str, 0, sizeof(tmp_str));
263 while (fgets(tmp_str, MAX_QUERY_SIZE, fp) != NULL) {
264 memset(repl_item, 0, sizeof(repl_item));
265 _media_content_replace_path(tmp_str, repl_item);
266 tmp_str_len = strlen(repl_item);
267 if (tmp_str_len > 0 && repl_item[tmp_str_len - 1] == '\n')
268 repl_item[tmp_str_len - 1] = '\0';
270 tmp_str_len = strlen(repl_item);
272 if (tmp_str_len > 0 && repl_item[0] != '#') {
273 if (!(current_index < (current_max_size - 1))) {
274 current_max_size += PLAYLIST_ARRAY_EXPAND;
275 char **tmp_ptr = calloc(current_max_size, sizeof(char*));
276 if (tmp_ptr == NULL) {
277 __media_playlist_destroy_import_item(*item_list, current_index);
278 media_content_error("Out of Memory");
280 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
282 memmove(tmp_ptr, *item_list, sizeof(char*) * current_index);
283 SAFE_FREE(*item_list);
284 *item_list = tmp_ptr;
287 (*item_list)[current_index] = malloc(tmp_str_len + 1);
288 if ((*item_list)[current_index] == NULL) {
289 __media_playlist_destroy_import_item(*item_list, current_index);
290 media_content_error("Out of Memory");
292 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
294 memset((*item_list)[current_index], 0, tmp_str_len + 1);
295 memmove((*item_list)[current_index], repl_item, tmp_str_len);
300 tmp_buf += (tmp_str_len);
303 *item_count = current_index;
306 return MEDIA_CONTENT_ERROR_NONE;
309 static int __media_playlist_destroy_import_item(char** item_list, int item_count)
313 for (i = 0; i < item_count; ++i) {
314 SAFE_FREE(item_list[i]);
318 if (item_list != NULL) {
319 SAFE_FREE(item_list);
323 return MEDIA_CONTENT_ERROR_NONE;
326 static void __media_playlist_destroy_export_item(gpointer data)
332 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
334 int ret = MEDIA_CONTENT_ERROR_NONE;
337 if (!STRING_VALID(name)) {
338 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
339 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
342 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
343 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
345 ret = __media_playlist_insert_playlist_record(name, &playlist_id);
347 if (ret != MEDIA_CONTENT_ERROR_NONE) {
348 SAFE_FREE(_playlist);
352 _playlist->playlist_id = playlist_id;
353 _playlist->name = strdup(name);
355 if (_playlist->name == NULL) {
356 SAFE_FREE(_playlist);
357 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
358 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
361 *playlist = (media_playlist_h)_playlist;
366 int media_playlist_delete_from_db(int playlist_id)
368 int ret = MEDIA_CONTENT_ERROR_NONE;
369 char *query_str = NULL;
371 if (playlist_id < 0) {
372 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
373 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
376 query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
378 ret = _content_query_sql(query_str);
380 SQLITE3_SAFE_FREE(query_str);
385 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
387 int ret = MEDIA_CONTENT_ERROR_NONE;
389 if (playlist_count != NULL) {
390 ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
392 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
393 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
399 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
401 int ret = MEDIA_CONTENT_ERROR_NONE;
403 if (callback == NULL) {
404 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
405 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
408 ret = _media_db_get_playlist(filter, callback, user_data);
413 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
415 int ret = MEDIA_CONTENT_ERROR_NONE;
417 if ((playlist_id > 0) && (media_count != NULL)) {
418 ret = _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
420 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
421 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
427 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
429 int ret = MEDIA_CONTENT_ERROR_NONE;
431 if ((playlist_id > 0) && (callback != NULL)) {
432 ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
434 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
435 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
441 int media_playlist_destroy(media_playlist_h playlist)
443 int ret = MEDIA_CONTENT_ERROR_NONE;
444 media_playlist_s *_playlist = (media_playlist_s*)playlist;
447 SAFE_FREE(_playlist->name);
448 SAFE_FREE(_playlist->thumbnail_path);
449 SAFE_FREE(_playlist);
451 ret = MEDIA_CONTENT_ERROR_NONE;
453 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
454 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
460 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
462 int ret = MEDIA_CONTENT_ERROR_NONE;
463 media_playlist_s *_src = (media_playlist_s*)src;
466 media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
467 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
469 _dst->playlist_id = _src->playlist_id;
471 if (STRING_VALID(_src->name)) {
472 _dst->name = strdup(_src->name);
473 if (_dst->name == NULL) {
474 media_playlist_destroy((media_playlist_h)_dst);
475 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
476 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
480 *dst = (media_playlist_h)_dst;
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_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
493 int ret = MEDIA_CONTENT_ERROR_NONE;
494 sqlite3_stmt *stmt = NULL;
495 char select_query[DEFAULT_QUERY_SIZE] = {0, };
497 if (playlist_id > 0) {
498 memset(select_query, 0x00, sizeof(select_query));
500 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
502 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
503 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
505 media_playlist_s *_playlist = NULL;
507 if (sqlite3_step(stmt) == SQLITE_ROW) {
508 _playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
509 if (_playlist == NULL) {
510 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
511 SQLITE3_FINALIZE(stmt);
512 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
515 _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
516 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
517 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
519 *playlist = (media_playlist_h)_playlist;
521 media_content_error("Nonexistent playlist id[%d]", playlist_id);
522 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
525 SQLITE3_FINALIZE(stmt);
527 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
528 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
534 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
536 int ret = MEDIA_CONTENT_ERROR_NONE;
538 media_playlist_s *_playlist = (media_playlist_s*)playlist;
540 if ((_playlist != NULL) && (playlist_id != NULL)) {
541 *playlist_id = _playlist->playlist_id;
543 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
544 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
550 int media_playlist_get_name(media_playlist_h playlist, char **name)
552 int ret = MEDIA_CONTENT_ERROR_NONE;
553 media_playlist_s *_playlist = (media_playlist_s*)playlist;
555 if (STRING_VALID(_playlist->name)) {
556 *name = strdup(_playlist->name);
557 media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
562 ret = MEDIA_CONTENT_ERROR_NONE;
564 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
565 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
571 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
573 int ret = MEDIA_CONTENT_ERROR_NONE;
574 media_playlist_s *_playlist = (media_playlist_s*)playlist;
576 if (STRING_VALID(_playlist->thumbnail_path)) {
577 *path = strdup(_playlist->thumbnail_path);
578 media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
583 ret = MEDIA_CONTENT_ERROR_NONE;
585 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
586 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
592 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
594 int ret = MEDIA_CONTENT_ERROR_NONE;
595 media_playlist_s *_playlist = (media_playlist_s*)playlist;
597 sqlite3_stmt *stmt = NULL;
598 char select_query[DEFAULT_QUERY_SIZE] = {0, };
600 if ((_playlist == NULL) || (playlist_member_id < 0) || (play_order == NULL)) {
601 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
602 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
605 playlist_id = _playlist->playlist_id;
607 memset(select_query, 0x00, sizeof(select_query));
609 snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
611 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
612 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
614 if (sqlite3_step(stmt) == SQLITE_ROW)
615 *play_order = (int)sqlite3_column_int(stmt, 0);
617 SQLITE3_FINALIZE(stmt);
622 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
624 int ret = MEDIA_CONTENT_ERROR_NONE;
625 media_playlist_s *_playlist = (media_playlist_s*)playlist;
627 if (_playlist != NULL && STRING_VALID(playlist_name)) {
628 SAFE_FREE(_playlist->name);
630 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
631 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
633 item->playlist_name = strdup(playlist_name);
634 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
635 if (item->playlist_name == NULL) {
637 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
638 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
641 _playlist->name = strdup(playlist_name);
642 if (_playlist->name == NULL) {
643 SAFE_FREE(item->playlist_name);
645 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
646 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
649 __media_playlist_item_add(_playlist, item);
651 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
652 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
658 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
660 int ret = MEDIA_CONTENT_ERROR_NONE;
661 media_playlist_s *_playlist = (media_playlist_s*)playlist;
663 if (_playlist != NULL && STRING_VALID(path)) {
664 SAFE_FREE(_playlist->thumbnail_path);
666 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
667 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
669 item->thumbnail_path = g_strdup(path);
670 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
671 if (item->thumbnail_path == NULL) {
673 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
674 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
677 _playlist->thumbnail_path = strdup(path);
678 if (_playlist->thumbnail_path == NULL) {
679 SAFE_FREE(item->thumbnail_path);
681 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
682 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
685 __media_playlist_item_add(_playlist, item);
687 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
688 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
694 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
696 int ret = MEDIA_CONTENT_ERROR_NONE;
697 media_playlist_s *_playlist = (media_playlist_s*)playlist;
699 if ((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0)) {
700 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
701 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
703 item->playlist_member_id = playlist_member_id;
704 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
705 item->play_order = play_order;
707 __media_playlist_item_add(_playlist, item);
709 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
710 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
716 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
718 int ret = MEDIA_CONTENT_ERROR_NONE;
719 media_playlist_s *_playlist = (media_playlist_s*)playlist;
721 if (_playlist != NULL && STRING_VALID(media_id)) {
722 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
723 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
725 item->media_id = strdup(media_id);
726 item->function = MEDIA_PLAYLIST_ADD;
728 if (item->media_id == NULL) {
730 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
731 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
734 __media_playlist_item_add(_playlist, item);
736 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
737 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
744 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
746 int ret = MEDIA_CONTENT_ERROR_NONE;
747 media_playlist_s *_playlist = (media_playlist_s*)playlist;
749 if ((_playlist != NULL) && (playlist_member_id > 0)) {
750 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
751 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
753 item->playlist_member_id = playlist_member_id;
754 item->function = MEDIA_PLAYLIST_REMOVE;
756 __media_playlist_item_add(_playlist, item);
758 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
759 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
765 int media_playlist_update_to_db(media_playlist_h playlist)
767 int ret = MEDIA_CONTENT_ERROR_NONE;
768 media_playlist_s *_playlist = (media_playlist_s*)playlist;
771 media_playlist_item_s *_playlist_item = NULL;
773 if (_playlist == NULL) {
774 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
775 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
778 if (_playlist->item_list != NULL) {
779 length = g_list_length(_playlist->item_list);
781 media_content_debug("operation list length is 0");
782 return MEDIA_CONTENT_ERROR_NONE;
785 for (idx = 0; idx < length; idx++) {
786 _playlist_item = (media_playlist_item_s*)g_list_nth_data(_playlist->item_list, idx);
787 if (_playlist_item != NULL) {
788 switch (_playlist_item->function) {
789 case MEDIA_PLAYLIST_ADD:
791 ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
795 case MEDIA_PLAYLIST_REMOVE:
797 ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
801 case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
803 ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
807 case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
809 ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
813 case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
815 ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
823 if (ret != MEDIA_CONTENT_ERROR_NONE)
824 media_content_error("Failed some operation[%d]", _playlist_item->function);
828 ret = media_svc_send_query(_content_get_uid());
830 __media_playlist_item_release(_playlist);
832 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
835 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
837 int ret = MEDIA_CONTENT_ERROR_NONE;
838 char** import_item_list = NULL;
839 int import_item_count = 0;
841 char repl_path[MAX_PATH_LEN] = {0, };
843 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
844 media_content_retvm_if(!STRING_VALID(playlist_name), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_name");
845 memset(repl_path, 0, sizeof(repl_path));
846 ret = _media_content_replace_path(path, repl_path);
847 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
849 ret = media_playlist_insert_to_db(playlist_name, playlist);
850 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
852 ret = __media_playlist_import_item_from_file(repl_path, &import_item_list, &import_item_count);
853 if (ret != MEDIA_CONTENT_ERROR_NONE) {
854 __media_playlist_destroy_import_item(import_item_list, import_item_count);
855 media_content_error("Fail to get playlist from file");
859 if (import_item_count == 0)
860 media_content_debug("The playlist from file is empty");
862 for (idx = 0; idx < import_item_count; idx++) {
863 filter_h filter = NULL;
864 char *media_id = NULL;
865 char *condition = NULL;
867 ret = media_filter_create(&filter);
868 if (ret != MEDIA_CONTENT_ERROR_NONE) {
869 __media_playlist_destroy_import_item(import_item_list, import_item_count);
870 media_filter_destroy(filter);
871 media_content_error("error media_filter_create");
874 condition = sqlite3_mprintf("path = '%q'", import_item_list[idx]);
875 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
876 if (ret != MEDIA_CONTENT_ERROR_NONE) {
877 __media_playlist_destroy_import_item(import_item_list, import_item_count);
878 media_filter_destroy(filter);
879 SQLITE3_SAFE_FREE(condition);
880 media_content_error("error media_filter_set_condition");
883 ret = _media_db_get_group_item(NULL, filter, __media_playlist_media_info_cb, &media_id, MEDIA_GROUP_NONE);
884 if (ret != MEDIA_CONTENT_ERROR_NONE) {
885 __media_playlist_destroy_import_item(import_item_list, import_item_count);
886 media_filter_destroy(filter);
888 SQLITE3_SAFE_FREE(condition);
889 media_content_error("error media_info_foreach_media_from_db");
892 ret = media_playlist_add_media((media_playlist_h)*playlist, media_id);
893 if (ret != MEDIA_CONTENT_ERROR_NONE) {
894 __media_playlist_destroy_import_item(import_item_list, import_item_count);
895 media_filter_destroy(filter);
897 SQLITE3_SAFE_FREE(condition);
898 media_content_error("error media_playlist_add_media");
901 media_filter_destroy(filter);
903 SQLITE3_SAFE_FREE(condition);
906 ret = media_playlist_update_to_db(*playlist);
907 if (ret != MEDIA_CONTENT_ERROR_NONE) {
908 __media_playlist_destroy_import_item(import_item_list, import_item_count);
909 media_content_error("Fail to update playlist to db");
912 __media_playlist_destroy_import_item(import_item_list, import_item_count);
917 int media_playlist_export_to_file(media_playlist_h playlist, const char* path)
919 int ret = MEDIA_CONTENT_ERROR_NONE;
920 media_playlist_s *_playlist = (media_playlist_s*)playlist;
921 GList *item_list = NULL;
922 unsigned int idx = 0;
923 char repl_path[MAX_PATH_LEN] = {0, };
925 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
926 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
927 media_content_retvm_if(_playlist->playlist_id <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_id");
928 memset(repl_path, 0, sizeof(repl_path));
929 ret = _media_content_replace_path(path, repl_path);
930 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
932 ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
933 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
935 ret = __media_playlist_reset_file(repl_path);
936 if (ret != MEDIA_CONTENT_ERROR_NONE) {
937 g_list_free_full(item_list, __media_playlist_destroy_export_item);
938 media_content_error("Fail to init playlist file");
942 for (idx = 0; idx < g_list_length(item_list); idx++) {
943 char *item = g_list_nth_data(item_list, idx);
944 if (STRING_VALID(item)) {
945 ret = __media_playlist_append_to_file(repl_path, item);
946 if (ret != MEDIA_CONTENT_ERROR_NONE) {
947 g_list_free_full(item_list, __media_playlist_destroy_export_item);
948 media_content_error("Fail to export paths into file");
954 g_list_free_full(item_list, __media_playlist_destroy_export_item);
959 int media_playlist_create(media_playlist_h *playlist)
961 int ret = MEDIA_CONTENT_ERROR_NONE;
963 media_content_retvm_if(playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid playlist");
965 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
966 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
968 _playlist->playlist_id = -1;
969 _playlist->name = NULL;
970 _playlist->thumbnail_path = NULL;
971 _playlist->item_list = NULL;
973 *playlist = (media_playlist_h)_playlist;
978 int media_playlist_get_play_order_v2(int playlist_id, int playlist_member_id, int *play_order)
980 int ret = MEDIA_CONTENT_ERROR_NONE;
981 sqlite3_stmt *stmt = NULL;
982 char select_query[DEFAULT_QUERY_SIZE] = {0, };
984 if ((playlist_id < 0) || (playlist_member_id < 0) || (play_order == NULL)) {
985 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
986 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
989 memset(select_query, 0x00, sizeof(select_query));
991 snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
993 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
994 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
996 if (sqlite3_step(stmt) == SQLITE_ROW)
997 *play_order = (int)sqlite3_column_int(stmt, 0);
999 SQLITE3_FINALIZE(stmt);
1004 int media_playlist_insert_to_db_v2(media_playlist_h playlist)
1006 int ret = MEDIA_CONTENT_ERROR_NONE;
1007 media_playlist_s *_playlist = (media_playlist_s*)playlist;
1008 int playlist_id = 0;
1010 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
1011 media_content_retvm_if(_playlist->playlist_id != -1, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid playlist insert");
1013 ret = __media_playlist_insert_playlist_record(_playlist->name, &playlist_id);
1014 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1015 __media_playlist_item_release(_playlist);
1016 media_content_error("Insert playlist Fail");
1020 _playlist->playlist_id = playlist_id;
1022 ret = media_playlist_update_to_db(playlist);
1027 int media_playlist_update_to_db_v2(int playlist_id, media_playlist_h playlist)
1029 media_playlist_s *_playlist = (media_playlist_s*)playlist;
1031 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
1033 _playlist->playlist_id = playlist_id;
1035 return media_playlist_update_to_db(playlist);