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;
71 #ifdef _USE_SENIOR_MODE
72 case MEDIA_CONTENT_GROUP_CONTACT:
73 return DB_FIELD_MEDIA_CONTACT;
76 case MEDIA_CONTENT_GROUP_ALBUM:
77 return DB_FIELD_MEDIA_ALBUM;
78 case MEDIA_PVR_GROUP_DURATION:
79 return DB_FIELD_PVR_DURATION;
80 case MEDIA_PVR_GROUP_TIME_ZONE:
81 return DB_FIELD_PVR_TIME_ZONE;
82 case MEDIA_PVR_GROUP_PTC:
83 return DB_FIELD_PVR_PTC;
84 case MEDIA_PVR_GROUP_MAJOR:
85 return DB_FIELD_PVR_MAJOR;
86 case MEDIA_PVR_GROUP_MINOR:
87 return DB_FIELD_PVR_MINOR;
88 case MEDIA_PVR_GROUP_CHANNEL_TYPE:
89 return DB_FIELD_PVR_CHANNEL_TYPE;
90 case MEDIA_PVR_GROUP_CHANNEL_NAME:
91 return DB_FIELD_PVR_CHANNEL_NAME;
92 case MEDIA_PVR_GROUP_CHANNEL_NUM:
93 return DB_FIELD_PVR_CHANNEL_NUM;
94 case MEDIA_PVR_GROUP_PROGRAM_TITLE:
95 return DB_FIELD_PVR_PROGRAM_TITLE;
96 case MEDIA_PVR_GROUP_PROGRAM_NUM:
97 return DB_FIELD_PVR_PROGRAM_NUM;
98 case MEDIA_PVR_GROUP_PROGRAM_CRID:
99 return DB_FIELD_PVR_PROGRAM_CRID;
100 case MEDIA_PVR_GROUP_GUIDANCE:
101 return DB_FIELD_PVR_GUIDANCE;
102 case MEDIA_PVR_GROUP_SYNOPSIS:
103 return DB_FIELD_PVR_SYNOPSIS;
104 case MEDIA_PVR_GROUP_GENRE:
105 return DB_FIELD_PVR_GENRE;
106 case MEDIA_PVR_GROUP_LANGUAGE:
107 return DB_FIELD_PVR_LANGUAGE;
108 case MEDIA_PVR_GROUP_EMBARGO_TIME:
109 return DB_FIELD_PVR_EMBARGO_TIME;
110 case MEDIA_PVR_GROUP_EXPIRY_TIME:
111 return DB_FIELD_PVR_EXPIRY_TIME;
112 case MEDIA_PVR_GROUP_START_TIME:
113 return DB_FIELD_PVR_START_TIME;
114 case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
115 return DB_FIELD_PVR_PROGRAM_START_TIME;
116 case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
117 return DB_FIELD_PVR_PROGRAM_END_TIME;
118 case MEDIA_PVR_GROUP_PROGRAM_DATE:
119 return DB_FIELD_PVR_PROGRAM_DATE;
120 case MEDIA_PVR_GROUP_PARENTAL_RATING:
121 return DB_FIELD_PVR_PARENTAL_RATING;
122 case MEDIA_PVR_GROUP_TIMER_RECORD:
123 return DB_FIELD_PVR_TIMER_RECORD;
124 case MEDIA_PVR_GROUP_SERIES_RECORD:
125 return DB_FIELD_PVR_SERIES_RECORD;
126 case MEDIA_PVR_GROUP_HD:
127 return DB_FIELD_PVR_HD;
128 case MEDIA_PVR_GROUP_SUBTITLE:
129 return DB_FIELD_PVR_SUBTITLE;
130 case MEDIA_PVR_GROUP_TTX:
131 return DB_FIELD_PVR_TTX;
132 case MEDIA_PVR_GROUP_AD:
133 return DB_FIELD_PVR_AD;
134 case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
135 return DB_FIELD_PVR_HARDOF_HEARINGRADIO;
136 case MEDIA_PVR_GROUP_DATA_SERVICE:
137 return DB_FIELD_PVR_DATA_SERVICE;
138 case MEDIA_PVR_GROUP_CONTENT_LOCK:
139 return DB_FIELD_PVR_CONTENT_LOCK;
140 case MEDIA_PVR_GROUP_CONTENT_WATCH:
141 return DB_FIELD_PVR_CONTENT_WATCH;
142 case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
143 return DB_FIELD_PVR_HAS_AUDIO_ONLY;
144 case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
145 return DB_FIELD_PVR_IS_LOCAL_RECORD;
146 case MEDIA_PVR_GROUP_RESOLUTION:
147 return DB_FIELD_PVR_RESOLUTION;
148 case MEDIA_PVR_GROUP_ASPECTRATIO:
149 return DB_FIELD_PVR_ASPECTRATIO;
150 case MEDIA_PVR_GROUP_MODIFIED_MONTH:
151 return DB_FIELD_PVR_MODIFIED_DATE;
152 case MEDIA_PVR_GROUP_MODIFIED_DATE:
153 return DB_FIELD_PVR_MODIFIED_DATE;
154 case MEDIA_PVR_GROUP_SPORTS_TYPE:
155 return DB_FIELD_PVR_SPORTS_TYPE;
156 case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
157 return DB_FIELD_PVR_GUIDANCE_LENGTH;
158 case MEDIA_PVR_GROUP_TVMODE:
159 return DB_FIELD_PVR_TVMODE;
160 case MEDIA_PVR_GROUP_PLAY_COUNT:
161 return DB_FIELD_PVR_PLAY_COUNT;
162 case MEDIA_PVR_GROUP_PRIVATE_DATA:
163 return DB_FIELD_PVR_PRIVATE_DATA;
164 case MEDIA_UHD_GROUP_CONTENT_TITLE:
165 return DB_FIELD_UHD_CONTENT_TITLE;
166 case MEDIA_UHD_GROUP_RELEASE_DATE:
167 return DB_FIELD_UHD_RELEASE_DATE;
168 case MEDIA_UHD_GROUP_SUB_TYPE:
169 return DB_FIELD_UHD_SUB_TYPE;
170 case MEDIA_UHD_GROUP_FILE_NAME:
171 return DB_FIELD_UHD_FILE_NAME;
172 case MEDIA_UHD_GROUP_PLAYED_COUNT:
173 return DB_FIELD_UHD_PLAYED_COUNT;
182 static int __media_db_make_query(filter_h filter, char **condition_query, char **option_query)
184 int ret = MEDIA_CONTENT_ERROR_NONE;
185 filter_s *_filter = (filter_s *)filter;
187 content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
189 if (STRING_VALID(_filter->condition)) {
190 ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
191 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
194 ret = _media_filter_build_option(filter, option_query);
195 if (ret != MEDIA_CONTENT_ERROR_NONE)
196 g_free(*condition_query);
201 #ifdef _USE_TVPD_MODE
202 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
204 int ret = MEDIA_CONTENT_ERROR_NONE;
205 sqlite3_stmt *stmt = NULL;
206 char *select_query = NULL;
207 char *condition_query = NULL;
208 char *option_query = NULL;
209 filter_s *_filter = (filter_s *)filter;
211 switch (group_type) {
212 case MEDIA_GROUP_ALBUM:
213 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
214 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, _filter->storage_id);
216 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
219 case MEDIA_GROUP_FOLDER:
220 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
221 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
223 select_query = g_strdup_printf(SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
226 case MEDIA_GROUP_PLAYLIST:
227 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
230 case MEDIA_GROUP_TAG:
231 select_query = g_strdup(SELECT_TAG_COUNT);
234 case MEDIA_GROUP_BOOKMARK:
235 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
236 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, _filter->storage_id);
238 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
242 case MEDIA_GROUP_STORAGE:
243 select_query = g_strdup(SELECT_STORAGE_COUNT);
246 case MEDIA_GROUP_FACE:
247 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
248 select_query = g_strdup_printf(SELECT_FACE_COUNT, _filter->storage_id);
250 select_query = g_strdup_printf(SELECT_FACE_COUNT, DB_VIEW_MEDIA);
254 content_error("Invalid group type [%d]", group_type);
255 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
258 ret = __media_db_make_query(filter, &condition_query, &option_query);
259 if (ret != MEDIA_CONTENT_ERROR_NONE) {
260 g_free(select_query);
264 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
265 g_free(select_query);
266 g_free(condition_query);
267 g_free(option_query);
268 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
270 if (sqlite3_step(stmt) == SQLITE_ROW)
271 *group_count = sqlite3_column_int(stmt, 0);
273 SQLITE3_FINALIZE(stmt);
278 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
280 int ret = MEDIA_CONTENT_ERROR_NONE;
281 sqlite3_stmt *stmt = NULL;
282 char select_query[MAX_QUERY_SIZE] = {0, };
283 char *condition_query = NULL;
284 char *option_query = NULL;
285 char *tmp_option = NULL;
286 filter_s *_filter = (filter_s *)filter;
288 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
289 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
290 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
292 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
293 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
294 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
295 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
297 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
298 } else { /*uhd content*/
299 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
300 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
302 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
304 ret = __media_db_make_query(filter, &condition_query, &option_query);
305 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
308 tmp_option = g_strconcat(option_query, ")", NULL);
309 g_free(option_query);
310 option_query = tmp_option;
312 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
315 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
316 SAFE_FREE(condition_query);
317 SAFE_FREE(option_query);
318 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
320 if (sqlite3_step(stmt) == SQLITE_ROW)
321 *group_count = sqlite3_column_int(stmt, 0);
323 SQLITE3_FINALIZE(stmt);
328 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
330 int ret = MEDIA_CONTENT_ERROR_NONE;
331 char select_query[MAX_QUERY_SIZE] = {0, };
332 char *condition_query = NULL;
333 char *option_query = NULL;
335 sqlite3_stmt *stmt = NULL;
336 filter_s *_filter = (filter_s *)filter;
338 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
339 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
340 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
342 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
343 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
344 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
345 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
347 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
348 } else { /* uhd content */
349 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
350 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
352 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
354 ret = __media_db_make_query(filter, &condition_query, &option_query);
355 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
357 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
358 SAFE_FREE(condition_query);
359 SAFE_FREE(option_query);
360 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
362 while (sqlite3_step(stmt) == SQLITE_ROW) {
363 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
365 if (callback(name, user_data) == false) {
373 SQLITE3_FINALIZE(stmt);
378 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
380 int ret = MEDIA_CONTENT_ERROR_NONE;
381 char select_query[DEFAULT_QUERY_SIZE] = {0, };
382 char group_query[DEFAULT_QUERY_SIZE] = {0, };
383 char *condition_query = NULL;
384 char *option_query = NULL;
386 sqlite3_stmt *stmt = NULL;
387 filter_s *_filter = (filter_s *)filter;
389 const char* group_name = __media_db_get_group_name(group);
390 if (!STRING_VALID(group_name)) {
391 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
392 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
395 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
396 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
397 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
399 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
400 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
401 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
402 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
404 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
405 } else {/*uhd content*/
406 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
407 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
409 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
412 ret = __media_db_make_query(filter, &condition_query, &option_query);
413 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
415 if (STRING_VALID(option_query))
416 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
418 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
420 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
421 SAFE_FREE(condition_query);
422 SAFE_FREE(option_query);
423 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
425 while (sqlite3_step(stmt) == SQLITE_ROW) {
426 if (STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
427 name = strdup((const char *)sqlite3_column_text(stmt, 0));
429 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
437 SQLITE3_FINALIZE(stmt);
442 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
444 int ret = MEDIA_CONTENT_ERROR_NONE;
445 sqlite3_stmt *stmt = NULL;
446 char *select_query = NULL;
447 char *condition_query = NULL;
448 char *option_query = NULL;
449 filter_s *_filter = (filter_s *)filter;
451 switch (group_type) {
452 case MEDIA_GROUP_ALBUM:
453 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
454 select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
456 select_query = g_strdup(SELECT_ALBUM_COUNT);
459 case MEDIA_GROUP_FOLDER:
460 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
461 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
463 select_query = g_strdup(SELECT_FOLDER_COUNT);
466 case MEDIA_GROUP_PLAYLIST:
467 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
470 case MEDIA_GROUP_TAG:
471 select_query = g_strdup(SELECT_TAG_COUNT);
474 case MEDIA_GROUP_BOOKMARK:
475 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
476 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
478 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
482 case MEDIA_GROUP_STORAGE:
483 select_query = g_strdup(SELECT_STORAGE_COUNT);
486 case MEDIA_GROUP_FACE:
487 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
488 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
490 select_query = g_strdup(SELECT_FACE_COUNT);
494 content_error("Invalid group type [%d]", group_type);
495 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
498 ret = __media_db_make_query(filter, &condition_query, &option_query);
499 if (ret != MEDIA_CONTENT_ERROR_NONE) {
500 g_free(select_query);
504 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
505 g_free(select_query);
506 g_free(condition_query);
507 g_free(option_query);
508 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
510 if (sqlite3_step(stmt) == SQLITE_ROW)
511 *group_count = sqlite3_column_int(stmt, 0);
513 SQLITE3_FINALIZE(stmt);
518 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
520 int ret = MEDIA_CONTENT_ERROR_NONE;
521 sqlite3_stmt *stmt = NULL;
522 char *select_query = NULL;
523 char *condition_query = NULL;
524 char *option_query = NULL;
525 filter_s *_filter = (filter_s *)filter;
527 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
528 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), __media_db_get_group_name(group), _filter->storage_id);
530 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
532 ret = __media_db_make_query(filter, &condition_query, &option_query);
533 if (ret != MEDIA_CONTENT_ERROR_NONE) {
534 g_free(select_query);
538 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
539 g_free(select_query);
540 g_free(condition_query);
541 g_free(option_query);
542 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
544 if (sqlite3_step(stmt) == SQLITE_ROW)
545 *group_count = sqlite3_column_int(stmt, 0);
547 SQLITE3_FINALIZE(stmt);
552 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
554 int ret = MEDIA_CONTENT_ERROR_NONE;
555 char *select_query = NULL;
556 char *condition_query = NULL;
557 char *option_query = NULL;
559 sqlite3_stmt *stmt = NULL;
560 filter_s *_filter = (filter_s *)filter;
562 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
563 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
565 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
567 ret = __media_db_make_query(filter, &condition_query, &option_query);
568 if (ret != MEDIA_CONTENT_ERROR_NONE) {
569 g_free(select_query);
573 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
574 g_free(select_query);
575 g_free(condition_query);
576 g_free(option_query);
577 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
579 while (sqlite3_step(stmt) == SQLITE_ROW) {
580 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
582 if (callback(name, user_data) == false) {
590 SQLITE3_FINALIZE(stmt);
596 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
598 int ret = MEDIA_CONTENT_ERROR_NONE;
599 char select_query[MAX_QUERY_SIZE] = {0, };
600 char *condition_query = NULL;
601 char *option_query = NULL;
602 sqlite3_stmt *stmt = NULL;
603 filter_s *_filter = (filter_s *)filter;
605 #ifdef _USE_TVPD_MODE
606 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
607 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
609 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
611 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
612 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
614 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
616 ret = __media_db_make_query(filter, &condition_query, &option_query);
617 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
619 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
620 SAFE_FREE(condition_query);
621 SAFE_FREE(option_query);
622 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
624 while (sqlite3_step(stmt) == SQLITE_ROW) {
625 media_album_s *album = (media_album_s*)calloc(1, sizeof(media_album_s));
628 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
629 SQLITE3_FINALIZE(stmt);
630 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
633 album->album_id = sqlite3_column_int(stmt, 0);
634 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
635 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
636 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
638 if (callback((media_album_h)album, user_data) == false) {
639 media_album_destroy((media_album_h)album);
643 media_album_destroy((media_album_h)album);
646 SQLITE3_FINALIZE(stmt);
651 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
653 int ret = MEDIA_CONTENT_ERROR_NONE;
654 char select_query[MAX_QUERY_SIZE] = {0, };
655 char *condition_query = NULL;
656 char *option_query = NULL;
657 sqlite3_stmt *stmt = NULL;
658 filter_s *_filter = (filter_s *)filter;
660 #ifdef _USE_TVPD_MODE
661 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
662 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
664 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
666 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
667 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
669 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
671 ret = __media_db_make_query(filter, &condition_query, &option_query);
672 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
674 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
675 SAFE_FREE(condition_query);
676 SAFE_FREE(option_query);
677 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
679 while (sqlite3_step(stmt) == SQLITE_ROW) {
680 media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
682 if (_folder == NULL) {
683 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
684 SQLITE3_FINALIZE(stmt);
685 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
688 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
689 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
690 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
691 _folder->storage_type = sqlite3_column_int(stmt, 3);
692 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
694 if (callback((media_folder_h)_folder, user_data) == false) {
695 media_folder_destroy((media_folder_h) _folder);
699 media_folder_destroy((media_folder_h) _folder);
702 SQLITE3_FINALIZE(stmt);
707 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
709 int ret = MEDIA_CONTENT_ERROR_NONE;
710 char *condition_query = NULL;
711 char *option_query = NULL;
712 sqlite3_stmt *stmt = NULL;
714 ret = __media_db_make_query(filter, &condition_query, &option_query);
715 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
717 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
718 SAFE_FREE(condition_query);
719 SAFE_FREE(option_query);
720 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
722 while (sqlite3_step(stmt) == SQLITE_ROW) {
723 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
725 if (_playlist == NULL) {
726 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
727 SQLITE3_FINALIZE(stmt);
728 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
731 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
732 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
733 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
735 if (callback((media_playlist_h)_playlist, user_data) == false) {
736 media_playlist_destroy((media_playlist_h)_playlist);
739 media_playlist_destroy((media_playlist_h)_playlist);
742 SQLITE3_FINALIZE(stmt);
747 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
749 int ret = MEDIA_CONTENT_ERROR_NONE;
750 char *select_query = NULL;
751 char *condition_query = NULL;
752 char *option_query = NULL;
753 sqlite3_stmt *stmt = NULL;
755 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
757 ret = __media_db_make_query(filter, &condition_query, &option_query);
758 if (ret != MEDIA_CONTENT_ERROR_NONE) {
759 g_free(select_query);
763 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
764 g_free(select_query);
765 g_free(condition_query);
766 g_free(option_query);
767 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
769 while (sqlite3_step(stmt) == SQLITE_ROW) {
770 int playlist_member_id = 0;
771 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
773 media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
775 if (_media == NULL) {
776 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
777 SQLITE3_FINALIZE(stmt);
778 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
781 _media_info_item_get_detail(stmt, (media_info_h)_media);
783 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
784 media_info_destroy((media_info_h)_media);
787 media_info_destroy((media_info_h)_media);
791 SQLITE3_FINALIZE(stmt);
796 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
798 int ret = MEDIA_CONTENT_ERROR_NONE;
799 char *select_query = NULL;
800 char *condition_query = NULL;
801 char *option_query = NULL;
802 sqlite3_stmt *stmt = NULL;
804 if (STRING_VALID(media_id))
805 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
807 select_query = g_strdup(SELECT_TAG_LIST);
809 ret = __media_db_make_query(filter, &condition_query, &option_query);
810 if (ret != MEDIA_CONTENT_ERROR_NONE) {
811 g_free(select_query);
815 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
816 g_free(select_query);
817 g_free(condition_query);
818 g_free(option_query);
819 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
821 while (sqlite3_step(stmt) == SQLITE_ROW) {
822 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
825 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
826 SQLITE3_FINALIZE(stmt);
827 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
830 _tag->tag_id = sqlite3_column_int(stmt, 0);
831 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
833 if (callback((media_tag_h)_tag, user_data) == false) {
834 media_tag_destroy((media_tag_h)_tag);
837 media_tag_destroy((media_tag_h)_tag);
840 SQLITE3_FINALIZE(stmt);
845 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
847 int ret = MEDIA_CONTENT_ERROR_NONE;
848 char select_query[MAX_QUERY_SIZE] = {0, };
849 char *condition_query = NULL;
850 char *option_query = NULL;
851 sqlite3_stmt *stmt = NULL;
852 filter_s *_filter = (filter_s *)filter;
854 #ifdef _USE_TVPD_MODE
855 if (STRING_VALID(media_id)) { //get bookmark by media_id
856 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
857 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
859 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
861 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
862 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, _filter->storage_id);
864 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
867 if (STRING_VALID(media_id)) { //get bookmark by media_id
868 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
870 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
871 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
873 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
877 ret = __media_db_make_query(filter, &condition_query, &option_query);
878 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
880 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
881 SAFE_FREE(condition_query);
882 SAFE_FREE(option_query);
883 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
885 while (sqlite3_step(stmt) == SQLITE_ROW) {
886 media_bookmark_s *bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
888 if (bookmark == NULL) {
889 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
890 SQLITE3_FINALIZE(stmt);
891 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
894 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
895 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
896 bookmark->marked_time = sqlite3_column_int(stmt, 2);
897 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
898 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
900 if (callback((media_bookmark_h)bookmark, user_data) == false) {
901 media_bookmark_destroy((media_bookmark_h)bookmark);
905 media_bookmark_destroy((media_bookmark_h)bookmark);
908 SQLITE3_FINALIZE(stmt);
914 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
916 int ret = MEDIA_CONTENT_ERROR_NONE;
917 char select_query[MAX_QUERY_SIZE] = {0, };
918 char *condition_query = NULL;
919 char *option_query = NULL;
920 sqlite3_stmt *stmt = NULL;
921 filter_s *_filter = (filter_s *)filter;
923 #ifdef _USE_TVPD_MODE
924 if (STRING_VALID(media_id)) { //get face by media_id
925 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
926 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
928 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
930 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
931 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, _filter->storage_id);
933 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
936 if (STRING_VALID(media_id)) { //get face by media_id
937 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
939 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
940 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
942 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
945 ret = __media_db_make_query(filter, &condition_query, &option_query);
946 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
948 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
949 SAFE_FREE(condition_query);
950 SAFE_FREE(option_query);
951 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
953 while (sqlite3_step(stmt) == SQLITE_ROW) {
954 media_face_s *face = (media_face_s*)calloc(1, sizeof(media_face_s));
957 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
958 SQLITE3_FINALIZE(stmt);
959 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
962 face->face_id = sqlite3_column_int(stmt, 0);
963 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
964 face->face_rect_x = sqlite3_column_int(stmt, 2);
965 face->face_rect_y = sqlite3_column_int(stmt, 3);
966 face->face_rect_w = sqlite3_column_int(stmt, 4);
967 face->face_rect_h = sqlite3_column_int(stmt, 5);
968 face->orientation = sqlite3_column_int(stmt, 6);
969 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
971 if (callback((media_face_h)face, user_data) == false) {
972 media_face_destroy((media_face_h)face);
976 media_face_destroy((media_face_h)face);
979 SQLITE3_FINALIZE(stmt);
985 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
987 int ret = MEDIA_CONTENT_ERROR_NONE;
988 sqlite3_stmt *stmt = NULL;
989 char select_query[MAX_QUERY_SIZE] = {0, };
990 char *condition_query = NULL;
991 char *option_query = NULL;
992 filter_s *_filter = (filter_s *)filter;
994 switch (group_type) {
995 case MEDIA_GROUP_ALBUM:
996 #ifdef _USE_TVPD_MODE
997 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
998 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
1000 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1002 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1003 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1005 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
1009 case MEDIA_GROUP_PLAYLIST:
1010 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
1013 case MEDIA_GROUP_TAG:
1014 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
1018 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1019 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1022 ret = __media_db_make_query(filter, &condition_query, &option_query);
1023 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1025 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1026 SAFE_FREE(condition_query);
1027 SAFE_FREE(option_query);
1028 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1030 if (sqlite3_step(stmt) == SQLITE_ROW)
1031 *item_count = sqlite3_column_int(stmt, 0);
1033 SQLITE3_FINALIZE(stmt);
1038 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
1040 int ret = MEDIA_CONTENT_ERROR_NONE;
1041 sqlite3_stmt *stmt = NULL;
1042 char select_query[MAX_QUERY_SIZE] = {0, };
1043 char *condition_query = NULL;
1044 char *option_query = NULL;
1045 char *tmp_option = NULL;
1046 bool need_bracket = false;
1047 filter_s *_filter = (filter_s *)filter;
1049 switch (group_type) {
1050 case MEDIA_GROUP_NONE:
1052 #ifdef _USE_TVPD_MODE
1053 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1055 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1060 if (_filter->offset < 0 && _filter->count < 0) {
1061 #ifdef _USE_TVPD_MODE
1062 if (STRING_VALID(_filter->storage_id))
1063 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1065 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1067 if (STRING_VALID(_filter->storage_id))
1068 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1070 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1073 #ifdef _USE_TVPD_MODE
1074 if (STRING_VALID(_filter->storage_id))
1075 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
1077 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1079 if (STRING_VALID(_filter->storage_id))
1080 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_BY_STORAGE_ID, _filter->storage_id);
1082 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
1085 need_bracket = true;
1089 case MEDIA_GROUP_FOLDER:
1090 #ifdef _USE_TVPD_MODE
1091 if (_filter && STRING_VALID(_filter->storage_id))
1092 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1094 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1096 if (_filter && STRING_VALID(_filter->storage_id))
1097 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1099 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1103 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1104 snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1107 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1108 #ifdef _USE_TVPD_MODE
1109 if (_filter && STRING_VALID(_filter->storage_id))
1110 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1112 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1114 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1118 case MEDIA_GROUP_STORAGE:
1119 #ifdef _USE_TVPD_MODE
1120 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1122 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1126 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1127 #ifdef _USE_TVPD_MODE
1128 if (_filter && STRING_VALID(_filter->storage_id))
1129 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1131 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1133 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1137 #ifdef _USE_TVPD_MODE
1138 case MEDIA_GROUP_PVR:
1139 if (_filter && STRING_VALID(_filter->storage_id))
1140 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1142 SAFE_STRLCPY(select_query, SELECT_PVR_COUNT, sizeof(select_query));
1145 case MEDIA_GROUP_UHD:
1146 if (_filter && STRING_VALID(_filter->storage_id))
1147 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1149 SAFE_STRLCPY(select_query, SELECT_UHD_COUNT, sizeof(select_query));
1153 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1154 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1157 ret = __media_db_make_query(filter, &condition_query, &option_query);
1158 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1161 tmp_option = g_strconcat(option_query, ")", NULL);
1162 g_free(option_query);
1163 option_query = tmp_option;
1166 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1167 SAFE_FREE(condition_query);
1168 SAFE_FREE(option_query);
1169 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1171 if (sqlite3_step(stmt) == SQLITE_ROW)
1172 *item_count = sqlite3_column_int(stmt, 0);
1174 SQLITE3_FINALIZE(stmt);
1179 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)
1181 int ret = MEDIA_CONTENT_ERROR_NONE;
1182 char select_query[MAX_QUERY_SIZE] = {0, };
1183 char *condition_query = NULL;
1184 char *option_query = NULL;
1185 sqlite3_stmt *stmt = NULL;
1186 filter_s *_filter = (filter_s *)filter;
1188 switch (group_type) {
1189 case MEDIA_GROUP_ALBUM:
1190 #ifdef _USE_TVPD_MODE
1191 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1192 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1194 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1196 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1197 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1199 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
1203 case MEDIA_GROUP_PLAYLIST:
1204 #ifdef _USE_TVPD_MODE
1205 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1206 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1208 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1210 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1211 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1213 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
1217 case MEDIA_GROUP_TAG:
1218 #ifdef _USE_TVPD_MODE
1219 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1220 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1222 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1224 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1225 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1227 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
1232 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1233 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1236 ret = __media_db_make_query(filter, &condition_query, &option_query);
1237 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1239 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1240 SAFE_FREE(condition_query);
1241 SAFE_FREE(option_query);
1242 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1244 while (sqlite3_step(stmt) == SQLITE_ROW) {
1245 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1247 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1248 SQLITE3_FINALIZE(stmt);
1249 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1252 _media_info_item_get_detail(stmt, (media_info_h)item);
1254 if (callback((media_info_h)item, user_data) == false) {
1255 media_info_destroy((media_info_h)item);
1259 media_info_destroy((media_info_h)item);
1262 SQLITE3_FINALIZE(stmt);
1267 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)
1269 int ret = MEDIA_CONTENT_ERROR_NONE;
1270 char select_query[MAX_QUERY_SIZE] = {0, };
1271 char *condition_query = NULL;
1272 char *option_query = NULL;
1273 sqlite3_stmt *stmt = NULL;
1274 filter_s *_filter = (filter_s *)filter;
1276 switch (group_type) {
1277 case MEDIA_GROUP_NONE:
1278 #ifdef _USE_TVPD_MODE
1279 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1280 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
1282 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1284 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1285 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1287 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
1291 case MEDIA_GROUP_FOLDER:
1292 #ifdef _USE_TVPD_MODE
1293 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1294 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1296 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1298 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
1302 case MEDIA_GROUP_STORAGE:
1303 #ifdef _USE_TVPD_MODE
1304 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1306 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
1311 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1312 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1315 ret = __media_db_make_query(filter, &condition_query, &option_query);
1316 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1318 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1319 SAFE_FREE(condition_query);
1320 SAFE_FREE(option_query);
1321 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1323 while (sqlite3_step(stmt) == SQLITE_ROW) {
1324 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1326 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1327 SQLITE3_FINALIZE(stmt);
1328 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1331 _media_info_item_get_detail(stmt, (media_info_h)item);
1333 if (callback((media_info_h)item, user_data) == false) {
1334 media_info_destroy((media_info_h)item);
1338 media_info_destroy((media_info_h)item);
1341 SQLITE3_FINALIZE(stmt);
1346 #ifdef _USE_SENIOR_MODE
1347 int _media_db_get_group_item_by_union_select(const char *group_name, filter_h filter1, filter_h filter2, media_info_cb callback, void *user_data)
1349 int ret = MEDIA_CONTENT_ERROR_NONE;
1350 char select_query1[MAX_QUERY_SIZE] = {0, };
1351 char *condition_query1 = NULL;
1352 char *option_query1 = NULL;
1353 char select_query2[MAX_QUERY_SIZE] = {0, };
1354 char *condition_query2 = NULL;
1355 char *option_query2 = NULL;
1356 sqlite3_stmt *stmt = NULL;
1357 filter_s *_filter1 = (filter_s *)filter1;
1358 filter_s *_filter2 = (filter_s *)filter2;
1360 if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
1361 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, _filter1->storage_id, group_name);
1363 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1365 ret = __media_db_make_query(filter, &condition_query, &option_query);
1366 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1367 SAFE_FREE(condition_query1);
1368 SAFE_FREE(option_query1);
1369 content_error("create select_query1 failed");
1373 if ((_filter2 != NULL) && STRING_VALID(_filter2->storage_id))
1374 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, _filter2->storage_id, group_name);
1376 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1378 ret = __media_db_make_query(filter, &condition_query, &option_query);
1379 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1380 SAFE_FREE(condition_query1);
1381 SAFE_FREE(option_query1);
1382 SAFE_FREE(condition_query2);
1383 SAFE_FREE(option_query2);
1384 content_error("create select_query2 failed");
1388 ret = _content_query_prepare_by_union_select(&stmt, select_query1, condition_query1, option_query1, select_query2, condition_query2, option_query2);
1389 SAFE_FREE(condition_query1);
1390 SAFE_FREE(option_query1);
1391 SAFE_FREE(condition_query2);
1392 SAFE_FREE(option_query2);
1393 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1395 while (sqlite3_step(stmt) == SQLITE_ROW) {
1396 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1398 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1399 SQLITE3_FINALIZE(stmt);
1400 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1403 _media_info_item_get_detail(stmt, (media_info_h)item);
1405 if (callback((media_info_h)item, user_data) == false) {
1406 media_info_destroy((media_info_h)item);
1410 media_info_destroy((media_info_h)item);
1413 SQLITE3_FINALIZE(stmt);
1419 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1421 int ret = MEDIA_CONTENT_ERROR_NONE;
1422 sqlite3_stmt *stmt = NULL;
1423 char select_query[MAX_QUERY_SIZE] = {0, };
1424 char *tmp_option = NULL;
1425 char *condition_query = NULL;
1426 char *option_query = NULL;
1427 filter_s *_filter = (filter_s *)filter;
1429 #ifdef _USE_TVPD_MODE
1430 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1431 if (group_name != NULL) {
1432 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1433 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1435 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1437 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1438 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1440 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1442 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1443 if (group_name != NULL) {
1444 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1445 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);
1447 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1449 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1450 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1452 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1454 } else {/*uhd content*/
1455 if (group_name != NULL) {
1456 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1457 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);
1459 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1461 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1462 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1464 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1468 if (group_name != NULL) {
1469 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1470 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1472 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1474 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1475 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1477 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1480 ret = __media_db_make_query(filter, &condition_query, &option_query);
1481 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1483 /* If 'filter' is not NULL, 'option_query' must be created. */
1485 tmp_option = g_strconcat(option_query, ")", NULL);
1486 g_free(option_query);
1487 option_query = tmp_option;
1489 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1492 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1493 SAFE_FREE(condition_query);
1494 SAFE_FREE(option_query);
1495 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1497 if (sqlite3_step(stmt) == SQLITE_ROW)
1498 *item_count = sqlite3_column_int(stmt, 0);
1500 SQLITE3_FINALIZE(stmt);
1505 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)
1507 int ret = MEDIA_CONTENT_ERROR_NONE;
1508 char select_query[MAX_QUERY_SIZE] = {0, };
1509 char *condition_query = NULL;
1510 char *option_query = NULL;
1511 sqlite3_stmt *stmt = NULL;
1512 filter_s *_filter = (filter_s *)filter;
1514 #ifdef _USE_TVPD_MODE
1515 if (group_name != NULL) {
1516 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1517 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1519 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1521 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1522 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1524 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1527 if (group_name != NULL) {
1528 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1529 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1531 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1533 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1534 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1536 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1539 ret = __media_db_make_query(filter, &condition_query, &option_query);
1540 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1542 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1543 SAFE_FREE(condition_query);
1544 SAFE_FREE(option_query);
1545 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1547 while (sqlite3_step(stmt) == SQLITE_ROW) {
1548 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1550 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1551 SQLITE3_FINALIZE(stmt);
1552 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1555 _media_info_item_get_detail(stmt, (media_info_h)item);
1557 if (callback((media_info_h)item, user_data) == false) {
1558 media_info_destroy((media_info_h)item);
1562 media_info_destroy((media_info_h)item);
1565 SQLITE3_FINALIZE(stmt);
1570 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1572 int ret = MEDIA_CONTENT_ERROR_NONE;
1573 char *condition_query = NULL;
1574 char *option_query = NULL;
1575 sqlite3_stmt *stmt = NULL;
1577 ret = __media_db_make_query(filter, &condition_query, &option_query);
1578 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1580 ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1581 SAFE_FREE(condition_query);
1582 SAFE_FREE(option_query);
1583 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1585 while (sqlite3_step(stmt) == SQLITE_ROW) {
1586 media_storage_s *_storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
1588 if (_storage == NULL) {
1589 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1590 SQLITE3_FINALIZE(stmt);
1591 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1594 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1595 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1596 _storage->storage_type = sqlite3_column_int(stmt, 2);
1598 if (callback((media_storage_h)_storage, user_data) == false) {
1599 media_storage_destroy((media_storage_h) _storage);
1603 media_storage_destroy((media_storage_h) _storage);
1606 SQLITE3_FINALIZE(stmt);
1611 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1613 int ret = MEDIA_CONTENT_ERROR_NONE;
1614 sqlite3_stmt *stmt = NULL;
1615 char *select_query = NULL;
1617 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1619 ret = _content_get_result(select_query, &stmt);
1620 SQLITE3_SAFE_FREE(select_query);
1621 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1623 if (sqlite3_step(stmt) == SQLITE_ROW) {
1624 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1626 content_error("Invalid media_id[%s]", media_id);
1627 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1630 SQLITE3_FINALIZE(stmt);
1635 #ifdef _USE_TVPD_MODE
1636 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)
1638 int ret = MEDIA_CONTENT_ERROR_NONE;
1639 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1640 char *condition_query = NULL;
1641 char *option_query = NULL;
1642 sqlite3_stmt *stmt = NULL;
1643 filter_s *_filter = (filter_s *)filter;
1645 if (group_name != NULL) {
1646 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1647 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);
1649 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1651 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1652 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1654 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1657 ret = __media_db_make_query(filter, &condition_query, &option_query);
1658 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1660 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1661 SAFE_FREE(condition_query);
1662 SAFE_FREE(option_query);
1663 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1665 while (sqlite3_step(stmt) == SQLITE_ROW) {
1666 media_pvr_s *item = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1668 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1669 SQLITE3_FINALIZE(stmt);
1670 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1673 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1675 if (callback((media_pvr_h)item, user_data) == false) {
1676 media_info_destroy((media_pvr_h)item);
1680 media_pvr_destroy((media_pvr_h)item);
1683 SQLITE3_FINALIZE(stmt);
1689 MEDIA_PVR_MEDIA_ID = 0,
1690 MEDIA_PVR_STORAGE_ID,
1694 MEDIA_PVR_TIME_ZONE,
1698 MEDIA_PVR_CHANNEL_TYPE,
1699 MEDIA_PVR_CHANNEL_NAME,
1700 MEDIA_PVR_CHANNEL_NUM,
1701 MEDIA_PVR_SERVICE_PROFILE,
1702 MEDIA_PVR_PROGRAM_TITLE,
1703 MEDIA_PVR_PROGRAM_NUM,
1704 MEDIA_PVR_PROGRAM_CRID,
1709 MEDIA_PVR_EMBARGO_TIME,
1710 MEDIA_PVR_EXPIRY_TIME,
1711 MEDIA_PVR_START_TIME,
1712 MEDIA_PVR_PROGRAM_START_TIME,
1713 MEDIA_PVR_PROGRAM_END_TIME,
1714 MEDIA_PVR_PROGRAM_DATE,
1715 MEDIA_PVR_PARENTAL_RATING,
1716 MEDIA_PVR_TIMER_RECORD,
1717 MEDIA_PVR_SERIES_RECORD,
1722 MEDIA_PVR_HARDOF_HEARINGRADIO,
1723 MEDIA_PVR_DATA_SERVICE,
1724 MEDIA_PVR_CONTENT_LOCK,
1725 MEDIA_PVR_CONTENT_WATCH,
1726 MEDIA_PVR_HAS_AUDIO_ONLY,
1727 MEDIA_PVR_IS_LOCAL_RECORDED,
1728 MEDIA_PVR_RESOLUTION,
1729 MEDIA_PVR_ASPECTRATIO,
1730 MEDIA_PVR_MODIFIED_MONTH,
1731 MEDIA_PVR_SPORTS_TYPE,
1732 MEDIA_PVR_GUIDANCE_LENGTH,
1734 MEDIA_PVR_PLAY_COUNT,
1735 MEDIA_PVR_PRIVATE_DATA,
1736 MEDIA_PVR_HIGHLIGHT,
1737 } media_pvr_field_e;
1739 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1741 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1743 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID)))
1744 _pvr->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1746 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID)))
1747 _pvr->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1749 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH)))
1750 _pvr->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1752 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1754 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1756 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1758 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1760 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1762 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1764 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1766 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1768 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME)))
1769 _pvr->channel_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1771 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM)))
1772 _pvr->channel_num = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1774 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE)))
1775 _pvr->program_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1777 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1779 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID)))
1780 _pvr->program_crid = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1782 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE)))
1783 _pvr->guidance = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1785 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS)))
1786 _pvr->synopsis = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1788 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE)))
1789 _pvr->genre = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1791 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE)))
1792 _pvr->language = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1794 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH)))
1795 _pvr->modified_month = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1797 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA)))
1798 _pvr->private_data = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1800 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1802 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1804 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1806 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1808 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1810 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1812 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1814 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1816 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1818 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1820 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1822 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1824 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1826 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1828 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1830 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1832 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1834 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1836 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1838 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1840 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1842 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1844 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1846 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1848 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1850 _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1855 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1857 int ret = MEDIA_CONTENT_ERROR_NONE;
1858 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1859 char *condition_query = NULL;
1860 char *option_query = NULL;
1861 sqlite3_stmt *stmt = NULL;
1862 filter_s *_filter = (filter_s *)filter;
1864 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1865 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1867 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1869 ret = __media_db_make_query(filter, &condition_query, &option_query);
1870 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1872 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1873 SAFE_FREE(condition_query);
1874 SAFE_FREE(option_query);
1875 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1877 while (sqlite3_step(stmt) == SQLITE_ROW) {
1878 media_pvr_s *_pvr = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1881 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1882 SQLITE3_FINALIZE(stmt);
1883 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1886 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1888 if (callback((media_pvr_h)_pvr, user_data) == false) {
1889 media_pvr_destroy((media_pvr_h) _pvr);
1893 media_pvr_destroy((media_pvr_h) _pvr);
1896 SQLITE3_FINALIZE(stmt);
1902 MEDIA_UHD_MEDIA_ID = 0,
1903 MEDIA_UHD_STORAGE_ID,
1906 MEDIA_UHD_CONTENT_ID,
1907 MEDIA_UHD_CONTENT_TITLE,
1908 MEDIA_UHD_FILE_NAME,
1909 MEDIA_UHD_FOLDER_ID,
1910 MEDIA_UHD_RELEASE_DATE,
1911 MEDIA_UHD_MODIFIED_TIME,
1912 MEDIA_UHD_PLAYED_POSITION,
1914 MEDIA_UHD_PLAYED_COUNT,
1915 } media_uhd_field_e;
1917 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1919 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1921 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID)))
1922 _uhd->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1924 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID)))
1925 _uhd->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1927 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH)))
1928 _uhd->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1930 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1932 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID)))
1933 _uhd->content_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1935 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE)))
1936 _uhd->content_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1938 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME)))
1939 _uhd->file_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1941 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE)))
1942 _uhd->release_date = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1944 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1945 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1946 _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1947 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1952 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1954 int ret = MEDIA_CONTENT_ERROR_NONE;
1955 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1956 char *condition_query = NULL;
1957 char *option_query = NULL;
1958 sqlite3_stmt *stmt = NULL;
1959 filter_s *_filter = (filter_s *)filter;
1961 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1962 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1964 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1966 ret = __media_db_make_query(filter, &condition_query, &option_query);
1967 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1969 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1970 SAFE_FREE(condition_query);
1971 SAFE_FREE(option_query);
1972 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1974 while (sqlite3_step(stmt) == SQLITE_ROW) {
1975 media_uhd_s *_uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
1978 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1979 SQLITE3_FINALIZE(stmt);
1980 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1983 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1985 if (callback((media_uhd_h)_uhd, user_data) == false) {
1986 media_uhd_destroy((media_uhd_h) _uhd);
1989 media_uhd_destroy((media_uhd_h) _uhd);
1992 SQLITE3_FINALIZE(stmt);