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_content.h>
19 #include <media_info_private.h>
20 #include <media_util_private.h>
22 static const char * __media_db_get_group_name(media_group_e group)
25 case MEDIA_CONTENT_GROUP_DISPLAY_NAME:
26 return DB_FIELD_MEDIA_DISPLAY_NAME;
27 case MEDIA_CONTENT_GROUP_TYPE:
28 return DB_FIELD_MEDIA_TYPE;
29 case MEDIA_CONTENT_GROUP_MIME_TYPE:
30 return DB_FIELD_MEDIA_MIME_TYPE;
31 case MEDIA_CONTENT_GROUP_SIZE:
32 return DB_FIELD_MEDIA_SIZE;
33 case MEDIA_CONTENT_GROUP_ADDED_TIME:
34 return DB_FIELD_MEDIA_ADDED_TIME;
35 case MEDIA_CONTENT_GROUP_MODIFIED_TIME:
36 return DB_FIELD_MEDIA_MODIFIED_TIME;
37 case MEDIA_CONTENT_GROUP_TITLE:
38 return DB_FIELD_MEDIA_TITLE;
39 case MEDIA_CONTENT_GROUP_ARTIST:
40 return DB_FIELD_MEDIA_ARTIST;
41 case MEDIA_CONTENT_GROUP_ALBUM_ARTIST:
42 return DB_FIELD_MEDIA_ALBUM_ARTIST;
43 case MEDIA_CONTENT_GROUP_GENRE:
44 return DB_FIELD_MEDIA_GENRE;
45 case MEDIA_CONTENT_GROUP_COMPOSER:
46 return DB_FIELD_MEDIA_COMPOSER;
47 case MEDIA_CONTENT_GROUP_YEAR:
48 return DB_FIELD_MEDIA_YEAR;
49 case MEDIA_CONTENT_GROUP_RECORDED_DATE:
50 return DB_FIELD_MEDIA_RECORDED_DATE;
51 case MEDIA_CONTENT_GROUP_COPYRIGHT:
52 return DB_FIELD_MEDIA_COPYRIGHT;
53 case MEDIA_CONTENT_GROUP_TRACK_NUM:
54 return DB_FIELD_MEDIA_TRACK_NUM;
55 case MEDIA_CONTENT_GROUP_DESCRIPTION:
56 return DB_FIELD_MEDIA_DESCRIPTION;
57 case MEDIA_CONTENT_GROUP_LONGITUDE:
58 return DB_FIELD_MEDIA_LONGITUDE;
59 case MEDIA_CONTENT_GROUP_LATITUDE:
60 return DB_FIELD_MEDIA_LATITUDE;
61 case MEDIA_CONTENT_GROUP_ALTITUDE:
62 return DB_FIELD_MEDIA_ALTITUDE;
63 case MEDIA_CONTENT_GROUP_RATING:
64 return DB_FIELD_MEDIA_RATING;
66 case MEDIA_CONTENT_GROUP_MODIFIED_DATE:
67 return DB_FIELD_MEDIA_MODIFIED_DATE;
68 case MEDIA_CONTENT_GROUP_ALBUM:
69 return DB_FIELD_MEDIA_ALBUM;
70 case MEDIA_PVR_GROUP_DURATION:
71 return DB_FIELD_PVR_DURATION;
72 case MEDIA_PVR_GROUP_TIME_ZONE:
73 return DB_FIELD_PVR_TIME_ZONE;
74 case MEDIA_PVR_GROUP_PTC:
75 return DB_FIELD_PVR_PTC;
76 case MEDIA_PVR_GROUP_MAJOR:
77 return DB_FIELD_PVR_MAJOR;
78 case MEDIA_PVR_GROUP_MINOR:
79 return DB_FIELD_PVR_MINOR;
80 case MEDIA_PVR_GROUP_CHANNEL_TYPE:
81 return DB_FIELD_PVR_CHANNEL_TYPE;
82 case MEDIA_PVR_GROUP_CHANNEL_NAME:
83 return DB_FIELD_PVR_CHANNEL_NAME;
84 case MEDIA_PVR_GROUP_CHANNEL_NUM:
85 return DB_FIELD_PVR_CHANNEL_NUM;
86 case MEDIA_PVR_GROUP_PROGRAM_TITLE:
87 return DB_FIELD_PVR_PROGRAM_TITLE;
88 case MEDIA_PVR_GROUP_PROGRAM_NUM:
89 return DB_FIELD_PVR_PROGRAM_NUM;
90 case MEDIA_PVR_GROUP_PROGRAM_CRID:
91 return DB_FIELD_PVR_PROGRAM_CRID;
92 case MEDIA_PVR_GROUP_GUIDANCE:
93 return DB_FIELD_PVR_GUIDANCE;
94 case MEDIA_PVR_GROUP_SYNOPSIS:
95 return DB_FIELD_PVR_SYNOPSIS;
96 case MEDIA_PVR_GROUP_GENRE:
97 return DB_FIELD_PVR_GENRE;
98 case MEDIA_PVR_GROUP_LANGUAGE:
99 return DB_FIELD_PVR_LANGUAGE;
100 case MEDIA_PVR_GROUP_EMBARGO_TIME:
101 return DB_FIELD_PVR_EMBARGO_TIME;
102 case MEDIA_PVR_GROUP_EXPIRY_TIME:
103 return DB_FIELD_PVR_EXPIRY_TIME;
104 case MEDIA_PVR_GROUP_START_TIME:
105 return DB_FIELD_PVR_START_TIME;
106 case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
107 return DB_FIELD_PVR_PROGRAM_START_TIME;
108 case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
109 return DB_FIELD_PVR_PROGRAM_END_TIME;
110 case MEDIA_PVR_GROUP_PROGRAM_DATE:
111 return DB_FIELD_PVR_PROGRAM_DATE;
112 case MEDIA_PVR_GROUP_PARENTAL_RATING:
113 return DB_FIELD_PVR_PARENTAL_RATING;
114 case MEDIA_PVR_GROUP_TIMER_RECORD:
115 return DB_FIELD_PVR_TIMER_RECORD;
116 case MEDIA_PVR_GROUP_SERIES_RECORD:
117 return DB_FIELD_PVR_SERIES_RECORD;
118 case MEDIA_PVR_GROUP_HD:
119 return DB_FIELD_PVR_HD;
120 case MEDIA_PVR_GROUP_SUBTITLE:
121 return DB_FIELD_PVR_SUBTITLE;
122 case MEDIA_PVR_GROUP_TTX:
123 return DB_FIELD_PVR_TTX;
124 case MEDIA_PVR_GROUP_AD:
125 return DB_FIELD_PVR_AD;
126 case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
127 return DB_FIELD_PVR_HARDOF_HEARINGRADIO;
128 case MEDIA_PVR_GROUP_DATA_SERVICE:
129 return DB_FIELD_PVR_DATA_SERVICE;
130 case MEDIA_PVR_GROUP_CONTENT_LOCK:
131 return DB_FIELD_PVR_CONTENT_LOCK;
132 case MEDIA_PVR_GROUP_CONTENT_WATCH:
133 return DB_FIELD_PVR_CONTENT_WATCH;
134 case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
135 return DB_FIELD_PVR_HAS_AUDIO_ONLY;
136 case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
137 return DB_FIELD_PVR_IS_LOCAL_RECORD;
138 case MEDIA_PVR_GROUP_RESOLUTION:
139 return DB_FIELD_PVR_RESOLUTION;
140 case MEDIA_PVR_GROUP_ASPECTRATIO:
141 return DB_FIELD_PVR_ASPECTRATIO;
142 case MEDIA_PVR_GROUP_MODIFIED_MONTH:
143 return DB_FIELD_PVR_MODIFIED_DATE;
144 case MEDIA_PVR_GROUP_MODIFIED_DATE:
145 return DB_FIELD_PVR_MODIFIED_DATE;
146 case MEDIA_PVR_GROUP_SPORTS_TYPE:
147 return DB_FIELD_PVR_SPORTS_TYPE;
148 case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
149 return DB_FIELD_PVR_GUIDANCE_LENGTH;
150 case MEDIA_PVR_GROUP_TVMODE:
151 return DB_FIELD_PVR_TVMODE;
152 case MEDIA_PVR_GROUP_PLAY_COUNT:
153 return DB_FIELD_PVR_PLAY_COUNT;
154 case MEDIA_PVR_GROUP_PRIVATE_DATA:
155 return DB_FIELD_PVR_PRIVATE_DATA;
156 case MEDIA_UHD_GROUP_CONTENT_TITLE:
157 return DB_FIELD_UHD_CONTENT_TITLE;
158 case MEDIA_UHD_GROUP_RELEASE_DATE:
159 return DB_FIELD_UHD_RELEASE_DATE;
160 case MEDIA_UHD_GROUP_SUB_TYPE:
161 return DB_FIELD_UHD_SUB_TYPE;
162 case MEDIA_UHD_GROUP_FILE_NAME:
163 return DB_FIELD_UHD_FILE_NAME;
164 case MEDIA_UHD_GROUP_PLAYED_COUNT:
165 return DB_FIELD_UHD_PLAYED_COUNT;
174 static int __media_db_make_query(filter_h filter, char **condition_query, char **option_query)
176 int ret = MEDIA_CONTENT_ERROR_NONE;
177 filter_s *_filter = (filter_s *)filter;
179 content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
181 if (STRING_VALID(_filter->condition)) {
182 ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
183 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
186 ret = _media_filter_build_option(filter, option_query);
187 if (ret != MEDIA_CONTENT_ERROR_NONE)
188 g_free(*condition_query);
193 #ifdef _USE_TVPD_MODE
194 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
196 int ret = MEDIA_CONTENT_ERROR_NONE;
197 sqlite3_stmt *stmt = NULL;
198 char *select_query = NULL;
199 char *condition_query = NULL;
200 char *option_query = NULL;
201 filter_s *_filter = (filter_s *)filter;
203 switch (group_type) {
204 case MEDIA_GROUP_ALBUM:
205 if (_filter && STRING_VALID(_filter->storage_id))
206 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, _filter->storage_id);
208 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
211 case MEDIA_GROUP_FOLDER:
212 if (_filter && STRING_VALID(_filter->storage_id))
213 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
215 select_query = g_strdup_printf(SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
218 case MEDIA_GROUP_PLAYLIST:
219 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
222 case MEDIA_GROUP_TAG:
223 select_query = g_strdup(SELECT_TAG_COUNT);
226 case MEDIA_GROUP_BOOKMARK:
227 if (_filter && STRING_VALID(_filter->storage_id))
228 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, _filter->storage_id);
230 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
234 case MEDIA_GROUP_FACE:
235 if (_filter && STRING_VALID(_filter->storage_id))
236 select_query = g_strdup_printf(SELECT_FACE_COUNT, _filter->storage_id);
238 select_query = g_strdup_printf(SELECT_FACE_COUNT, DB_VIEW_MEDIA);
242 content_error("Invalid group type [%d]", group_type);
243 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
246 ret = __media_db_make_query(filter, &condition_query, &option_query);
247 if (ret != MEDIA_CONTENT_ERROR_NONE) {
248 g_free(select_query);
252 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
253 g_free(select_query);
254 g_free(condition_query);
255 g_free(option_query);
256 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
258 if (sqlite3_step(stmt) == SQLITE_ROW)
259 *group_count = sqlite3_column_int(stmt, 0);
261 SQLITE3_FINALIZE(stmt);
266 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
268 int ret = MEDIA_CONTENT_ERROR_NONE;
269 sqlite3_stmt *stmt = NULL;
270 char select_query[MAX_QUERY_SIZE] = {0, };
271 char *condition_query = NULL;
272 char *option_query = NULL;
273 char *tmp_option = NULL;
274 filter_s *_filter = (filter_s *)filter;
276 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
277 if (_filter && STRING_VALID(_filter->storage_id))
278 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
280 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
281 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
282 if (_filter && STRING_VALID(_filter->storage_id))
283 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
285 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
286 } else { /*uhd content*/
287 if (_filter && STRING_VALID(_filter->storage_id))
288 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
290 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
292 ret = __media_db_make_query(filter, &condition_query, &option_query);
293 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
296 tmp_option = g_strconcat(option_query, ")", NULL);
297 g_free(option_query);
298 option_query = tmp_option;
300 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
303 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
304 g_free(condition_query);
305 g_free(option_query);
306 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
308 if (sqlite3_step(stmt) == SQLITE_ROW)
309 *group_count = sqlite3_column_int(stmt, 0);
311 SQLITE3_FINALIZE(stmt);
316 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
318 int ret = MEDIA_CONTENT_ERROR_NONE;
319 char select_query[MAX_QUERY_SIZE] = {0, };
320 char *condition_query = NULL;
321 char *option_query = NULL;
323 sqlite3_stmt *stmt = NULL;
324 filter_s *_filter = (filter_s *)filter;
326 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
327 if (_filter && STRING_VALID(_filter->storage_id))
328 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
330 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
331 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
332 if (_filter && STRING_VALID(_filter->storage_id))
333 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
335 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
336 } else { /* uhd content */
337 if (_filter && STRING_VALID(_filter->storage_id))
338 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
340 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
342 ret = __media_db_make_query(filter, &condition_query, &option_query);
343 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
345 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
346 g_free(condition_query);
347 g_free(option_query);
348 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
350 while (sqlite3_step(stmt) == SQLITE_ROW) {
351 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
353 if (callback(name, user_data) == false) {
361 SQLITE3_FINALIZE(stmt);
366 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
368 int ret = MEDIA_CONTENT_ERROR_NONE;
369 char select_query[DEFAULT_QUERY_SIZE] = {0, };
370 char group_query[DEFAULT_QUERY_SIZE] = {0, };
371 char *condition_query = NULL;
372 char *option_query = NULL;
374 sqlite3_stmt *stmt = NULL;
375 filter_s *_filter = (filter_s *)filter;
377 const char* group_name = __media_db_get_group_name(group);
378 content_retip_if_fail(STRING_VALID(group_name));
380 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
381 if (_filter && STRING_VALID(_filter->storage_id))
382 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
384 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
385 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
386 if (_filter && STRING_VALID(_filter->storage_id))
387 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
389 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
390 } else {/*uhd content*/
391 if (_filter && STRING_VALID(_filter->storage_id))
392 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
394 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
397 ret = __media_db_make_query(filter, &condition_query, &option_query);
398 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
400 if (STRING_VALID(option_query))
401 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
403 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
405 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
406 g_free(condition_query);
407 g_free(option_query);
408 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
410 while (sqlite3_step(stmt) == SQLITE_ROW) {
411 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
413 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
421 SQLITE3_FINALIZE(stmt);
426 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
428 int ret = MEDIA_CONTENT_ERROR_NONE;
429 sqlite3_stmt *stmt = NULL;
430 char *select_query = NULL;
431 char *condition_query = NULL;
432 char *option_query = NULL;
434 switch (group_type) {
435 case MEDIA_GROUP_ALBUM:
436 select_query = g_strdup(SELECT_ALBUM_COUNT);
439 case MEDIA_GROUP_FOLDER:
440 select_query = g_strdup(SELECT_FOLDER_COUNT);
443 case MEDIA_GROUP_PLAYLIST:
444 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
447 case MEDIA_GROUP_TAG:
448 select_query = g_strdup(SELECT_TAG_COUNT);
451 case MEDIA_GROUP_BOOKMARK:
452 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
455 case MEDIA_GROUP_FACE:
456 select_query = g_strdup(SELECT_FACE_COUNT);
460 content_error("Invalid group type [%d]", group_type);
461 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
464 ret = __media_db_make_query(filter, &condition_query, &option_query);
465 if (ret != MEDIA_CONTENT_ERROR_NONE) {
466 g_free(select_query);
470 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
471 g_free(select_query);
472 g_free(condition_query);
473 g_free(option_query);
474 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
476 if (sqlite3_step(stmt) == SQLITE_ROW)
477 *group_count = sqlite3_column_int(stmt, 0);
479 SQLITE3_FINALIZE(stmt);
484 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
486 int ret = MEDIA_CONTENT_ERROR_NONE;
487 sqlite3_stmt *stmt = NULL;
488 char *select_query = NULL;
489 char *condition_query = NULL;
490 char *option_query = NULL;
492 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
494 ret = __media_db_make_query(filter, &condition_query, &option_query);
495 if (ret != MEDIA_CONTENT_ERROR_NONE) {
496 g_free(select_query);
500 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
501 g_free(select_query);
502 g_free(condition_query);
503 g_free(option_query);
504 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
506 if (sqlite3_step(stmt) == SQLITE_ROW)
507 *group_count = sqlite3_column_int(stmt, 0);
509 SQLITE3_FINALIZE(stmt);
514 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
516 int ret = MEDIA_CONTENT_ERROR_NONE;
517 char *select_query = NULL;
518 char *condition_query = NULL;
519 char *option_query = NULL;
521 sqlite3_stmt *stmt = NULL;
523 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
525 ret = __media_db_make_query(filter, &condition_query, &option_query);
526 if (ret != MEDIA_CONTENT_ERROR_NONE) {
527 g_free(select_query);
531 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
532 g_free(select_query);
533 g_free(condition_query);
534 g_free(option_query);
535 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
537 while (sqlite3_step(stmt) == SQLITE_ROW) {
538 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
540 if (callback(name, user_data) == false) {
548 SQLITE3_FINALIZE(stmt);
554 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
556 int ret = MEDIA_CONTENT_ERROR_NONE;
557 char *select_query = NULL;
558 char *condition_query = NULL;
559 char *option_query = NULL;
560 sqlite3_stmt *stmt = NULL;
561 #ifdef _USE_TVPD_MODE
562 filter_s *_filter = (filter_s *)filter;
563 if (_filter && STRING_VALID(_filter->storage_id))
564 select_query = g_strdup_printf(SELECT_ALBUM_LIST, _filter->storage_id);
566 select_query = g_strdup_printf(SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
568 select_query = g_strdup(SELECT_ALBUM_LIST);
570 ret = __media_db_make_query(filter, &condition_query, &option_query);
571 if (ret != MEDIA_CONTENT_ERROR_NONE) {
572 g_free(select_query);
576 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
577 g_free(select_query);
578 g_free(condition_query);
579 g_free(option_query);
580 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
582 while (sqlite3_step(stmt) == SQLITE_ROW) {
583 media_album_s *album = g_new0(media_album_s, 1);
585 album->album_id = sqlite3_column_int(stmt, 0);
586 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
587 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
588 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
590 if (callback((media_album_h)album, user_data) == false) {
591 media_album_destroy((media_album_h)album);
595 media_album_destroy((media_album_h)album);
598 SQLITE3_FINALIZE(stmt);
603 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
605 int ret = MEDIA_CONTENT_ERROR_NONE;
606 char *select_query = NULL;
607 char *condition_query = NULL;
608 char *option_query = NULL;
609 sqlite3_stmt *stmt = NULL;
610 #ifdef _USE_TVPD_MODE
611 filter_s *_filter = (filter_s *)filter;
612 if (_filter && STRING_VALID(_filter->storage_id))
613 select_query = g_strdup_printf(SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
615 select_query = g_strdup_printf(SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
617 select_query = g_strdup(SELECT_FOLDER_LIST);
619 ret = __media_db_make_query(filter, &condition_query, &option_query);
620 if (ret != MEDIA_CONTENT_ERROR_NONE) {
621 g_free(select_query);
625 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
626 g_free(select_query);
627 g_free(condition_query);
628 g_free(option_query);
629 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
631 while (sqlite3_step(stmt) == SQLITE_ROW) {
632 media_folder_s *_folder = g_new0(media_folder_s, 1);
633 _folder->folder_id = g_strdup_printf("%lld", sqlite3_column_int64(stmt, 0));
634 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
635 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
636 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 3));
638 if (callback((media_folder_h)_folder, user_data) == false) {
639 media_folder_destroy((media_folder_h) _folder);
643 media_folder_destroy((media_folder_h) _folder);
646 SQLITE3_FINALIZE(stmt);
651 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
653 int ret = MEDIA_CONTENT_ERROR_NONE;
654 char *condition_query = NULL;
655 char *option_query = NULL;
656 sqlite3_stmt *stmt = NULL;
658 ret = __media_db_make_query(filter, &condition_query, &option_query);
659 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
661 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
662 g_free(condition_query);
663 g_free(option_query);
664 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
666 while (sqlite3_step(stmt) == SQLITE_ROW) {
667 media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
669 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
670 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
671 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
673 if (callback((media_playlist_h)_playlist, user_data) == false) {
674 media_playlist_destroy((media_playlist_h)_playlist);
677 media_playlist_destroy((media_playlist_h)_playlist);
680 SQLITE3_FINALIZE(stmt);
685 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
687 int ret = MEDIA_CONTENT_ERROR_NONE;
688 char *select_query = NULL;
689 char *condition_query = NULL;
690 char *option_query = NULL;
691 sqlite3_stmt *stmt = NULL;
693 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
695 ret = __media_db_make_query(filter, &condition_query, &option_query);
696 if (ret != MEDIA_CONTENT_ERROR_NONE) {
697 g_free(select_query);
701 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
702 g_free(select_query);
703 g_free(condition_query);
704 g_free(option_query);
705 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
707 while (sqlite3_step(stmt) == SQLITE_ROW) {
708 int playlist_member_id = 0;
709 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
711 media_info_s *_media = g_new0(media_info_s, 1);
713 _media_info_item_get_detail(stmt, (media_info_h)_media);
715 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
716 media_info_destroy((media_info_h)_media);
719 media_info_destroy((media_info_h)_media);
723 SQLITE3_FINALIZE(stmt);
728 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
730 int ret = MEDIA_CONTENT_ERROR_NONE;
731 char *select_query = NULL;
732 char *condition_query = NULL;
733 char *option_query = NULL;
734 sqlite3_stmt *stmt = NULL;
736 if (STRING_VALID(media_id))
737 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
739 select_query = g_strdup(SELECT_TAG_LIST);
741 ret = __media_db_make_query(filter, &condition_query, &option_query);
742 if (ret != MEDIA_CONTENT_ERROR_NONE) {
743 g_free(select_query);
747 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
748 g_free(select_query);
749 g_free(condition_query);
750 g_free(option_query);
751 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
753 while (sqlite3_step(stmt) == SQLITE_ROW) {
754 media_tag_s *_tag = g_new0(media_tag_s, 1);
756 _tag->tag_id = sqlite3_column_int(stmt, 0);
757 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
759 if (callback((media_tag_h)_tag, user_data) == false) {
760 media_tag_destroy((media_tag_h)_tag);
763 media_tag_destroy((media_tag_h)_tag);
766 SQLITE3_FINALIZE(stmt);
771 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
773 int ret = MEDIA_CONTENT_ERROR_NONE;
774 char *select_query = NULL;
775 char *condition_query = NULL;
776 char *option_query = NULL;
777 sqlite3_stmt *stmt = NULL;
778 #ifdef _USE_TVPD_MODE
779 filter_s *_filter = (filter_s *)filter;
780 if (STRING_VALID(media_id)) { //get bookmark by media_id
781 if (_filter && STRING_VALID(_filter->storage_id))
782 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
784 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
786 if (_filter && STRING_VALID(_filter->storage_id))
787 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, _filter->storage_id);
789 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
792 if (STRING_VALID(media_id))
793 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
795 select_query = g_strdup(SELECT_BOOKMARK_LIST);
798 ret = __media_db_make_query(filter, &condition_query, &option_query);
799 if (ret != MEDIA_CONTENT_ERROR_NONE) {
800 g_free(select_query);
804 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
805 g_free(select_query);
806 g_free(condition_query);
807 g_free(option_query);
808 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
810 while (sqlite3_step(stmt) == SQLITE_ROW) {
811 media_bookmark_s *bookmark = g_new0(media_bookmark_s, 1);
813 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
814 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
815 bookmark->marked_time = sqlite3_column_int(stmt, 2);
816 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
817 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
819 if (callback((media_bookmark_h)bookmark, user_data) == false) {
820 media_bookmark_destroy((media_bookmark_h)bookmark);
824 media_bookmark_destroy((media_bookmark_h)bookmark);
827 SQLITE3_FINALIZE(stmt);
833 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
835 int ret = MEDIA_CONTENT_ERROR_NONE;
836 char *select_query = NULL;
837 char *condition_query = NULL;
838 char *option_query = NULL;
839 sqlite3_stmt *stmt = NULL;
840 #ifdef _USE_TVPD_MODE
841 filter_s *_filter = (filter_s *)filter;
842 if (STRING_VALID(media_id)) { //get face by media_id
843 if (_filter && STRING_VALID(_filter->storage_id))
844 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
846 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
848 if (_filter && STRING_VALID(_filter->storage_id))
849 select_query = g_strdup_printf(SELECT_FACE_LIST, _filter->storage_id);
851 select_query = g_strdup_printf(SELECT_FACE_LIST, DB_VIEW_MEDIA);
854 if (STRING_VALID(media_id))
855 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
857 select_query = g_strdup(SELECT_FACE_LIST);
859 ret = __media_db_make_query(filter, &condition_query, &option_query);
860 if (ret != MEDIA_CONTENT_ERROR_NONE) {
861 g_free(select_query);
865 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
866 g_free(select_query);
867 g_free(condition_query);
868 g_free(option_query);
869 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
871 while (sqlite3_step(stmt) == SQLITE_ROW) {
872 media_face_s *face = g_new0(media_face_s, 1);
874 face->face_id = sqlite3_column_int(stmt, 0);
875 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
876 face->face_rect_x = sqlite3_column_int(stmt, 2);
877 face->face_rect_y = sqlite3_column_int(stmt, 3);
878 face->face_rect_w = sqlite3_column_int(stmt, 4);
879 face->face_rect_h = sqlite3_column_int(stmt, 5);
880 face->orientation = sqlite3_column_int(stmt, 6);
881 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
883 if (callback((media_face_h)face, user_data) == false) {
884 media_face_destroy((media_face_h)face);
888 media_face_destroy((media_face_h)face);
891 SQLITE3_FINALIZE(stmt);
897 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
899 int ret = MEDIA_CONTENT_ERROR_NONE;
900 sqlite3_stmt *stmt = NULL;
901 char *select_query = NULL;
902 char *condition_query = NULL;
903 char *option_query = NULL;
904 #ifdef _USE_TVPD_MODE
905 filter_s *_filter = (filter_s *)filter;
907 switch (group_type) {
908 case MEDIA_GROUP_ALBUM:
909 #ifdef _USE_TVPD_MODE
910 if (_filter && STRING_VALID(_filter->storage_id))
911 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
913 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
915 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
919 case MEDIA_GROUP_PLAYLIST:
920 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
923 case MEDIA_GROUP_TAG:
924 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_TAG, group_id);
928 content_error("INVALID_PARAMETER");
929 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
932 ret = __media_db_make_query(filter, &condition_query, &option_query);
933 if (ret != MEDIA_CONTENT_ERROR_NONE) {
934 g_free(select_query);
938 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
939 g_free(select_query);
940 g_free(condition_query);
941 g_free(option_query);
942 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
944 if (sqlite3_step(stmt) == SQLITE_ROW)
945 *item_count = sqlite3_column_int(stmt, 0);
947 SQLITE3_FINALIZE(stmt);
952 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
954 int ret = MEDIA_CONTENT_ERROR_NONE;
955 sqlite3_stmt *stmt = NULL;
956 char *select_query = NULL;
957 char *condition_query = NULL;
958 char *option_query = NULL;
959 char *tmp_option = NULL;
960 bool need_bracket = false;
961 filter_s *_filter = (filter_s *)filter;
963 switch (group_type) {
964 case MEDIA_GROUP_NONE:
966 #ifdef _USE_TVPD_MODE
967 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
969 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
974 if (_filter->offset < 0 && _filter->count < 0) {
975 #ifdef _USE_TVPD_MODE
976 if (STRING_VALID(_filter->storage_id))
977 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
979 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
981 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
984 #ifdef _USE_TVPD_MODE
985 if (STRING_VALID(_filter->storage_id))
986 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
988 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
990 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA);
996 case MEDIA_GROUP_FOLDER:
997 #ifdef _USE_TVPD_MODE
998 if (_filter && STRING_VALID(_filter->storage_id))
999 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1001 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1003 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1007 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1008 select_query = g_strdup_printf(SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1011 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1012 #ifdef _USE_TVPD_MODE
1013 if (_filter && STRING_VALID(_filter->storage_id))
1014 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1016 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1018 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1022 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1023 #ifdef _USE_TVPD_MODE
1024 if (_filter && STRING_VALID(_filter->storage_id))
1025 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1027 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1029 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1033 #ifdef _USE_TVPD_MODE
1034 case MEDIA_GROUP_PVR:
1035 if (_filter && STRING_VALID(_filter->storage_id))
1036 select_query = g_strdup_printf(SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1038 select_query = g_strdup(SELECT_PVR_COUNT);
1041 case MEDIA_GROUP_UHD:
1042 if (_filter && STRING_VALID(_filter->storage_id))
1043 select_query = g_strdup_printf(SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1045 select_query = g_strdup(SELECT_UHD_COUNT);
1049 content_error("INVALID_PARAMETER");
1050 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1053 ret = __media_db_make_query(filter, &condition_query, &option_query);
1054 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1055 g_free(select_query);
1060 tmp_option = g_strconcat(option_query, ")", NULL);
1061 g_free(option_query);
1062 option_query = tmp_option;
1065 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1066 g_free(select_query);
1067 g_free(condition_query);
1068 g_free(option_query);
1069 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1071 if (sqlite3_step(stmt) == SQLITE_ROW)
1072 *item_count = sqlite3_column_int(stmt, 0);
1074 SQLITE3_FINALIZE(stmt);
1079 int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type)
1081 int ret = MEDIA_CONTENT_ERROR_NONE;
1082 char *select_query = NULL;
1083 char *condition_query = NULL;
1084 char *option_query = NULL;
1085 sqlite3_stmt *stmt = NULL;
1086 #ifdef _USE_TVPD_MODE
1087 filter_s *_filter = (filter_s *)filter;
1090 switch (group_type) {
1091 case MEDIA_GROUP_ALBUM:
1092 #ifdef _USE_TVPD_MODE
1093 if (_filter && STRING_VALID(_filter->storage_id))
1094 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1096 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1098 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, group_id);
1102 case MEDIA_GROUP_PLAYLIST:
1103 #ifdef _USE_TVPD_MODE
1104 if (_filter && STRING_VALID(_filter->storage_id))
1105 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1107 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1109 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, group_id);
1113 case MEDIA_GROUP_TAG:
1114 #ifdef _USE_TVPD_MODE
1115 if (_filter && STRING_VALID(_filter->storage_id))
1116 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1118 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1120 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, group_id);
1125 content_error("INVALID_PARAMETER");
1126 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1129 ret = __media_db_make_query(filter, &condition_query, &option_query);
1130 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1131 g_free(select_query);
1135 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1136 g_free(select_query);
1137 g_free(condition_query);
1138 g_free(option_query);
1139 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1141 while (sqlite3_step(stmt) == SQLITE_ROW) {
1142 media_info_s *item = g_new0(media_info_s, 1);
1144 _media_info_item_get_detail(stmt, (media_info_h)item);
1146 if (callback((media_info_h)item, user_data) == false) {
1147 media_info_destroy((media_info_h)item);
1151 media_info_destroy((media_info_h)item);
1154 SQLITE3_FINALIZE(stmt);
1159 int _media_db_get_group_item(const char *group_name, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type)
1161 int ret = MEDIA_CONTENT_ERROR_NONE;
1162 char *select_query = NULL;
1163 char *condition_query = NULL;
1164 char *option_query = NULL;
1165 sqlite3_stmt *stmt = NULL;
1166 #ifdef _USE_TVPD_MODE
1167 filter_s *_filter = (filter_s *)filter;
1170 switch (group_type) {
1171 case MEDIA_GROUP_NONE:
1172 #ifdef _USE_TVPD_MODE
1173 if (_filter && STRING_VALID(_filter->storage_id))
1174 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, _filter->storage_id);
1176 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1178 select_query = g_strdup(SELECT_MEDIA_ITEM);
1182 case MEDIA_GROUP_FOLDER:
1183 #ifdef _USE_TVPD_MODE
1184 if (_filter && STRING_VALID(_filter->storage_id))
1185 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1187 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1189 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, group_name);
1194 content_error("INVALID_PARAMETER");
1195 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1198 ret = __media_db_make_query(filter, &condition_query, &option_query);
1199 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1200 g_free(select_query);
1204 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1205 g_free(select_query);
1206 g_free(condition_query);
1207 g_free(option_query);
1208 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1210 while (sqlite3_step(stmt) == SQLITE_ROW) {
1211 media_info_s *item = g_new0(media_info_s, 1);
1213 _media_info_item_get_detail(stmt, (media_info_h)item);
1215 if (callback((media_info_h)item, user_data) == false) {
1216 media_info_destroy((media_info_h)item);
1220 media_info_destroy((media_info_h)item);
1223 SQLITE3_FINALIZE(stmt);
1228 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1230 int ret = MEDIA_CONTENT_ERROR_NONE;
1231 sqlite3_stmt *stmt = NULL;
1232 char select_query[MAX_QUERY_SIZE] = {0, };
1233 char *tmp_option = NULL;
1234 char *condition_query = NULL;
1235 char *option_query = NULL;
1236 #ifdef _USE_TVPD_MODE
1237 filter_s *_filter = (filter_s *)filter;
1238 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1240 if (_filter && STRING_VALID(_filter->storage_id))
1241 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1243 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1245 if (_filter && STRING_VALID(_filter->storage_id))
1246 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1248 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1250 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1252 if (_filter && STRING_VALID(_filter->storage_id))
1253 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1255 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1257 if (_filter && STRING_VALID(_filter->storage_id))
1258 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1260 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1262 } else {/*uhd content*/
1264 if (_filter && STRING_VALID(_filter->storage_id))
1265 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1267 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1269 if (_filter && STRING_VALID(_filter->storage_id))
1270 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1272 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1277 sqlite3_snprintf(MAX_QUERY_SIZE, select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1279 snprintf(select_query, MAX_QUERY_SIZE, SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1281 ret = __media_db_make_query(filter, &condition_query, &option_query);
1282 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1284 /* If 'filter' is not NULL, 'option_query' must be created. */
1286 tmp_option = g_strconcat(option_query, ")", NULL);
1287 g_free(option_query);
1288 option_query = tmp_option;
1290 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1293 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1294 g_free(condition_query);
1295 g_free(option_query);
1296 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1298 if (sqlite3_step(stmt) == SQLITE_ROW)
1299 *item_count = sqlite3_column_int(stmt, 0);
1301 SQLITE3_FINALIZE(stmt);
1306 int _media_db_get_media_group_item(const char *group_name, filter_h filter, media_group_e group, media_info_cb callback, void *user_data)
1308 int ret = MEDIA_CONTENT_ERROR_NONE;
1309 char select_query[MAX_QUERY_SIZE] = {0, };
1310 char *condition_query = NULL;
1311 char *option_query = NULL;
1312 sqlite3_stmt *stmt = NULL;
1313 #ifdef _USE_TVPD_MODE
1314 filter_s *_filter = (filter_s *)filter;
1316 if (_filter && STRING_VALID(_filter->storage_id))
1317 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1319 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1321 if (_filter && STRING_VALID(_filter->storage_id))
1322 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1324 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1328 sqlite3_snprintf(MAX_QUERY_SIZE, select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1330 snprintf(select_query, MAX_QUERY_SIZE, SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1332 ret = __media_db_make_query(filter, &condition_query, &option_query);
1333 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1335 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1336 g_free(condition_query);
1337 g_free(option_query);
1338 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1340 while (sqlite3_step(stmt) == SQLITE_ROW) {
1341 media_info_s *item = g_new0(media_info_s, 1);
1343 _media_info_item_get_detail(stmt, (media_info_h)item);
1345 if (callback((media_info_h)item, user_data) == false) {
1346 media_info_destroy((media_info_h)item);
1350 media_info_destroy((media_info_h)item);
1353 SQLITE3_FINALIZE(stmt);
1358 #ifdef _USE_TVPD_MODE
1359 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1361 int ret = MEDIA_CONTENT_ERROR_NONE;
1362 sqlite3_stmt *stmt = NULL;
1363 char *select_query = NULL;
1365 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1367 ret = _content_get_result(select_query, &stmt);
1368 SQLITE3_SAFE_FREE(select_query);
1369 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1371 if (sqlite3_step(stmt) == SQLITE_ROW) {
1372 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1374 content_error("Invalid media_id[%s]", media_id);
1375 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1378 SQLITE3_FINALIZE(stmt);
1383 int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_group_e group, media_pvr_cb callback, void *user_data)
1385 int ret = MEDIA_CONTENT_ERROR_NONE;
1386 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1387 char *condition_query = NULL;
1388 char *option_query = NULL;
1389 sqlite3_stmt *stmt = NULL;
1390 filter_s *_filter = (filter_s *)filter;
1393 if (_filter && STRING_VALID(_filter->storage_id))
1394 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1396 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1398 if (_filter && STRING_VALID(_filter->storage_id))
1399 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1401 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1404 ret = __media_db_make_query(filter, &condition_query, &option_query);
1405 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1407 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1408 g_free(condition_query);
1409 g_free(option_query);
1410 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1412 while (sqlite3_step(stmt) == SQLITE_ROW) {
1413 media_pvr_s *item = g_new0(media_pvr_s, 1);
1415 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1417 if (callback((media_pvr_h)item, user_data) == false) {
1418 media_info_destroy((media_pvr_h)item);
1422 media_pvr_destroy((media_pvr_h)item);
1425 SQLITE3_FINALIZE(stmt);
1431 MEDIA_PVR_MEDIA_ID = 0,
1432 MEDIA_PVR_STORAGE_ID,
1436 MEDIA_PVR_TIME_ZONE,
1440 MEDIA_PVR_CHANNEL_TYPE,
1441 MEDIA_PVR_CHANNEL_NAME,
1442 MEDIA_PVR_CHANNEL_NUM,
1443 MEDIA_PVR_SERVICE_PROFILE,
1444 MEDIA_PVR_PROGRAM_TITLE,
1445 MEDIA_PVR_PROGRAM_NUM,
1446 MEDIA_PVR_PROGRAM_CRID,
1451 MEDIA_PVR_EMBARGO_TIME,
1452 MEDIA_PVR_EXPIRY_TIME,
1453 MEDIA_PVR_START_TIME,
1454 MEDIA_PVR_PROGRAM_START_TIME,
1455 MEDIA_PVR_PROGRAM_END_TIME,
1456 MEDIA_PVR_PROGRAM_DATE,
1457 MEDIA_PVR_PARENTAL_RATING,
1458 MEDIA_PVR_TIMER_RECORD,
1459 MEDIA_PVR_SERIES_RECORD,
1464 MEDIA_PVR_HARDOF_HEARINGRADIO,
1465 MEDIA_PVR_DATA_SERVICE,
1466 MEDIA_PVR_CONTENT_LOCK,
1467 MEDIA_PVR_CONTENT_WATCH,
1468 MEDIA_PVR_HAS_AUDIO_ONLY,
1469 MEDIA_PVR_IS_LOCAL_RECORDED,
1470 MEDIA_PVR_RESOLUTION,
1471 MEDIA_PVR_ASPECTRATIO,
1472 MEDIA_PVR_MODIFIED_MONTH,
1473 MEDIA_PVR_SPORTS_TYPE,
1474 MEDIA_PVR_GUIDANCE_LENGTH,
1476 MEDIA_PVR_PLAY_COUNT,
1477 MEDIA_PVR_PRIVATE_DATA,
1478 MEDIA_PVR_HIGHLIGHT,
1479 } media_pvr_field_e;
1481 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1483 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1485 _pvr->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1486 _pvr->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1487 _pvr->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1488 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1489 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1490 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1491 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1492 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1493 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1494 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1495 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1496 _pvr->channel_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1497 _pvr->channel_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1498 _pvr->program_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1499 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1500 _pvr->program_crid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1501 _pvr->guidance = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1502 _pvr->synopsis = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1503 _pvr->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1504 _pvr->language = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1505 _pvr->modified_month = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1506 _pvr->private_data = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1507 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1508 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1509 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1510 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1511 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1512 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1513 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1514 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1515 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1516 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1517 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1518 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1519 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1520 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1521 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1522 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1523 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1524 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1525 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1526 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1527 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1528 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1529 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1530 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1531 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1532 _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1537 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1539 int ret = MEDIA_CONTENT_ERROR_NONE;
1540 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1541 char *condition_query = NULL;
1542 char *option_query = NULL;
1543 sqlite3_stmt *stmt = NULL;
1544 filter_s *_filter = (filter_s *)filter;
1546 if (_filter && STRING_VALID(_filter->storage_id))
1547 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1549 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1551 ret = __media_db_make_query(filter, &condition_query, &option_query);
1552 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1554 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1555 g_free(condition_query);
1556 g_free(option_query);
1557 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1559 while (sqlite3_step(stmt) == SQLITE_ROW) {
1560 media_pvr_s *_pvr = g_new0(media_pvr_s, 1);
1562 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1564 if (callback((media_pvr_h)_pvr, user_data) == false) {
1565 media_pvr_destroy((media_pvr_h) _pvr);
1569 media_pvr_destroy((media_pvr_h) _pvr);
1572 SQLITE3_FINALIZE(stmt);
1578 MEDIA_UHD_MEDIA_ID = 0,
1579 MEDIA_UHD_STORAGE_ID,
1582 MEDIA_UHD_CONTENT_ID,
1583 MEDIA_UHD_CONTENT_TITLE,
1584 MEDIA_UHD_FILE_NAME,
1585 MEDIA_UHD_FOLDER_ID,
1586 MEDIA_UHD_RELEASE_DATE,
1587 MEDIA_UHD_MODIFIED_TIME,
1588 MEDIA_UHD_PLAYED_POSITION,
1590 MEDIA_UHD_PLAYED_COUNT,
1591 } media_uhd_field_e;
1593 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1595 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1597 _uhd->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1598 _uhd->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1599 _uhd->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1600 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1601 _uhd->content_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1602 _uhd->content_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1603 _uhd->file_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1604 _uhd->release_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1605 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1606 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1607 _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1608 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1613 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1615 int ret = MEDIA_CONTENT_ERROR_NONE;
1616 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1617 char *condition_query = NULL;
1618 char *option_query = NULL;
1619 sqlite3_stmt *stmt = NULL;
1620 filter_s *_filter = (filter_s *)filter;
1622 if (_filter && STRING_VALID(_filter->storage_id))
1623 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1625 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1627 ret = __media_db_make_query(filter, &condition_query, &option_query);
1628 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1630 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1631 g_free(condition_query);
1632 g_free(option_query);
1633 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1635 while (sqlite3_step(stmt) == SQLITE_ROW) {
1636 media_uhd_s *_uhd = g_new0(media_uhd_s, 1);
1638 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1640 if (callback((media_uhd_h)_uhd, user_data) == false) {
1641 media_uhd_destroy((media_uhd_h) _uhd);
1644 media_uhd_destroy((media_uhd_h) _uhd);
1647 SQLITE3_FINALIZE(stmt);
1652 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1654 int ret = MEDIA_CONTENT_ERROR_NONE;
1655 char *condition_query = NULL;
1656 char *option_query = NULL;
1657 sqlite3_stmt *stmt = NULL;
1659 ret = __media_db_make_query(filter, &condition_query, &option_query);
1660 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1662 ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1663 g_free(condition_query);
1664 g_free(option_query);
1665 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1667 while (sqlite3_step(stmt) == SQLITE_ROW) {
1668 media_storage_s *_storage = g_new0(media_storage_s, 1);
1670 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1671 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1673 if (callback((media_storage_h)_storage, user_data) == false) {
1674 media_storage_destroy((media_storage_h) _storage);
1678 media_storage_destroy((media_storage_h) _storage);
1681 SQLITE3_FINALIZE(stmt);