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[MAX_QUERY_SIZE] = {0, };
236 char repl_item[MAX_QUERY_SIZE] = {0, };
238 long int file_size = 0;
240 *item_list = NULL; *item_count = 0;
242 fp = fopen(playlist_path, "rb");
243 media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail");
245 fseek(fp, 0, SEEK_END);
246 file_size = ftell(fp);
247 fseek(fp, 0 , SEEK_SET);
249 if (file_size == 0) {
250 media_content_debug("file is empty.");
252 return MEDIA_CONTENT_ERROR_NONE;
255 *item_list = calloc(current_max_size, sizeof(char*));
256 if (*item_list == NULL) {
258 SAFE_FREE(*item_list);
259 media_content_error("Out of Memory");
260 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
262 memset(tmp_str, 0, sizeof(tmp_str));
264 while (fgets(tmp_str, MAX_QUERY_SIZE, fp) != NULL) {
265 memset(repl_item, 0, sizeof(repl_item));
266 _media_content_replace_path(tmp_str, repl_item);
267 tmp_str_len = strlen(repl_item);
268 if (tmp_str_len > 0 && repl_item[tmp_str_len - 1] == '\n')
269 repl_item[tmp_str_len - 1] = '\0';
271 tmp_str_len = strlen(repl_item);
273 if (tmp_str_len > 0 && repl_item[0] != '#') {
274 if (!(current_index < (current_max_size - 1))) {
275 current_max_size += PLAYLIST_ARRAY_EXPAND;
276 char **tmp_ptr = calloc(current_max_size, sizeof(char*));
277 if (tmp_ptr == NULL) {
278 __media_playlist_destroy_import_item(*item_list, current_index);
279 media_content_error("Out of Memory");
281 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
283 memmove(tmp_ptr, *item_list, sizeof(char*) * current_index);
284 SAFE_FREE(*item_list);
285 *item_list = tmp_ptr;
288 (*item_list)[current_index] = malloc(tmp_str_len + 1);
289 if ((*item_list)[current_index] == NULL) {
290 __media_playlist_destroy_import_item(*item_list, current_index);
291 media_content_error("Out of Memory");
293 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
295 memset((*item_list)[current_index], 0, tmp_str_len + 1);
296 memmove((*item_list)[current_index], repl_item, tmp_str_len);
301 tmp_buf += (tmp_str_len);
304 *item_count = current_index;
307 return MEDIA_CONTENT_ERROR_NONE;
310 static int __media_playlist_destroy_import_item(char** item_list, int item_count)
314 for (i = 0; i < item_count; ++i) {
315 SAFE_FREE(item_list[i]);
319 if (item_list != NULL) {
320 SAFE_FREE(item_list);
324 return MEDIA_CONTENT_ERROR_NONE;
327 static void __media_playlist_destroy_export_item(gpointer data)
333 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
335 int ret = MEDIA_CONTENT_ERROR_NONE;
338 if (!STRING_VALID(name)) {
339 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
340 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
343 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
344 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
346 ret = __media_playlist_insert_playlist_record(name, &playlist_id);
348 if (ret != MEDIA_CONTENT_ERROR_NONE) {
349 SAFE_FREE(_playlist);
353 _playlist->playlist_id = playlist_id;
354 _playlist->name = strdup(name);
356 if (_playlist->name == NULL) {
357 SAFE_FREE(_playlist);
358 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
359 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
362 *playlist = (media_playlist_h)_playlist;
367 int media_playlist_delete_from_db(int playlist_id)
369 int ret = MEDIA_CONTENT_ERROR_NONE;
370 char *query_str = NULL;
372 if (playlist_id < 0) {
373 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
374 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
377 query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
379 ret = _content_query_sql(query_str);
381 SQLITE3_SAFE_FREE(query_str);
386 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
388 int ret = MEDIA_CONTENT_ERROR_NONE;
390 if (playlist_count != NULL) {
391 ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
393 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
394 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
400 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
402 int ret = MEDIA_CONTENT_ERROR_NONE;
404 if (callback == NULL) {
405 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
406 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
409 ret = _media_db_get_playlist(filter, callback, user_data);
414 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
416 int ret = MEDIA_CONTENT_ERROR_NONE;
418 if ((playlist_id > 0) && (media_count != NULL)) {
419 ret = _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
421 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
422 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
428 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
430 int ret = MEDIA_CONTENT_ERROR_NONE;
432 if ((playlist_id > 0) && (callback != NULL)) {
433 ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
435 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
436 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
442 int media_playlist_destroy(media_playlist_h playlist)
444 int ret = MEDIA_CONTENT_ERROR_NONE;
445 media_playlist_s *_playlist = (media_playlist_s*)playlist;
448 SAFE_FREE(_playlist->name);
449 SAFE_FREE(_playlist->thumbnail_path);
450 SAFE_FREE(_playlist);
452 ret = MEDIA_CONTENT_ERROR_NONE;
454 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
455 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
461 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
463 int ret = MEDIA_CONTENT_ERROR_NONE;
464 media_playlist_s *_src = (media_playlist_s*)src;
467 media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
468 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
470 _dst->playlist_id = _src->playlist_id;
472 if (STRING_VALID(_src->name)) {
473 _dst->name = strdup(_src->name);
474 if (_dst->name == NULL) {
475 media_playlist_destroy((media_playlist_h)_dst);
476 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
477 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
481 *dst = (media_playlist_h)_dst;
483 ret = MEDIA_CONTENT_ERROR_NONE;
485 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
486 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
492 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
494 int ret = MEDIA_CONTENT_ERROR_NONE;
495 sqlite3_stmt *stmt = NULL;
496 char select_query[DEFAULT_QUERY_SIZE];
498 if (playlist_id > 0) {
499 memset(select_query, 0x00, sizeof(select_query));
501 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
503 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
504 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
506 media_playlist_s *_playlist = NULL;
508 while (sqlite3_step(stmt) == SQLITE_ROW) {
510 media_playlist_destroy((media_playlist_h)_playlist);
512 _playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
513 if (_playlist == NULL) {
514 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
515 SQLITE3_FINALIZE(stmt);
516 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
519 _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
520 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
521 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
523 *playlist = (media_playlist_h)_playlist;
526 SQLITE3_FINALIZE(stmt);
528 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
529 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
535 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
537 int ret = MEDIA_CONTENT_ERROR_NONE;
539 media_playlist_s *_playlist = (media_playlist_s*)playlist;
541 if ((_playlist != NULL) && (playlist_id != NULL)) {
542 *playlist_id = _playlist->playlist_id;
544 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
545 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
551 int media_playlist_get_name(media_playlist_h playlist, char **name)
553 int ret = MEDIA_CONTENT_ERROR_NONE;
554 media_playlist_s *_playlist = (media_playlist_s*)playlist;
556 if (STRING_VALID(_playlist->name)) {
557 *name = strdup(_playlist->name);
558 media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
563 ret = MEDIA_CONTENT_ERROR_NONE;
565 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
566 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
572 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
574 int ret = MEDIA_CONTENT_ERROR_NONE;
575 media_playlist_s *_playlist = (media_playlist_s*)playlist;
577 if (STRING_VALID(_playlist->thumbnail_path)) {
578 *path = strdup(_playlist->thumbnail_path);
579 media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
584 ret = MEDIA_CONTENT_ERROR_NONE;
586 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
587 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
593 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
595 int ret = MEDIA_CONTENT_ERROR_NONE;
596 media_playlist_s *_playlist = (media_playlist_s*)playlist;
598 sqlite3_stmt *stmt = NULL;
599 char select_query[DEFAULT_QUERY_SIZE];
601 if ((_playlist == NULL) || (playlist_member_id < 0) || (play_order == NULL)) {
602 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
603 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
606 playlist_id = _playlist->playlist_id;
608 memset(select_query, 0x00, sizeof(select_query));
610 snprintf(select_query, sizeof(select_query), SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
612 ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
613 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
615 while (sqlite3_step(stmt) == SQLITE_ROW)
616 *play_order = (int)sqlite3_column_int(stmt, 0);
618 SQLITE3_FINALIZE(stmt);
623 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
625 int ret = MEDIA_CONTENT_ERROR_NONE;
626 media_playlist_s *_playlist = (media_playlist_s*)playlist;
628 if (_playlist != NULL && STRING_VALID(playlist_name)) {
629 SAFE_FREE(_playlist->name);
631 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
632 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
634 item->playlist_name = strdup(playlist_name);
635 item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
636 if (item->playlist_name == NULL) {
638 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
639 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
642 _playlist->name = strdup(playlist_name);
643 if (_playlist->name == NULL) {
644 SAFE_FREE(item->playlist_name);
646 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
647 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
650 __media_playlist_item_add(_playlist, item);
652 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
653 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
659 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
661 int ret = MEDIA_CONTENT_ERROR_NONE;
662 media_playlist_s *_playlist = (media_playlist_s*)playlist;
664 if (_playlist != NULL && STRING_VALID(path)) {
665 SAFE_FREE(_playlist->thumbnail_path);
667 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
668 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
670 item->thumbnail_path = g_strdup(path);
671 item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
672 if (item->thumbnail_path == NULL) {
674 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
675 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
678 _playlist->thumbnail_path = strdup(path);
679 if (_playlist->thumbnail_path == NULL) {
680 SAFE_FREE(item->thumbnail_path);
682 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
683 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
686 __media_playlist_item_add(_playlist, item);
688 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
689 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
695 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
697 int ret = MEDIA_CONTENT_ERROR_NONE;
698 media_playlist_s *_playlist = (media_playlist_s*)playlist;
700 if ((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0)) {
701 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
702 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
704 item->playlist_member_id = playlist_member_id;
705 item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
706 item->play_order = play_order;
708 __media_playlist_item_add(_playlist, item);
710 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
711 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
717 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
719 int ret = MEDIA_CONTENT_ERROR_NONE;
720 media_playlist_s *_playlist = (media_playlist_s*)playlist;
722 if (_playlist != NULL && STRING_VALID(media_id)) {
723 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
724 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
726 item->media_id = strdup(media_id);
727 item->function = MEDIA_PLAYLIST_ADD;
729 if (item->media_id == NULL) {
731 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
732 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
735 __media_playlist_item_add(_playlist, item);
737 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
738 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
745 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
747 int ret = MEDIA_CONTENT_ERROR_NONE;
748 media_playlist_s *_playlist = (media_playlist_s*)playlist;
750 if ((_playlist != NULL) && (playlist_member_id > 0)) {
751 media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
752 media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
754 item->playlist_member_id = playlist_member_id;
755 item->function = MEDIA_PLAYLIST_REMOVE;
757 __media_playlist_item_add(_playlist, item);
759 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
760 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
766 int media_playlist_update_to_db(media_playlist_h playlist)
768 int ret = MEDIA_CONTENT_ERROR_NONE;
769 media_playlist_s *_playlist = (media_playlist_s*)playlist;
772 media_playlist_item_s *_playlist_item = NULL;
774 if (_playlist == NULL) {
775 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
776 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
779 if (_playlist->item_list != NULL) {
780 length = g_list_length(_playlist->item_list);
782 media_content_debug("operation list length is 0");
783 return MEDIA_CONTENT_ERROR_NONE;
786 for (idx = 0; idx < length; idx++) {
787 _playlist_item = (media_playlist_item_s*)g_list_nth_data(_playlist->item_list, idx);
788 if (_playlist_item != NULL) {
789 switch (_playlist_item->function) {
790 case MEDIA_PLAYLIST_ADD:
792 ret = __media_playlist_insert_item_to_playlist(_playlist->playlist_id, _playlist_item->media_id);
796 case MEDIA_PLAYLIST_REMOVE:
798 ret = __media_playlist_remove_item_from_playlist(_playlist->playlist_id, _playlist_item->playlist_member_id);
802 case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
804 ret = __media_playlist_update_playlist_name(_playlist->playlist_id, _playlist_item->playlist_name);
808 case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
810 ret = __media_playlist_update_thumbnail_path(_playlist->playlist_id, _playlist_item->thumbnail_path);
814 case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
816 ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
825 ret = media_svc_send_query(tzplatform_getuid(TZ_USER_NAME));
827 __media_playlist_item_release(_playlist);
829 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
832 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
834 int ret = MEDIA_CONTENT_ERROR_NONE;
835 char** import_item_list = NULL;
836 int import_item_count = 0;
838 char repl_path[MAX_PATH_LEN] = {0, };
840 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
841 media_content_retvm_if(!STRING_VALID(playlist_name), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_name");
842 memset(repl_path, 0, sizeof(repl_path));
843 ret = _media_content_replace_path(path, repl_path);
844 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
846 ret = media_playlist_insert_to_db(playlist_name, playlist);
847 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
849 ret = __media_playlist_import_item_from_file(repl_path, &import_item_list, &import_item_count);
850 if (ret != MEDIA_CONTENT_ERROR_NONE) {
851 __media_playlist_destroy_import_item(import_item_list, import_item_count);
852 media_content_error("Fail to get playlist from file");
856 if (import_item_count == 0)
857 media_content_debug("The playlist from file is empty");
859 for (idx = 0; idx < import_item_count; idx++) {
860 filter_h filter = NULL;
861 char *media_id = NULL;
862 char *condition = NULL;
864 ret = media_filter_create(&filter);
865 if (ret != MEDIA_CONTENT_ERROR_NONE) {
866 __media_playlist_destroy_import_item(import_item_list, import_item_count);
867 media_filter_destroy(filter);
868 media_content_error("error media_filter_create");
871 condition = sqlite3_mprintf("path = '%q'", import_item_list[idx]);
872 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
873 if (ret != MEDIA_CONTENT_ERROR_NONE) {
874 __media_playlist_destroy_import_item(import_item_list, import_item_count);
875 media_filter_destroy(filter);
876 SQLITE3_SAFE_FREE(condition);
877 media_content_error("error media_filter_set_condition");
880 ret = _media_db_get_group_item(NULL, filter, __media_playlist_media_info_cb, &media_id, MEDIA_GROUP_NONE);
881 if (ret != MEDIA_CONTENT_ERROR_NONE) {
882 __media_playlist_destroy_import_item(import_item_list, import_item_count);
883 media_filter_destroy(filter);
885 SQLITE3_SAFE_FREE(condition);
886 media_content_error("error media_info_foreach_media_from_db");
889 ret = media_playlist_add_media((media_playlist_h)*playlist, media_id);
890 if (ret != MEDIA_CONTENT_ERROR_NONE) {
891 __media_playlist_destroy_import_item(import_item_list, import_item_count);
892 media_filter_destroy(filter);
894 SQLITE3_SAFE_FREE(condition);
895 media_content_error("error media_playlist_add_media");
898 media_filter_destroy(filter);
900 SQLITE3_SAFE_FREE(condition);
903 ret = media_playlist_update_to_db(*playlist);
904 if (ret != MEDIA_CONTENT_ERROR_NONE) {
905 __media_playlist_destroy_import_item(import_item_list, import_item_count);
906 media_content_error("Fail to update playlist to db");
909 __media_playlist_destroy_import_item(import_item_list, import_item_count);
914 int media_playlist_export_to_file(media_playlist_h playlist, const char* path)
916 int ret = MEDIA_CONTENT_ERROR_NONE;
917 media_playlist_s *_playlist = (media_playlist_s*)playlist;
918 GList *item_list = NULL;
919 unsigned int idx = 0;
920 char repl_path[MAX_PATH_LEN] = {0, };
921 char repl_item[MAX_QUERY_SIZE] = {0, };
923 media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
924 media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist");
925 media_content_retvm_if(_playlist->playlist_id <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_id");
926 memset(repl_path, 0, sizeof(repl_path));
927 ret = _media_content_replace_path(path, repl_path);
928 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
930 ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
931 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
933 ret = __media_playlist_reset_file(repl_path);
934 if (ret != MEDIA_CONTENT_ERROR_NONE) {
935 g_list_free_full(item_list, __media_playlist_destroy_export_item);
936 media_content_error("Fail to init playlist file");
940 for (idx = 0; idx < g_list_length(item_list); idx++) {
941 char *item = g_list_nth_data(item_list, idx);
942 memset(repl_item, 0, sizeof(repl_item));
943 ret = _media_content_rollback_path(item, repl_item);
945 ret = __media_playlist_append_to_file(repl_path, repl_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");
953 g_list_free_full(item_list, __media_playlist_destroy_export_item);