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_PLAYLIST_ITEM_TO_PLAYLIST_MAP, playlist_id, media_id, play_order);
123 ret = media_svc_append_query(query_str, _content_get_uid());
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, _content_get_uid());
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, _content_get_uid());
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, _content_get_uid());
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, _content_get_uid());
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;
232 char *tmp_buf = NULL;
233 char tmp_str[MAX_QUERY_SIZE] = {0, };
234 char repl_item[MAX_QUERY_SIZE] = {0, };
236 long int file_size = 0;
238 *item_list = NULL; *item_count = 0;
240 fp = fopen(playlist_path, "rb");
241 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
243 if (fseek(fp, 0, SEEK_END) < 0) {
244 media_content_stderror("fseek failed");
246 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
248 file_size = ftell(fp);
249 if (file_size == 0) {
250 media_content_debug("file is empty.");
252 return MEDIA_CONTENT_ERROR_NONE;
255 if (fseek(fp, 0, SEEK_SET) < 0) {
256 media_content_stderror("fseek failed");
258 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
261 *item_list = calloc(current_max_size, sizeof(char*));
262 if (*item_list == NULL) {
264 SAFE_FREE(*item_list);
265 media_content_error("Out of Memory");
266 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
268 memset(tmp_str, 0, sizeof(tmp_str));
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';
277 tmp_str_len = strlen(repl_item);
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");
287 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
289 memmove(tmp_ptr, *item_list, sizeof(char*) * current_index);
290 SAFE_FREE(*item_list);
291 *item_list = tmp_ptr;
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");
299 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
301 memset((*item_list)[current_index], 0, tmp_str_len + 1);
302 memmove((*item_list)[current_index], repl_item, tmp_str_len);
307 tmp_buf += (tmp_str_len);
310 *item_count = current_index;
313 return MEDIA_CONTENT_ERROR_NONE;
316 static int __media_playlist_destroy_import_item(char** item_list, int item_count)
320 for (i = 0; i < item_count; ++i) {
321 SAFE_FREE(item_list[i]);
325 if (item_list != NULL) {
326 SAFE_FREE(item_list);
330 return MEDIA_CONTENT_ERROR_NONE;
333 static void __media_playlist_destroy_export_item(gpointer data)
339 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
341 int ret = MEDIA_CONTENT_ERROR_NONE;
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;
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");
352 ret = __media_playlist_insert_playlist_record(name, &playlist_id);
354 if (ret != MEDIA_CONTENT_ERROR_NONE) {
355 SAFE_FREE(_playlist);
359 _playlist->playlist_id = playlist_id;
360 _playlist->name = strdup(name);
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;
368 *playlist = (media_playlist_h)_playlist;
373 int media_playlist_delete_from_db(int playlist_id)
375 int ret = MEDIA_CONTENT_ERROR_NONE;
376 char *query_str = NULL;
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;
383 query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
385 ret = _content_query_sql(query_str);
387 SQLITE3_SAFE_FREE(query_str);
392 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
394 int ret = MEDIA_CONTENT_ERROR_NONE;
396 if (playlist_count != NULL) {
397 ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
399 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
400 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
406 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
408 int ret = MEDIA_CONTENT_ERROR_NONE;
410 if (callback == NULL) {
411 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
412 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
415 ret = _media_db_get_playlist(filter, callback, user_data);
420 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
422 int ret = MEDIA_CONTENT_ERROR_NONE;
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);
427 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
428 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
434 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
436 int ret = MEDIA_CONTENT_ERROR_NONE;
438 if ((playlist_id > 0) && (callback != NULL)) {
439 ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
441 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
442 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
448 int media_playlist_destroy(media_playlist_h playlist)
450 int ret = MEDIA_CONTENT_ERROR_NONE;
451 media_playlist_s *_playlist = (media_playlist_s*)playlist;
454 SAFE_FREE(_playlist->name);
455 SAFE_FREE(_playlist->thumbnail_path);
456 SAFE_FREE(_playlist);
458 ret = MEDIA_CONTENT_ERROR_NONE;
460 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
461 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
467 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
469 int ret = MEDIA_CONTENT_ERROR_NONE;
470 media_playlist_s *_src = (media_playlist_s*)src;
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");
476 _dst->playlist_id = _src->playlist_id;
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;
487 *dst = (media_playlist_h)_dst;
489 ret = MEDIA_CONTENT_ERROR_NONE;
491 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
492 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
498 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
500 int ret = MEDIA_CONTENT_ERROR_NONE;
501 sqlite3_stmt *stmt = NULL;
502 char select_query[DEFAULT_QUERY_SIZE] = {0, };
504 if (playlist_id > 0) {
505 memset(select_query, 0x00, sizeof(select_query));
507 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
509 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
510 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
512 media_playlist_s *_playlist = NULL;
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;
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));
526 *playlist = (media_playlist_h)_playlist;
528 media_content_error("Nonexistent playlist id[%d]", playlist_id);
529 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
532 SQLITE3_FINALIZE(stmt);
534 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
535 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
541 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
543 int ret = MEDIA_CONTENT_ERROR_NONE;
545 media_playlist_s *_playlist = (media_playlist_s*)playlist;
547 if ((_playlist != NULL) && (playlist_id != NULL)) {
548 *playlist_id = _playlist->playlist_id;
550 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
551 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
557 int media_playlist_get_name(media_playlist_h playlist, char **name)
559 int ret = MEDIA_CONTENT_ERROR_NONE;
560 media_playlist_s *_playlist = (media_playlist_s*)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");
569 ret = MEDIA_CONTENT_ERROR_NONE;
571 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
572 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
578 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
580 int ret = MEDIA_CONTENT_ERROR_NONE;
581 media_playlist_s *_playlist = (media_playlist_s*)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");
590 ret = MEDIA_CONTENT_ERROR_NONE;
592 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
593 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
599 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
601 int ret = MEDIA_CONTENT_ERROR_NONE;
602 media_playlist_s *_playlist = (media_playlist_s*)playlist;
604 sqlite3_stmt *stmt = NULL;
605 char select_query[DEFAULT_QUERY_SIZE] = {0, };
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;
612 playlist_id = _playlist->playlist_id;
614 memset(select_query, 0x00, sizeof(select_query));
616 snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
618 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
619 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
621 if (sqlite3_step(stmt) == SQLITE_ROW)
622 *play_order = (int)sqlite3_column_int(stmt, 0);
624 SQLITE3_FINALIZE(stmt);
629 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
631 int ret = MEDIA_CONTENT_ERROR_NONE;
632 media_playlist_s *_playlist = (media_playlist_s*)playlist;
634 if (_playlist != NULL && STRING_VALID(playlist_name)) {
635 SAFE_FREE(_playlist->name);
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");
640 item->playlist_name = strdup(playlist_name);
641 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
642 if (item->playlist_name == NULL) {
644 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
645 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
648 _playlist->name = strdup(playlist_name);
649 if (_playlist->name == NULL) {
650 SAFE_FREE(item->playlist_name);
652 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
653 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
656 __media_playlist_item_add(_playlist, item);
658 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
659 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
665 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
667 int ret = MEDIA_CONTENT_ERROR_NONE;
668 media_playlist_s *_playlist = (media_playlist_s*)playlist;
670 if (_playlist != NULL && STRING_VALID(path)) {
671 SAFE_FREE(_playlist->thumbnail_path);
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");
676 item->thumbnail_path = g_strdup(path);
677 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
678 if (item->thumbnail_path == NULL) {
680 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
681 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
684 _playlist->thumbnail_path = strdup(path);
685 if (_playlist->thumbnail_path == NULL) {
686 SAFE_FREE(item->thumbnail_path);
688 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
689 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
692 __media_playlist_item_add(_playlist, item);
694 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
695 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
701 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
703 int ret = MEDIA_CONTENT_ERROR_NONE;
704 media_playlist_s *_playlist = (media_playlist_s*)playlist;
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");
710 item->playlist_member_id = playlist_member_id;
711 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
712 item->play_order = play_order;
714 __media_playlist_item_add(_playlist, item);
716 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
717 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
723 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
725 int ret = MEDIA_CONTENT_ERROR_NONE;
726 media_playlist_s *_playlist = (media_playlist_s*)playlist;
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");
732 item->media_id = strdup(media_id);
733 item->function = MEDIA_PLAYLIST_ADD;
735 if (item->media_id == NULL) {
737 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
738 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
741 __media_playlist_item_add(_playlist, item);
743 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
744 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
751 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
753 int ret = MEDIA_CONTENT_ERROR_NONE;
754 media_playlist_s *_playlist = (media_playlist_s*)playlist;
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");
760 item->playlist_member_id = playlist_member_id;
761 item->function = MEDIA_PLAYLIST_REMOVE;
763 __media_playlist_item_add(_playlist, item);
765 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
766 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
772 int media_playlist_update_to_db(media_playlist_h playlist)
774 int ret = MEDIA_CONTENT_ERROR_NONE;
775 media_playlist_s *_playlist = (media_playlist_s*)playlist;
778 media_playlist_item_s *_playlist_item = NULL;
780 if (_playlist == NULL) {
781 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
782 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
785 if (_playlist->item_list != NULL) {
786 length = g_list_length(_playlist->item_list);
788 media_content_debug("operation list length is 0");
789 return MEDIA_CONTENT_ERROR_NONE;
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:
798 ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
802 case MEDIA_PLAYLIST_REMOVE:
804 ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
808 case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
810 ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
814 case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
816 ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
820 case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
822 ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
830 if (ret != MEDIA_CONTENT_ERROR_NONE)
831 media_content_error("Failed some operation[%d]", _playlist_item->function);
835 ret = media_svc_send_query(_content_get_uid());
837 __media_playlist_item_release(_playlist);
839 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
842 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
844 int ret = MEDIA_CONTENT_ERROR_NONE;
845 char** import_item_list = NULL;
846 int import_item_count = 0;
848 char repl_path[MAX_PATH_LEN] = {0, };
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");
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");
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");
866 if (import_item_count == 0)
867 media_content_debug("The playlist from file is empty");
869 for (idx = 0; idx < import_item_count; idx++) {
870 filter_h filter = NULL;
871 char *media_id = NULL;
872 char *condition = NULL;
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");
881 condition = sqlite3_mprintf("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");
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);
895 SQLITE3_SAFE_FREE(condition);
896 media_content_error("error media_info_foreach_media_from_db");
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);
904 SQLITE3_SAFE_FREE(condition);
905 media_content_error("error media_playlist_add_media");
908 media_filter_destroy(filter);
910 SQLITE3_SAFE_FREE(condition);
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");
919 __media_playlist_destroy_import_item(import_item_list, import_item_count);
924 int media_playlist_export_to_file(media_playlist_h playlist, const char* path)
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, };
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");
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");
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");
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");
961 g_list_free_full(item_list, __media_playlist_destroy_export_item);
966 int media_playlist_create(media_playlist_h *playlist)
968 int ret = MEDIA_CONTENT_ERROR_NONE;
970 media_content_retvm_if(playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid playlist");
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");
975 _playlist->playlist_id = -1;
976 _playlist->name = NULL;
977 _playlist->thumbnail_path = NULL;
978 _playlist->item_list = NULL;
980 *playlist = (media_playlist_h)_playlist;
985 int media_playlist_get_play_order_v2(int playlist_id, int playlist_member_id, int *play_order)
987 int ret = MEDIA_CONTENT_ERROR_NONE;
988 sqlite3_stmt *stmt = NULL;
989 char select_query[DEFAULT_QUERY_SIZE] = {0, };
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;
996 memset(select_query, 0x00, sizeof(select_query));
998 snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
1000 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
1001 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1003 if (sqlite3_step(stmt) == SQLITE_ROW)
1004 *play_order = (int)sqlite3_column_int(stmt, 0);
1006 SQLITE3_FINALIZE(stmt);
1011 int media_playlist_insert_to_db_v2(media_playlist_h playlist)
1013 int ret = MEDIA_CONTENT_ERROR_NONE;
1014 media_playlist_s *_playlist = (media_playlist_s*)playlist;
1015 int playlist_id = 0;
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");
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");
1027 _playlist->playlist_id = playlist_id;
1029 ret = media_playlist_update_to_db(playlist);
1034 int media_playlist_update_to_db_v2(int playlist_id, media_playlist_h playlist)
1036 media_playlist_s *_playlist = (media_playlist_s*)playlist;
1038 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
1040 _playlist->playlist_id = playlist_id;
1042 return media_playlist_update_to_db(playlist);