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_MONTH:
67 return DB_FIELD_MEDIA_MODIFIED_DATE;
68 case MEDIA_CONTENT_GROUP_MODIFIED_DATE:
69 return DB_FIELD_MEDIA_MODIFIED_DATE;
70 case MEDIA_CONTENT_GROUP_ALBUM:
71 return DB_FIELD_MEDIA_ALBUM;
72 case MEDIA_PVR_GROUP_DURATION:
73 return DB_FIELD_PVR_DURATION;
74 case MEDIA_PVR_GROUP_TIME_ZONE:
75 return DB_FIELD_PVR_TIME_ZONE;
76 case MEDIA_PVR_GROUP_PTC:
77 return DB_FIELD_PVR_PTC;
78 case MEDIA_PVR_GROUP_MAJOR:
79 return DB_FIELD_PVR_MAJOR;
80 case MEDIA_PVR_GROUP_MINOR:
81 return DB_FIELD_PVR_MINOR;
82 case MEDIA_PVR_GROUP_CHANNEL_TYPE:
83 return DB_FIELD_PVR_CHANNEL_TYPE;
84 case MEDIA_PVR_GROUP_CHANNEL_NAME:
85 return DB_FIELD_PVR_CHANNEL_NAME;
86 case MEDIA_PVR_GROUP_CHANNEL_NUM:
87 return DB_FIELD_PVR_CHANNEL_NUM;
88 case MEDIA_PVR_GROUP_PROGRAM_TITLE:
89 return DB_FIELD_PVR_PROGRAM_TITLE;
90 case MEDIA_PVR_GROUP_PROGRAM_NUM:
91 return DB_FIELD_PVR_PROGRAM_NUM;
92 case MEDIA_PVR_GROUP_PROGRAM_CRID:
93 return DB_FIELD_PVR_PROGRAM_CRID;
94 case MEDIA_PVR_GROUP_GUIDANCE:
95 return DB_FIELD_PVR_GUIDANCE;
96 case MEDIA_PVR_GROUP_SYNOPSIS:
97 return DB_FIELD_PVR_SYNOPSIS;
98 case MEDIA_PVR_GROUP_GENRE:
99 return DB_FIELD_PVR_GENRE;
100 case MEDIA_PVR_GROUP_LANGUAGE:
101 return DB_FIELD_PVR_LANGUAGE;
102 case MEDIA_PVR_GROUP_EMBARGO_TIME:
103 return DB_FIELD_PVR_EMBARGO_TIME;
104 case MEDIA_PVR_GROUP_EXPIRY_TIME:
105 return DB_FIELD_PVR_EXPIRY_TIME;
106 case MEDIA_PVR_GROUP_START_TIME:
107 return DB_FIELD_PVR_START_TIME;
108 case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
109 return DB_FIELD_PVR_PROGRAM_START_TIME;
110 case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
111 return DB_FIELD_PVR_PROGRAM_END_TIME;
112 case MEDIA_PVR_GROUP_PROGRAM_DATE:
113 return DB_FIELD_PVR_PROGRAM_DATE;
114 case MEDIA_PVR_GROUP_PARENTAL_RATING:
115 return DB_FIELD_PVR_PARENTAL_RATING;
116 case MEDIA_PVR_GROUP_TIMER_RECORD:
117 return DB_FIELD_PVR_TIMER_RECORD;
118 case MEDIA_PVR_GROUP_SERIES_RECORD:
119 return DB_FIELD_PVR_SERIES_RECORD;
120 case MEDIA_PVR_GROUP_HD:
121 return DB_FIELD_PVR_HD;
122 case MEDIA_PVR_GROUP_SUBTITLE:
123 return DB_FIELD_PVR_SUBTITLE;
124 case MEDIA_PVR_GROUP_TTX:
125 return DB_FIELD_PVR_TTX;
126 case MEDIA_PVR_GROUP_AD:
127 return DB_FIELD_PVR_AD;
128 case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
129 return DB_FIELD_PVR_HARDOF_HEARINGRADIO;
130 case MEDIA_PVR_GROUP_DATA_SERVICE:
131 return DB_FIELD_PVR_DATA_SERVICE;
132 case MEDIA_PVR_GROUP_CONTENT_LOCK:
133 return DB_FIELD_PVR_CONTENT_LOCK;
134 case MEDIA_PVR_GROUP_CONTENT_WATCH:
135 return DB_FIELD_PVR_CONTENT_WATCH;
136 case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
137 return DB_FIELD_PVR_HAS_AUDIO_ONLY;
138 case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
139 return DB_FIELD_PVR_IS_LOCAL_RECORD;
140 case MEDIA_PVR_GROUP_RESOLUTION:
141 return DB_FIELD_PVR_RESOLUTION;
142 case MEDIA_PVR_GROUP_ASPECTRATIO:
143 return DB_FIELD_PVR_ASPECTRATIO;
144 case MEDIA_PVR_GROUP_MODIFIED_MONTH:
145 return DB_FIELD_PVR_MODIFIED_DATE;
146 case MEDIA_PVR_GROUP_MODIFIED_DATE:
147 return DB_FIELD_PVR_MODIFIED_DATE;
148 case MEDIA_PVR_GROUP_SPORTS_TYPE:
149 return DB_FIELD_PVR_SPORTS_TYPE;
150 case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
151 return DB_FIELD_PVR_GUIDANCE_LENGTH;
152 case MEDIA_PVR_GROUP_TVMODE:
153 return DB_FIELD_PVR_TVMODE;
154 case MEDIA_PVR_GROUP_PLAY_COUNT:
155 return DB_FIELD_PVR_PLAY_COUNT;
156 case MEDIA_PVR_GROUP_PRIVATE_DATA:
157 return DB_FIELD_PVR_PRIVATE_DATA;
158 case MEDIA_UHD_GROUP_CONTENT_TITLE:
159 return DB_FIELD_UHD_CONTENT_TITLE;
160 case MEDIA_UHD_GROUP_RELEASE_DATE:
161 return DB_FIELD_UHD_RELEASE_DATE;
162 case MEDIA_UHD_GROUP_SUB_TYPE:
163 return DB_FIELD_UHD_SUB_TYPE;
164 case MEDIA_UHD_GROUP_FILE_NAME:
165 return DB_FIELD_UHD_FILE_NAME;
166 case MEDIA_UHD_GROUP_PLAYED_COUNT:
167 return DB_FIELD_UHD_PLAYED_COUNT;
176 static int __media_db_make_query(filter_h filter, char **condition_query, char **option_query)
178 int ret = MEDIA_CONTENT_ERROR_NONE;
179 filter_s *_filter = (filter_s *)filter;
181 content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
183 if (STRING_VALID(_filter->condition)) {
184 ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
185 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
188 ret = _media_filter_build_option(filter, option_query);
189 if (ret != MEDIA_CONTENT_ERROR_NONE)
190 g_free(*condition_query);
195 #ifdef _USE_TVPD_MODE
196 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
198 int ret = MEDIA_CONTENT_ERROR_NONE;
199 sqlite3_stmt *stmt = NULL;
200 char *select_query = NULL;
201 char *condition_query = NULL;
202 char *option_query = NULL;
203 filter_s *_filter = (filter_s *)filter;
205 switch (group_type) {
206 case MEDIA_GROUP_ALBUM:
207 if (_filter && STRING_VALID(_filter->storage_id))
208 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, _filter->storage_id);
210 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
213 case MEDIA_GROUP_FOLDER:
214 if (_filter && STRING_VALID(_filter->storage_id))
215 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
217 select_query = g_strdup_printf(SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
220 case MEDIA_GROUP_PLAYLIST:
221 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
224 case MEDIA_GROUP_TAG:
225 select_query = g_strdup(SELECT_TAG_COUNT);
228 case MEDIA_GROUP_BOOKMARK:
229 if (_filter && STRING_VALID(_filter->storage_id))
230 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, _filter->storage_id);
232 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
236 case MEDIA_GROUP_FACE:
237 if (_filter && STRING_VALID(_filter->storage_id))
238 select_query = g_strdup_printf(SELECT_FACE_COUNT, _filter->storage_id);
240 select_query = g_strdup_printf(SELECT_FACE_COUNT, DB_VIEW_MEDIA);
244 content_error("Invalid group type [%d]", group_type);
245 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
248 ret = __media_db_make_query(filter, &condition_query, &option_query);
249 if (ret != MEDIA_CONTENT_ERROR_NONE) {
250 g_free(select_query);
254 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
255 g_free(select_query);
256 g_free(condition_query);
257 g_free(option_query);
258 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
260 if (sqlite3_step(stmt) == SQLITE_ROW)
261 *group_count = sqlite3_column_int(stmt, 0);
263 SQLITE3_FINALIZE(stmt);
268 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
270 int ret = MEDIA_CONTENT_ERROR_NONE;
271 sqlite3_stmt *stmt = NULL;
272 char select_query[MAX_QUERY_SIZE] = {0, };
273 char *condition_query = NULL;
274 char *option_query = NULL;
275 char *tmp_option = NULL;
276 filter_s *_filter = (filter_s *)filter;
278 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
279 if (_filter && STRING_VALID(_filter->storage_id))
280 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
282 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
283 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
284 if (_filter && STRING_VALID(_filter->storage_id))
285 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
287 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
288 } else { /*uhd content*/
289 if (_filter && STRING_VALID(_filter->storage_id))
290 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
292 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
294 ret = __media_db_make_query(filter, &condition_query, &option_query);
295 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
298 tmp_option = g_strconcat(option_query, ")", NULL);
299 g_free(option_query);
300 option_query = tmp_option;
302 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
305 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
306 g_free(condition_query);
307 g_free(option_query);
308 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
310 if (sqlite3_step(stmt) == SQLITE_ROW)
311 *group_count = sqlite3_column_int(stmt, 0);
313 SQLITE3_FINALIZE(stmt);
318 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
320 int ret = MEDIA_CONTENT_ERROR_NONE;
321 char select_query[MAX_QUERY_SIZE] = {0, };
322 char *condition_query = NULL;
323 char *option_query = NULL;
325 sqlite3_stmt *stmt = NULL;
326 filter_s *_filter = (filter_s *)filter;
328 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
329 if (_filter && STRING_VALID(_filter->storage_id))
330 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
332 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
333 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
334 if (_filter && STRING_VALID(_filter->storage_id))
335 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
337 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
338 } else { /* uhd content */
339 if (_filter && STRING_VALID(_filter->storage_id))
340 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
342 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
344 ret = __media_db_make_query(filter, &condition_query, &option_query);
345 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
347 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
348 g_free(condition_query);
349 g_free(option_query);
350 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
352 while (sqlite3_step(stmt) == SQLITE_ROW) {
353 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
355 if (callback(name, user_data) == false) {
363 SQLITE3_FINALIZE(stmt);
368 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
370 int ret = MEDIA_CONTENT_ERROR_NONE;
371 char select_query[DEFAULT_QUERY_SIZE] = {0, };
372 char group_query[DEFAULT_QUERY_SIZE] = {0, };
373 char *condition_query = NULL;
374 char *option_query = NULL;
376 sqlite3_stmt *stmt = NULL;
377 filter_s *_filter = (filter_s *)filter;
379 const char* group_name = __media_db_get_group_name(group);
380 content_retip_if_fail(STRING_VALID(group_name));
382 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
383 if (_filter && STRING_VALID(_filter->storage_id))
384 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
386 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
387 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
388 if (_filter && STRING_VALID(_filter->storage_id))
389 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
391 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
392 } else {/*uhd content*/
393 if (_filter && STRING_VALID(_filter->storage_id))
394 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
396 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
399 ret = __media_db_make_query(filter, &condition_query, &option_query);
400 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
402 if (STRING_VALID(option_query))
403 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
405 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
407 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
408 g_free(condition_query);
409 g_free(option_query);
410 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
412 while (sqlite3_step(stmt) == SQLITE_ROW) {
413 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
415 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
423 SQLITE3_FINALIZE(stmt);
428 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
430 int ret = MEDIA_CONTENT_ERROR_NONE;
431 sqlite3_stmt *stmt = NULL;
432 char *select_query = NULL;
433 char *condition_query = NULL;
434 char *option_query = NULL;
436 switch (group_type) {
437 case MEDIA_GROUP_ALBUM:
438 select_query = g_strdup(SELECT_ALBUM_COUNT);
441 case MEDIA_GROUP_FOLDER:
442 select_query = g_strdup(SELECT_FOLDER_COUNT);
445 case MEDIA_GROUP_PLAYLIST:
446 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
449 case MEDIA_GROUP_TAG:
450 select_query = g_strdup(SELECT_TAG_COUNT);
453 case MEDIA_GROUP_BOOKMARK:
454 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
457 case MEDIA_GROUP_FACE:
458 select_query = g_strdup(SELECT_FACE_COUNT);
462 content_error("Invalid group type [%d]", group_type);
463 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
466 ret = __media_db_make_query(filter, &condition_query, &option_query);
467 if (ret != MEDIA_CONTENT_ERROR_NONE) {
468 g_free(select_query);
472 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
473 g_free(select_query);
474 g_free(condition_query);
475 g_free(option_query);
476 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
478 if (sqlite3_step(stmt) == SQLITE_ROW)
479 *group_count = sqlite3_column_int(stmt, 0);
481 SQLITE3_FINALIZE(stmt);
486 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
488 int ret = MEDIA_CONTENT_ERROR_NONE;
489 sqlite3_stmt *stmt = NULL;
490 char *select_query = NULL;
491 char *condition_query = NULL;
492 char *option_query = NULL;
494 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
496 ret = __media_db_make_query(filter, &condition_query, &option_query);
497 if (ret != MEDIA_CONTENT_ERROR_NONE) {
498 g_free(select_query);
502 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
503 g_free(select_query);
504 g_free(condition_query);
505 g_free(option_query);
506 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
508 if (sqlite3_step(stmt) == SQLITE_ROW)
509 *group_count = sqlite3_column_int(stmt, 0);
511 SQLITE3_FINALIZE(stmt);
516 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
518 int ret = MEDIA_CONTENT_ERROR_NONE;
519 char *select_query = NULL;
520 char *condition_query = NULL;
521 char *option_query = NULL;
523 sqlite3_stmt *stmt = NULL;
525 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
527 ret = __media_db_make_query(filter, &condition_query, &option_query);
528 if (ret != MEDIA_CONTENT_ERROR_NONE) {
529 g_free(select_query);
533 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
534 g_free(select_query);
535 g_free(condition_query);
536 g_free(option_query);
537 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
539 while (sqlite3_step(stmt) == SQLITE_ROW) {
540 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
542 if (callback(name, user_data) == false) {
550 SQLITE3_FINALIZE(stmt);
556 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
558 int ret = MEDIA_CONTENT_ERROR_NONE;
559 char *select_query = NULL;
560 char *condition_query = NULL;
561 char *option_query = NULL;
562 sqlite3_stmt *stmt = NULL;
563 #ifdef _USE_TVPD_MODE
564 filter_s *_filter = (filter_s *)filter;
565 if (_filter && STRING_VALID(_filter->storage_id))
566 select_query = g_strdup_printf(SELECT_ALBUM_LIST, _filter->storage_id);
568 select_query = g_strdup_printf(SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
570 select_query = g_strdup(SELECT_ALBUM_LIST);
572 ret = __media_db_make_query(filter, &condition_query, &option_query);
573 if (ret != MEDIA_CONTENT_ERROR_NONE) {
574 g_free(select_query);
578 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
579 g_free(select_query);
580 g_free(condition_query);
581 g_free(option_query);
582 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
584 while (sqlite3_step(stmt) == SQLITE_ROW) {
585 media_album_s *album = g_new0(media_album_s, 1);
587 album->album_id = sqlite3_column_int(stmt, 0);
588 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
589 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
590 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
592 if (callback((media_album_h)album, user_data) == false) {
593 media_album_destroy((media_album_h)album);
597 media_album_destroy((media_album_h)album);
600 SQLITE3_FINALIZE(stmt);
605 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
607 int ret = MEDIA_CONTENT_ERROR_NONE;
608 char *select_query = NULL;
609 char *condition_query = NULL;
610 char *option_query = NULL;
611 sqlite3_stmt *stmt = NULL;
612 #ifdef _USE_TVPD_MODE
613 filter_s *_filter = (filter_s *)filter;
614 if (_filter && STRING_VALID(_filter->storage_id))
615 select_query = g_strdup_printf(SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
617 select_query = g_strdup_printf(SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
619 select_query = g_strdup(SELECT_FOLDER_LIST);
621 ret = __media_db_make_query(filter, &condition_query, &option_query);
622 if (ret != MEDIA_CONTENT_ERROR_NONE) {
623 g_free(select_query);
627 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
628 g_free(select_query);
629 g_free(condition_query);
630 g_free(option_query);
631 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
633 while (sqlite3_step(stmt) == SQLITE_ROW) {
634 media_folder_s *_folder = g_new0(media_folder_s, 1);
635 #ifdef _USE_TVPD_MODE
636 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
638 _folder->folder_id = g_strdup_printf("%lld", sqlite3_column_int64(stmt, 0));
640 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
641 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
642 _folder->storage_type = sqlite3_column_int(stmt, 3);
643 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
645 if (callback((media_folder_h)_folder, user_data) == false) {
646 media_folder_destroy((media_folder_h) _folder);
650 media_folder_destroy((media_folder_h) _folder);
653 SQLITE3_FINALIZE(stmt);
658 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
660 int ret = MEDIA_CONTENT_ERROR_NONE;
661 char *condition_query = NULL;
662 char *option_query = NULL;
663 sqlite3_stmt *stmt = NULL;
665 ret = __media_db_make_query(filter, &condition_query, &option_query);
666 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
668 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
669 g_free(condition_query);
670 g_free(option_query);
671 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
673 while (sqlite3_step(stmt) == SQLITE_ROW) {
674 media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
676 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
677 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
678 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
680 if (callback((media_playlist_h)_playlist, user_data) == false) {
681 media_playlist_destroy((media_playlist_h)_playlist);
684 media_playlist_destroy((media_playlist_h)_playlist);
687 SQLITE3_FINALIZE(stmt);
692 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
694 int ret = MEDIA_CONTENT_ERROR_NONE;
695 char *select_query = NULL;
696 char *condition_query = NULL;
697 char *option_query = NULL;
698 sqlite3_stmt *stmt = NULL;
700 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
702 ret = __media_db_make_query(filter, &condition_query, &option_query);
703 if (ret != MEDIA_CONTENT_ERROR_NONE) {
704 g_free(select_query);
708 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
709 g_free(select_query);
710 g_free(condition_query);
711 g_free(option_query);
712 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
714 while (sqlite3_step(stmt) == SQLITE_ROW) {
715 int playlist_member_id = 0;
716 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
718 media_info_s *_media = g_new0(media_info_s, 1);
720 _media_info_item_get_detail(stmt, (media_info_h)_media);
722 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
723 media_info_destroy((media_info_h)_media);
726 media_info_destroy((media_info_h)_media);
730 SQLITE3_FINALIZE(stmt);
735 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
737 int ret = MEDIA_CONTENT_ERROR_NONE;
738 char *select_query = NULL;
739 char *condition_query = NULL;
740 char *option_query = NULL;
741 sqlite3_stmt *stmt = NULL;
743 if (STRING_VALID(media_id))
744 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
746 select_query = g_strdup(SELECT_TAG_LIST);
748 ret = __media_db_make_query(filter, &condition_query, &option_query);
749 if (ret != MEDIA_CONTENT_ERROR_NONE) {
750 g_free(select_query);
754 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
755 g_free(select_query);
756 g_free(condition_query);
757 g_free(option_query);
758 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
760 while (sqlite3_step(stmt) == SQLITE_ROW) {
761 media_tag_s *_tag = g_new0(media_tag_s, 1);
763 _tag->tag_id = sqlite3_column_int(stmt, 0);
764 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
766 if (callback((media_tag_h)_tag, user_data) == false) {
767 media_tag_destroy((media_tag_h)_tag);
770 media_tag_destroy((media_tag_h)_tag);
773 SQLITE3_FINALIZE(stmt);
778 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
780 int ret = MEDIA_CONTENT_ERROR_NONE;
781 char *select_query = NULL;
782 char *condition_query = NULL;
783 char *option_query = NULL;
784 sqlite3_stmt *stmt = NULL;
785 #ifdef _USE_TVPD_MODE
786 filter_s *_filter = (filter_s *)filter;
787 if (STRING_VALID(media_id)) { //get bookmark by media_id
788 if (_filter && STRING_VALID(_filter->storage_id))
789 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
791 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
793 if (_filter && STRING_VALID(_filter->storage_id))
794 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, _filter->storage_id);
796 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
799 if (STRING_VALID(media_id))
800 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
802 select_query = g_strdup(SELECT_BOOKMARK_LIST);
805 ret = __media_db_make_query(filter, &condition_query, &option_query);
806 if (ret != MEDIA_CONTENT_ERROR_NONE) {
807 g_free(select_query);
811 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
812 g_free(select_query);
813 g_free(condition_query);
814 g_free(option_query);
815 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
817 while (sqlite3_step(stmt) == SQLITE_ROW) {
818 media_bookmark_s *bookmark = g_new0(media_bookmark_s, 1);
820 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
821 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
822 bookmark->marked_time = sqlite3_column_int(stmt, 2);
823 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
824 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
826 if (callback((media_bookmark_h)bookmark, user_data) == false) {
827 media_bookmark_destroy((media_bookmark_h)bookmark);
831 media_bookmark_destroy((media_bookmark_h)bookmark);
834 SQLITE3_FINALIZE(stmt);
840 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
842 int ret = MEDIA_CONTENT_ERROR_NONE;
843 char *select_query = NULL;
844 char *condition_query = NULL;
845 char *option_query = NULL;
846 sqlite3_stmt *stmt = NULL;
847 #ifdef _USE_TVPD_MODE
848 filter_s *_filter = (filter_s *)filter;
849 if (STRING_VALID(media_id)) { //get face by media_id
850 if (_filter && STRING_VALID(_filter->storage_id))
851 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
853 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
855 if (_filter && STRING_VALID(_filter->storage_id))
856 select_query = g_strdup_printf(SELECT_FACE_LIST, _filter->storage_id);
858 select_query = g_strdup_printf(SELECT_FACE_LIST, DB_VIEW_MEDIA);
861 if (STRING_VALID(media_id))
862 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
864 select_query = g_strdup(SELECT_FACE_LIST);
866 ret = __media_db_make_query(filter, &condition_query, &option_query);
867 if (ret != MEDIA_CONTENT_ERROR_NONE) {
868 g_free(select_query);
872 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
873 g_free(select_query);
874 g_free(condition_query);
875 g_free(option_query);
876 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
878 while (sqlite3_step(stmt) == SQLITE_ROW) {
879 media_face_s *face = g_new0(media_face_s, 1);
881 face->face_id = sqlite3_column_int(stmt, 0);
882 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
883 face->face_rect_x = sqlite3_column_int(stmt, 2);
884 face->face_rect_y = sqlite3_column_int(stmt, 3);
885 face->face_rect_w = sqlite3_column_int(stmt, 4);
886 face->face_rect_h = sqlite3_column_int(stmt, 5);
887 face->orientation = sqlite3_column_int(stmt, 6);
888 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
890 if (callback((media_face_h)face, user_data) == false) {
891 media_face_destroy((media_face_h)face);
895 media_face_destroy((media_face_h)face);
898 SQLITE3_FINALIZE(stmt);
904 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
906 int ret = MEDIA_CONTENT_ERROR_NONE;
907 sqlite3_stmt *stmt = NULL;
908 char *select_query = NULL;
909 char *condition_query = NULL;
910 char *option_query = NULL;
911 #ifdef _USE_TVPD_MODE
912 filter_s *_filter = (filter_s *)filter;
914 switch (group_type) {
915 case MEDIA_GROUP_ALBUM:
916 #ifdef _USE_TVPD_MODE
917 if (_filter && STRING_VALID(_filter->storage_id))
918 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
920 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
922 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
926 case MEDIA_GROUP_PLAYLIST:
927 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
930 case MEDIA_GROUP_TAG:
931 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_TAG, group_id);
935 content_error("INVALID_PARAMETER");
936 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
939 ret = __media_db_make_query(filter, &condition_query, &option_query);
940 if (ret != MEDIA_CONTENT_ERROR_NONE) {
941 g_free(select_query);
945 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
946 g_free(select_query);
947 g_free(condition_query);
948 g_free(option_query);
949 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
951 if (sqlite3_step(stmt) == SQLITE_ROW)
952 *item_count = sqlite3_column_int(stmt, 0);
954 SQLITE3_FINALIZE(stmt);
959 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
961 int ret = MEDIA_CONTENT_ERROR_NONE;
962 sqlite3_stmt *stmt = NULL;
963 char *select_query = NULL;
964 char *condition_query = NULL;
965 char *option_query = NULL;
966 char *tmp_option = NULL;
967 bool need_bracket = false;
968 filter_s *_filter = (filter_s *)filter;
970 switch (group_type) {
971 case MEDIA_GROUP_NONE:
973 #ifdef _USE_TVPD_MODE
974 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
976 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
981 if (_filter->offset < 0 && _filter->count < 0) {
982 #ifdef _USE_TVPD_MODE
983 if (STRING_VALID(_filter->storage_id))
984 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
986 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
988 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
991 #ifdef _USE_TVPD_MODE
992 if (STRING_VALID(_filter->storage_id))
993 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
995 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
997 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA);
1003 case MEDIA_GROUP_FOLDER:
1004 #ifdef _USE_TVPD_MODE
1005 if (_filter && STRING_VALID(_filter->storage_id))
1006 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1008 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1010 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1014 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1015 select_query = g_strdup_printf(SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1018 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1019 #ifdef _USE_TVPD_MODE
1020 if (_filter && STRING_VALID(_filter->storage_id))
1021 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1023 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1025 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1029 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1030 #ifdef _USE_TVPD_MODE
1031 if (_filter && STRING_VALID(_filter->storage_id))
1032 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1034 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1036 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1040 #ifdef _USE_TVPD_MODE
1041 case MEDIA_GROUP_PVR:
1042 if (_filter && STRING_VALID(_filter->storage_id))
1043 select_query = g_strdup_printf(SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1045 select_query = g_strdup(SELECT_PVR_COUNT);
1048 case MEDIA_GROUP_UHD:
1049 if (_filter && STRING_VALID(_filter->storage_id))
1050 select_query = g_strdup_printf(SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1052 select_query = g_strdup(SELECT_UHD_COUNT);
1056 content_error("INVALID_PARAMETER");
1057 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1060 ret = __media_db_make_query(filter, &condition_query, &option_query);
1061 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1062 g_free(select_query);
1067 tmp_option = g_strconcat(option_query, ")", NULL);
1068 g_free(option_query);
1069 option_query = tmp_option;
1072 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1073 g_free(select_query);
1074 g_free(condition_query);
1075 g_free(option_query);
1076 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1078 if (sqlite3_step(stmt) == SQLITE_ROW)
1079 *item_count = sqlite3_column_int(stmt, 0);
1081 SQLITE3_FINALIZE(stmt);
1086 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)
1088 int ret = MEDIA_CONTENT_ERROR_NONE;
1089 char *select_query = NULL;
1090 char *condition_query = NULL;
1091 char *option_query = NULL;
1092 sqlite3_stmt *stmt = NULL;
1093 #ifdef _USE_TVPD_MODE
1094 filter_s *_filter = (filter_s *)filter;
1097 switch (group_type) {
1098 case MEDIA_GROUP_ALBUM:
1099 #ifdef _USE_TVPD_MODE
1100 if (_filter && STRING_VALID(_filter->storage_id))
1101 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1103 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1105 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, group_id);
1109 case MEDIA_GROUP_PLAYLIST:
1110 #ifdef _USE_TVPD_MODE
1111 if (_filter && STRING_VALID(_filter->storage_id))
1112 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1114 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1116 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, group_id);
1120 case MEDIA_GROUP_TAG:
1121 #ifdef _USE_TVPD_MODE
1122 if (_filter && STRING_VALID(_filter->storage_id))
1123 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1125 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1127 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, group_id);
1132 content_error("INVALID_PARAMETER");
1133 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1136 ret = __media_db_make_query(filter, &condition_query, &option_query);
1137 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1138 g_free(select_query);
1142 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1143 g_free(select_query);
1144 g_free(condition_query);
1145 g_free(option_query);
1146 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1148 while (sqlite3_step(stmt) == SQLITE_ROW) {
1149 media_info_s *item = g_new0(media_info_s, 1);
1151 _media_info_item_get_detail(stmt, (media_info_h)item);
1153 if (callback((media_info_h)item, user_data) == false) {
1154 media_info_destroy((media_info_h)item);
1158 media_info_destroy((media_info_h)item);
1161 SQLITE3_FINALIZE(stmt);
1166 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)
1168 int ret = MEDIA_CONTENT_ERROR_NONE;
1169 char *select_query = NULL;
1170 char *condition_query = NULL;
1171 char *option_query = NULL;
1172 sqlite3_stmt *stmt = NULL;
1173 #ifdef _USE_TVPD_MODE
1174 filter_s *_filter = (filter_s *)filter;
1177 switch (group_type) {
1178 case MEDIA_GROUP_NONE:
1179 #ifdef _USE_TVPD_MODE
1180 if (_filter && STRING_VALID(_filter->storage_id))
1181 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, _filter->storage_id);
1183 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1185 select_query = g_strdup(SELECT_MEDIA_ITEM);
1189 case MEDIA_GROUP_FOLDER:
1190 #ifdef _USE_TVPD_MODE
1191 if (_filter && STRING_VALID(_filter->storage_id))
1192 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1194 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1196 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, group_name);
1201 content_error("INVALID_PARAMETER");
1202 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1205 ret = __media_db_make_query(filter, &condition_query, &option_query);
1206 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1207 g_free(select_query);
1211 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1212 g_free(select_query);
1213 g_free(condition_query);
1214 g_free(option_query);
1215 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1217 while (sqlite3_step(stmt) == SQLITE_ROW) {
1218 media_info_s *item = g_new0(media_info_s, 1);
1220 _media_info_item_get_detail(stmt, (media_info_h)item);
1222 if (callback((media_info_h)item, user_data) == false) {
1223 media_info_destroy((media_info_h)item);
1227 media_info_destroy((media_info_h)item);
1230 SQLITE3_FINALIZE(stmt);
1235 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1237 int ret = MEDIA_CONTENT_ERROR_NONE;
1238 sqlite3_stmt *stmt = NULL;
1239 char select_query[MAX_QUERY_SIZE] = {0, };
1240 char *tmp_option = NULL;
1241 char *condition_query = NULL;
1242 char *option_query = NULL;
1243 #ifdef _USE_TVPD_MODE
1244 filter_s *_filter = (filter_s *)filter;
1245 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1247 if (_filter && STRING_VALID(_filter->storage_id))
1248 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1250 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1252 if (_filter && STRING_VALID(_filter->storage_id))
1253 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1255 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1257 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1259 if (_filter && STRING_VALID(_filter->storage_id))
1260 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);
1262 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1264 if (_filter && STRING_VALID(_filter->storage_id))
1265 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1267 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1269 } else {/*uhd content*/
1271 if (_filter && STRING_VALID(_filter->storage_id))
1272 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);
1274 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1276 if (_filter && STRING_VALID(_filter->storage_id))
1277 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1279 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1284 sqlite3_snprintf(MAX_QUERY_SIZE, select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1286 snprintf(select_query, MAX_QUERY_SIZE, SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1288 ret = __media_db_make_query(filter, &condition_query, &option_query);
1289 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1291 /* If 'filter' is not NULL, 'option_query' must be created. */
1293 tmp_option = g_strconcat(option_query, ")", NULL);
1294 g_free(option_query);
1295 option_query = tmp_option;
1297 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1300 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1301 g_free(condition_query);
1302 g_free(option_query);
1303 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1305 if (sqlite3_step(stmt) == SQLITE_ROW)
1306 *item_count = sqlite3_column_int(stmt, 0);
1308 SQLITE3_FINALIZE(stmt);
1313 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)
1315 int ret = MEDIA_CONTENT_ERROR_NONE;
1316 char select_query[MAX_QUERY_SIZE] = {0, };
1317 char *condition_query = NULL;
1318 char *option_query = NULL;
1319 sqlite3_stmt *stmt = NULL;
1320 #ifdef _USE_TVPD_MODE
1321 filter_s *_filter = (filter_s *)filter;
1323 if (_filter && STRING_VALID(_filter->storage_id))
1324 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1326 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1328 if (_filter && STRING_VALID(_filter->storage_id))
1329 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1331 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1335 sqlite3_snprintf(MAX_QUERY_SIZE, select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1337 snprintf(select_query, MAX_QUERY_SIZE, SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1339 ret = __media_db_make_query(filter, &condition_query, &option_query);
1340 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1342 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1343 g_free(condition_query);
1344 g_free(option_query);
1345 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1347 while (sqlite3_step(stmt) == SQLITE_ROW) {
1348 media_info_s *item = g_new0(media_info_s, 1);
1350 _media_info_item_get_detail(stmt, (media_info_h)item);
1352 if (callback((media_info_h)item, user_data) == false) {
1353 media_info_destroy((media_info_h)item);
1357 media_info_destroy((media_info_h)item);
1360 SQLITE3_FINALIZE(stmt);
1365 #ifdef _USE_TVPD_MODE
1366 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1368 int ret = MEDIA_CONTENT_ERROR_NONE;
1369 sqlite3_stmt *stmt = NULL;
1370 char *select_query = NULL;
1372 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1374 ret = _content_get_result(select_query, &stmt);
1375 SQLITE3_SAFE_FREE(select_query);
1376 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1378 if (sqlite3_step(stmt) == SQLITE_ROW) {
1379 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1381 content_error("Invalid media_id[%s]", media_id);
1382 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1385 SQLITE3_FINALIZE(stmt);
1390 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)
1392 int ret = MEDIA_CONTENT_ERROR_NONE;
1393 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1394 char *condition_query = NULL;
1395 char *option_query = NULL;
1396 sqlite3_stmt *stmt = NULL;
1397 filter_s *_filter = (filter_s *)filter;
1400 if (_filter && STRING_VALID(_filter->storage_id))
1401 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);
1403 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1405 if (_filter && STRING_VALID(_filter->storage_id))
1406 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1408 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1411 ret = __media_db_make_query(filter, &condition_query, &option_query);
1412 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1414 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1415 g_free(condition_query);
1416 g_free(option_query);
1417 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1419 while (sqlite3_step(stmt) == SQLITE_ROW) {
1420 media_pvr_s *item = g_new0(media_pvr_s, 1);
1422 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1424 if (callback((media_pvr_h)item, user_data) == false) {
1425 media_info_destroy((media_pvr_h)item);
1429 media_pvr_destroy((media_pvr_h)item);
1432 SQLITE3_FINALIZE(stmt);
1438 MEDIA_PVR_MEDIA_ID = 0,
1439 MEDIA_PVR_STORAGE_ID,
1443 MEDIA_PVR_TIME_ZONE,
1447 MEDIA_PVR_CHANNEL_TYPE,
1448 MEDIA_PVR_CHANNEL_NAME,
1449 MEDIA_PVR_CHANNEL_NUM,
1450 MEDIA_PVR_SERVICE_PROFILE,
1451 MEDIA_PVR_PROGRAM_TITLE,
1452 MEDIA_PVR_PROGRAM_NUM,
1453 MEDIA_PVR_PROGRAM_CRID,
1458 MEDIA_PVR_EMBARGO_TIME,
1459 MEDIA_PVR_EXPIRY_TIME,
1460 MEDIA_PVR_START_TIME,
1461 MEDIA_PVR_PROGRAM_START_TIME,
1462 MEDIA_PVR_PROGRAM_END_TIME,
1463 MEDIA_PVR_PROGRAM_DATE,
1464 MEDIA_PVR_PARENTAL_RATING,
1465 MEDIA_PVR_TIMER_RECORD,
1466 MEDIA_PVR_SERIES_RECORD,
1471 MEDIA_PVR_HARDOF_HEARINGRADIO,
1472 MEDIA_PVR_DATA_SERVICE,
1473 MEDIA_PVR_CONTENT_LOCK,
1474 MEDIA_PVR_CONTENT_WATCH,
1475 MEDIA_PVR_HAS_AUDIO_ONLY,
1476 MEDIA_PVR_IS_LOCAL_RECORDED,
1477 MEDIA_PVR_RESOLUTION,
1478 MEDIA_PVR_ASPECTRATIO,
1479 MEDIA_PVR_MODIFIED_MONTH,
1480 MEDIA_PVR_SPORTS_TYPE,
1481 MEDIA_PVR_GUIDANCE_LENGTH,
1483 MEDIA_PVR_PLAY_COUNT,
1484 MEDIA_PVR_PRIVATE_DATA,
1485 MEDIA_PVR_HIGHLIGHT,
1486 } media_pvr_field_e;
1488 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1490 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1492 _pvr->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1493 _pvr->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1494 _pvr->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1495 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1496 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1497 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1498 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1499 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1500 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1501 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1502 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1503 _pvr->channel_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1504 _pvr->channel_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1505 _pvr->program_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1506 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1507 _pvr->program_crid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1508 _pvr->guidance = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1509 _pvr->synopsis = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1510 _pvr->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1511 _pvr->language = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1512 _pvr->modified_month = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1513 _pvr->private_data = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1514 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1515 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1516 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1517 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1518 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1519 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1520 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1521 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1522 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1523 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1524 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1525 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1526 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1527 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1528 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1529 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1530 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1531 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1532 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1533 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1534 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1535 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1536 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1537 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1538 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1539 _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1544 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1546 int ret = MEDIA_CONTENT_ERROR_NONE;
1547 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1548 char *condition_query = NULL;
1549 char *option_query = NULL;
1550 sqlite3_stmt *stmt = NULL;
1551 filter_s *_filter = (filter_s *)filter;
1553 if (_filter && STRING_VALID(_filter->storage_id))
1554 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1556 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1558 ret = __media_db_make_query(filter, &condition_query, &option_query);
1559 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1561 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1562 g_free(condition_query);
1563 g_free(option_query);
1564 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1566 while (sqlite3_step(stmt) == SQLITE_ROW) {
1567 media_pvr_s *_pvr = g_new0(media_pvr_s, 1);
1569 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1571 if (callback((media_pvr_h)_pvr, user_data) == false) {
1572 media_pvr_destroy((media_pvr_h) _pvr);
1576 media_pvr_destroy((media_pvr_h) _pvr);
1579 SQLITE3_FINALIZE(stmt);
1585 MEDIA_UHD_MEDIA_ID = 0,
1586 MEDIA_UHD_STORAGE_ID,
1589 MEDIA_UHD_CONTENT_ID,
1590 MEDIA_UHD_CONTENT_TITLE,
1591 MEDIA_UHD_FILE_NAME,
1592 MEDIA_UHD_FOLDER_ID,
1593 MEDIA_UHD_RELEASE_DATE,
1594 MEDIA_UHD_MODIFIED_TIME,
1595 MEDIA_UHD_PLAYED_POSITION,
1597 MEDIA_UHD_PLAYED_COUNT,
1598 } media_uhd_field_e;
1600 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1602 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1604 _uhd->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1605 _uhd->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1606 _uhd->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1607 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1608 _uhd->content_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1609 _uhd->content_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1610 _uhd->file_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1611 _uhd->release_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1612 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1613 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1614 _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1615 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1620 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1622 int ret = MEDIA_CONTENT_ERROR_NONE;
1623 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1624 char *condition_query = NULL;
1625 char *option_query = NULL;
1626 sqlite3_stmt *stmt = NULL;
1627 filter_s *_filter = (filter_s *)filter;
1629 if (_filter && STRING_VALID(_filter->storage_id))
1630 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1632 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1634 ret = __media_db_make_query(filter, &condition_query, &option_query);
1635 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1637 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1638 g_free(condition_query);
1639 g_free(option_query);
1640 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1642 while (sqlite3_step(stmt) == SQLITE_ROW) {
1643 media_uhd_s *_uhd = g_new0(media_uhd_s, 1);
1645 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1647 if (callback((media_uhd_h)_uhd, user_data) == false) {
1648 media_uhd_destroy((media_uhd_h) _uhd);
1651 media_uhd_destroy((media_uhd_h) _uhd);
1654 SQLITE3_FINALIZE(stmt);
1659 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1661 int ret = MEDIA_CONTENT_ERROR_NONE;
1662 char *condition_query = NULL;
1663 char *option_query = NULL;
1664 sqlite3_stmt *stmt = NULL;
1666 ret = __media_db_make_query(filter, &condition_query, &option_query);
1667 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1669 ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1670 g_free(condition_query);
1671 g_free(option_query);
1672 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1674 while (sqlite3_step(stmt) == SQLITE_ROW) {
1675 media_storage_s *_storage = g_new0(media_storage_s, 1);
1677 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1678 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1679 _storage->storage_type = sqlite3_column_int(stmt, 2);
1681 if (callback((media_storage_h)_storage, user_data) == false) {
1682 media_storage_destroy((media_storage_h) _storage);
1686 media_storage_destroy((media_storage_h) _storage);
1689 SQLITE3_FINALIZE(stmt);