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>
22 #include <media_util_private.h>
25 #define PLAYLIST_ARRAY_SIZE 20
26 #define PLAYLIST_ARRAY_EXPAND 10
27 #define MAX_TMP_STR 2048
29 static void __media_playlist_item_add(media_playlist_s *playlist, media_playlist_item_s *item_s);
30 static void __media_playlist_item_release(media_playlist_s *playlist);
31 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id);
32 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id);
33 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id);
34 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name);
35 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path);
36 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order);
37 static int __media_playlist_reset_file(const char* playlist_path);
38 static int __media_playlist_append_to_file(const char* playlist_path, const char* path);
39 static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count);
40 static int __media_playlist_destroy_import_item(char** item_list, int item_count);
41 static void __media_playlist_destroy_export_item(gpointer data);
43 static void __media_playlist_item_add(media_playlist_s *playlist, media_playlist_item_s *item_s)
45 playlist->item_list = g_list_append(playlist->item_list, item_s);
48 static void __media_playlist_item_release(media_playlist_s *playlist)
52 media_playlist_item_s *item = NULL;
54 list_cnt = g_list_length(playlist->item_list);
56 media_content_debug("list_cnt : [%d]", list_cnt);
58 for (idx = 0; idx < list_cnt; idx++) {
59 item = (media_playlist_item_s*)g_list_nth_data(playlist->item_list, idx);
61 SAFE_FREE(item->media_id);
62 SAFE_FREE(item->playlist_name);
63 SAFE_FREE(item->thumbnail_path);
68 g_list_free(playlist->item_list);
69 playlist->item_list = NULL;
73 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id)
75 int ret = MEDIA_CONTENT_ERROR_NONE;
76 char *query_str = NULL;
77 char *select_query = NULL;
78 sqlite3_stmt *stmt = NULL;
80 query_str = sqlite3_mprintf(INSERT_PLAYLIST_TO_PLAYLIST, playlist_name);
82 ret = _content_query_sql(query_str);
83 SQLITE3_SAFE_FREE(query_str);
84 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
86 select_query = sqlite3_mprintf(SELECT_PLAYLIST_ID_FROM_PLAYLIST, playlist_name);
88 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
89 SQLITE3_SAFE_FREE(select_query);
90 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
92 while (sqlite3_step(stmt) == SQLITE_ROW)
93 *playlist_id = (int)sqlite3_column_int(stmt, 0);
95 SQLITE3_FINALIZE(stmt);
97 return MEDIA_CONTENT_ERROR_NONE;
100 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id)
102 int ret = MEDIA_CONTENT_ERROR_NONE;
103 sqlite3_stmt *stmt = NULL;
104 char select_query[DEFAULT_QUERY_SIZE];
105 char *query_str = NULL;
108 memset(select_query, 0x00, sizeof(select_query));
110 snprintf(select_query, sizeof(select_query), SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id);
112 /* get the max play_order */
113 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
114 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
116 while (sqlite3_step(stmt) == SQLITE_ROW)
117 play_order = (int)sqlite3_column_int(stmt, 0);
119 SQLITE3_FINALIZE(stmt);
123 query_str = sqlite3_mprintf("INSERT INTO %q (playlist_id, media_uuid, play_order) values (%d, '%q', %d);",
124 DB_TABLE_PLAYLIST_MAP, playlist_id, media_id, play_order);
125 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
127 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
130 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id)
132 int ret = MEDIA_CONTENT_ERROR_NONE;
133 char *query_str = NULL;
135 query_str = sqlite3_mprintf(REMOVE_PLAYLIST_ITEM_FROM_PLAYLIST_MAP, playlist_id, playlist_member_id);
136 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
138 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
141 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name)
143 int ret = MEDIA_CONTENT_ERROR_NONE;
144 char *query_str = NULL;
146 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_NAME_FROM_PLAYLIST, playlist_name, playlist_id);
147 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
149 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
152 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path)
154 int ret = MEDIA_CONTENT_ERROR_NONE;
155 char *query_str = NULL;
157 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST, path, playlist_id);
158 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
160 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
163 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order)
165 int ret = MEDIA_CONTENT_ERROR_NONE;
166 char *query_str = NULL;
168 query_str = sqlite3_mprintf(UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP, play_order, playlist_id, playlist_member_id);
169 ret = media_svc_append_query(query_str, tzplatform_getuid(TZ_USER_NAME));
171 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
174 static bool __media_playlist_media_info_cb(media_info_h media, void *user_data)
176 int ret = MEDIA_CONTENT_ERROR_NONE;
177 char **media_id = (char**)user_data;
179 ret = media_info_get_media_id(media, media_id);
180 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_media_id fail");
185 static bool __media_playlist_member_cb(int playlist_member_id, media_info_h media, void *user_data)
187 int ret = MEDIA_CONTENT_ERROR_NONE;
188 GList **list = (GList**)user_data;
191 ret = media_info_get_file_path(media, &path);
192 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_file_path fail");
194 *list = g_list_append(*list, path);
199 static int __media_playlist_reset_file(const char* playlist_path)
203 fp = fopen(playlist_path, "wb");
204 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
206 fputs("", fp); /* remove previous playlist */
210 return MEDIA_CONTENT_ERROR_NONE;
213 static int __media_playlist_append_to_file(const char* playlist_path, const char* path)
217 fp = fopen(playlist_path, "a"); /* append only */
218 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
226 return MEDIA_CONTENT_ERROR_NONE;
229 static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count)
231 int current_index = 0;
232 int current_max_size = PLAYLIST_ARRAY_SIZE;
234 char *tmp_buf = NULL;
235 char *tmp_str = NULL;
236 char repl_item[MAX_QUERY_SIZE] = {0, };
239 long int file_size = 0;
241 *item_list = NULL; *item_count = 0;
243 fp = fopen(playlist_path, "rb");
244 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
246 fseek(fp, 0, SEEK_END);
247 file_size = ftell(fp);
248 fseek(fp, 0 , SEEK_SET);
250 if (file_size == 0) {
251 media_content_debug("file is empty.");
253 return MEDIA_CONTENT_ERROR_NONE;
256 *item_list = calloc(current_max_size, sizeof(char*));
257 tmp_str = malloc(MAX_QUERY_SIZE);
258 if (tmp_str == NULL || *item_list == NULL) {
260 SAFE_FREE(*item_list);
262 media_content_error("Out of Memory");
263 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
265 memset(tmp_str, 0, sizeof(MAX_QUERY_SIZE));
267 while (fgets(tmp_str, MAX_QUERY_SIZE, fp) != NULL) {
268 memset(repl_item, 0, sizeof(repl_item));
269 _media_content_replace_path(tmp_str, repl_item);
270 tmp_str_len = strlen(repl_item);
271 if (repl_item[tmp_str_len - 1] == '\n')
272 repl_item[tmp_str_len - 1] = '\0';
275 tmp_str = strndup(repl_item, strlen(repl_item));
277 if (tmp_str[0] != '#') {
278 if (!(current_index < (current_max_size - 1))) {
279 current_max_size += PLAYLIST_ARRAY_EXPAND;
280 char **tmp_ptr = calloc(current_max_size, sizeof(char*));
281 if (tmp_ptr == NULL) {
282 __media_playlist_destroy_import_item(*item_list, current_index);
284 media_content_error("Out of Memory");
286 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
288 memmove(tmp_ptr, *item_list, sizeof(char*) * current_index);
289 SAFE_FREE(*item_list);
290 *item_list = tmp_ptr;
293 (*item_list)[current_index] = malloc(tmp_str_len + 1);
294 if ((*item_list)[current_index] == NULL) {
295 __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], tmp_str, tmp_str_len);
307 tmp_buf += (tmp_str_len);
310 *item_count = current_index;
314 return MEDIA_CONTENT_ERROR_NONE;
317 static int __media_playlist_destroy_import_item(char** item_list, int item_count)
321 for (i = 0; i < item_count; ++i) {
322 SAFE_FREE(item_list[i]);
326 if (item_list != NULL) {
327 SAFE_FREE(item_list);
331 return MEDIA_CONTENT_ERROR_NONE;
334 static void __media_playlist_destroy_export_item(gpointer data)
340 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
342 int ret = MEDIA_CONTENT_ERROR_NONE;
345 if (!STRING_VALID(name)) {
346 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
347 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
350 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
351 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
353 ret = __media_playlist_insert_playlist_record(name, &playlist_id);
355 if (ret != MEDIA_CONTENT_ERROR_NONE) {
356 SAFE_FREE(_playlist);
360 _playlist->playlist_id = playlist_id;
361 _playlist->name = strdup(name);
363 if (_playlist->name == NULL) {
364 SAFE_FREE(_playlist);
365 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
366 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
369 *playlist = (media_playlist_h)_playlist;
374 int media_playlist_delete_from_db(int playlist_id)
376 int ret = MEDIA_CONTENT_ERROR_NONE;
377 char *query_str = NULL;
379 if (playlist_id < 0) {
380 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
381 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
384 query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
386 ret = _content_query_sql(query_str);
388 SQLITE3_SAFE_FREE(query_str);
393 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
395 int ret = MEDIA_CONTENT_ERROR_NONE;
397 if (playlist_count != NULL) {
398 ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
400 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
401 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
407 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
409 int ret = MEDIA_CONTENT_ERROR_NONE;
411 if (callback == NULL) {
412 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
413 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
416 ret = _media_db_get_playlist(filter, callback, user_data);
421 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
423 int ret = MEDIA_CONTENT_ERROR_NONE;
425 if ((playlist_id > 0) && (media_count != NULL)) {
426 ret = _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
428 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
429 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
435 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
437 int ret = MEDIA_CONTENT_ERROR_NONE;
439 if ((playlist_id > 0) && (callback != NULL)) {
440 ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
442 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
443 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
449 int media_playlist_destroy(media_playlist_h playlist)
451 int ret = MEDIA_CONTENT_ERROR_NONE;
452 media_playlist_s *_playlist = (media_playlist_s*)playlist;
455 SAFE_FREE(_playlist->name);
456 SAFE_FREE(_playlist->thumbnail_path);
457 SAFE_FREE(_playlist);
459 ret = MEDIA_CONTENT_ERROR_NONE;
461 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
462 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
468 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
470 int ret = MEDIA_CONTENT_ERROR_NONE;
471 media_playlist_s *_src = (media_playlist_s*)src;
474 media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
475 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
477 _dst->playlist_id = _src->playlist_id;
479 if (STRING_VALID(_src->name)) {
480 _dst->name = strdup(_src->name);
481 if (_dst->name == NULL) {
482 media_playlist_destroy((media_playlist_h)_dst);
483 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
484 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
488 *dst = (media_playlist_h)_dst;
490 ret = MEDIA_CONTENT_ERROR_NONE;
492 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
493 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
499 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
501 int ret = MEDIA_CONTENT_ERROR_NONE;
502 sqlite3_stmt *stmt = NULL;
503 char select_query[DEFAULT_QUERY_SIZE];
505 if (playlist_id > 0) {
506 memset(select_query, 0x00, sizeof(select_query));
508 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
510 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
511 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
513 media_playlist_s *_playlist = NULL;
515 while (sqlite3_step(stmt) == SQLITE_ROW) {
517 media_playlist_destroy((media_playlist_h)_playlist);
519 _playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
520 if (_playlist == NULL) {
521 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
522 SQLITE3_FINALIZE(stmt);
523 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
526 _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
527 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
528 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
530 *playlist = (media_playlist_h)_playlist;
533 SQLITE3_FINALIZE(stmt);
535 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
536 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
542 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
544 int ret = MEDIA_CONTENT_ERROR_NONE;
546 media_playlist_s *_playlist = (media_playlist_s*)playlist;
548 if ((_playlist != NULL) && (playlist_id != NULL)) {
549 *playlist_id = _playlist->playlist_id;
551 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
552 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
558 int media_playlist_get_name(media_playlist_h playlist, char **name)
560 int ret = MEDIA_CONTENT_ERROR_NONE;
561 media_playlist_s *_playlist = (media_playlist_s*)playlist;
563 if (STRING_VALID(_playlist->name)) {
564 *name = strdup(_playlist->name);
565 media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
570 ret = MEDIA_CONTENT_ERROR_NONE;
572 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
573 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
579 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
581 int ret = MEDIA_CONTENT_ERROR_NONE;
582 media_playlist_s *_playlist = (media_playlist_s*)playlist;
584 if (STRING_VALID(_playlist->thumbnail_path)) {
585 *path = strdup(_playlist->thumbnail_path);
586 media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
591 ret = MEDIA_CONTENT_ERROR_NONE;
593 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
594 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
600 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
602 int ret = MEDIA_CONTENT_ERROR_NONE;
603 media_playlist_s *_playlist = (media_playlist_s*)playlist;
605 sqlite3_stmt *stmt = NULL;
606 char select_query[DEFAULT_QUERY_SIZE];
608 if ((_playlist == NULL) || (playlist_member_id < 0) || (play_order == NULL)) {
609 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
610 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
613 playlist_id = _playlist->playlist_id;
615 memset(select_query, 0x00, sizeof(select_query));
617 snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
619 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
620 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
622 while (sqlite3_step(stmt) == SQLITE_ROW)
623 *play_order = (int)sqlite3_column_int(stmt, 0);
625 SQLITE3_FINALIZE(stmt);
630 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
632 int ret = MEDIA_CONTENT_ERROR_NONE;
633 media_playlist_s *_playlist = (media_playlist_s*)playlist;
635 if (_playlist != NULL && STRING_VALID(playlist_name)) {
636 SAFE_FREE(_playlist->name);
638 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
639 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
641 item->playlist_name = strdup(playlist_name);
642 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
643 if (item->playlist_name == NULL) {
645 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
646 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
649 _playlist->name = strdup(playlist_name);
650 if (_playlist->name == NULL) {
651 SAFE_FREE(item->playlist_name);
653 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
654 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
657 __media_playlist_item_add(_playlist, item);
659 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
660 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
666 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
668 int ret = MEDIA_CONTENT_ERROR_NONE;
669 media_playlist_s *_playlist = (media_playlist_s*)playlist;
670 char repl_path[MAX_QUERY_SIZE] = {0, };
672 if (_playlist != NULL && STRING_VALID(path)) {
673 SAFE_FREE(_playlist->thumbnail_path);
675 memset(repl_path, 0, sizeof(repl_path));
676 ret = _media_content_replace_path(path, repl_path);
677 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
679 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
680 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
682 item->thumbnail_path = strdup(repl_path);
683 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
684 if (item->thumbnail_path == NULL) {
686 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
687 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
690 _playlist->thumbnail_path = strdup(path);
691 if (_playlist->thumbnail_path == NULL) {
692 SAFE_FREE(item->thumbnail_path);
694 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
695 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
698 __media_playlist_item_add(_playlist, item);
700 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
701 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
707 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
709 int ret = MEDIA_CONTENT_ERROR_NONE;
710 media_playlist_s *_playlist = (media_playlist_s*)playlist;
712 if ((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0)) {
713 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
714 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
716 item->playlist_member_id = playlist_member_id;
717 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
718 item->play_order = play_order;
720 __media_playlist_item_add(_playlist, item);
722 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
723 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
729 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
731 int ret = MEDIA_CONTENT_ERROR_NONE;
732 media_playlist_s *_playlist = (media_playlist_s*)playlist;
734 if (_playlist != NULL && STRING_VALID(media_id)) {
735 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
736 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
738 item->media_id = strdup(media_id);
739 item->function = MEDIA_PLAYLIST_ADD;
741 if (item->media_id == NULL) {
743 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
744 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
747 __media_playlist_item_add(_playlist, item);
749 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
750 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
757 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
759 int ret = MEDIA_CONTENT_ERROR_NONE;
760 media_playlist_s *_playlist = (media_playlist_s*)playlist;
762 if ((_playlist != NULL) && (playlist_member_id > 0)) {
763 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
764 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
766 item->playlist_member_id = playlist_member_id;
767 item->function = MEDIA_PLAYLIST_REMOVE;
769 __media_playlist_item_add(_playlist, item);
771 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
772 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
778 int media_playlist_update_to_db(media_playlist_h playlist)
780 int ret = MEDIA_CONTENT_ERROR_NONE;
781 media_playlist_s *_playlist = (media_playlist_s*)playlist;
784 media_playlist_item_s *_playlist_item = NULL;
786 if (_playlist == NULL) {
787 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
788 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
791 if (_playlist->item_list != NULL) {
792 length = g_list_length(_playlist->item_list);
794 media_content_debug("operation list length is 0");
795 return MEDIA_CONTENT_ERROR_NONE;
798 for (idx = 0; idx < length; idx++) {
799 _playlist_item = (media_playlist_item_s*)g_list_nth_data(_playlist->item_list, idx);
800 if (_playlist_item != NULL) {
801 switch (_playlist_item->function) {
802 case MEDIA_PLAYLIST_ADD:
804 ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
808 case MEDIA_PLAYLIST_REMOVE:
810 ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
814 case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
816 ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
820 case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
822 ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
826 case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
828 ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
837 ret = media_svc_send_query(tzplatform_getuid(TZ_USER_NAME));
839 __media_playlist_item_release(_playlist);
841 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
844 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
846 int ret = MEDIA_CONTENT_ERROR_NONE;
847 char** import_item_list = NULL;
848 int import_item_count = 0;
850 char repl_path[MAX_QUERY_SIZE] = {0, };
852 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
853 media_content_retvm_if(!STRING_VALID(playlist_name), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_name");
854 memset(repl_path, 0, sizeof(repl_path));
855 ret = _media_content_replace_path(path, repl_path);
856 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
858 ret = media_playlist_insert_to_db(playlist_name, playlist);
859 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
861 ret = __media_playlist_import_item_from_file(repl_path, &import_item_list, &import_item_count);
862 if (ret != MEDIA_CONTENT_ERROR_NONE) {
863 __media_playlist_destroy_import_item(import_item_list, import_item_count);
864 media_content_error("Fail to get playlist from file");
868 if (import_item_count == 0)
869 media_content_debug("The playlist from file is empty");
871 for (idx = 0; idx < import_item_count; idx++) {
872 filter_h filter = NULL;
873 char *media_id = NULL;
874 char *condition = NULL;
876 ret = media_filter_create(&filter);
877 if (ret != MEDIA_CONTENT_ERROR_NONE) {
878 __media_playlist_destroy_import_item(import_item_list, import_item_count);
879 media_filter_destroy(filter);
880 media_content_error("error media_filter_create");
883 condition = sqlite3_mprintf("path = '%q'", import_item_list[idx]);
884 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
885 if (ret != MEDIA_CONTENT_ERROR_NONE) {
886 __media_playlist_destroy_import_item(import_item_list, import_item_count);
887 media_filter_destroy(filter);
888 SQLITE3_SAFE_FREE(condition);
889 media_content_error("error media_filter_set_condition");
892 ret = _media_db_get_group_item(NULL, filter, __media_playlist_media_info_cb, &media_id, MEDIA_GROUP_NONE);
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_info_foreach_media_from_db");
901 ret = media_playlist_add_media((media_playlist_h)*playlist, media_id);
902 if (ret != MEDIA_CONTENT_ERROR_NONE) {
903 __media_playlist_destroy_import_item(import_item_list, import_item_count);
904 media_filter_destroy(filter);
906 SQLITE3_SAFE_FREE(condition);
907 media_content_error("error media_playlist_add_media");
910 media_filter_destroy(filter);
912 SQLITE3_SAFE_FREE(condition);
915 ret = media_playlist_update_to_db(*playlist);
916 if (ret != MEDIA_CONTENT_ERROR_NONE) {
917 __media_playlist_destroy_import_item(import_item_list, import_item_count);
918 media_content_error("Fail to update playlist to db");
921 __media_playlist_destroy_import_item(import_item_list, import_item_count);
926 int media_playlist_export_to_file(media_playlist_h playlist, const char* path)
928 int ret = MEDIA_CONTENT_ERROR_NONE;
929 media_playlist_s *_playlist = (media_playlist_s*)playlist;
930 GList *item_list = NULL;
931 unsigned int idx = 0;
932 char repl_path[MAX_QUERY_SIZE] = {0, };
933 char repl_item[MAX_QUERY_SIZE] = {0, };
935 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
936 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
937 media_content_retvm_if(_playlist->playlist_id <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_id");
938 memset(repl_path, 0, sizeof(repl_path));
939 ret = _media_content_replace_path(path, repl_path);
940 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
942 ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
943 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
945 ret = __media_playlist_reset_file(repl_path);
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 init playlist file");
952 for (idx = 0; idx < g_list_length(item_list); idx++) {
953 char *item = g_list_nth_data(item_list, idx);
954 memset(repl_item, 0, sizeof(repl_item));
955 ret = _media_content_rollback_path(item, repl_item);
957 ret = __media_playlist_append_to_file(repl_path, repl_item);
958 if (ret != MEDIA_CONTENT_ERROR_NONE) {
959 g_list_free_full(item_list, __media_playlist_destroy_export_item);
960 media_content_error("Fail to export paths into file");
965 g_list_free_full(item_list, __media_playlist_destroy_export_item);