2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include <media_content.h>
19 #include <media_info_private.h>
20 #include <media_util_private.h>
22 static const char * __media_db_get_group_name(media_group_e group)
25 case MEDIA_CONTENT_GROUP_DISPLAY_NAME:
26 return DB_FIELD_MEDIA_DISPLAY_NAME;
27 case MEDIA_CONTENT_GROUP_TYPE:
28 return DB_FIELD_MEDIA_TYPE;
29 case MEDIA_CONTENT_GROUP_MIME_TYPE:
30 return DB_FIELD_MEDIA_MIME_TYPE;
31 case MEDIA_CONTENT_GROUP_SIZE:
32 return DB_FIELD_MEDIA_SIZE;
33 case MEDIA_CONTENT_GROUP_ADDED_TIME:
34 return DB_FIELD_MEDIA_ADDED_TIME;
35 case MEDIA_CONTENT_GROUP_MODIFIED_TIME:
36 return DB_FIELD_MEDIA_MODIFIED_TIME;
37 case MEDIA_CONTENT_GROUP_TITLE:
38 return DB_FIELD_MEDIA_TITLE;
39 case MEDIA_CONTENT_GROUP_ARTIST:
40 return DB_FIELD_MEDIA_ARTIST;
41 case MEDIA_CONTENT_GROUP_ALBUM_ARTIST:
42 return DB_FIELD_MEDIA_ALBUM_ARTIST;
43 case MEDIA_CONTENT_GROUP_GENRE:
44 return DB_FIELD_MEDIA_GENRE;
45 case MEDIA_CONTENT_GROUP_COMPOSER:
46 return DB_FIELD_MEDIA_COMPOSER;
47 case MEDIA_CONTENT_GROUP_YEAR:
48 return DB_FIELD_MEDIA_YEAR;
49 case MEDIA_CONTENT_GROUP_RECORDED_DATE:
50 return DB_FIELD_MEDIA_RECORDED_DATE;
51 case MEDIA_CONTENT_GROUP_COPYRIGHT:
52 return DB_FIELD_MEDIA_COPYRIGHT;
53 case MEDIA_CONTENT_GROUP_TRACK_NUM:
54 return DB_FIELD_MEDIA_TRACK_NUM;
55 case MEDIA_CONTENT_GROUP_DESCRIPTION:
56 return DB_FIELD_MEDIA_DESCRIPTION;
57 case MEDIA_CONTENT_GROUP_LONGITUDE:
58 return DB_FIELD_MEDIA_LONGITUDE;
59 case MEDIA_CONTENT_GROUP_LATITUDE:
60 return DB_FIELD_MEDIA_LATITUDE;
61 case MEDIA_CONTENT_GROUP_ALTITUDE:
62 return DB_FIELD_MEDIA_ALTITUDE;
63 case MEDIA_CONTENT_GROUP_RATING:
64 return DB_FIELD_MEDIA_RATING;
66 case MEDIA_CONTENT_GROUP_MODIFIED_MONTH:
67 return DB_FIELD_MEDIA_MODIFIED_DATE;
68 case MEDIA_CONTENT_GROUP_MODIFIED_DATE:
69 return DB_FIELD_MEDIA_MODIFIED_DATE;
70 case MEDIA_CONTENT_GROUP_ALBUM:
71 return DB_FIELD_MEDIA_ALBUM;
72 case MEDIA_PVR_GROUP_DURATION:
73 return DB_FIELD_PVR_DURATION;
74 case MEDIA_PVR_GROUP_TIME_ZONE:
75 return DB_FIELD_PVR_TIME_ZONE;
76 case MEDIA_PVR_GROUP_PTC:
77 return DB_FIELD_PVR_PTC;
78 case MEDIA_PVR_GROUP_MAJOR:
79 return DB_FIELD_PVR_MAJOR;
80 case MEDIA_PVR_GROUP_MINOR:
81 return DB_FIELD_PVR_MINOR;
82 case MEDIA_PVR_GROUP_CHANNEL_TYPE:
83 return DB_FIELD_PVR_CHANNEL_TYPE;
84 case MEDIA_PVR_GROUP_CHANNEL_NAME:
85 return DB_FIELD_PVR_CHANNEL_NAME;
86 case MEDIA_PVR_GROUP_CHANNEL_NUM:
87 return DB_FIELD_PVR_CHANNEL_NUM;
88 case MEDIA_PVR_GROUP_PROGRAM_TITLE:
89 return DB_FIELD_PVR_PROGRAM_TITLE;
90 case MEDIA_PVR_GROUP_PROGRAM_NUM:
91 return DB_FIELD_PVR_PROGRAM_NUM;
92 case MEDIA_PVR_GROUP_PROGRAM_CRID:
93 return DB_FIELD_PVR_PROGRAM_CRID;
94 case MEDIA_PVR_GROUP_GUIDANCE:
95 return DB_FIELD_PVR_GUIDANCE;
96 case MEDIA_PVR_GROUP_SYNOPSIS:
97 return DB_FIELD_PVR_SYNOPSIS;
98 case MEDIA_PVR_GROUP_GENRE:
99 return DB_FIELD_PVR_GENRE;
100 case MEDIA_PVR_GROUP_LANGUAGE:
101 return DB_FIELD_PVR_LANGUAGE;
102 case MEDIA_PVR_GROUP_EMBARGO_TIME:
103 return DB_FIELD_PVR_EMBARGO_TIME;
104 case MEDIA_PVR_GROUP_EXPIRY_TIME:
105 return DB_FIELD_PVR_EXPIRY_TIME;
106 case MEDIA_PVR_GROUP_START_TIME:
107 return DB_FIELD_PVR_START_TIME;
108 case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
109 return DB_FIELD_PVR_PROGRAM_START_TIME;
110 case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
111 return DB_FIELD_PVR_PROGRAM_END_TIME;
112 case MEDIA_PVR_GROUP_PROGRAM_DATE:
113 return DB_FIELD_PVR_PROGRAM_DATE;
114 case MEDIA_PVR_GROUP_PARENTAL_RATING:
115 return DB_FIELD_PVR_PARENTAL_RATING;
116 case MEDIA_PVR_GROUP_TIMER_RECORD:
117 return DB_FIELD_PVR_TIMER_RECORD;
118 case MEDIA_PVR_GROUP_SERIES_RECORD:
119 return DB_FIELD_PVR_SERIES_RECORD;
120 case MEDIA_PVR_GROUP_HD:
121 return DB_FIELD_PVR_HD;
122 case MEDIA_PVR_GROUP_SUBTITLE:
123 return DB_FIELD_PVR_SUBTITLE;
124 case MEDIA_PVR_GROUP_TTX:
125 return DB_FIELD_PVR_TTX;
126 case MEDIA_PVR_GROUP_AD:
127 return DB_FIELD_PVR_AD;
128 case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
129 return DB_FIELD_PVR_HARDOF_HEARINGRADIO;
130 case MEDIA_PVR_GROUP_DATA_SERVICE:
131 return DB_FIELD_PVR_DATA_SERVICE;
132 case MEDIA_PVR_GROUP_CONTENT_LOCK:
133 return DB_FIELD_PVR_CONTENT_LOCK;
134 case MEDIA_PVR_GROUP_CONTENT_WATCH:
135 return DB_FIELD_PVR_CONTENT_WATCH;
136 case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
137 return DB_FIELD_PVR_HAS_AUDIO_ONLY;
138 case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
139 return DB_FIELD_PVR_IS_LOCAL_RECORD;
140 case MEDIA_PVR_GROUP_RESOLUTION:
141 return DB_FIELD_PVR_RESOLUTION;
142 case MEDIA_PVR_GROUP_ASPECTRATIO:
143 return DB_FIELD_PVR_ASPECTRATIO;
144 case MEDIA_PVR_GROUP_MODIFIED_MONTH:
145 return DB_FIELD_PVR_MODIFIED_DATE;
146 case MEDIA_PVR_GROUP_MODIFIED_DATE:
147 return DB_FIELD_PVR_MODIFIED_DATE;
148 case MEDIA_PVR_GROUP_SPORTS_TYPE:
149 return DB_FIELD_PVR_SPORTS_TYPE;
150 case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
151 return DB_FIELD_PVR_GUIDANCE_LENGTH;
152 case MEDIA_PVR_GROUP_TVMODE:
153 return DB_FIELD_PVR_TVMODE;
154 case MEDIA_PVR_GROUP_PLAY_COUNT:
155 return DB_FIELD_PVR_PLAY_COUNT;
156 case MEDIA_PVR_GROUP_PRIVATE_DATA:
157 return DB_FIELD_PVR_PRIVATE_DATA;
158 case MEDIA_UHD_GROUP_CONTENT_TITLE:
159 return DB_FIELD_UHD_CONTENT_TITLE;
160 case MEDIA_UHD_GROUP_RELEASE_DATE:
161 return DB_FIELD_UHD_RELEASE_DATE;
162 case MEDIA_UHD_GROUP_SUB_TYPE:
163 return DB_FIELD_UHD_SUB_TYPE;
164 case MEDIA_UHD_GROUP_FILE_NAME:
165 return DB_FIELD_UHD_FILE_NAME;
166 case MEDIA_UHD_GROUP_PLAYED_COUNT:
167 return DB_FIELD_UHD_PLAYED_COUNT;
176 static int __media_db_make_query(filter_h filter, char **condition_query, char **option_query)
178 int ret = MEDIA_CONTENT_ERROR_NONE;
179 filter_s *_filter = (filter_s *)filter;
181 content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
183 if (STRING_VALID(_filter->condition)) {
184 ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
185 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
188 ret = _media_filter_build_option(filter, option_query);
189 if (ret != MEDIA_CONTENT_ERROR_NONE)
190 g_free(*condition_query);
195 #ifdef _USE_TVPD_MODE
196 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
198 int ret = MEDIA_CONTENT_ERROR_NONE;
199 sqlite3_stmt *stmt = NULL;
200 char *select_query = NULL;
201 char *condition_query = NULL;
202 char *option_query = NULL;
203 filter_s *_filter = (filter_s *)filter;
205 switch (group_type) {
206 case MEDIA_GROUP_ALBUM:
207 if (_filter && STRING_VALID(_filter->storage_id))
208 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, _filter->storage_id);
210 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
213 case MEDIA_GROUP_FOLDER:
214 if (_filter && STRING_VALID(_filter->storage_id))
215 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
217 select_query = g_strdup_printf(SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
220 case MEDIA_GROUP_PLAYLIST:
221 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
224 case MEDIA_GROUP_TAG:
225 select_query = g_strdup(SELECT_TAG_COUNT);
228 case MEDIA_GROUP_BOOKMARK:
229 if (_filter && STRING_VALID(_filter->storage_id))
230 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, _filter->storage_id);
232 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
236 case MEDIA_GROUP_STORAGE:
237 select_query = g_strdup(SELECT_STORAGE_COUNT);
240 case MEDIA_GROUP_FACE:
241 if (_filter && STRING_VALID(_filter->storage_id))
242 select_query = g_strdup_printf(SELECT_FACE_COUNT, _filter->storage_id);
244 select_query = g_strdup_printf(SELECT_FACE_COUNT, DB_VIEW_MEDIA);
248 content_error("Invalid group type [%d]", group_type);
249 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
252 ret = __media_db_make_query(filter, &condition_query, &option_query);
253 if (ret != MEDIA_CONTENT_ERROR_NONE) {
254 g_free(select_query);
258 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
259 g_free(select_query);
260 g_free(condition_query);
261 g_free(option_query);
262 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
264 if (sqlite3_step(stmt) == SQLITE_ROW)
265 *group_count = sqlite3_column_int(stmt, 0);
267 SQLITE3_FINALIZE(stmt);
272 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
274 int ret = MEDIA_CONTENT_ERROR_NONE;
275 sqlite3_stmt *stmt = NULL;
276 char select_query[MAX_QUERY_SIZE] = {0, };
277 char *condition_query = NULL;
278 char *option_query = NULL;
279 char *tmp_option = NULL;
280 filter_s *_filter = (filter_s *)filter;
282 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
283 if (_filter && STRING_VALID(_filter->storage_id))
284 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
286 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
287 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
288 if (_filter && STRING_VALID(_filter->storage_id))
289 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
291 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
292 } else { /*uhd content*/
293 if (_filter && STRING_VALID(_filter->storage_id))
294 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
296 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
298 ret = __media_db_make_query(filter, &condition_query, &option_query);
299 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
302 tmp_option = g_strconcat(option_query, ")", NULL);
303 g_free(option_query);
304 option_query = tmp_option;
306 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
309 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
310 g_free(condition_query);
311 g_free(option_query);
312 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
314 if (sqlite3_step(stmt) == SQLITE_ROW)
315 *group_count = sqlite3_column_int(stmt, 0);
317 SQLITE3_FINALIZE(stmt);
322 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
324 int ret = MEDIA_CONTENT_ERROR_NONE;
325 char select_query[MAX_QUERY_SIZE] = {0, };
326 char *condition_query = NULL;
327 char *option_query = NULL;
329 sqlite3_stmt *stmt = NULL;
330 filter_s *_filter = (filter_s *)filter;
332 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
333 if (_filter && STRING_VALID(_filter->storage_id))
334 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
336 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
337 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
338 if (_filter && STRING_VALID(_filter->storage_id))
339 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
341 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
342 } else { /* uhd content */
343 if (_filter && STRING_VALID(_filter->storage_id))
344 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
346 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
348 ret = __media_db_make_query(filter, &condition_query, &option_query);
349 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
351 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
352 g_free(condition_query);
353 g_free(option_query);
354 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
356 while (sqlite3_step(stmt) == SQLITE_ROW) {
357 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
359 if (callback(name, user_data) == false) {
367 SQLITE3_FINALIZE(stmt);
372 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
374 int ret = MEDIA_CONTENT_ERROR_NONE;
375 char select_query[DEFAULT_QUERY_SIZE] = {0, };
376 char group_query[DEFAULT_QUERY_SIZE] = {0, };
377 char *condition_query = NULL;
378 char *option_query = NULL;
380 sqlite3_stmt *stmt = NULL;
381 filter_s *_filter = (filter_s *)filter;
383 const char* group_name = __media_db_get_group_name(group);
384 content_retip_if_fail(STRING_VALID(group_name));
386 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
387 if (_filter && STRING_VALID(_filter->storage_id))
388 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
390 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
391 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
392 if (_filter && STRING_VALID(_filter->storage_id))
393 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
395 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
396 } else {/*uhd content*/
397 if (_filter && STRING_VALID(_filter->storage_id))
398 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
400 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
403 ret = __media_db_make_query(filter, &condition_query, &option_query);
404 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
406 if (STRING_VALID(option_query))
407 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
409 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
411 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
412 g_free(condition_query);
413 g_free(option_query);
414 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
416 while (sqlite3_step(stmt) == SQLITE_ROW) {
417 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
419 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
427 SQLITE3_FINALIZE(stmt);
432 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
434 int ret = MEDIA_CONTENT_ERROR_NONE;
435 sqlite3_stmt *stmt = NULL;
436 char *select_query = NULL;
437 char *condition_query = NULL;
438 char *option_query = NULL;
439 filter_s *_filter = (filter_s *)filter;
441 switch (group_type) {
442 case MEDIA_GROUP_ALBUM:
443 if (_filter && STRING_VALID(_filter->storage_id))
444 select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
446 select_query = g_strdup(SELECT_ALBUM_COUNT);
449 case MEDIA_GROUP_FOLDER:
450 if (_filter && STRING_VALID(_filter->storage_id))
451 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
453 select_query = g_strdup(SELECT_FOLDER_COUNT);
456 case MEDIA_GROUP_PLAYLIST:
457 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
460 case MEDIA_GROUP_TAG:
461 select_query = g_strdup(SELECT_TAG_COUNT);
464 case MEDIA_GROUP_BOOKMARK:
465 if (_filter && STRING_VALID(_filter->storage_id))
466 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
468 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
472 case MEDIA_GROUP_STORAGE:
473 select_query = g_strdup(SELECT_STORAGE_COUNT);
476 case MEDIA_GROUP_FACE:
477 if (_filter && STRING_VALID(_filter->storage_id))
478 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
480 select_query = g_strdup(SELECT_FACE_COUNT);
484 content_error("Invalid group type [%d]", group_type);
485 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
488 ret = __media_db_make_query(filter, &condition_query, &option_query);
489 if (ret != MEDIA_CONTENT_ERROR_NONE) {
490 g_free(select_query);
494 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
495 g_free(select_query);
496 g_free(condition_query);
497 g_free(option_query);
498 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
500 if (sqlite3_step(stmt) == SQLITE_ROW)
501 *group_count = sqlite3_column_int(stmt, 0);
503 SQLITE3_FINALIZE(stmt);
508 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
510 int ret = MEDIA_CONTENT_ERROR_NONE;
511 sqlite3_stmt *stmt = NULL;
512 char *select_query = NULL;
513 char *condition_query = NULL;
514 char *option_query = NULL;
515 filter_s *_filter = (filter_s *)filter;
517 if (_filter && STRING_VALID(_filter->storage_id))
518 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);
520 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
522 ret = __media_db_make_query(filter, &condition_query, &option_query);
523 if (ret != MEDIA_CONTENT_ERROR_NONE) {
524 g_free(select_query);
528 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
529 g_free(select_query);
530 g_free(condition_query);
531 g_free(option_query);
532 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
534 if (sqlite3_step(stmt) == SQLITE_ROW)
535 *group_count = sqlite3_column_int(stmt, 0);
537 SQLITE3_FINALIZE(stmt);
542 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
544 int ret = MEDIA_CONTENT_ERROR_NONE;
545 char *select_query = NULL;
546 char *condition_query = NULL;
547 char *option_query = NULL;
549 sqlite3_stmt *stmt = NULL;
550 filter_s *_filter = (filter_s *)filter;
552 if (_filter && STRING_VALID(_filter->storage_id))
553 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
555 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
557 ret = __media_db_make_query(filter, &condition_query, &option_query);
558 if (ret != MEDIA_CONTENT_ERROR_NONE) {
559 g_free(select_query);
563 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
564 g_free(select_query);
565 g_free(condition_query);
566 g_free(option_query);
567 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
569 while (sqlite3_step(stmt) == SQLITE_ROW) {
570 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
572 if (callback(name, user_data) == false) {
580 SQLITE3_FINALIZE(stmt);
586 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
588 int ret = MEDIA_CONTENT_ERROR_NONE;
589 char *select_query = NULL;
590 char *condition_query = NULL;
591 char *option_query = NULL;
592 sqlite3_stmt *stmt = NULL;
593 filter_s *_filter = (filter_s *)filter;
595 #ifdef _USE_TVPD_MODE
596 if (_filter && STRING_VALID(_filter->storage_id))
597 select_query = g_strdup_printf(SELECT_ALBUM_LIST, _filter->storage_id);
599 select_query = g_strdup_printf(SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
601 if (_filter && STRING_VALID(_filter->storage_id))
602 select_query = g_strdup_printf(SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
604 select_query = g_strdup(SELECT_ALBUM_LIST);
606 ret = __media_db_make_query(filter, &condition_query, &option_query);
607 if (ret != MEDIA_CONTENT_ERROR_NONE) {
608 g_free(select_query);
612 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
613 g_free(select_query);
614 g_free(condition_query);
615 g_free(option_query);
616 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
618 while (sqlite3_step(stmt) == SQLITE_ROW) {
619 media_album_s *album = g_new0(media_album_s, 1);
621 album->album_id = sqlite3_column_int(stmt, 0);
622 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
623 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
624 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
626 if (callback((media_album_h)album, user_data) == false) {
627 media_album_destroy((media_album_h)album);
631 media_album_destroy((media_album_h)album);
634 SQLITE3_FINALIZE(stmt);
639 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
641 int ret = MEDIA_CONTENT_ERROR_NONE;
642 char *select_query = NULL;
643 char *condition_query = NULL;
644 char *option_query = NULL;
645 sqlite3_stmt *stmt = NULL;
646 filter_s *_filter = (filter_s *)filter;
648 #ifdef _USE_TVPD_MODE
649 if (_filter && STRING_VALID(_filter->storage_id))
650 select_query = g_strdup_printf(SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
652 select_query = g_strdup_printf(SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
654 if (_filter && STRING_VALID(_filter->storage_id))
655 select_query = g_strdup_printf(SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
657 select_query = g_strdup(SELECT_FOLDER_LIST);
659 ret = __media_db_make_query(filter, &condition_query, &option_query);
660 if (ret != MEDIA_CONTENT_ERROR_NONE) {
661 g_free(select_query);
665 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
666 g_free(select_query);
667 g_free(condition_query);
668 g_free(option_query);
669 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
671 while (sqlite3_step(stmt) == SQLITE_ROW) {
672 media_folder_s *_folder = g_new0(media_folder_s, 1);
673 #ifdef _USE_TVPD_MODE
674 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
676 _folder->folder_id = g_strdup_printf("%lld", sqlite3_column_int64(stmt, 0));
678 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
679 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
680 _folder->storage_type = sqlite3_column_int(stmt, 3);
681 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
683 if (callback((media_folder_h)_folder, user_data) == false) {
684 media_folder_destroy((media_folder_h) _folder);
688 media_folder_destroy((media_folder_h) _folder);
691 SQLITE3_FINALIZE(stmt);
696 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
698 int ret = MEDIA_CONTENT_ERROR_NONE;
699 char *condition_query = NULL;
700 char *option_query = NULL;
701 sqlite3_stmt *stmt = NULL;
703 ret = __media_db_make_query(filter, &condition_query, &option_query);
704 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
706 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
707 g_free(condition_query);
708 g_free(option_query);
709 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
711 while (sqlite3_step(stmt) == SQLITE_ROW) {
712 media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
714 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
715 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
716 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
718 if (callback((media_playlist_h)_playlist, user_data) == false) {
719 media_playlist_destroy((media_playlist_h)_playlist);
722 media_playlist_destroy((media_playlist_h)_playlist);
725 SQLITE3_FINALIZE(stmt);
730 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
732 int ret = MEDIA_CONTENT_ERROR_NONE;
733 char *select_query = NULL;
734 char *condition_query = NULL;
735 char *option_query = NULL;
736 sqlite3_stmt *stmt = NULL;
738 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
740 ret = __media_db_make_query(filter, &condition_query, &option_query);
741 if (ret != MEDIA_CONTENT_ERROR_NONE) {
742 g_free(select_query);
746 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
747 g_free(select_query);
748 g_free(condition_query);
749 g_free(option_query);
750 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
752 while (sqlite3_step(stmt) == SQLITE_ROW) {
753 int playlist_member_id = 0;
754 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
756 media_info_s *_media = g_new0(media_info_s, 1);
758 _media_info_item_get_detail(stmt, (media_info_h)_media);
760 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
761 media_info_destroy((media_info_h)_media);
764 media_info_destroy((media_info_h)_media);
768 SQLITE3_FINALIZE(stmt);
773 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
775 int ret = MEDIA_CONTENT_ERROR_NONE;
776 char *select_query = NULL;
777 char *condition_query = NULL;
778 char *option_query = NULL;
779 sqlite3_stmt *stmt = NULL;
781 if (STRING_VALID(media_id))
782 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
784 select_query = g_strdup(SELECT_TAG_LIST);
786 ret = __media_db_make_query(filter, &condition_query, &option_query);
787 if (ret != MEDIA_CONTENT_ERROR_NONE) {
788 g_free(select_query);
792 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
793 g_free(select_query);
794 g_free(condition_query);
795 g_free(option_query);
796 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
798 while (sqlite3_step(stmt) == SQLITE_ROW) {
799 media_tag_s *_tag = g_new0(media_tag_s, 1);
801 _tag->tag_id = sqlite3_column_int(stmt, 0);
802 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
804 if (callback((media_tag_h)_tag, user_data) == false) {
805 media_tag_destroy((media_tag_h)_tag);
808 media_tag_destroy((media_tag_h)_tag);
811 SQLITE3_FINALIZE(stmt);
816 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
818 int ret = MEDIA_CONTENT_ERROR_NONE;
819 char *select_query = NULL;
820 char *condition_query = NULL;
821 char *option_query = NULL;
822 sqlite3_stmt *stmt = NULL;
823 filter_s *_filter = (filter_s *)filter;
825 #ifdef _USE_TVPD_MODE
826 if (STRING_VALID(media_id)) { //get bookmark by media_id
827 if (_filter && STRING_VALID(_filter->storage_id))
828 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
830 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
832 if (_filter && STRING_VALID(_filter->storage_id))
833 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, _filter->storage_id);
835 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
838 if (STRING_VALID(media_id)) { //get bookmark by media_id
839 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
841 if (_filter && STRING_VALID(_filter->storage_id))
842 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
844 select_query = g_strdup(SELECT_BOOKMARK_LIST);
848 ret = __media_db_make_query(filter, &condition_query, &option_query);
849 if (ret != MEDIA_CONTENT_ERROR_NONE) {
850 g_free(select_query);
854 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
855 g_free(select_query);
856 g_free(condition_query);
857 g_free(option_query);
858 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
860 while (sqlite3_step(stmt) == SQLITE_ROW) {
861 media_bookmark_s *bookmark = g_new0(media_bookmark_s, 1);
863 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
864 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
865 bookmark->marked_time = sqlite3_column_int(stmt, 2);
866 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
867 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
869 if (callback((media_bookmark_h)bookmark, user_data) == false) {
870 media_bookmark_destroy((media_bookmark_h)bookmark);
874 media_bookmark_destroy((media_bookmark_h)bookmark);
877 SQLITE3_FINALIZE(stmt);
883 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
885 int ret = MEDIA_CONTENT_ERROR_NONE;
886 char *select_query = NULL;
887 char *condition_query = NULL;
888 char *option_query = NULL;
889 sqlite3_stmt *stmt = NULL;
890 filter_s *_filter = (filter_s *)filter;
892 #ifdef _USE_TVPD_MODE
893 if (STRING_VALID(media_id)) { //get face by media_id
894 if (_filter && STRING_VALID(_filter->storage_id))
895 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
897 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
899 if (_filter && STRING_VALID(_filter->storage_id))
900 select_query = g_strdup_printf(SELECT_FACE_LIST, _filter->storage_id);
902 select_query = g_strdup_printf(SELECT_FACE_LIST, DB_VIEW_MEDIA);
905 if (STRING_VALID(media_id)) { //get face by media_id
906 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
908 if (_filter && STRING_VALID(_filter->storage_id))
909 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
911 select_query = g_strdup(SELECT_FACE_LIST);
914 ret = __media_db_make_query(filter, &condition_query, &option_query);
915 if (ret != MEDIA_CONTENT_ERROR_NONE) {
916 g_free(select_query);
920 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
921 g_free(select_query);
922 g_free(condition_query);
923 g_free(option_query);
924 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
926 while (sqlite3_step(stmt) == SQLITE_ROW) {
927 media_face_s *face = g_new0(media_face_s, 1);
929 face->face_id = sqlite3_column_int(stmt, 0);
930 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
931 face->face_rect_x = sqlite3_column_int(stmt, 2);
932 face->face_rect_y = sqlite3_column_int(stmt, 3);
933 face->face_rect_w = sqlite3_column_int(stmt, 4);
934 face->face_rect_h = sqlite3_column_int(stmt, 5);
935 face->orientation = sqlite3_column_int(stmt, 6);
936 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
938 if (callback((media_face_h)face, user_data) == false) {
939 media_face_destroy((media_face_h)face);
943 media_face_destroy((media_face_h)face);
946 SQLITE3_FINALIZE(stmt);
952 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
954 int ret = MEDIA_CONTENT_ERROR_NONE;
955 sqlite3_stmt *stmt = NULL;
956 char *select_query = NULL;
957 char *condition_query = NULL;
958 char *option_query = NULL;
959 filter_s *_filter = (filter_s *)filter;
961 switch (group_type) {
962 case MEDIA_GROUP_ALBUM:
963 #ifdef _USE_TVPD_MODE
964 if (_filter && STRING_VALID(_filter->storage_id))
965 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
967 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
969 if (_filter && STRING_VALID(_filter->storage_id))
970 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
972 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
976 case MEDIA_GROUP_PLAYLIST:
977 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
980 case MEDIA_GROUP_TAG:
981 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_TAG, group_id);
985 content_error("INVALID_PARAMETER");
986 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
989 ret = __media_db_make_query(filter, &condition_query, &option_query);
990 if (ret != MEDIA_CONTENT_ERROR_NONE) {
991 g_free(select_query);
995 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
996 g_free(select_query);
997 g_free(condition_query);
998 g_free(option_query);
999 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1001 if (sqlite3_step(stmt) == SQLITE_ROW)
1002 *item_count = sqlite3_column_int(stmt, 0);
1004 SQLITE3_FINALIZE(stmt);
1009 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
1011 int ret = MEDIA_CONTENT_ERROR_NONE;
1012 sqlite3_stmt *stmt = NULL;
1013 char *select_query = NULL;
1014 char *condition_query = NULL;
1015 char *option_query = NULL;
1016 char *tmp_option = NULL;
1017 bool need_bracket = false;
1018 filter_s *_filter = (filter_s *)filter;
1020 switch (group_type) {
1021 case MEDIA_GROUP_NONE:
1023 #ifdef _USE_TVPD_MODE
1024 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1026 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1031 if (_filter->offset < 0 && _filter->count < 0) {
1032 #ifdef _USE_TVPD_MODE
1033 if (STRING_VALID(_filter->storage_id))
1034 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1036 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1038 if (STRING_VALID(_filter->storage_id))
1039 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1041 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1044 #ifdef _USE_TVPD_MODE
1045 if (STRING_VALID(_filter->storage_id))
1046 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
1048 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1050 if (STRING_VALID(_filter->storage_id))
1051 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_BY_STORAGE_ID, _filter->storage_id);
1053 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA);
1055 need_bracket = true;
1059 case MEDIA_GROUP_FOLDER:
1060 #ifdef _USE_TVPD_MODE
1061 if (_filter && STRING_VALID(_filter->storage_id))
1062 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1064 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1066 if (_filter && STRING_VALID(_filter->storage_id))
1067 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1069 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1073 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1074 select_query = g_strdup_printf(SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1077 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1078 #ifdef _USE_TVPD_MODE
1079 if (_filter && STRING_VALID(_filter->storage_id))
1080 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1082 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1084 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1088 case MEDIA_GROUP_STORAGE:
1089 #ifdef _USE_TVPD_MODE
1090 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1092 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1096 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1097 #ifdef _USE_TVPD_MODE
1098 if (_filter && STRING_VALID(_filter->storage_id))
1099 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1101 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1103 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1107 #ifdef _USE_TVPD_MODE
1108 case MEDIA_GROUP_PVR:
1109 if (_filter && STRING_VALID(_filter->storage_id))
1110 select_query = g_strdup_printf(SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1112 select_query = g_strdup(SELECT_PVR_COUNT);
1115 case MEDIA_GROUP_UHD:
1116 if (_filter && STRING_VALID(_filter->storage_id))
1117 select_query = g_strdup_printf(SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1119 select_query = g_strdup(SELECT_UHD_COUNT);
1123 content_error("INVALID_PARAMETER");
1124 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1127 ret = __media_db_make_query(filter, &condition_query, &option_query);
1128 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1129 g_free(select_query);
1134 tmp_option = g_strconcat(option_query, ")", NULL);
1135 g_free(option_query);
1136 option_query = tmp_option;
1139 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1140 g_free(select_query);
1141 g_free(condition_query);
1142 g_free(option_query);
1143 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1145 if (sqlite3_step(stmt) == SQLITE_ROW)
1146 *item_count = sqlite3_column_int(stmt, 0);
1148 SQLITE3_FINALIZE(stmt);
1153 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)
1155 int ret = MEDIA_CONTENT_ERROR_NONE;
1156 char *select_query = NULL;
1157 char *condition_query = NULL;
1158 char *option_query = NULL;
1159 sqlite3_stmt *stmt = NULL;
1160 filter_s *_filter = (filter_s *)filter;
1162 switch (group_type) {
1163 case MEDIA_GROUP_ALBUM:
1164 #ifdef _USE_TVPD_MODE
1165 if (_filter && STRING_VALID(_filter->storage_id))
1166 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1168 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1170 if (_filter && STRING_VALID(_filter->storage_id))
1171 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1173 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, group_id);
1177 case MEDIA_GROUP_PLAYLIST:
1178 #ifdef _USE_TVPD_MODE
1179 if (_filter && STRING_VALID(_filter->storage_id))
1180 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1182 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1184 if (_filter && STRING_VALID(_filter->storage_id))
1185 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1187 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, group_id);
1191 case MEDIA_GROUP_TAG:
1192 #ifdef _USE_TVPD_MODE
1193 if (_filter && STRING_VALID(_filter->storage_id))
1194 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1196 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1198 if (_filter && STRING_VALID(_filter->storage_id))
1199 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1201 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, group_id);
1206 content_error("INVALID_PARAMETER");
1207 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1210 ret = __media_db_make_query(filter, &condition_query, &option_query);
1211 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1212 g_free(select_query);
1216 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1217 g_free(select_query);
1218 g_free(condition_query);
1219 g_free(option_query);
1220 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1222 while (sqlite3_step(stmt) == SQLITE_ROW) {
1223 media_info_s *item = g_new0(media_info_s, 1);
1225 _media_info_item_get_detail(stmt, (media_info_h)item);
1227 if (callback((media_info_h)item, user_data) == false) {
1228 media_info_destroy((media_info_h)item);
1232 media_info_destroy((media_info_h)item);
1235 SQLITE3_FINALIZE(stmt);
1240 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)
1242 int ret = MEDIA_CONTENT_ERROR_NONE;
1243 char *select_query = NULL;
1244 char *condition_query = NULL;
1245 char *option_query = NULL;
1246 sqlite3_stmt *stmt = NULL;
1247 filter_s *_filter = (filter_s *)filter;
1249 switch (group_type) {
1250 case MEDIA_GROUP_NONE:
1251 #ifdef _USE_TVPD_MODE
1252 if (_filter && STRING_VALID(_filter->storage_id))
1253 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, _filter->storage_id);
1255 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1257 if (_filter && STRING_VALID(_filter->storage_id))
1258 select_query = g_strdup_printf(SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1260 select_query = g_strdup(SELECT_MEDIA_ITEM);
1264 case MEDIA_GROUP_FOLDER:
1265 #ifdef _USE_TVPD_MODE
1266 if (_filter && STRING_VALID(_filter->storage_id))
1267 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1269 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1271 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, group_name);
1275 case MEDIA_GROUP_STORAGE:
1276 #ifdef _USE_TVPD_MODE
1277 select_query = g_strdup_printf(SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1279 select_query = g_strdup_printf(SELECT_MEDIA_FROM_STORAGE, group_name);
1284 content_error("INVALID_PARAMETER");
1285 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1288 ret = __media_db_make_query(filter, &condition_query, &option_query);
1289 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1290 g_free(select_query);
1294 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1295 g_free(select_query);
1296 g_free(condition_query);
1297 g_free(option_query);
1298 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1300 while (sqlite3_step(stmt) == SQLITE_ROW) {
1301 media_info_s *item = g_new0(media_info_s, 1);
1303 _media_info_item_get_detail(stmt, (media_info_h)item);
1305 if (callback((media_info_h)item, user_data) == false) {
1306 media_info_destroy((media_info_h)item);
1310 media_info_destroy((media_info_h)item);
1313 SQLITE3_FINALIZE(stmt);
1318 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1320 int ret = MEDIA_CONTENT_ERROR_NONE;
1321 sqlite3_stmt *stmt = NULL;
1322 char select_query[MAX_QUERY_SIZE] = {0, };
1323 char *tmp_option = NULL;
1324 char *condition_query = NULL;
1325 char *option_query = NULL;
1326 filter_s *_filter = (filter_s *)filter;
1328 #ifdef _USE_TVPD_MODE
1329 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1331 if (_filter && STRING_VALID(_filter->storage_id))
1332 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1334 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1336 if (_filter && STRING_VALID(_filter->storage_id))
1337 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1339 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1341 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1343 if (_filter && STRING_VALID(_filter->storage_id))
1344 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);
1346 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1348 if (_filter && STRING_VALID(_filter->storage_id))
1349 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1351 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1353 } else {/*uhd content*/
1355 if (_filter && STRING_VALID(_filter->storage_id))
1356 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);
1358 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1360 if (_filter && STRING_VALID(_filter->storage_id))
1361 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1363 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1368 if (_filter && STRING_VALID(_filter->storage_id))
1369 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);
1371 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1373 if (_filter && STRING_VALID(_filter->storage_id))
1374 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1376 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1379 ret = __media_db_make_query(filter, &condition_query, &option_query);
1380 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1382 /* If 'filter' is not NULL, 'option_query' must be created. */
1384 tmp_option = g_strconcat(option_query, ")", NULL);
1385 g_free(option_query);
1386 option_query = tmp_option;
1388 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1391 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1392 g_free(condition_query);
1393 g_free(option_query);
1394 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1396 if (sqlite3_step(stmt) == SQLITE_ROW)
1397 *item_count = sqlite3_column_int(stmt, 0);
1399 SQLITE3_FINALIZE(stmt);
1404 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)
1406 int ret = MEDIA_CONTENT_ERROR_NONE;
1407 char select_query[MAX_QUERY_SIZE] = {0, };
1408 char *condition_query = NULL;
1409 char *option_query = NULL;
1410 sqlite3_stmt *stmt = NULL;
1411 filter_s *_filter = (filter_s *)filter;
1413 #ifdef _USE_TVPD_MODE
1415 if (_filter && STRING_VALID(_filter->storage_id))
1416 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1418 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1420 if (_filter && STRING_VALID(_filter->storage_id))
1421 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1423 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1427 if (_filter && STRING_VALID(_filter->storage_id))
1428 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);
1430 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1432 if (_filter && STRING_VALID(_filter->storage_id))
1433 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1435 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1438 ret = __media_db_make_query(filter, &condition_query, &option_query);
1439 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1441 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1442 g_free(condition_query);
1443 g_free(option_query);
1444 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1446 while (sqlite3_step(stmt) == SQLITE_ROW) {
1447 media_info_s *item = g_new0(media_info_s, 1);
1449 _media_info_item_get_detail(stmt, (media_info_h)item);
1451 if (callback((media_info_h)item, user_data) == false) {
1452 media_info_destroy((media_info_h)item);
1456 media_info_destroy((media_info_h)item);
1459 SQLITE3_FINALIZE(stmt);
1464 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1466 int ret = MEDIA_CONTENT_ERROR_NONE;
1467 char *condition_query = NULL;
1468 char *option_query = NULL;
1469 sqlite3_stmt *stmt = NULL;
1471 ret = __media_db_make_query(filter, &condition_query, &option_query);
1472 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1474 ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1475 g_free(condition_query);
1476 g_free(option_query);
1477 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1479 while (sqlite3_step(stmt) == SQLITE_ROW) {
1480 media_storage_s *_storage = g_new0(media_storage_s, 1);
1482 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1483 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1484 _storage->storage_type = sqlite3_column_int(stmt, 2);
1486 if (callback((media_storage_h)_storage, user_data) == false) {
1487 media_storage_destroy((media_storage_h) _storage);
1491 media_storage_destroy((media_storage_h) _storage);
1494 SQLITE3_FINALIZE(stmt);
1499 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1501 int ret = MEDIA_CONTENT_ERROR_NONE;
1502 sqlite3_stmt *stmt = NULL;
1503 char *select_query = NULL;
1505 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1507 ret = _content_get_result(select_query, &stmt);
1508 SQLITE3_SAFE_FREE(select_query);
1509 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1511 if (sqlite3_step(stmt) == SQLITE_ROW) {
1512 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1514 content_error("Invalid media_id[%s]", media_id);
1515 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1518 SQLITE3_FINALIZE(stmt);
1523 #ifdef _USE_TVPD_MODE
1524 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)
1526 int ret = MEDIA_CONTENT_ERROR_NONE;
1527 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1528 char *condition_query = NULL;
1529 char *option_query = NULL;
1530 sqlite3_stmt *stmt = NULL;
1531 filter_s *_filter = (filter_s *)filter;
1534 if (_filter && STRING_VALID(_filter->storage_id))
1535 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);
1537 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1539 if (_filter && STRING_VALID(_filter->storage_id))
1540 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1542 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1545 ret = __media_db_make_query(filter, &condition_query, &option_query);
1546 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1548 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1549 g_free(condition_query);
1550 g_free(option_query);
1551 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1553 while (sqlite3_step(stmt) == SQLITE_ROW) {
1554 media_pvr_s *item = g_new0(media_pvr_s, 1);
1556 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1558 if (callback((media_pvr_h)item, user_data) == false) {
1559 media_info_destroy((media_pvr_h)item);
1563 media_pvr_destroy((media_pvr_h)item);
1566 SQLITE3_FINALIZE(stmt);
1572 MEDIA_PVR_MEDIA_ID = 0,
1573 MEDIA_PVR_STORAGE_ID,
1577 MEDIA_PVR_TIME_ZONE,
1581 MEDIA_PVR_CHANNEL_TYPE,
1582 MEDIA_PVR_CHANNEL_NAME,
1583 MEDIA_PVR_CHANNEL_NUM,
1584 MEDIA_PVR_SERVICE_PROFILE,
1585 MEDIA_PVR_PROGRAM_TITLE,
1586 MEDIA_PVR_PROGRAM_NUM,
1587 MEDIA_PVR_PROGRAM_CRID,
1592 MEDIA_PVR_EMBARGO_TIME,
1593 MEDIA_PVR_EXPIRY_TIME,
1594 MEDIA_PVR_START_TIME,
1595 MEDIA_PVR_PROGRAM_START_TIME,
1596 MEDIA_PVR_PROGRAM_END_TIME,
1597 MEDIA_PVR_PROGRAM_DATE,
1598 MEDIA_PVR_PARENTAL_RATING,
1599 MEDIA_PVR_TIMER_RECORD,
1600 MEDIA_PVR_SERIES_RECORD,
1605 MEDIA_PVR_HARDOF_HEARINGRADIO,
1606 MEDIA_PVR_DATA_SERVICE,
1607 MEDIA_PVR_CONTENT_LOCK,
1608 MEDIA_PVR_CONTENT_WATCH,
1609 MEDIA_PVR_HAS_AUDIO_ONLY,
1610 MEDIA_PVR_IS_LOCAL_RECORDED,
1611 MEDIA_PVR_RESOLUTION,
1612 MEDIA_PVR_ASPECTRATIO,
1613 MEDIA_PVR_MODIFIED_MONTH,
1614 MEDIA_PVR_SPORTS_TYPE,
1615 MEDIA_PVR_GUIDANCE_LENGTH,
1617 MEDIA_PVR_PLAY_COUNT,
1618 MEDIA_PVR_PRIVATE_DATA,
1619 MEDIA_PVR_HIGHLIGHT,
1620 } media_pvr_field_e;
1622 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1624 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1626 _pvr->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1627 _pvr->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1628 _pvr->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1629 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1630 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1631 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1632 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1633 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1634 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1635 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1636 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1637 _pvr->channel_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1638 _pvr->channel_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1639 _pvr->program_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1640 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1641 _pvr->program_crid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1642 _pvr->guidance = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1643 _pvr->synopsis = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1644 _pvr->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1645 _pvr->language = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1646 _pvr->modified_month = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1647 _pvr->private_data = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1648 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1649 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1650 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1651 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1652 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1653 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1654 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1655 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1656 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1657 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1658 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1659 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1660 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1661 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1662 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1663 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1664 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1665 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1666 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1667 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1668 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1669 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1670 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1671 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1672 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1673 _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1678 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1680 int ret = MEDIA_CONTENT_ERROR_NONE;
1681 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1682 char *condition_query = NULL;
1683 char *option_query = NULL;
1684 sqlite3_stmt *stmt = NULL;
1685 filter_s *_filter = (filter_s *)filter;
1687 if (_filter && STRING_VALID(_filter->storage_id))
1688 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1690 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1692 ret = __media_db_make_query(filter, &condition_query, &option_query);
1693 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1695 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1696 g_free(condition_query);
1697 g_free(option_query);
1698 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1700 while (sqlite3_step(stmt) == SQLITE_ROW) {
1701 media_pvr_s *_pvr = g_new0(media_pvr_s, 1);
1703 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1705 if (callback((media_pvr_h)_pvr, user_data) == false) {
1706 media_pvr_destroy((media_pvr_h) _pvr);
1710 media_pvr_destroy((media_pvr_h) _pvr);
1713 SQLITE3_FINALIZE(stmt);
1719 MEDIA_UHD_MEDIA_ID = 0,
1720 MEDIA_UHD_STORAGE_ID,
1723 MEDIA_UHD_CONTENT_ID,
1724 MEDIA_UHD_CONTENT_TITLE,
1725 MEDIA_UHD_FILE_NAME,
1726 MEDIA_UHD_FOLDER_ID,
1727 MEDIA_UHD_RELEASE_DATE,
1728 MEDIA_UHD_MODIFIED_TIME,
1729 MEDIA_UHD_PLAYED_POSITION,
1731 MEDIA_UHD_PLAYED_COUNT,
1732 } media_uhd_field_e;
1734 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1736 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1738 _uhd->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1739 _uhd->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1740 _uhd->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1741 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1742 _uhd->content_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1743 _uhd->content_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1744 _uhd->file_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1745 _uhd->release_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1746 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1747 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1748 _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1749 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1754 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1756 int ret = MEDIA_CONTENT_ERROR_NONE;
1757 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1758 char *condition_query = NULL;
1759 char *option_query = NULL;
1760 sqlite3_stmt *stmt = NULL;
1761 filter_s *_filter = (filter_s *)filter;
1763 if (_filter && STRING_VALID(_filter->storage_id))
1764 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1766 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1768 ret = __media_db_make_query(filter, &condition_query, &option_query);
1769 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1771 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1772 g_free(condition_query);
1773 g_free(option_query);
1774 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1776 while (sqlite3_step(stmt) == SQLITE_ROW) {
1777 media_uhd_s *_uhd = g_new0(media_uhd_s, 1);
1779 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1781 if (callback((media_uhd_h)_uhd, user_data) == false) {
1782 media_uhd_destroy((media_uhd_h) _uhd);
1785 media_uhd_destroy((media_uhd_h) _uhd);
1788 SQLITE3_FINALIZE(stmt);