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 && 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 && 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 && 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 && 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 && 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 && 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 && 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 && 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 && 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 && 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 content_retip_if_fail(STRING_VALID(group_name));
392 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
393 if (_filter && STRING_VALID(_filter->storage_id))
394 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
396 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
397 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
398 if (_filter && STRING_VALID(_filter->storage_id))
399 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
401 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
402 } else {/*uhd content*/
403 if (_filter && STRING_VALID(_filter->storage_id))
404 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
406 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
409 ret = __media_db_make_query(filter, &condition_query, &option_query);
410 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
412 if (STRING_VALID(option_query))
413 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
415 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
417 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
418 g_free(condition_query);
419 g_free(option_query);
420 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
422 while (sqlite3_step(stmt) == SQLITE_ROW) {
423 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
425 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
433 SQLITE3_FINALIZE(stmt);
438 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
440 int ret = MEDIA_CONTENT_ERROR_NONE;
441 sqlite3_stmt *stmt = NULL;
442 char *select_query = NULL;
443 char *condition_query = NULL;
444 char *option_query = NULL;
445 filter_s *_filter = (filter_s *)filter;
447 switch (group_type) {
448 case MEDIA_GROUP_ALBUM:
449 if (_filter && STRING_VALID(_filter->storage_id))
450 select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
452 select_query = g_strdup(SELECT_ALBUM_COUNT);
455 case MEDIA_GROUP_FOLDER:
456 if (_filter && STRING_VALID(_filter->storage_id))
457 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
459 select_query = g_strdup(SELECT_FOLDER_COUNT);
462 case MEDIA_GROUP_PLAYLIST:
463 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
466 case MEDIA_GROUP_TAG:
467 select_query = g_strdup(SELECT_TAG_COUNT);
470 case MEDIA_GROUP_BOOKMARK:
471 if (_filter && STRING_VALID(_filter->storage_id))
472 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
474 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
478 case MEDIA_GROUP_STORAGE:
479 select_query = g_strdup(SELECT_STORAGE_COUNT);
482 case MEDIA_GROUP_FACE:
483 if (_filter && STRING_VALID(_filter->storage_id))
484 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
486 select_query = g_strdup(SELECT_FACE_COUNT);
490 content_error("Invalid group type [%d]", group_type);
491 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
494 ret = __media_db_make_query(filter, &condition_query, &option_query);
495 if (ret != MEDIA_CONTENT_ERROR_NONE) {
496 g_free(select_query);
500 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
501 g_free(select_query);
502 g_free(condition_query);
503 g_free(option_query);
504 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
506 if (sqlite3_step(stmt) == SQLITE_ROW)
507 *group_count = sqlite3_column_int(stmt, 0);
509 SQLITE3_FINALIZE(stmt);
514 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
516 int ret = MEDIA_CONTENT_ERROR_NONE;
517 sqlite3_stmt *stmt = NULL;
518 char *select_query = NULL;
519 char *condition_query = NULL;
520 char *option_query = NULL;
521 filter_s *_filter = (filter_s *)filter;
523 if (_filter && STRING_VALID(_filter->storage_id))
524 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);
526 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
528 ret = __media_db_make_query(filter, &condition_query, &option_query);
529 if (ret != MEDIA_CONTENT_ERROR_NONE) {
530 g_free(select_query);
534 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
535 g_free(select_query);
536 g_free(condition_query);
537 g_free(option_query);
538 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
540 if (sqlite3_step(stmt) == SQLITE_ROW)
541 *group_count = sqlite3_column_int(stmt, 0);
543 SQLITE3_FINALIZE(stmt);
548 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
550 int ret = MEDIA_CONTENT_ERROR_NONE;
551 char *select_query = NULL;
552 char *condition_query = NULL;
553 char *option_query = NULL;
555 sqlite3_stmt *stmt = NULL;
556 filter_s *_filter = (filter_s *)filter;
558 if (_filter && STRING_VALID(_filter->storage_id))
559 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
561 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
563 ret = __media_db_make_query(filter, &condition_query, &option_query);
564 if (ret != MEDIA_CONTENT_ERROR_NONE) {
565 g_free(select_query);
569 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
570 g_free(select_query);
571 g_free(condition_query);
572 g_free(option_query);
573 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
575 while (sqlite3_step(stmt) == SQLITE_ROW) {
576 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
578 if (callback(name, user_data) == false) {
586 SQLITE3_FINALIZE(stmt);
592 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
594 int ret = MEDIA_CONTENT_ERROR_NONE;
595 char *select_query = NULL;
596 char *condition_query = NULL;
597 char *option_query = NULL;
598 sqlite3_stmt *stmt = NULL;
599 filter_s *_filter = (filter_s *)filter;
601 #ifdef _USE_TVPD_MODE
602 if (_filter && STRING_VALID(_filter->storage_id))
603 select_query = g_strdup_printf(SELECT_ALBUM_LIST, _filter->storage_id);
605 select_query = g_strdup_printf(SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
607 if (_filter && STRING_VALID(_filter->storage_id))
608 select_query = g_strdup_printf(SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
610 select_query = g_strdup(SELECT_ALBUM_LIST);
612 ret = __media_db_make_query(filter, &condition_query, &option_query);
613 if (ret != MEDIA_CONTENT_ERROR_NONE) {
614 g_free(select_query);
618 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
619 g_free(select_query);
620 g_free(condition_query);
621 g_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 = g_new0(media_album_s, 1);
627 album->album_id = sqlite3_column_int(stmt, 0);
628 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
629 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
630 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
632 if (callback((media_album_h)album, user_data) == false) {
633 media_album_destroy((media_album_h)album);
637 media_album_destroy((media_album_h)album);
640 SQLITE3_FINALIZE(stmt);
645 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
647 int ret = MEDIA_CONTENT_ERROR_NONE;
648 char *select_query = NULL;
649 char *condition_query = NULL;
650 char *option_query = NULL;
651 sqlite3_stmt *stmt = NULL;
652 filter_s *_filter = (filter_s *)filter;
654 #ifdef _USE_TVPD_MODE
655 if (_filter && STRING_VALID(_filter->storage_id))
656 select_query = g_strdup_printf(SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
658 select_query = g_strdup_printf(SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
660 if (_filter && STRING_VALID(_filter->storage_id))
661 select_query = g_strdup_printf(SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
663 select_query = g_strdup(SELECT_FOLDER_LIST);
665 ret = __media_db_make_query(filter, &condition_query, &option_query);
666 if (ret != MEDIA_CONTENT_ERROR_NONE) {
667 g_free(select_query);
671 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
672 g_free(select_query);
673 g_free(condition_query);
674 g_free(option_query);
675 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
677 while (sqlite3_step(stmt) == SQLITE_ROW) {
678 media_folder_s *_folder = g_new0(media_folder_s, 1);
680 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
681 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
682 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
683 _folder->storage_type = sqlite3_column_int(stmt, 3);
684 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
686 if (callback((media_folder_h)_folder, user_data) == false) {
687 media_folder_destroy((media_folder_h) _folder);
691 media_folder_destroy((media_folder_h) _folder);
694 SQLITE3_FINALIZE(stmt);
699 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
701 int ret = MEDIA_CONTENT_ERROR_NONE;
702 char *condition_query = NULL;
703 char *option_query = NULL;
704 sqlite3_stmt *stmt = NULL;
706 ret = __media_db_make_query(filter, &condition_query, &option_query);
707 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
709 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
710 g_free(condition_query);
711 g_free(option_query);
712 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
714 while (sqlite3_step(stmt) == SQLITE_ROW) {
715 media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
717 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
718 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
719 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
721 if (callback((media_playlist_h)_playlist, user_data) == false) {
722 media_playlist_destroy((media_playlist_h)_playlist);
725 media_playlist_destroy((media_playlist_h)_playlist);
728 SQLITE3_FINALIZE(stmt);
733 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
735 int ret = MEDIA_CONTENT_ERROR_NONE;
736 char *select_query = NULL;
737 char *condition_query = NULL;
738 char *option_query = NULL;
739 sqlite3_stmt *stmt = NULL;
741 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
743 ret = __media_db_make_query(filter, &condition_query, &option_query);
744 if (ret != MEDIA_CONTENT_ERROR_NONE) {
745 g_free(select_query);
749 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
750 g_free(select_query);
751 g_free(condition_query);
752 g_free(option_query);
753 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
755 while (sqlite3_step(stmt) == SQLITE_ROW) {
756 int playlist_member_id = 0;
757 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
759 media_info_s *_media = g_new0(media_info_s, 1);
761 _media_info_item_get_detail(stmt, (media_info_h)_media);
763 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
764 media_info_destroy((media_info_h)_media);
767 media_info_destroy((media_info_h)_media);
771 SQLITE3_FINALIZE(stmt);
776 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
778 int ret = MEDIA_CONTENT_ERROR_NONE;
779 char *select_query = NULL;
780 char *condition_query = NULL;
781 char *option_query = NULL;
782 sqlite3_stmt *stmt = NULL;
784 if (STRING_VALID(media_id))
785 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
787 select_query = g_strdup(SELECT_TAG_LIST);
789 ret = __media_db_make_query(filter, &condition_query, &option_query);
790 if (ret != MEDIA_CONTENT_ERROR_NONE) {
791 g_free(select_query);
795 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
796 g_free(select_query);
797 g_free(condition_query);
798 g_free(option_query);
799 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
801 while (sqlite3_step(stmt) == SQLITE_ROW) {
802 media_tag_s *_tag = g_new0(media_tag_s, 1);
804 _tag->tag_id = sqlite3_column_int(stmt, 0);
805 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
807 if (callback((media_tag_h)_tag, user_data) == false) {
808 media_tag_destroy((media_tag_h)_tag);
811 media_tag_destroy((media_tag_h)_tag);
814 SQLITE3_FINALIZE(stmt);
819 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
821 int ret = MEDIA_CONTENT_ERROR_NONE;
822 char *select_query = NULL;
823 char *condition_query = NULL;
824 char *option_query = NULL;
825 sqlite3_stmt *stmt = NULL;
826 filter_s *_filter = (filter_s *)filter;
828 #ifdef _USE_TVPD_MODE
829 if (STRING_VALID(media_id)) { //get bookmark by media_id
830 if (_filter && STRING_VALID(_filter->storage_id))
831 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
833 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
835 if (_filter && STRING_VALID(_filter->storage_id))
836 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, _filter->storage_id);
838 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
841 if (STRING_VALID(media_id)) { //get bookmark by media_id
842 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
844 if (_filter && STRING_VALID(_filter->storage_id))
845 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
847 select_query = g_strdup(SELECT_BOOKMARK_LIST);
851 ret = __media_db_make_query(filter, &condition_query, &option_query);
852 if (ret != MEDIA_CONTENT_ERROR_NONE) {
853 g_free(select_query);
857 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
858 g_free(select_query);
859 g_free(condition_query);
860 g_free(option_query);
861 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
863 while (sqlite3_step(stmt) == SQLITE_ROW) {
864 media_bookmark_s *bookmark = g_new0(media_bookmark_s, 1);
866 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
867 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
868 bookmark->marked_time = sqlite3_column_int(stmt, 2);
869 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
870 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
872 if (callback((media_bookmark_h)bookmark, user_data) == false) {
873 media_bookmark_destroy((media_bookmark_h)bookmark);
877 media_bookmark_destroy((media_bookmark_h)bookmark);
880 SQLITE3_FINALIZE(stmt);
886 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
888 int ret = MEDIA_CONTENT_ERROR_NONE;
889 char *select_query = NULL;
890 char *condition_query = NULL;
891 char *option_query = NULL;
892 sqlite3_stmt *stmt = NULL;
893 filter_s *_filter = (filter_s *)filter;
895 #ifdef _USE_TVPD_MODE
896 if (STRING_VALID(media_id)) { //get face by media_id
897 if (_filter && STRING_VALID(_filter->storage_id))
898 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
900 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
902 if (_filter && STRING_VALID(_filter->storage_id))
903 select_query = g_strdup_printf(SELECT_FACE_LIST, _filter->storage_id);
905 select_query = g_strdup_printf(SELECT_FACE_LIST, DB_VIEW_MEDIA);
908 if (STRING_VALID(media_id)) { //get face by media_id
909 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
911 if (_filter && STRING_VALID(_filter->storage_id))
912 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
914 select_query = g_strdup(SELECT_FACE_LIST);
917 ret = __media_db_make_query(filter, &condition_query, &option_query);
918 if (ret != MEDIA_CONTENT_ERROR_NONE) {
919 g_free(select_query);
923 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
924 g_free(select_query);
925 g_free(condition_query);
926 g_free(option_query);
927 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
929 while (sqlite3_step(stmt) == SQLITE_ROW) {
930 media_face_s *face = g_new0(media_face_s, 1);
932 face->face_id = sqlite3_column_int(stmt, 0);
933 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
934 face->face_rect_x = sqlite3_column_int(stmt, 2);
935 face->face_rect_y = sqlite3_column_int(stmt, 3);
936 face->face_rect_w = sqlite3_column_int(stmt, 4);
937 face->face_rect_h = sqlite3_column_int(stmt, 5);
938 face->orientation = sqlite3_column_int(stmt, 6);
939 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
941 if (callback((media_face_h)face, user_data) == false) {
942 media_face_destroy((media_face_h)face);
946 media_face_destroy((media_face_h)face);
949 SQLITE3_FINALIZE(stmt);
955 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
957 int ret = MEDIA_CONTENT_ERROR_NONE;
958 sqlite3_stmt *stmt = NULL;
959 char *select_query = NULL;
960 char *condition_query = NULL;
961 char *option_query = NULL;
962 filter_s *_filter = (filter_s *)filter;
964 switch (group_type) {
965 case MEDIA_GROUP_ALBUM:
966 #ifdef _USE_TVPD_MODE
967 if (_filter && STRING_VALID(_filter->storage_id))
968 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
970 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
972 if (_filter && STRING_VALID(_filter->storage_id))
973 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
975 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
979 case MEDIA_GROUP_PLAYLIST:
980 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
983 case MEDIA_GROUP_TAG:
984 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_TAG, group_id);
988 content_error("INVALID_PARAMETER");
989 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
992 ret = __media_db_make_query(filter, &condition_query, &option_query);
993 if (ret != MEDIA_CONTENT_ERROR_NONE) {
994 g_free(select_query);
998 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
999 g_free(select_query);
1000 g_free(condition_query);
1001 g_free(option_query);
1002 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1004 if (sqlite3_step(stmt) == SQLITE_ROW)
1005 *item_count = sqlite3_column_int(stmt, 0);
1007 SQLITE3_FINALIZE(stmt);
1012 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
1014 int ret = MEDIA_CONTENT_ERROR_NONE;
1015 sqlite3_stmt *stmt = NULL;
1016 char *select_query = NULL;
1017 char *condition_query = NULL;
1018 char *option_query = NULL;
1019 char *tmp_option = NULL;
1020 bool need_bracket = false;
1021 filter_s *_filter = (filter_s *)filter;
1023 switch (group_type) {
1024 case MEDIA_GROUP_NONE:
1026 #ifdef _USE_TVPD_MODE
1027 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1029 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1034 if (_filter->offset < 0 && _filter->count < 0) {
1035 #ifdef _USE_TVPD_MODE
1036 if (STRING_VALID(_filter->storage_id))
1037 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1039 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1041 if (STRING_VALID(_filter->storage_id))
1042 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1044 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1047 #ifdef _USE_TVPD_MODE
1048 if (STRING_VALID(_filter->storage_id))
1049 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
1051 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1053 if (STRING_VALID(_filter->storage_id))
1054 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_BY_STORAGE_ID, _filter->storage_id);
1056 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA);
1058 need_bracket = true;
1062 case MEDIA_GROUP_FOLDER:
1063 #ifdef _USE_TVPD_MODE
1064 if (_filter && STRING_VALID(_filter->storage_id))
1065 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1067 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1069 if (_filter && STRING_VALID(_filter->storage_id))
1070 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1072 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1076 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1077 select_query = g_strdup_printf(SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1080 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1081 #ifdef _USE_TVPD_MODE
1082 if (_filter && STRING_VALID(_filter->storage_id))
1083 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1085 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1087 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1091 case MEDIA_GROUP_STORAGE:
1092 #ifdef _USE_TVPD_MODE
1093 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1095 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1099 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1100 #ifdef _USE_TVPD_MODE
1101 if (_filter && STRING_VALID(_filter->storage_id))
1102 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1104 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1106 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1110 #ifdef _USE_TVPD_MODE
1111 case MEDIA_GROUP_PVR:
1112 if (_filter && STRING_VALID(_filter->storage_id))
1113 select_query = g_strdup_printf(SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1115 select_query = g_strdup(SELECT_PVR_COUNT);
1118 case MEDIA_GROUP_UHD:
1119 if (_filter && STRING_VALID(_filter->storage_id))
1120 select_query = g_strdup_printf(SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1122 select_query = g_strdup(SELECT_UHD_COUNT);
1126 content_error("INVALID_PARAMETER");
1127 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1130 ret = __media_db_make_query(filter, &condition_query, &option_query);
1131 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1132 g_free(select_query);
1137 tmp_option = g_strconcat(option_query, ")", NULL);
1138 g_free(option_query);
1139 option_query = tmp_option;
1142 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1143 g_free(select_query);
1144 g_free(condition_query);
1145 g_free(option_query);
1146 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1148 if (sqlite3_step(stmt) == SQLITE_ROW)
1149 *item_count = sqlite3_column_int(stmt, 0);
1151 SQLITE3_FINALIZE(stmt);
1156 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)
1158 int ret = MEDIA_CONTENT_ERROR_NONE;
1159 char *select_query = NULL;
1160 char *condition_query = NULL;
1161 char *option_query = NULL;
1162 sqlite3_stmt *stmt = NULL;
1163 filter_s *_filter = (filter_s *)filter;
1165 switch (group_type) {
1166 case MEDIA_GROUP_ALBUM:
1167 #ifdef _USE_TVPD_MODE
1168 if (_filter && STRING_VALID(_filter->storage_id))
1169 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1171 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1173 if (_filter && STRING_VALID(_filter->storage_id))
1174 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1176 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, group_id);
1180 case MEDIA_GROUP_PLAYLIST:
1181 #ifdef _USE_TVPD_MODE
1182 if (_filter && STRING_VALID(_filter->storage_id))
1183 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1185 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1187 if (_filter && STRING_VALID(_filter->storage_id))
1188 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1190 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, group_id);
1194 case MEDIA_GROUP_TAG:
1195 #ifdef _USE_TVPD_MODE
1196 if (_filter && STRING_VALID(_filter->storage_id))
1197 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1199 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1201 if (_filter && STRING_VALID(_filter->storage_id))
1202 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1204 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, group_id);
1209 content_error("INVALID_PARAMETER");
1210 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1213 ret = __media_db_make_query(filter, &condition_query, &option_query);
1214 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1215 g_free(select_query);
1219 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1220 g_free(select_query);
1221 g_free(condition_query);
1222 g_free(option_query);
1223 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1225 while (sqlite3_step(stmt) == SQLITE_ROW) {
1226 media_info_s *item = g_new0(media_info_s, 1);
1228 _media_info_item_get_detail(stmt, (media_info_h)item);
1230 if (callback((media_info_h)item, user_data) == false) {
1231 media_info_destroy((media_info_h)item);
1235 media_info_destroy((media_info_h)item);
1238 SQLITE3_FINALIZE(stmt);
1243 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)
1245 int ret = MEDIA_CONTENT_ERROR_NONE;
1246 char *select_query = NULL;
1247 char *condition_query = NULL;
1248 char *option_query = NULL;
1249 sqlite3_stmt *stmt = NULL;
1250 filter_s *_filter = (filter_s *)filter;
1252 switch (group_type) {
1253 case MEDIA_GROUP_NONE:
1254 #ifdef _USE_TVPD_MODE
1255 if (_filter && STRING_VALID(_filter->storage_id))
1256 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, _filter->storage_id);
1258 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1260 if (_filter && STRING_VALID(_filter->storage_id))
1261 select_query = g_strdup_printf(SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1263 select_query = g_strdup(SELECT_MEDIA_ITEM);
1267 case MEDIA_GROUP_FOLDER:
1268 #ifdef _USE_TVPD_MODE
1269 if (_filter && STRING_VALID(_filter->storage_id))
1270 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1272 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1274 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, group_name);
1278 case MEDIA_GROUP_STORAGE:
1279 #ifdef _USE_TVPD_MODE
1280 select_query = g_strdup_printf(SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1282 select_query = g_strdup_printf(SELECT_MEDIA_FROM_STORAGE, group_name);
1287 content_error("INVALID_PARAMETER");
1288 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1291 ret = __media_db_make_query(filter, &condition_query, &option_query);
1292 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1293 g_free(select_query);
1297 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1298 g_free(select_query);
1299 g_free(condition_query);
1300 g_free(option_query);
1301 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1303 while (sqlite3_step(stmt) == SQLITE_ROW) {
1304 media_info_s *item = g_new0(media_info_s, 1);
1306 _media_info_item_get_detail(stmt, (media_info_h)item);
1308 if (callback((media_info_h)item, user_data) == false) {
1309 media_info_destroy((media_info_h)item);
1313 media_info_destroy((media_info_h)item);
1316 SQLITE3_FINALIZE(stmt);
1321 #ifdef _USE_SENIOR_MODE
1322 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)
1324 int ret = MEDIA_CONTENT_ERROR_NONE;
1325 char select_query1[MAX_QUERY_SIZE] = {0, };
1326 char *condition_query1 = NULL;
1327 char *option_query1 = NULL;
1328 char select_query2[MAX_QUERY_SIZE] = {0, };
1329 char *condition_query2 = NULL;
1330 char *option_query2 = NULL;
1331 sqlite3_stmt *stmt = NULL;
1332 filter_s *_filter1 = (filter_s *)filter1;
1333 filter_s *_filter2 = (filter_s *)filter2;
1335 if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
1336 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, _filter1->storage_id, group_name);
1338 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1340 ret = __media_db_make_query(filter1, &condition_query1, &option_query1);
1341 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1342 SAFE_FREE(condition_query1);
1343 SAFE_FREE(option_query1);
1344 content_error("create select_query1 failed");
1348 if ((_filter2 != NULL) && STRING_VALID(_filter2->storage_id))
1349 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, _filter2->storage_id, group_name);
1351 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1353 ret = __media_db_make_query(filter2, &condition_query2, &option_query2);
1354 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1355 SAFE_FREE(condition_query1);
1356 SAFE_FREE(option_query1);
1357 SAFE_FREE(condition_query2);
1358 SAFE_FREE(option_query2);
1359 content_error("create select_query2 failed");
1363 ret = _content_query_prepare_by_union_select(&stmt, select_query1, condition_query1, option_query1, select_query2, condition_query2, option_query2);
1364 SAFE_FREE(condition_query1);
1365 SAFE_FREE(option_query1);
1366 SAFE_FREE(condition_query2);
1367 SAFE_FREE(option_query2);
1368 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1370 while (sqlite3_step(stmt) == SQLITE_ROW) {
1371 media_info_s *item = g_new0(media_info_s, 1);
1373 _media_info_item_get_detail(stmt, (media_info_h)item);
1375 if (callback((media_info_h)item, user_data) == false) {
1376 media_info_destroy((media_info_h)item);
1380 media_info_destroy((media_info_h)item);
1383 SQLITE3_FINALIZE(stmt);
1389 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1391 int ret = MEDIA_CONTENT_ERROR_NONE;
1392 sqlite3_stmt *stmt = NULL;
1393 char select_query[MAX_QUERY_SIZE] = {0, };
1394 char *tmp_option = NULL;
1395 char *condition_query = NULL;
1396 char *option_query = NULL;
1397 filter_s *_filter = (filter_s *)filter;
1399 #ifdef _USE_TVPD_MODE
1400 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1402 if (_filter && STRING_VALID(_filter->storage_id))
1403 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1405 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1407 if (_filter && STRING_VALID(_filter->storage_id))
1408 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1410 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1412 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1414 if (_filter && STRING_VALID(_filter->storage_id))
1415 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);
1417 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1419 if (_filter && STRING_VALID(_filter->storage_id))
1420 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1422 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1424 } else {/*uhd content*/
1426 if (_filter && STRING_VALID(_filter->storage_id))
1427 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);
1429 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1431 if (_filter && STRING_VALID(_filter->storage_id))
1432 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1434 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1439 if (_filter && STRING_VALID(_filter->storage_id))
1440 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);
1442 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1444 if (_filter && STRING_VALID(_filter->storage_id))
1445 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1447 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1450 ret = __media_db_make_query(filter, &condition_query, &option_query);
1451 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1453 /* If 'filter' is not NULL, 'option_query' must be created. */
1455 tmp_option = g_strconcat(option_query, ")", NULL);
1456 g_free(option_query);
1457 option_query = tmp_option;
1459 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1462 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1463 g_free(condition_query);
1464 g_free(option_query);
1465 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1467 if (sqlite3_step(stmt) == SQLITE_ROW)
1468 *item_count = sqlite3_column_int(stmt, 0);
1470 SQLITE3_FINALIZE(stmt);
1475 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)
1477 int ret = MEDIA_CONTENT_ERROR_NONE;
1478 char select_query[MAX_QUERY_SIZE] = {0, };
1479 char *condition_query = NULL;
1480 char *option_query = NULL;
1481 sqlite3_stmt *stmt = NULL;
1482 filter_s *_filter = (filter_s *)filter;
1484 #ifdef _USE_TVPD_MODE
1486 if (_filter && STRING_VALID(_filter->storage_id))
1487 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1489 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1491 if (_filter && STRING_VALID(_filter->storage_id))
1492 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1494 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1498 if (_filter && STRING_VALID(_filter->storage_id))
1499 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);
1501 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1503 if (_filter && STRING_VALID(_filter->storage_id))
1504 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1506 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1509 ret = __media_db_make_query(filter, &condition_query, &option_query);
1510 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1512 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1513 g_free(condition_query);
1514 g_free(option_query);
1515 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1517 while (sqlite3_step(stmt) == SQLITE_ROW) {
1518 media_info_s *item = g_new0(media_info_s, 1);
1520 _media_info_item_get_detail(stmt, (media_info_h)item);
1522 if (callback((media_info_h)item, user_data) == false) {
1523 media_info_destroy((media_info_h)item);
1527 media_info_destroy((media_info_h)item);
1530 SQLITE3_FINALIZE(stmt);
1535 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1537 int ret = MEDIA_CONTENT_ERROR_NONE;
1538 char *condition_query = NULL;
1539 char *option_query = NULL;
1540 sqlite3_stmt *stmt = NULL;
1542 ret = __media_db_make_query(filter, &condition_query, &option_query);
1543 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1545 ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1546 g_free(condition_query);
1547 g_free(option_query);
1548 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1550 while (sqlite3_step(stmt) == SQLITE_ROW) {
1551 media_storage_s *_storage = g_new0(media_storage_s, 1);
1553 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1554 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1555 _storage->storage_type = sqlite3_column_int(stmt, 2);
1557 if (callback((media_storage_h)_storage, user_data) == false) {
1558 media_storage_destroy((media_storage_h) _storage);
1562 media_storage_destroy((media_storage_h) _storage);
1565 SQLITE3_FINALIZE(stmt);
1570 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1572 int ret = MEDIA_CONTENT_ERROR_NONE;
1573 sqlite3_stmt *stmt = NULL;
1574 char *select_query = NULL;
1576 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1578 ret = _content_get_result(select_query, &stmt);
1579 SQLITE3_SAFE_FREE(select_query);
1580 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1582 if (sqlite3_step(stmt) == SQLITE_ROW) {
1583 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1585 content_error("Invalid media_id[%s]", media_id);
1586 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1589 SQLITE3_FINALIZE(stmt);
1594 #ifdef _USE_TVPD_MODE
1595 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)
1597 int ret = MEDIA_CONTENT_ERROR_NONE;
1598 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1599 char *condition_query = NULL;
1600 char *option_query = NULL;
1601 sqlite3_stmt *stmt = NULL;
1602 filter_s *_filter = (filter_s *)filter;
1605 if (_filter && STRING_VALID(_filter->storage_id))
1606 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);
1608 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1610 if (_filter && STRING_VALID(_filter->storage_id))
1611 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1613 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1616 ret = __media_db_make_query(filter, &condition_query, &option_query);
1617 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1619 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1620 g_free(condition_query);
1621 g_free(option_query);
1622 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1624 while (sqlite3_step(stmt) == SQLITE_ROW) {
1625 media_pvr_s *item = g_new0(media_pvr_s, 1);
1627 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1629 if (callback((media_pvr_h)item, user_data) == false) {
1630 media_info_destroy((media_pvr_h)item);
1634 media_pvr_destroy((media_pvr_h)item);
1637 SQLITE3_FINALIZE(stmt);
1643 MEDIA_PVR_MEDIA_ID = 0,
1644 MEDIA_PVR_STORAGE_ID,
1648 MEDIA_PVR_TIME_ZONE,
1652 MEDIA_PVR_CHANNEL_TYPE,
1653 MEDIA_PVR_CHANNEL_NAME,
1654 MEDIA_PVR_CHANNEL_NUM,
1655 MEDIA_PVR_SERVICE_PROFILE,
1656 MEDIA_PVR_PROGRAM_TITLE,
1657 MEDIA_PVR_PROGRAM_NUM,
1658 MEDIA_PVR_PROGRAM_CRID,
1663 MEDIA_PVR_EMBARGO_TIME,
1664 MEDIA_PVR_EXPIRY_TIME,
1665 MEDIA_PVR_START_TIME,
1666 MEDIA_PVR_PROGRAM_START_TIME,
1667 MEDIA_PVR_PROGRAM_END_TIME,
1668 MEDIA_PVR_PROGRAM_DATE,
1669 MEDIA_PVR_PARENTAL_RATING,
1670 MEDIA_PVR_TIMER_RECORD,
1671 MEDIA_PVR_SERIES_RECORD,
1676 MEDIA_PVR_HARDOF_HEARINGRADIO,
1677 MEDIA_PVR_DATA_SERVICE,
1678 MEDIA_PVR_CONTENT_LOCK,
1679 MEDIA_PVR_CONTENT_WATCH,
1680 MEDIA_PVR_HAS_AUDIO_ONLY,
1681 MEDIA_PVR_IS_LOCAL_RECORDED,
1682 MEDIA_PVR_RESOLUTION,
1683 MEDIA_PVR_ASPECTRATIO,
1684 MEDIA_PVR_MODIFIED_MONTH,
1685 MEDIA_PVR_SPORTS_TYPE,
1686 MEDIA_PVR_GUIDANCE_LENGTH,
1688 MEDIA_PVR_PLAY_COUNT,
1689 MEDIA_PVR_PRIVATE_DATA,
1690 MEDIA_PVR_HIGHLIGHT,
1691 } media_pvr_field_e;
1693 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1695 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1697 _pvr->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1698 _pvr->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1699 _pvr->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1700 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1701 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1702 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1703 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1704 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1705 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1706 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1707 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1708 _pvr->channel_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1709 _pvr->channel_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1710 _pvr->program_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1711 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1712 _pvr->program_crid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1713 _pvr->guidance = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1714 _pvr->synopsis = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1715 _pvr->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1716 _pvr->language = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1717 _pvr->modified_month = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1718 _pvr->private_data = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1719 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1720 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1721 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1722 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1723 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1724 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1725 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1726 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1727 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1728 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1729 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1730 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1731 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1732 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1733 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1734 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1735 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1736 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1737 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1738 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1739 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1740 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1741 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1742 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1743 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1744 _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1749 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1751 int ret = MEDIA_CONTENT_ERROR_NONE;
1752 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1753 char *condition_query = NULL;
1754 char *option_query = NULL;
1755 sqlite3_stmt *stmt = NULL;
1756 filter_s *_filter = (filter_s *)filter;
1758 if (_filter && STRING_VALID(_filter->storage_id))
1759 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1761 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1763 ret = __media_db_make_query(filter, &condition_query, &option_query);
1764 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1766 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1767 g_free(condition_query);
1768 g_free(option_query);
1769 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1771 while (sqlite3_step(stmt) == SQLITE_ROW) {
1772 media_pvr_s *_pvr = g_new0(media_pvr_s, 1);
1774 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1776 if (callback((media_pvr_h)_pvr, user_data) == false) {
1777 media_pvr_destroy((media_pvr_h) _pvr);
1781 media_pvr_destroy((media_pvr_h) _pvr);
1784 SQLITE3_FINALIZE(stmt);
1790 MEDIA_UHD_MEDIA_ID = 0,
1791 MEDIA_UHD_STORAGE_ID,
1794 MEDIA_UHD_CONTENT_ID,
1795 MEDIA_UHD_CONTENT_TITLE,
1796 MEDIA_UHD_FILE_NAME,
1797 MEDIA_UHD_FOLDER_ID,
1798 MEDIA_UHD_RELEASE_DATE,
1799 MEDIA_UHD_MODIFIED_TIME,
1800 MEDIA_UHD_PLAYED_POSITION,
1802 MEDIA_UHD_PLAYED_COUNT,
1803 } media_uhd_field_e;
1805 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1807 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1809 _uhd->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1810 _uhd->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1811 _uhd->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1812 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1813 _uhd->content_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1814 _uhd->content_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1815 _uhd->file_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1816 _uhd->release_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1817 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1818 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1819 _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1820 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1825 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1827 int ret = MEDIA_CONTENT_ERROR_NONE;
1828 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1829 char *condition_query = NULL;
1830 char *option_query = NULL;
1831 sqlite3_stmt *stmt = NULL;
1832 filter_s *_filter = (filter_s *)filter;
1834 if (_filter && STRING_VALID(_filter->storage_id))
1835 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1837 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1839 ret = __media_db_make_query(filter, &condition_query, &option_query);
1840 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1842 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1843 g_free(condition_query);
1844 g_free(option_query);
1845 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1847 while (sqlite3_step(stmt) == SQLITE_ROW) {
1848 media_uhd_s *_uhd = g_new0(media_uhd_s, 1);
1850 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1852 if (callback((media_uhd_h)_uhd, user_data) == false) {
1853 media_uhd_destroy((media_uhd_h) _uhd);
1856 media_uhd_destroy((media_uhd_h) _uhd);
1859 SQLITE3_FINALIZE(stmt);