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 g_free(condition_query);
317 g_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 g_free(condition_query);
359 g_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 g_free(condition_query);
422 g_free(option_query);
423 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
425 while (sqlite3_step(stmt) == SQLITE_ROW) {
426 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
428 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
436 SQLITE3_FINALIZE(stmt);
441 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
443 int ret = MEDIA_CONTENT_ERROR_NONE;
444 sqlite3_stmt *stmt = NULL;
445 char *select_query = NULL;
446 char *condition_query = NULL;
447 char *option_query = NULL;
448 filter_s *_filter = (filter_s *)filter;
450 switch (group_type) {
451 case MEDIA_GROUP_ALBUM:
452 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
453 select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
455 select_query = g_strdup(SELECT_ALBUM_COUNT);
458 case MEDIA_GROUP_FOLDER:
459 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
460 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
462 select_query = g_strdup(SELECT_FOLDER_COUNT);
465 case MEDIA_GROUP_PLAYLIST:
466 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
469 case MEDIA_GROUP_TAG:
470 select_query = g_strdup(SELECT_TAG_COUNT);
473 case MEDIA_GROUP_BOOKMARK:
474 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
475 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
477 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
481 case MEDIA_GROUP_STORAGE:
482 select_query = g_strdup(SELECT_STORAGE_COUNT);
485 case MEDIA_GROUP_FACE:
486 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
487 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
489 select_query = g_strdup(SELECT_FACE_COUNT);
493 content_error("Invalid group type [%d]", group_type);
494 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
497 ret = __media_db_make_query(filter, &condition_query, &option_query);
498 if (ret != MEDIA_CONTENT_ERROR_NONE) {
499 g_free(select_query);
503 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
504 g_free(select_query);
505 g_free(condition_query);
506 g_free(option_query);
507 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
509 if (sqlite3_step(stmt) == SQLITE_ROW)
510 *group_count = sqlite3_column_int(stmt, 0);
512 SQLITE3_FINALIZE(stmt);
517 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
519 int ret = MEDIA_CONTENT_ERROR_NONE;
520 sqlite3_stmt *stmt = NULL;
521 char *select_query = NULL;
522 char *condition_query = NULL;
523 char *option_query = NULL;
524 filter_s *_filter = (filter_s *)filter;
526 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
527 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);
529 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
531 ret = __media_db_make_query(filter, &condition_query, &option_query);
532 if (ret != MEDIA_CONTENT_ERROR_NONE) {
533 g_free(select_query);
537 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
538 g_free(select_query);
539 g_free(condition_query);
540 g_free(option_query);
541 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
543 if (sqlite3_step(stmt) == SQLITE_ROW)
544 *group_count = sqlite3_column_int(stmt, 0);
546 SQLITE3_FINALIZE(stmt);
551 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
553 int ret = MEDIA_CONTENT_ERROR_NONE;
554 char *select_query = NULL;
555 char *condition_query = NULL;
556 char *option_query = NULL;
558 sqlite3_stmt *stmt = NULL;
559 filter_s *_filter = (filter_s *)filter;
561 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
562 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
564 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
566 ret = __media_db_make_query(filter, &condition_query, &option_query);
567 if (ret != MEDIA_CONTENT_ERROR_NONE) {
568 g_free(select_query);
572 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
573 g_free(select_query);
574 g_free(condition_query);
575 g_free(option_query);
576 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
578 while (sqlite3_step(stmt) == SQLITE_ROW) {
579 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
581 if (callback(name, user_data) == false) {
589 SQLITE3_FINALIZE(stmt);
595 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
597 int ret = MEDIA_CONTENT_ERROR_NONE;
598 char select_query[MAX_QUERY_SIZE] = {0, };
599 char *condition_query = NULL;
600 char *option_query = NULL;
601 sqlite3_stmt *stmt = NULL;
602 filter_s *_filter = (filter_s *)filter;
604 #ifdef _USE_TVPD_MODE
605 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
606 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
608 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
610 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
611 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
613 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
615 ret = __media_db_make_query(filter, &condition_query, &option_query);
616 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
618 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
619 g_free(condition_query);
620 g_free(option_query);
621 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
623 while (sqlite3_step(stmt) == SQLITE_ROW) {
624 media_album_s *album = g_new0(media_album_s, 1);
626 album->album_id = sqlite3_column_int(stmt, 0);
627 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
628 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
629 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
631 if (callback((media_album_h)album, user_data) == false) {
632 media_album_destroy((media_album_h)album);
636 media_album_destroy((media_album_h)album);
639 SQLITE3_FINALIZE(stmt);
644 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
646 int ret = MEDIA_CONTENT_ERROR_NONE;
647 char select_query[MAX_QUERY_SIZE] = {0, };
648 char *condition_query = NULL;
649 char *option_query = NULL;
650 sqlite3_stmt *stmt = NULL;
651 filter_s *_filter = (filter_s *)filter;
653 #ifdef _USE_TVPD_MODE
654 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
655 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
657 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
659 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
660 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
662 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
664 ret = __media_db_make_query(filter, &condition_query, &option_query);
665 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
667 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
668 g_free(condition_query);
669 g_free(option_query);
670 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
672 while (sqlite3_step(stmt) == SQLITE_ROW) {
673 media_folder_s *_folder = g_new0(media_folder_s, 1);
675 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
676 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
677 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
678 _folder->storage_type = sqlite3_column_int(stmt, 3);
679 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
681 if (callback((media_folder_h)_folder, user_data) == false) {
682 media_folder_destroy((media_folder_h) _folder);
686 media_folder_destroy((media_folder_h) _folder);
689 SQLITE3_FINALIZE(stmt);
694 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
696 int ret = MEDIA_CONTENT_ERROR_NONE;
697 char *condition_query = NULL;
698 char *option_query = NULL;
699 sqlite3_stmt *stmt = NULL;
701 ret = __media_db_make_query(filter, &condition_query, &option_query);
702 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
704 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
705 g_free(condition_query);
706 g_free(option_query);
707 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
709 while (sqlite3_step(stmt) == SQLITE_ROW) {
710 media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
712 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
713 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
714 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
716 if (callback((media_playlist_h)_playlist, user_data) == false) {
717 media_playlist_destroy((media_playlist_h)_playlist);
720 media_playlist_destroy((media_playlist_h)_playlist);
723 SQLITE3_FINALIZE(stmt);
728 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
730 int ret = MEDIA_CONTENT_ERROR_NONE;
731 char *select_query = NULL;
732 char *condition_query = NULL;
733 char *option_query = NULL;
734 sqlite3_stmt *stmt = NULL;
736 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
738 ret = __media_db_make_query(filter, &condition_query, &option_query);
739 if (ret != MEDIA_CONTENT_ERROR_NONE) {
740 g_free(select_query);
744 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
745 g_free(select_query);
746 g_free(condition_query);
747 g_free(option_query);
748 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
750 while (sqlite3_step(stmt) == SQLITE_ROW) {
751 int playlist_member_id = 0;
752 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
754 media_info_s *_media = g_new0(media_info_s, 1);
756 _media_info_item_get_detail(stmt, (media_info_h)_media);
758 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
759 media_info_destroy((media_info_h)_media);
762 media_info_destroy((media_info_h)_media);
766 SQLITE3_FINALIZE(stmt);
771 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
773 int ret = MEDIA_CONTENT_ERROR_NONE;
774 char *select_query = NULL;
775 char *condition_query = NULL;
776 char *option_query = NULL;
777 sqlite3_stmt *stmt = NULL;
779 if (STRING_VALID(media_id))
780 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
782 select_query = g_strdup(SELECT_TAG_LIST);
784 ret = __media_db_make_query(filter, &condition_query, &option_query);
785 if (ret != MEDIA_CONTENT_ERROR_NONE) {
786 g_free(select_query);
790 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
791 g_free(select_query);
792 g_free(condition_query);
793 g_free(option_query);
794 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
796 while (sqlite3_step(stmt) == SQLITE_ROW) {
797 media_tag_s *_tag = g_new0(media_tag_s, 1);
799 _tag->tag_id = sqlite3_column_int(stmt, 0);
800 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
802 if (callback((media_tag_h)_tag, user_data) == false) {
803 media_tag_destroy((media_tag_h)_tag);
806 media_tag_destroy((media_tag_h)_tag);
809 SQLITE3_FINALIZE(stmt);
814 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
816 int ret = MEDIA_CONTENT_ERROR_NONE;
817 char select_query[MAX_QUERY_SIZE] = {0, };
818 char *condition_query = NULL;
819 char *option_query = NULL;
820 sqlite3_stmt *stmt = NULL;
821 filter_s *_filter = (filter_s *)filter;
823 #ifdef _USE_TVPD_MODE
824 if (STRING_VALID(media_id)) { //get bookmark by media_id
825 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
826 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
828 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
830 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
831 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, _filter->storage_id);
833 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
836 if (STRING_VALID(media_id)) { //get bookmark by media_id
837 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
839 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
840 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
842 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
846 ret = __media_db_make_query(filter, &condition_query, &option_query);
847 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
849 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
850 g_free(condition_query);
851 g_free(option_query);
852 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
854 while (sqlite3_step(stmt) == SQLITE_ROW) {
855 media_bookmark_s *bookmark = g_new0(media_bookmark_s, 1);
857 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
858 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
859 bookmark->marked_time = sqlite3_column_int(stmt, 2);
860 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
861 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
863 if (callback((media_bookmark_h)bookmark, user_data) == false) {
864 media_bookmark_destroy((media_bookmark_h)bookmark);
868 media_bookmark_destroy((media_bookmark_h)bookmark);
871 SQLITE3_FINALIZE(stmt);
877 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
879 int ret = MEDIA_CONTENT_ERROR_NONE;
880 char select_query[MAX_QUERY_SIZE] = {0, };
881 char *condition_query = NULL;
882 char *option_query = NULL;
883 sqlite3_stmt *stmt = NULL;
884 filter_s *_filter = (filter_s *)filter;
886 #ifdef _USE_TVPD_MODE
887 if (STRING_VALID(media_id)) { //get face by media_id
888 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
889 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
891 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
893 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
894 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, _filter->storage_id);
896 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
899 if (STRING_VALID(media_id)) { //get face by media_id
900 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
902 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
903 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
905 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
908 ret = __media_db_make_query(filter, &condition_query, &option_query);
909 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
911 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
912 g_free(condition_query);
913 g_free(option_query);
914 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
916 while (sqlite3_step(stmt) == SQLITE_ROW) {
917 media_face_s *face = g_new0(media_face_s, 1);
919 face->face_id = sqlite3_column_int(stmt, 0);
920 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
921 face->face_rect_x = sqlite3_column_int(stmt, 2);
922 face->face_rect_y = sqlite3_column_int(stmt, 3);
923 face->face_rect_w = sqlite3_column_int(stmt, 4);
924 face->face_rect_h = sqlite3_column_int(stmt, 5);
925 face->orientation = sqlite3_column_int(stmt, 6);
926 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
928 if (callback((media_face_h)face, user_data) == false) {
929 media_face_destroy((media_face_h)face);
933 media_face_destroy((media_face_h)face);
936 SQLITE3_FINALIZE(stmt);
942 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
944 int ret = MEDIA_CONTENT_ERROR_NONE;
945 sqlite3_stmt *stmt = NULL;
946 char select_query[MAX_QUERY_SIZE] = {0, };
947 char *condition_query = NULL;
948 char *option_query = NULL;
949 filter_s *_filter = (filter_s *)filter;
951 switch (group_type) {
952 case MEDIA_GROUP_ALBUM:
953 #ifdef _USE_TVPD_MODE
954 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
955 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
957 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
959 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
960 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
962 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
966 case MEDIA_GROUP_PLAYLIST:
967 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
970 case MEDIA_GROUP_TAG:
971 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
975 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
976 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
979 ret = __media_db_make_query(filter, &condition_query, &option_query);
980 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
982 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
983 g_free(condition_query);
984 g_free(option_query);
985 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
987 if (sqlite3_step(stmt) == SQLITE_ROW)
988 *item_count = sqlite3_column_int(stmt, 0);
990 SQLITE3_FINALIZE(stmt);
995 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
997 int ret = MEDIA_CONTENT_ERROR_NONE;
998 sqlite3_stmt *stmt = NULL;
999 char select_query[MAX_QUERY_SIZE] = {0, };
1000 char *condition_query = NULL;
1001 char *option_query = NULL;
1002 char *tmp_option = NULL;
1003 bool need_bracket = false;
1004 filter_s *_filter = (filter_s *)filter;
1006 switch (group_type) {
1007 case MEDIA_GROUP_NONE:
1009 #ifdef _USE_TVPD_MODE
1010 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1012 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1017 if (_filter->offset < 0 && _filter->count < 0) {
1018 #ifdef _USE_TVPD_MODE
1019 if (STRING_VALID(_filter->storage_id))
1020 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1022 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1024 if (STRING_VALID(_filter->storage_id))
1025 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1027 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1030 #ifdef _USE_TVPD_MODE
1031 if (STRING_VALID(_filter->storage_id))
1032 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
1034 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1036 if (STRING_VALID(_filter->storage_id))
1037 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_BY_STORAGE_ID, _filter->storage_id);
1039 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
1042 need_bracket = true;
1046 case MEDIA_GROUP_FOLDER:
1047 #ifdef _USE_TVPD_MODE
1048 if (_filter && STRING_VALID(_filter->storage_id))
1049 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1051 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1053 if (_filter && STRING_VALID(_filter->storage_id))
1054 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1056 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1060 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1061 snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1064 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1065 #ifdef _USE_TVPD_MODE
1066 if (_filter && STRING_VALID(_filter->storage_id))
1067 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1069 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1071 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1075 case MEDIA_GROUP_STORAGE:
1076 #ifdef _USE_TVPD_MODE
1077 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1079 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1083 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1084 #ifdef _USE_TVPD_MODE
1085 if (_filter && STRING_VALID(_filter->storage_id))
1086 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1088 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1090 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1094 #ifdef _USE_TVPD_MODE
1095 case MEDIA_GROUP_PVR:
1096 if (_filter && STRING_VALID(_filter->storage_id))
1097 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1099 SAFE_STRLCPY(select_query, SELECT_PVR_COUNT, sizeof(select_query));
1102 case MEDIA_GROUP_UHD:
1103 if (_filter && STRING_VALID(_filter->storage_id))
1104 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1106 SAFE_STRLCPY(select_query, SELECT_UHD_COUNT, sizeof(select_query));
1110 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1111 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1114 ret = __media_db_make_query(filter, &condition_query, &option_query);
1115 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1118 tmp_option = g_strconcat(option_query, ")", NULL);
1119 g_free(option_query);
1120 option_query = tmp_option;
1123 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1124 g_free(condition_query);
1125 g_free(option_query);
1126 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1128 if (sqlite3_step(stmt) == SQLITE_ROW)
1129 *item_count = sqlite3_column_int(stmt, 0);
1131 SQLITE3_FINALIZE(stmt);
1136 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)
1138 int ret = MEDIA_CONTENT_ERROR_NONE;
1139 char select_query[MAX_QUERY_SIZE] = {0, };
1140 char *condition_query = NULL;
1141 char *option_query = NULL;
1142 sqlite3_stmt *stmt = NULL;
1143 filter_s *_filter = (filter_s *)filter;
1145 switch (group_type) {
1146 case MEDIA_GROUP_ALBUM:
1147 #ifdef _USE_TVPD_MODE
1148 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1149 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1151 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1153 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1154 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1156 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
1160 case MEDIA_GROUP_PLAYLIST:
1161 #ifdef _USE_TVPD_MODE
1162 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1163 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1165 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1167 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1168 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1170 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
1174 case MEDIA_GROUP_TAG:
1175 #ifdef _USE_TVPD_MODE
1176 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1177 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1179 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1181 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1182 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1184 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
1189 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1190 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1193 ret = __media_db_make_query(filter, &condition_query, &option_query);
1194 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1196 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1197 g_free(condition_query);
1198 g_free(option_query);
1199 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1201 while (sqlite3_step(stmt) == SQLITE_ROW) {
1202 media_info_s *item = g_new0(media_info_s, 1);
1204 _media_info_item_get_detail(stmt, (media_info_h)item);
1206 if (callback((media_info_h)item, user_data) == false) {
1207 media_info_destroy((media_info_h)item);
1211 media_info_destroy((media_info_h)item);
1214 SQLITE3_FINALIZE(stmt);
1219 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)
1221 int ret = MEDIA_CONTENT_ERROR_NONE;
1222 char select_query[MAX_QUERY_SIZE] = {0, };
1223 char *condition_query = NULL;
1224 char *option_query = NULL;
1225 sqlite3_stmt *stmt = NULL;
1226 filter_s *_filter = (filter_s *)filter;
1228 switch (group_type) {
1229 case MEDIA_GROUP_NONE:
1230 #ifdef _USE_TVPD_MODE
1231 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1232 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
1234 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1236 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1237 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1239 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
1243 case MEDIA_GROUP_FOLDER:
1244 #ifdef _USE_TVPD_MODE
1245 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1246 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1248 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1250 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
1254 case MEDIA_GROUP_STORAGE:
1255 #ifdef _USE_TVPD_MODE
1256 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1258 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
1263 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1264 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1267 ret = __media_db_make_query(filter, &condition_query, &option_query);
1268 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1270 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1271 g_free(condition_query);
1272 g_free(option_query);
1273 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1275 while (sqlite3_step(stmt) == SQLITE_ROW) {
1276 media_info_s *item = g_new0(media_info_s, 1);
1278 _media_info_item_get_detail(stmt, (media_info_h)item);
1280 if (callback((media_info_h)item, user_data) == false) {
1281 media_info_destroy((media_info_h)item);
1285 media_info_destroy((media_info_h)item);
1288 SQLITE3_FINALIZE(stmt);
1293 #ifdef _USE_SENIOR_MODE
1294 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)
1296 int ret = MEDIA_CONTENT_ERROR_NONE;
1297 char select_query1[MAX_QUERY_SIZE] = {0, };
1298 char *condition_query1 = NULL;
1299 char *option_query1 = NULL;
1300 char select_query2[MAX_QUERY_SIZE] = {0, };
1301 char *condition_query2 = NULL;
1302 char *option_query2 = NULL;
1303 sqlite3_stmt *stmt = NULL;
1304 filter_s *_filter1 = (filter_s *)filter1;
1305 filter_s *_filter2 = (filter_s *)filter2;
1307 if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
1308 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, _filter1->storage_id, group_name);
1310 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1312 ret = __media_db_make_query(filter, &condition_query1, &option_query1);
1313 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1314 SAFE_FREE(condition_query1);
1315 SAFE_FREE(option_query1);
1316 content_error("create select_query1 failed");
1320 if ((_filter2 != NULL) && STRING_VALID(_filter2->storage_id))
1321 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, _filter2->storage_id, group_name);
1323 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1325 ret = __media_db_make_query(filter, &condition_query2, &option_query2);
1326 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1327 SAFE_FREE(condition_query1);
1328 SAFE_FREE(option_query1);
1329 SAFE_FREE(condition_query2);
1330 SAFE_FREE(option_query2);
1331 content_error("create select_query2 failed");
1335 ret = _content_query_prepare_by_union_select(&stmt, select_query1, condition_query1, option_query1, select_query2, condition_query2, option_query2);
1336 SAFE_FREE(condition_query1);
1337 SAFE_FREE(option_query1);
1338 SAFE_FREE(condition_query2);
1339 SAFE_FREE(option_query2);
1340 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1342 while (sqlite3_step(stmt) == SQLITE_ROW) {
1343 media_info_s *item = g_new0(media_info_s, 1);
1345 _media_info_item_get_detail(stmt, (media_info_h)item);
1347 if (callback((media_info_h)item, user_data) == false) {
1348 media_info_destroy((media_info_h)item);
1352 media_info_destroy((media_info_h)item);
1355 SQLITE3_FINALIZE(stmt);
1361 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1363 int ret = MEDIA_CONTENT_ERROR_NONE;
1364 sqlite3_stmt *stmt = NULL;
1365 char select_query[MAX_QUERY_SIZE] = {0, };
1366 char *tmp_option = NULL;
1367 char *condition_query = NULL;
1368 char *option_query = NULL;
1369 filter_s *_filter = (filter_s *)filter;
1371 #ifdef _USE_TVPD_MODE
1372 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1373 if (group_name != NULL) {
1374 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1375 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1377 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1379 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1380 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1382 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1384 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1385 if (group_name != NULL) {
1386 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1387 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);
1389 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1391 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1392 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1394 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1396 } else {/*uhd content*/
1397 if (group_name != NULL) {
1398 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1399 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);
1401 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1403 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1404 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1406 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1410 if (group_name != NULL) {
1411 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1412 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);
1414 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1416 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1417 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1419 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1422 ret = __media_db_make_query(filter, &condition_query, &option_query);
1423 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1425 /* If 'filter' is not NULL, 'option_query' must be created. */
1427 tmp_option = g_strconcat(option_query, ")", NULL);
1428 g_free(option_query);
1429 option_query = tmp_option;
1431 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1434 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1435 g_free(condition_query);
1436 g_free(option_query);
1437 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1439 if (sqlite3_step(stmt) == SQLITE_ROW)
1440 *item_count = sqlite3_column_int(stmt, 0);
1442 SQLITE3_FINALIZE(stmt);
1447 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)
1449 int ret = MEDIA_CONTENT_ERROR_NONE;
1450 char select_query[MAX_QUERY_SIZE] = {0, };
1451 char *condition_query = NULL;
1452 char *option_query = NULL;
1453 sqlite3_stmt *stmt = NULL;
1454 filter_s *_filter = (filter_s *)filter;
1456 #ifdef _USE_TVPD_MODE
1457 if (group_name != NULL) {
1458 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1459 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1461 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1463 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1464 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1466 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1469 if (group_name != NULL) {
1470 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1471 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);
1473 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1475 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1476 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1478 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1481 ret = __media_db_make_query(filter, &condition_query, &option_query);
1482 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1484 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1485 g_free(condition_query);
1486 g_free(option_query);
1487 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1489 while (sqlite3_step(stmt) == SQLITE_ROW) {
1490 media_info_s *item = g_new0(media_info_s, 1);
1492 _media_info_item_get_detail(stmt, (media_info_h)item);
1494 if (callback((media_info_h)item, user_data) == false) {
1495 media_info_destroy((media_info_h)item);
1499 media_info_destroy((media_info_h)item);
1502 SQLITE3_FINALIZE(stmt);
1507 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1509 int ret = MEDIA_CONTENT_ERROR_NONE;
1510 char *condition_query = NULL;
1511 char *option_query = NULL;
1512 sqlite3_stmt *stmt = NULL;
1514 ret = __media_db_make_query(filter, &condition_query, &option_query);
1515 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1517 ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1518 g_free(condition_query);
1519 g_free(option_query);
1520 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1522 while (sqlite3_step(stmt) == SQLITE_ROW) {
1523 media_storage_s *_storage = g_new0(media_storage_s, 1);
1525 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1526 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1527 _storage->storage_type = sqlite3_column_int(stmt, 2);
1529 if (callback((media_storage_h)_storage, user_data) == false) {
1530 media_storage_destroy((media_storage_h) _storage);
1534 media_storage_destroy((media_storage_h) _storage);
1537 SQLITE3_FINALIZE(stmt);
1542 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1544 int ret = MEDIA_CONTENT_ERROR_NONE;
1545 sqlite3_stmt *stmt = NULL;
1546 char *select_query = NULL;
1548 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1550 ret = _content_get_result(select_query, &stmt);
1551 SQLITE3_SAFE_FREE(select_query);
1552 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1554 if (sqlite3_step(stmt) == SQLITE_ROW) {
1555 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1557 content_error("Invalid media_id[%s]", media_id);
1558 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1561 SQLITE3_FINALIZE(stmt);
1566 #ifdef _USE_TVPD_MODE
1567 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)
1569 int ret = MEDIA_CONTENT_ERROR_NONE;
1570 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1571 char *condition_query = NULL;
1572 char *option_query = NULL;
1573 sqlite3_stmt *stmt = NULL;
1574 filter_s *_filter = (filter_s *)filter;
1576 if (group_name != NULL) {
1577 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1578 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);
1580 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1582 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1583 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1585 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1588 ret = __media_db_make_query(filter, &condition_query, &option_query);
1589 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1591 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1592 g_free(condition_query);
1593 g_free(option_query);
1594 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1596 while (sqlite3_step(stmt) == SQLITE_ROW) {
1597 media_pvr_s *item = g_new0(media_pvr_s, 1);
1599 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1601 if (callback((media_pvr_h)item, user_data) == false) {
1602 media_info_destroy((media_pvr_h)item);
1606 media_pvr_destroy((media_pvr_h)item);
1609 SQLITE3_FINALIZE(stmt);
1615 MEDIA_PVR_MEDIA_ID = 0,
1616 MEDIA_PVR_STORAGE_ID,
1620 MEDIA_PVR_TIME_ZONE,
1624 MEDIA_PVR_CHANNEL_TYPE,
1625 MEDIA_PVR_CHANNEL_NAME,
1626 MEDIA_PVR_CHANNEL_NUM,
1627 MEDIA_PVR_SERVICE_PROFILE,
1628 MEDIA_PVR_PROGRAM_TITLE,
1629 MEDIA_PVR_PROGRAM_NUM,
1630 MEDIA_PVR_PROGRAM_CRID,
1635 MEDIA_PVR_EMBARGO_TIME,
1636 MEDIA_PVR_EXPIRY_TIME,
1637 MEDIA_PVR_START_TIME,
1638 MEDIA_PVR_PROGRAM_START_TIME,
1639 MEDIA_PVR_PROGRAM_END_TIME,
1640 MEDIA_PVR_PROGRAM_DATE,
1641 MEDIA_PVR_PARENTAL_RATING,
1642 MEDIA_PVR_TIMER_RECORD,
1643 MEDIA_PVR_SERIES_RECORD,
1648 MEDIA_PVR_HARDOF_HEARINGRADIO,
1649 MEDIA_PVR_DATA_SERVICE,
1650 MEDIA_PVR_CONTENT_LOCK,
1651 MEDIA_PVR_CONTENT_WATCH,
1652 MEDIA_PVR_HAS_AUDIO_ONLY,
1653 MEDIA_PVR_IS_LOCAL_RECORDED,
1654 MEDIA_PVR_RESOLUTION,
1655 MEDIA_PVR_ASPECTRATIO,
1656 MEDIA_PVR_MODIFIED_MONTH,
1657 MEDIA_PVR_SPORTS_TYPE,
1658 MEDIA_PVR_GUIDANCE_LENGTH,
1660 MEDIA_PVR_PLAY_COUNT,
1661 MEDIA_PVR_PRIVATE_DATA,
1662 MEDIA_PVR_HIGHLIGHT,
1663 } media_pvr_field_e;
1665 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1667 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1669 _pvr->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1670 _pvr->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1671 _pvr->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1672 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1673 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1674 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1675 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1676 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1677 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1678 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1679 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1680 _pvr->channel_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1681 _pvr->channel_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1682 _pvr->program_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1683 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1684 _pvr->program_crid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1685 _pvr->guidance = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1686 _pvr->synopsis = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1687 _pvr->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1688 _pvr->language = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1689 _pvr->modified_month = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1690 _pvr->private_data = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1691 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1692 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1693 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1694 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1695 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1696 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1697 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1698 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1699 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1700 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1701 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1702 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1703 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1704 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1705 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1706 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1707 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1708 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1709 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1710 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1711 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1712 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1713 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1714 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1715 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1716 _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1721 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1723 int ret = MEDIA_CONTENT_ERROR_NONE;
1724 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1725 char *condition_query = NULL;
1726 char *option_query = NULL;
1727 sqlite3_stmt *stmt = NULL;
1728 filter_s *_filter = (filter_s *)filter;
1730 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1731 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1733 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1735 ret = __media_db_make_query(filter, &condition_query, &option_query);
1736 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1738 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1739 g_free(condition_query);
1740 g_free(option_query);
1741 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1743 while (sqlite3_step(stmt) == SQLITE_ROW) {
1744 media_pvr_s *_pvr = g_new0(media_pvr_s, 1);
1746 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1748 if (callback((media_pvr_h)_pvr, user_data) == false) {
1749 media_pvr_destroy((media_pvr_h) _pvr);
1753 media_pvr_destroy((media_pvr_h) _pvr);
1756 SQLITE3_FINALIZE(stmt);
1762 MEDIA_UHD_MEDIA_ID = 0,
1763 MEDIA_UHD_STORAGE_ID,
1766 MEDIA_UHD_CONTENT_ID,
1767 MEDIA_UHD_CONTENT_TITLE,
1768 MEDIA_UHD_FILE_NAME,
1769 MEDIA_UHD_FOLDER_ID,
1770 MEDIA_UHD_RELEASE_DATE,
1771 MEDIA_UHD_MODIFIED_TIME,
1772 MEDIA_UHD_PLAYED_POSITION,
1774 MEDIA_UHD_PLAYED_COUNT,
1775 } media_uhd_field_e;
1777 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1779 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1781 _uhd->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1782 _uhd->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1783 _uhd->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1784 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1785 _uhd->content_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1786 _uhd->content_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1787 _uhd->file_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1788 _uhd->release_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1789 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1790 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1791 _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1792 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1797 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1799 int ret = MEDIA_CONTENT_ERROR_NONE;
1800 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1801 char *condition_query = NULL;
1802 char *option_query = NULL;
1803 sqlite3_stmt *stmt = NULL;
1804 filter_s *_filter = (filter_s *)filter;
1806 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1807 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1809 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1811 ret = __media_db_make_query(filter, &condition_query, &option_query);
1812 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1814 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1815 g_free(condition_query);
1816 g_free(option_query);
1817 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1819 while (sqlite3_step(stmt) == SQLITE_ROW) {
1820 media_uhd_s *_uhd = g_new0(media_uhd_s, 1);
1822 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1824 if (callback((media_uhd_h)_uhd, user_data) == false) {
1825 media_uhd_destroy((media_uhd_h) _uhd);
1828 media_uhd_destroy((media_uhd_h) _uhd);
1831 SQLITE3_FINALIZE(stmt);