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 int __media_db_make_query(filter_h filter, char *select_query, int select_query_size, char **condition_query, char **option_query);
24 static char * __media_db_get_group_name(media_group_e group)
27 case MEDIA_CONTENT_GROUP_DISPLAY_NAME:
28 return (char *)DB_FIELD_MEDIA_DISPLAY_NAME;
29 case MEDIA_CONTENT_GROUP_TYPE:
30 return (char *)DB_FIELD_MEDIA_TYPE;
31 case MEDIA_CONTENT_GROUP_MIME_TYPE:
32 return (char *) DB_FIELD_MEDIA_MIME_TYPE;
33 case MEDIA_CONTENT_GROUP_SIZE:
34 return (char *) DB_FIELD_MEDIA_SIZE;
35 case MEDIA_CONTENT_GROUP_ADDED_TIME:
36 return (char *) DB_FIELD_MEDIA_ADDED_TIME;
37 case MEDIA_CONTENT_GROUP_MODIFIED_TIME:
38 return (char *) DB_FIELD_MEDIA_MODIFIED_TIME;
39 case MEDIA_CONTENT_GROUP_TITLE:
40 return (char *) DB_FIELD_MEDIA_TITLE;
41 case MEDIA_CONTENT_GROUP_ARTIST:
42 return (char *) DB_FIELD_MEDIA_ARTIST;
43 case MEDIA_CONTENT_GROUP_ALBUM_ARTIST:
44 return (char *) DB_FIELD_MEDIA_ALBUM_ARTIST;
45 case MEDIA_CONTENT_GROUP_GENRE:
46 return (char *) DB_FIELD_MEDIA_GENRE;
47 case MEDIA_CONTENT_GROUP_COMPOSER:
48 return (char *) DB_FIELD_MEDIA_COMPOSER;
49 case MEDIA_CONTENT_GROUP_YEAR:
50 return (char *) DB_FIELD_MEDIA_YEAR;
51 case MEDIA_CONTENT_GROUP_RECORDED_DATE:
52 return (char *) DB_FIELD_MEDIA_RECORDED_DATE;
53 case MEDIA_CONTENT_GROUP_COPYRIGHT:
54 return (char *) DB_FIELD_MEDIA_COPYRIGHT;
55 case MEDIA_CONTENT_GROUP_TRACK_NUM:
56 return (char *) DB_FIELD_MEDIA_TRACK_NUM;
57 case MEDIA_CONTENT_GROUP_DESCRIPTION:
58 return (char *) DB_FIELD_MEDIA_DESCRIPTION;
59 case MEDIA_CONTENT_GROUP_LONGITUDE:
60 return (char *) DB_FIELD_MEDIA_LONGITUDE;
61 case MEDIA_CONTENT_GROUP_LATITUDE:
62 return (char *) DB_FIELD_MEDIA_LATITUDE;
63 case MEDIA_CONTENT_GROUP_ALTITUDE:
64 return (char *) DB_FIELD_MEDIA_ALTITUDE;
65 case MEDIA_CONTENT_GROUP_RATING:
66 return (char *) DB_FIELD_MEDIA_RATING;
68 case MEDIA_CONTENT_GROUP_MODIFIED_MONTH:
69 return (char *) DB_FIELD_MEDIA_MODIFIED_DATE;
70 case MEDIA_CONTENT_GROUP_MODIFIED_DATE:
71 return (char *) DB_FIELD_MEDIA_MODIFIED_DATE;
73 #ifdef _USE_SENIOR_MODE
74 case MEDIA_CONTENT_GROUP_CONTACT:
75 return (char *) DB_FIELD_MEDIA_CONTACT;
78 case MEDIA_CONTENT_GROUP_ALBUM:
79 return (char *) DB_FIELD_MEDIA_ALBUM;
80 case MEDIA_PVR_GROUP_DURATION:
81 return (char *) DB_FIELD_PVR_DURATION;
82 case MEDIA_PVR_GROUP_TIME_ZONE:
83 return (char *) DB_FIELD_PVR_TIME_ZONE;
84 case MEDIA_PVR_GROUP_PTC:
85 return (char *) DB_FIELD_PVR_PTC;
86 case MEDIA_PVR_GROUP_MAJOR:
87 return (char *) DB_FIELD_PVR_MAJOR;
88 case MEDIA_PVR_GROUP_MINOR:
89 return (char *) DB_FIELD_PVR_MINOR;
90 case MEDIA_PVR_GROUP_CHANNEL_TYPE:
91 return (char *) DB_FIELD_PVR_CHANNEL_TYPE;
92 case MEDIA_PVR_GROUP_CHANNEL_NAME:
93 return (char *) DB_FIELD_PVR_CHANNEL_NAME;
94 case MEDIA_PVR_GROUP_CHANNEL_NUM:
95 return (char *) DB_FIELD_PVR_CHANNEL_NUM;
96 case MEDIA_PVR_GROUP_PROGRAM_TITLE:
97 return (char *) DB_FIELD_PVR_PROGRAM_TITLE;
98 case MEDIA_PVR_GROUP_PROGRAM_NUM:
99 return (char *) DB_FIELD_PVR_PROGRAM_NUM;
100 case MEDIA_PVR_GROUP_PROGRAM_CRID:
101 return (char *) DB_FIELD_PVR_PROGRAM_CRID;
102 case MEDIA_PVR_GROUP_GUIDANCE:
103 return (char *) DB_FIELD_PVR_GUIDANCE;
104 case MEDIA_PVR_GROUP_SYNOPSIS:
105 return (char *) DB_FIELD_PVR_SYNOPSIS;
106 case MEDIA_PVR_GROUP_GENRE:
107 return (char *) DB_FIELD_PVR_GENRE;
108 case MEDIA_PVR_GROUP_LANGUAGE:
109 return (char *) DB_FIELD_PVR_LANGUAGE;
110 case MEDIA_PVR_GROUP_EMBARGO_TIME:
111 return (char *) DB_FIELD_PVR_EMBARGO_TIME;
112 case MEDIA_PVR_GROUP_EXPIRY_TIME:
113 return (char *) DB_FIELD_PVR_EXPIRY_TIME;
114 case MEDIA_PVR_GROUP_START_TIME:
115 return (char *) DB_FIELD_PVR_START_TIME;
116 case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
117 return (char *) DB_FIELD_PVR_PROGRAM_START_TIME;
118 case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
119 return (char *) DB_FIELD_PVR_PROGRAM_END_TIME;
120 case MEDIA_PVR_GROUP_PROGRAM_DATE:
121 return (char *) DB_FIELD_PVR_PROGRAM_DATE;
122 case MEDIA_PVR_GROUP_PARENTAL_RATING:
123 return (char *) DB_FIELD_PVR_PARENTAL_RATING;
124 case MEDIA_PVR_GROUP_TIMER_RECORD:
125 return (char *) DB_FIELD_PVR_TIMER_RECORD;
126 case MEDIA_PVR_GROUP_SERIES_RECORD:
127 return (char *) DB_FIELD_PVR_SERIES_RECORD;
128 case MEDIA_PVR_GROUP_HD:
129 return (char *) DB_FIELD_PVR_HD;
130 case MEDIA_PVR_GROUP_SUBTITLE:
131 return (char *) DB_FIELD_PVR_SUBTITLE;
132 case MEDIA_PVR_GROUP_TTX:
133 return (char *) DB_FIELD_PVR_TTX;
134 case MEDIA_PVR_GROUP_AD:
135 return (char *) DB_FIELD_PVR_AD;
136 case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
137 return (char *) DB_FIELD_PVR_HARDOF_HEARINGRADIO;
138 case MEDIA_PVR_GROUP_DATA_SERVICE:
139 return (char *) DB_FIELD_PVR_DATA_SERVICE;
140 case MEDIA_PVR_GROUP_CONTENT_LOCK:
141 return (char *) DB_FIELD_PVR_CONTENT_LOCK;
142 case MEDIA_PVR_GROUP_CONTENT_WATCH:
143 return (char *) DB_FIELD_PVR_CONTENT_WATCH;
144 case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
145 return (char *) DB_FIELD_PVR_HAS_AUDIO_ONLY;
146 case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
147 return (char *) DB_FIELD_PVR_IS_LOCAL_RECORD;
148 case MEDIA_PVR_GROUP_RESOLUTION:
149 return (char *) DB_FIELD_PVR_RESOLUTION;
150 case MEDIA_PVR_GROUP_ASPECTRATIO:
151 return (char *) DB_FIELD_PVR_ASPECTRATIO;
152 case MEDIA_PVR_GROUP_MODIFIED_MONTH:
153 return (char *) DB_FIELD_PVR_MODIFIED_DATE;
154 case MEDIA_PVR_GROUP_MODIFIED_DATE:
155 return (char *) DB_FIELD_PVR_MODIFIED_DATE;
156 case MEDIA_PVR_GROUP_SPORTS_TYPE:
157 return (char *) DB_FIELD_PVR_SPORTS_TYPE;
158 case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
159 return (char *) DB_FIELD_PVR_GUIDANCE_LENGTH;
160 case MEDIA_PVR_GROUP_TVMODE:
161 return (char *) DB_FIELD_PVR_TVMODE;
162 case MEDIA_PVR_GROUP_PLAY_COUNT:
163 return (char *) DB_FIELD_PVR_PLAY_COUNT;
164 case MEDIA_PVR_GROUP_PRIVATE_DATA:
165 return (char *) DB_FIELD_PVR_PRIVATE_DATA;
166 case MEDIA_UHD_GROUP_CONTENT_TITLE:
167 return (char *) DB_FIELD_UHD_CONTENT_TITLE;
168 case MEDIA_UHD_GROUP_RELEASE_DATE:
169 return (char *) DB_FIELD_UHD_RELEASE_DATE;
170 case MEDIA_UHD_GROUP_SUB_TYPE:
171 return (char *) DB_FIELD_UHD_SUB_TYPE;
172 case MEDIA_UHD_GROUP_FILE_NAME:
173 return (char *) DB_FIELD_UHD_FILE_NAME;
174 case MEDIA_UHD_GROUP_PLAYED_COUNT:
175 return (char *) DB_FIELD_UHD_PLAYED_COUNT;
184 static int __media_db_make_query(filter_h filter, char *select_query, int select_query_size, char **condition_query, char **option_query)
186 int ret = MEDIA_CONTENT_ERROR_NONE;
187 filter_s *_filter = NULL;
189 if (filter != NULL) {
190 _filter = (filter_s*)filter;
192 if (STRING_VALID(_filter->condition)) {
193 ret = _media_filter_attribute_generate(filter, condition_query);
194 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
197 if (_filter->is_full_order == false) {
198 /* Process for filter v1 */
199 ret = _media_filter_attribute_option_generate(filter, option_query);
200 if (ret != MEDIA_CONTENT_ERROR_NONE) {
201 SAFE_FREE(*condition_query);
205 /* Process for filter v2 */
206 ret = _media_filter_attribute_option_generate_with_full_query(filter, option_query);
207 if (ret != MEDIA_CONTENT_ERROR_NONE) {
208 SAFE_FREE(*condition_query);
213 if (STRING_VALID(*condition_query)) {
214 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, select_query_size);
215 SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, select_query_size);
222 #ifdef _USE_TVPD_MODE
223 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
225 int ret = MEDIA_CONTENT_ERROR_NONE;
226 sqlite3_stmt *stmt = NULL;
227 char select_query[MAX_QUERY_SIZE] = {0, };
228 char *condition_query = NULL;
229 char *option_query = NULL;
230 filter_s *_filter = (filter_s*)filter;
232 memset(select_query, 0x00, sizeof(select_query));
234 switch (group_type) {
235 case MEDIA_GROUP_NONE:
236 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
237 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
238 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
240 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
241 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
244 case MEDIA_GROUP_ALBUM:
245 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
246 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, _filter->storage_id);
248 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
251 case MEDIA_GROUP_FOLDER:
252 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
253 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
255 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
258 case MEDIA_GROUP_PLAYLIST:
259 if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query))) {
260 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
261 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
264 case MEDIA_GROUP_TAG:
265 if (!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query))) {
266 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
267 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
270 case MEDIA_GROUP_BOOKMARK:
271 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
272 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, _filter->storage_id);
274 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
277 case MEDIA_GROUP_STORAGE:
278 if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_COUNT, sizeof(select_query))) {
279 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
280 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
283 case MEDIA_GROUP_FACE:
284 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
285 snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, _filter->storage_id);
287 snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, DB_VIEW_MEDIA);
289 case MEDIA_GROUP_PVR:
290 case MEDIA_GROUP_UHD:
293 media_content_error("Invalid group type [%d]", group_type);
294 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
299 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
300 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
302 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
303 SAFE_FREE(condition_query);
304 SAFE_FREE(option_query);
305 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
307 if (sqlite3_step(stmt) == SQLITE_ROW)
308 *group_count = (int)sqlite3_column_int(stmt, 0);
310 SQLITE3_FINALIZE(stmt);
315 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
317 int ret = MEDIA_CONTENT_ERROR_NONE;
318 sqlite3_stmt *stmt = NULL;
319 char select_query[MAX_QUERY_SIZE] = {0, };
320 char *condition_query = NULL;
321 char *option_query = NULL;
322 filter_s *_filter = (filter_s*)filter;
324 memset(select_query, 0x00, sizeof(select_query));
325 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
326 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
327 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
329 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
330 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
331 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
332 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
334 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
335 } else { /*uhd content*/
336 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
337 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
339 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
341 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
342 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
344 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
345 if (STRING_VALID(condition_query))
346 SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
347 if (STRING_VALID(option_query))
348 SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
349 SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
351 SAFE_FREE(condition_query);
352 SAFE_FREE(option_query);
354 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
355 SAFE_FREE(condition_query);
356 SAFE_FREE(option_query);
357 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
359 if (sqlite3_step(stmt) == SQLITE_ROW)
360 *group_count = (int)sqlite3_column_int(stmt, 0);
362 SQLITE3_FINALIZE(stmt);
367 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
369 int ret = MEDIA_CONTENT_ERROR_NONE;
370 char select_query[MAX_QUERY_SIZE] = {0, };
371 char *condition_query = NULL;
372 char *option_query = NULL;
374 sqlite3_stmt *stmt = NULL;
375 filter_s *_filter = (filter_s*)filter;
376 memset(select_query, 0x00, sizeof(select_query));
377 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
378 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
379 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
381 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
382 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
383 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
384 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
386 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
387 } else { /* uhd content */
388 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
389 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
391 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
393 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
394 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
396 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
397 SAFE_FREE(condition_query);
398 SAFE_FREE(option_query);
399 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
401 while (sqlite3_step(stmt) == SQLITE_ROW) {
402 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
404 if (callback(name, user_data) == false) {
412 SQLITE3_FINALIZE(stmt);
417 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
419 int ret = MEDIA_CONTENT_ERROR_NONE;
420 char select_query[DEFAULT_QUERY_SIZE] = {0, };
421 char group_query[DEFAULT_QUERY_SIZE] = {0, };
422 char *condition_query = NULL;
423 char *option_query = NULL;
425 sqlite3_stmt *stmt = NULL;
426 filter_s *_filter = (filter_s*)filter;
428 memset(select_query, 0x00, sizeof(select_query));
429 memset(group_query, 0x00, sizeof(group_query));
431 char* group_name = __media_db_get_group_name(group);
432 if (!STRING_VALID(group_name)) {
433 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
434 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
437 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
438 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
439 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
441 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
442 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
443 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
444 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
446 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
447 } else {/*uhd content*/
448 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
449 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
451 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
454 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
455 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
457 if (STRING_VALID(option_query))
458 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
460 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
462 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
463 SAFE_FREE(condition_query);
464 SAFE_FREE(option_query);
465 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
467 while (sqlite3_step(stmt) == SQLITE_ROW) {
468 if (STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
469 name = strdup((const char *)sqlite3_column_text(stmt, 0));
471 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
479 SQLITE3_FINALIZE(stmt);
484 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
486 int ret = MEDIA_CONTENT_ERROR_NONE;
487 sqlite3_stmt *stmt = NULL;
488 char select_query[MAX_QUERY_SIZE] = {0, };
489 char *condition_query = NULL;
490 char *option_query = NULL;
491 filter_s *_filter = (filter_s*)filter;
493 memset(select_query, 0x00, sizeof(select_query));
495 switch (group_type) {
496 case MEDIA_GROUP_NONE:
497 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
498 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
499 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
501 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
502 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
505 case MEDIA_GROUP_ALBUM:
506 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
507 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
509 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT);
512 case MEDIA_GROUP_FOLDER:
513 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
514 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
516 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT);
519 case MEDIA_GROUP_PLAYLIST:
520 if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query))) {
521 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
522 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
525 case MEDIA_GROUP_TAG:
526 if (!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query))) {
527 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
528 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
531 case MEDIA_GROUP_BOOKMARK:
532 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
533 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
535 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT);
538 case MEDIA_GROUP_STORAGE:
539 if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_COUNT, sizeof(select_query))) {
540 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
541 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
544 case MEDIA_GROUP_FACE:
545 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
546 snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
548 snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT);
552 media_content_error("Invalid group type [%d]", group_type);
553 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
558 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
559 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
561 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
562 SAFE_FREE(condition_query);
563 SAFE_FREE(option_query);
564 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
566 if (sqlite3_step(stmt) == SQLITE_ROW)
567 *group_count = (int)sqlite3_column_int(stmt, 0);
569 SQLITE3_FINALIZE(stmt);
574 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
576 int ret = MEDIA_CONTENT_ERROR_NONE;
577 sqlite3_stmt *stmt = NULL;
578 char select_query[MAX_QUERY_SIZE] = {0, };
579 char *condition_query = NULL;
580 char *option_query = NULL;
581 filter_s *_filter = (filter_s*)filter;
583 memset(select_query, 0x00, sizeof(select_query));
584 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
585 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
587 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group));
589 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
590 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
592 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
593 if (STRING_VALID(condition_query))
594 SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
595 if (STRING_VALID(option_query))
596 SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
597 SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
599 SAFE_FREE(condition_query);
600 SAFE_FREE(option_query);
602 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
603 SAFE_FREE(condition_query);
604 SAFE_FREE(option_query);
605 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
607 if (sqlite3_step(stmt) == SQLITE_ROW)
608 *group_count = (int)sqlite3_column_int(stmt, 0);
610 SQLITE3_FINALIZE(stmt);
615 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
617 int ret = MEDIA_CONTENT_ERROR_NONE;
618 char select_query[MAX_QUERY_SIZE] = {0, };
619 char *condition_query = NULL;
620 char *option_query = NULL;
622 sqlite3_stmt *stmt = NULL;
623 filter_s *_filter = (filter_s*)filter;
624 memset(select_query, 0x00, sizeof(select_query));
626 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
627 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
629 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
631 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
632 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
634 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
635 SAFE_FREE(condition_query);
636 SAFE_FREE(option_query);
637 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
639 while (sqlite3_step(stmt) == SQLITE_ROW) {
640 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
642 if (callback(name, user_data) == false) {
650 SQLITE3_FINALIZE(stmt);
656 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
658 int ret = MEDIA_CONTENT_ERROR_NONE;
659 char select_query[MAX_QUERY_SIZE] = {0, };
660 char *condition_query = NULL;
661 char *option_query = NULL;
662 sqlite3_stmt *stmt = NULL;
663 filter_s *_filter = (filter_s*)filter;
665 memset(select_query, 0x00, sizeof(select_query));
666 #ifdef _USE_TVPD_MODE
667 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
668 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
670 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
672 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
673 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
675 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
677 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
678 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
680 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
681 SAFE_FREE(condition_query);
682 SAFE_FREE(option_query);
683 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
685 while (sqlite3_step(stmt) == SQLITE_ROW) {
686 media_album_s *album = (media_album_s*)calloc(1, sizeof(media_album_s));
689 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
690 SQLITE3_FINALIZE(stmt);
691 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
694 album->album_id = (int)sqlite3_column_int(stmt, 0);
695 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
696 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
697 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
699 if (callback((media_album_h)album, user_data) == false) {
700 media_album_destroy((media_album_h)album);
704 media_album_destroy((media_album_h)album);
707 SQLITE3_FINALIZE(stmt);
712 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
714 int ret = MEDIA_CONTENT_ERROR_NONE;
715 char select_query[MAX_QUERY_SIZE] = {0, };
716 char *condition_query = NULL;
717 char *option_query = NULL;
718 sqlite3_stmt *stmt = NULL;
719 filter_s *_filter = (filter_s*)filter;
721 memset(select_query, 0x00, sizeof(select_query));
722 #ifdef _USE_TVPD_MODE
723 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
724 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
726 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
728 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
729 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
731 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
733 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
734 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
736 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
737 SAFE_FREE(condition_query);
738 SAFE_FREE(option_query);
739 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
741 while (sqlite3_step(stmt) == SQLITE_ROW) {
742 media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
744 if (_folder == NULL) {
745 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
746 SQLITE3_FINALIZE(stmt);
747 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
750 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
751 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
752 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
753 _folder->storage_type = (int)sqlite3_column_int(stmt, 3);
754 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
756 if (callback((media_folder_h)_folder, user_data) == false) {
757 media_folder_destroy((media_folder_h) _folder);
761 media_folder_destroy((media_folder_h) _folder);
764 SQLITE3_FINALIZE(stmt);
769 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
771 int ret = MEDIA_CONTENT_ERROR_NONE;
772 char select_query[MAX_QUERY_SIZE] = {0, };
773 char *condition_query = NULL;
774 char *option_query = NULL;
775 sqlite3_stmt *stmt = NULL;
777 memset(select_query, 0x00, sizeof(select_query));
779 if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_LIST, sizeof(select_query))) {
780 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
781 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
784 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
785 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
787 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
788 SAFE_FREE(condition_query);
789 SAFE_FREE(option_query);
790 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
792 while (sqlite3_step(stmt) == SQLITE_ROW) {
793 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
795 if (_playlist == NULL) {
796 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
797 SQLITE3_FINALIZE(stmt);
798 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
801 _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
802 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
803 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
805 if (callback((media_playlist_h)_playlist, user_data) == false) {
806 media_playlist_destroy((media_playlist_h)_playlist);
809 media_playlist_destroy((media_playlist_h)_playlist);
812 SQLITE3_FINALIZE(stmt);
817 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
819 int ret = MEDIA_CONTENT_ERROR_NONE;
820 char select_query[MAX_QUERY_SIZE] = {0, };
821 char *condition_query = NULL;
822 char *option_query = NULL;
823 sqlite3_stmt *stmt = NULL;
825 memset(select_query, 0x00, sizeof(select_query));
827 snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
829 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
830 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
832 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
833 SAFE_FREE(condition_query);
834 SAFE_FREE(option_query);
835 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
837 while (sqlite3_step(stmt) == SQLITE_ROW) {
838 int playlist_member_id = 0;
839 playlist_member_id = (int)sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
841 media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
843 if (_media == NULL) {
844 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
845 SQLITE3_FINALIZE(stmt);
846 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
849 _media_info_item_get_detail(stmt, (media_info_h)_media);
851 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
852 media_info_destroy((media_info_h)_media);
855 media_info_destroy((media_info_h)_media);
859 SQLITE3_FINALIZE(stmt);
864 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
866 int ret = MEDIA_CONTENT_ERROR_NONE;
867 char select_query[MAX_QUERY_SIZE] = {0, };
868 char *condition_query = NULL;
869 char *option_query = NULL;
870 sqlite3_stmt *stmt = NULL;
872 memset(select_query, 0x00, sizeof(select_query));
874 if (!STRING_VALID(media_id)) {
875 if (!SAFE_STRLCPY(select_query, SELECT_TAG_LIST, sizeof(select_query))) {
876 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
877 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
880 snprintf(select_query, sizeof(select_query), SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
882 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
883 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
885 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
887 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
888 SAFE_FREE(condition_query);
889 SAFE_FREE(option_query);
890 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
892 while (sqlite3_step(stmt) == SQLITE_ROW) {
893 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
896 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
897 SQLITE3_FINALIZE(stmt);
898 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
901 _tag->tag_id = (int)sqlite3_column_int(stmt, 0);
902 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
904 if (callback((media_tag_h)_tag, user_data) == false) {
905 media_tag_destroy((media_tag_h)_tag);
908 media_tag_destroy((media_tag_h)_tag);
911 SQLITE3_FINALIZE(stmt);
916 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
918 int ret = MEDIA_CONTENT_ERROR_NONE;
919 char select_query[MAX_QUERY_SIZE] = {0, };
920 char *condition_query = NULL;
921 char *option_query = NULL;
922 sqlite3_stmt *stmt = NULL;
923 filter_s *_filter = (filter_s*)filter;
925 memset(select_query, 0x00, sizeof(select_query));
926 #ifdef _USE_TVPD_MODE
927 if (STRING_VALID(media_id)) { //get bookmark by media_id
928 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
929 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
931 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
933 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
934 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, _filter->storage_id);
936 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
939 if (STRING_VALID(media_id)) { //get bookmark by media_id
940 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
942 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
943 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
945 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
949 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
950 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
952 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
953 SAFE_FREE(condition_query);
954 SAFE_FREE(option_query);
955 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
957 while (sqlite3_step(stmt) == SQLITE_ROW) {
958 media_bookmark_s *bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
960 if (bookmark == NULL) {
961 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
962 SQLITE3_FINALIZE(stmt);
963 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
966 bookmark->bookmark_id = (int)sqlite3_column_int(stmt, 0);
967 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
968 bookmark->marked_time = (int)sqlite3_column_int(stmt, 2);
969 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
970 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
972 if (callback((media_bookmark_h)bookmark, user_data) == false) {
973 media_bookmark_destroy((media_bookmark_h)bookmark);
977 media_bookmark_destroy((media_bookmark_h)bookmark);
980 SQLITE3_FINALIZE(stmt);
986 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
988 int ret = MEDIA_CONTENT_ERROR_NONE;
989 char select_query[MAX_QUERY_SIZE] = {0, };
990 char *condition_query = NULL;
991 char *option_query = NULL;
992 sqlite3_stmt *stmt = NULL;
993 filter_s *_filter = (filter_s*)filter;
995 memset(select_query, 0x00, sizeof(select_query));
996 #ifdef _USE_TVPD_MODE
997 if (STRING_VALID(media_id)) { //get face by media_id
998 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
999 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
1001 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
1003 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1004 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, _filter->storage_id);
1006 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
1009 if (STRING_VALID(media_id)) { //get face by media_id
1010 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
1012 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1013 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
1015 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
1018 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1019 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1021 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1022 SAFE_FREE(condition_query);
1023 SAFE_FREE(option_query);
1024 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1026 while (sqlite3_step(stmt) == SQLITE_ROW) {
1027 media_face_s *face = (media_face_s*)calloc(1, sizeof(media_face_s));
1030 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1031 SQLITE3_FINALIZE(stmt);
1032 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1035 face->face_id = (int)sqlite3_column_int(stmt, 0);
1036 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1037 face->face_rect_x = (int)sqlite3_column_int(stmt, 2);
1038 face->face_rect_y = (int)sqlite3_column_int(stmt, 3);
1039 face->face_rect_w = (int)sqlite3_column_int(stmt, 4);
1040 face->face_rect_h = (int)sqlite3_column_int(stmt, 5);
1041 face->orientation = (int)sqlite3_column_int(stmt, 6);
1042 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
1044 if (callback((media_face_h)face, user_data) == false) {
1045 media_face_destroy((media_face_h)face);
1049 media_face_destroy((media_face_h)face);
1052 SQLITE3_FINALIZE(stmt);
1058 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
1060 int ret = MEDIA_CONTENT_ERROR_NONE;
1061 sqlite3_stmt *stmt = NULL;
1062 char select_query[MAX_QUERY_SIZE] = {0, };
1063 char *condition_query = NULL;
1064 char *option_query = NULL;
1065 filter_s *_filter = (filter_s*)filter;
1067 memset(select_query, 0x00, sizeof(select_query));
1069 if (group_type == MEDIA_GROUP_ALBUM) {
1070 #ifdef _USE_TVPD_MODE
1071 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1072 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
1074 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1076 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1077 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1079 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
1081 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1082 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
1083 } else if (group_type == MEDIA_GROUP_TAG) {
1084 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
1086 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1087 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1090 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1091 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1093 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1094 SAFE_FREE(condition_query);
1095 SAFE_FREE(option_query);
1096 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1098 if (sqlite3_step(stmt) == SQLITE_ROW)
1099 *item_count = (int)sqlite3_column_int(stmt, 0);
1101 SQLITE3_FINALIZE(stmt);
1106 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
1108 int ret = MEDIA_CONTENT_ERROR_NONE;
1109 sqlite3_stmt *stmt = NULL;
1110 char select_query[MAX_QUERY_SIZE] = {0, };
1111 char *tmp_query = NULL;
1112 char *condition_query = NULL;
1113 char *option_query = NULL;
1114 bool is_simple = FALSE;
1115 filter_s *_filter = (filter_s*)filter;
1117 memset(select_query, 0x00, sizeof(select_query));
1119 if (group_type == MEDIA_GROUP_NONE) {
1120 /* There are 2 ways to get count for media table for performance
1121 If user wants to set offset and count, use SQL SELECT_MEDIA_COUNT_FROM_MEDIA.
1122 If user wants to get count without setting count, SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE */
1123 if (_filter && ((_filter->offset < 0) && (_filter->count < 0))) {
1124 #ifdef _USE_TVPD_MODE
1125 if (STRING_VALID(_filter->storage_id))
1126 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1128 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1130 if (STRING_VALID(_filter->storage_id))
1131 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1133 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1137 #ifdef _USE_TVPD_MODE
1138 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1140 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
1143 } else if (group_type == MEDIA_GROUP_FOLDER) {
1144 #ifdef _USE_TVPD_MODE
1145 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1146 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1148 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1150 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1151 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1153 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1155 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1156 } else if (group_type == MEDIA_GROUP_TAG_BY_MEDIA_ID) {
1157 snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1158 } else if (group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID) {
1159 #ifdef _USE_TVPD_MODE
1160 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1161 tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1163 tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1165 tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1167 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1168 } else if (group_type == MEDIA_GROUP_STORAGE) {
1169 #ifdef _USE_TVPD_MODE
1170 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1172 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1174 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1175 } else if (group_type == MEDIA_GROUP_FACE_BY_MEDIA_ID) {
1176 #ifdef _USE_TVPD_MODE
1177 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1178 tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1180 tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1182 tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1184 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1185 #ifdef _USE_TVPD_MODE
1186 } else if (group_type == MEDIA_GROUP_PVR) {
1187 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1188 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1190 SAFE_STRLCAT(select_query, SELECT_PVR_COUNT, sizeof(select_query));
1191 } else if (group_type == MEDIA_GROUP_UHD) {
1192 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1193 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1195 SAFE_STRLCAT(select_query, SELECT_UHD_COUNT, sizeof(select_query));
1198 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1199 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1202 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1203 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1204 if (tmp_query != NULL)
1205 SQLITE3_SAFE_FREE(tmp_query);
1209 if (group_type == MEDIA_GROUP_NONE) {
1210 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
1211 if (STRING_VALID(condition_query))
1212 SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
1213 if (STRING_VALID(option_query))
1214 SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
1217 SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
1219 SAFE_FREE(condition_query);
1220 SAFE_FREE(option_query);
1223 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1224 if (tmp_query != NULL)
1225 SQLITE3_SAFE_FREE(tmp_query);
1226 SAFE_FREE(condition_query);
1227 SAFE_FREE(option_query);
1228 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1230 if (sqlite3_step(stmt) == SQLITE_ROW)
1231 *item_count = (int)sqlite3_column_int(stmt, 0);
1233 SQLITE3_FINALIZE(stmt);
1238 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)
1240 int ret = MEDIA_CONTENT_ERROR_NONE;
1241 char select_query[MAX_QUERY_SIZE] = {0, };
1242 char *condition_query = NULL;
1243 char *option_query = NULL;
1244 sqlite3_stmt *stmt = NULL;
1245 filter_s *_filter = (filter_s*)filter;
1247 memset(select_query, 0x00, sizeof(select_query));
1249 #ifdef _USE_TVPD_MODE
1250 if (group_type == MEDIA_GROUP_ALBUM) {
1251 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1252 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1254 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1255 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1256 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1257 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1259 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1260 } else if (group_type == MEDIA_GROUP_TAG) {
1261 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1262 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1264 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1266 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1267 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1270 if (group_type == MEDIA_GROUP_ALBUM) {
1271 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1272 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1274 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
1275 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1276 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1277 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1279 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
1280 } else if (group_type == MEDIA_GROUP_TAG) {
1281 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1282 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1284 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
1286 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1287 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1290 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1291 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1293 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1294 SAFE_FREE(condition_query);
1295 SAFE_FREE(option_query);
1296 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1298 while (sqlite3_step(stmt) == SQLITE_ROW) {
1299 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1301 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1302 SQLITE3_FINALIZE(stmt);
1303 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
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 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)
1323 int ret = MEDIA_CONTENT_ERROR_NONE;
1324 char select_query[MAX_QUERY_SIZE] = {0, };
1325 char *condition_query = NULL;
1326 char *option_query = NULL;
1327 sqlite3_stmt *stmt = NULL;
1328 filter_s *_filter = (filter_s*)filter;
1330 memset(select_query, 0x00, sizeof(select_query));
1331 #ifdef _USE_TVPD_MODE
1332 if (group_type == MEDIA_GROUP_NONE) {
1333 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1334 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
1336 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1337 } else if (group_type == MEDIA_GROUP_FOLDER) {
1338 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1339 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1341 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1342 } else if (group_type == MEDIA_GROUP_STORAGE) {
1343 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1345 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1346 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1349 if (group_type == MEDIA_GROUP_NONE) {
1350 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1351 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1353 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
1354 } else if (group_type == MEDIA_GROUP_FOLDER) {
1355 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
1356 } else if (group_type == MEDIA_GROUP_STORAGE) {
1357 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
1359 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1360 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1363 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1364 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1366 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1367 SAFE_FREE(condition_query);
1368 SAFE_FREE(option_query);
1369 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1371 while (sqlite3_step(stmt) == SQLITE_ROW) {
1372 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1374 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1375 SQLITE3_FINALIZE(stmt);
1376 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1379 _media_info_item_get_detail(stmt, (media_info_h)item);
1381 if (callback((media_info_h)item, user_data) == false) {
1382 media_info_destroy((media_info_h)item);
1386 media_info_destroy((media_info_h)item);
1389 SQLITE3_FINALIZE(stmt);
1394 #ifdef _USE_SENIOR_MODE
1395 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)
1397 int ret = MEDIA_CONTENT_ERROR_NONE;
1398 char select_query1[MAX_QUERY_SIZE] = {0, };
1399 char *condition_query1 = NULL;
1400 char *option_query1 = NULL;
1401 char select_query2[MAX_QUERY_SIZE] = {0, };
1402 char *condition_query2 = NULL;
1403 char *option_query2 = NULL;
1404 sqlite3_stmt *stmt = NULL;
1405 filter_s *_filter1 = (filter_s*)filter1;
1406 filter_s *_filter2 = (filter_s*)filter2;
1408 memset(select_query1, 0x00, sizeof(select_query1));
1410 if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
1411 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, _filter1->storage_id, group_name);
1413 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1415 ret = __media_db_make_query(filter1, select_query1, sizeof(select_query1), &condition_query1, &option_query1);
1416 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1417 SAFE_FREE(condition_query1);
1418 SAFE_FREE(option_query1);
1419 media_content_error("create select_query1 failed");
1423 memset(select_query2, 0x00, sizeof(select_query2));
1425 if ((_filter2 != NULL) && STRING_VALID(_filter2->storage_id))
1426 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, _filter2->storage_id, group_name);
1428 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1430 ret = __media_db_make_query(filter2, select_query2, sizeof(select_query2), &condition_query2, &option_query2);
1431 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1432 SAFE_FREE(condition_query1);
1433 SAFE_FREE(option_query1);
1434 SAFE_FREE(condition_query2);
1435 SAFE_FREE(option_query2);
1436 media_content_error("create select_query2 failed");
1440 ret = _content_query_prepare_by_union_select(&stmt, select_query1, condition_query1, option_query1, select_query2, condition_query2, option_query2);
1441 SAFE_FREE(condition_query1);
1442 SAFE_FREE(option_query1);
1443 SAFE_FREE(condition_query2);
1444 SAFE_FREE(option_query2);
1445 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1447 while (sqlite3_step(stmt) == SQLITE_ROW) {
1448 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1450 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1451 SQLITE3_FINALIZE(stmt);
1452 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1455 _media_info_item_get_detail(stmt, (media_info_h)item);
1457 if (callback((media_info_h)item, user_data) == false) {
1458 media_info_destroy((media_info_h)item);
1462 media_info_destroy((media_info_h)item);
1465 SQLITE3_FINALIZE(stmt);
1471 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1473 int ret = MEDIA_CONTENT_ERROR_NONE;
1474 sqlite3_stmt *stmt = NULL;
1475 char select_query[MAX_QUERY_SIZE] = {0, };
1476 char *tmp_query = NULL;
1477 char *condition_query = NULL;
1478 char *option_query = NULL;
1479 filter_s *_filter = (filter_s*)filter;
1481 memset(select_query, 0x00, sizeof(select_query));
1482 #ifdef _USE_TVPD_MODE
1483 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1484 if (group_name != NULL) {
1485 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1486 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1488 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1490 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1492 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1493 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1495 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1497 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1498 if (group_name != NULL) {
1499 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1500 tmp_query = sqlite3_mprintf(SELECT_PVR_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1502 tmp_query = sqlite3_mprintf(SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1504 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1506 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1507 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1509 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1511 } else {/*uhd content*/
1512 if (group_name != NULL) {
1513 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1514 tmp_query = sqlite3_mprintf(SELECT_UHD_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1516 tmp_query = sqlite3_mprintf(SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1518 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1520 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1521 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1523 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1527 if (group_name != NULL) {
1528 if ((_filter != NULL) && STRING_VALID(_filter->storage_id)) {
1529 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1530 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1532 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1533 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1536 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1537 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1539 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1542 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1543 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1544 if (tmp_query != NULL)
1545 SQLITE3_SAFE_FREE(tmp_query);
1549 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
1550 if (STRING_VALID(condition_query))
1551 SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
1552 if (STRING_VALID(option_query))
1553 SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
1554 SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
1556 SAFE_FREE(condition_query);
1557 SAFE_FREE(option_query);
1559 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1560 if (tmp_query != NULL)
1561 SQLITE3_SAFE_FREE(tmp_query);
1562 SAFE_FREE(condition_query);
1563 SAFE_FREE(option_query);
1564 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1566 if (sqlite3_step(stmt) == SQLITE_ROW)
1567 *item_count = (int)sqlite3_column_int(stmt, 0);
1569 SQLITE3_FINALIZE(stmt);
1574 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)
1576 int ret = MEDIA_CONTENT_ERROR_NONE;
1577 char select_query[MAX_QUERY_SIZE] = {0, };
1578 char *tmp_query = NULL;
1579 char *condition_query = NULL;
1580 char *option_query = NULL;
1581 sqlite3_stmt *stmt = NULL;
1582 filter_s *_filter = (filter_s*)filter;
1584 memset(select_query, 0x00, sizeof(select_query));
1585 #ifdef _USE_TVPD_MODE
1586 if (group_name != NULL) {
1587 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1588 tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1590 tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1592 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1594 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1595 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1597 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1600 if (group_name != NULL) {
1601 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1602 tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1604 tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1606 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1608 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1609 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1611 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1614 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1615 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1616 if (tmp_query != NULL)
1617 SQLITE3_SAFE_FREE(tmp_query);
1621 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1622 if (tmp_query != NULL)
1623 SQLITE3_SAFE_FREE(tmp_query);
1624 SAFE_FREE(condition_query);
1625 SAFE_FREE(option_query);
1626 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1628 while (sqlite3_step(stmt) == SQLITE_ROW) {
1629 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1631 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1632 SQLITE3_FINALIZE(stmt);
1633 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1636 _media_info_item_get_detail(stmt, (media_info_h)item);
1638 if (callback((media_info_h)item, user_data) == false) {
1639 media_info_destroy((media_info_h)item);
1643 media_info_destroy((media_info_h)item);
1646 SQLITE3_FINALIZE(stmt);
1651 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1653 int ret = MEDIA_CONTENT_ERROR_NONE;
1654 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1655 char *condition_query = NULL;
1656 char *option_query = NULL;
1657 sqlite3_stmt *stmt = NULL;
1659 memset(select_query, 0x00, sizeof(select_query));
1661 if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_LIST, sizeof(select_query))) {
1662 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1663 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1666 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1667 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1669 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1670 SAFE_FREE(condition_query);
1671 SAFE_FREE(option_query);
1672 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1674 while (sqlite3_step(stmt) == SQLITE_ROW) {
1675 media_storage_s *_storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
1677 if (_storage == NULL) {
1678 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1679 SQLITE3_FINALIZE(stmt);
1680 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1683 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1684 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1685 _storage->storage_type = (int)sqlite3_column_int(stmt, 2);
1687 if (callback((media_storage_h)_storage, user_data) == false) {
1688 media_storage_destroy((media_storage_h) _storage);
1692 media_storage_destroy((media_storage_h) _storage);
1695 SQLITE3_FINALIZE(stmt);
1700 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1702 int ret = MEDIA_CONTENT_ERROR_NONE;
1703 sqlite3_stmt *stmt = NULL;
1704 char *select_query = NULL;
1706 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1708 ret = _content_get_result(select_query, &stmt);
1709 SQLITE3_SAFE_FREE(select_query);
1710 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1712 if (sqlite3_step(stmt) == SQLITE_ROW) {
1713 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1715 media_content_error("Invalid media_id[%s]", media_id);
1716 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1719 SQLITE3_FINALIZE(stmt);
1724 #ifdef _USE_TVPD_MODE
1725 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)
1727 int ret = MEDIA_CONTENT_ERROR_NONE;
1728 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1729 char *tmp_query = NULL;
1730 char *condition_query = NULL;
1731 char *option_query = NULL;
1732 sqlite3_stmt *stmt = NULL;
1733 filter_s *_filter = (filter_s*)filter;
1735 memset(select_query, 0x00, sizeof(select_query));
1737 if (group_name != NULL) {
1738 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1739 tmp_query = sqlite3_mprintf(SELECT_PVR_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1741 tmp_query = sqlite3_mprintf(SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1743 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1745 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1746 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1748 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1751 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1752 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1753 if (tmp_query != NULL)
1754 sqlite3_free(tmp_query);
1758 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1759 if (tmp_query != NULL)
1760 sqlite3_free(tmp_query);
1761 SAFE_FREE(condition_query);
1762 SAFE_FREE(option_query);
1763 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1765 while (sqlite3_step(stmt) == SQLITE_ROW) {
1766 media_pvr_s *item = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1768 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1769 SQLITE3_FINALIZE(stmt);
1770 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1773 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1775 if (callback((media_pvr_h)item, user_data) == false) {
1776 media_info_destroy((media_pvr_h)item);
1780 media_pvr_destroy((media_pvr_h)item);
1783 SQLITE3_FINALIZE(stmt);
1789 MEDIA_PVR_MEDIA_ID = 0,
1790 MEDIA_PVR_STORAGE_ID,
1794 MEDIA_PVR_TIME_ZONE,
1798 MEDIA_PVR_CHANNEL_TYPE,
1799 MEDIA_PVR_CHANNEL_NAME,
1800 MEDIA_PVR_CHANNEL_NUM,
1801 MEDIA_PVR_SERVICE_PROFILE,
1802 MEDIA_PVR_PROGRAM_TITLE,
1803 MEDIA_PVR_PROGRAM_NUM,
1804 MEDIA_PVR_PROGRAM_CRID,
1809 MEDIA_PVR_EMBARGO_TIME,
1810 MEDIA_PVR_EXPIRY_TIME,
1811 MEDIA_PVR_START_TIME,
1812 MEDIA_PVR_PROGRAM_START_TIME,
1813 MEDIA_PVR_PROGRAM_END_TIME,
1814 MEDIA_PVR_PROGRAM_DATE,
1815 MEDIA_PVR_PARENTAL_RATING,
1816 MEDIA_PVR_TIMER_RECORD,
1817 MEDIA_PVR_SERIES_RECORD,
1822 MEDIA_PVR_HARDOF_HEARINGRADIO,
1823 MEDIA_PVR_DATA_SERVICE,
1824 MEDIA_PVR_CONTENT_LOCK,
1825 MEDIA_PVR_CONTENT_WATCH,
1826 MEDIA_PVR_HAS_AUDIO_ONLY,
1827 MEDIA_PVR_IS_LOCAL_RECORDED,
1828 MEDIA_PVR_RESOLUTION,
1829 MEDIA_PVR_ASPECTRATIO,
1830 MEDIA_PVR_MODIFIED_MONTH,
1831 MEDIA_PVR_SPORTS_TYPE,
1832 MEDIA_PVR_GUIDANCE_LENGTH,
1834 MEDIA_PVR_PLAY_COUNT,
1835 MEDIA_PVR_PRIVATE_DATA,
1836 MEDIA_PVR_HIGHLIGHT,
1837 } media_pvr_field_e;
1839 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1841 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1843 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID)))
1844 _pvr->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1846 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID)))
1847 _pvr->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1849 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH)))
1850 _pvr->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1852 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1854 _pvr->duration = (int)sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1856 _pvr->timezone = (int)sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1858 _pvr->ptc = (int)sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1860 _pvr->major = (int)sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1862 _pvr->minor = (int)sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1864 _pvr->channel_type = (int)sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1866 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1868 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME)))
1869 _pvr->channel_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1871 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM)))
1872 _pvr->channel_num = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1874 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE)))
1875 _pvr->program_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1877 _pvr->program_num = (int)sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1879 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID)))
1880 _pvr->program_crid = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1882 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE)))
1883 _pvr->guidance = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1885 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS)))
1886 _pvr->synopsis = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1888 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE)))
1889 _pvr->genre = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1891 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE)))
1892 _pvr->language = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1894 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH)))
1895 _pvr->modified_month = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1897 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA)))
1898 _pvr->private_data = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1900 _pvr->embargo_time = (int)sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1902 _pvr->expiry_time = (int)sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1904 _pvr->start_time = (int)sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1906 _pvr->program_start_time = (int)sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1908 _pvr->program_end_time = (int)sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1910 _pvr->program_date = (int)sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1912 _pvr->parental_rating = (int)sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1914 _pvr->timer_record = (int)sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1916 _pvr->series_record = (int)sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1918 _pvr->hd = (int)sqlite3_column_int(stmt, MEDIA_PVR_HD);
1920 _pvr->subtitle = (int)sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1922 _pvr->ttx = (int)sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1924 _pvr->ad = (int)sqlite3_column_int(stmt, MEDIA_PVR_AD);
1926 _pvr->hard_of_hearing_radio = (int)sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1928 _pvr->data_service = (int)sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1930 _pvr->content_lock = (int)sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1932 _pvr->content_watch = (int)sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1934 _pvr->has_audio_only = (int)sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1936 _pvr->is_local_record = (int)sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1938 _pvr->resolution = (int)sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1940 _pvr->aspectratio = (int)sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1942 _pvr->sports_type = (int)sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1944 _pvr->guidance_length = (int)sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1946 _pvr->tvmode = (int)sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1948 _pvr->play_count = (int)sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1950 _pvr->highlight = (int)sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1955 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1957 int ret = MEDIA_CONTENT_ERROR_NONE;
1958 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1959 char *condition_query = NULL;
1960 char *option_query = NULL;
1961 sqlite3_stmt *stmt = NULL;
1962 filter_s *_filter = (filter_s*)filter;
1964 memset(select_query, 0x00, sizeof(select_query));
1966 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1967 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1969 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1971 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
1972 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1974 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1975 SAFE_FREE(condition_query);
1976 SAFE_FREE(option_query);
1977 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1979 while (sqlite3_step(stmt) == SQLITE_ROW) {
1980 media_pvr_s *_pvr = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1983 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1984 SQLITE3_FINALIZE(stmt);
1985 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1988 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1990 if (callback((media_pvr_h)_pvr, user_data) == false) {
1991 media_pvr_destroy((media_pvr_h) _pvr);
1995 media_pvr_destroy((media_pvr_h) _pvr);
1998 SQLITE3_FINALIZE(stmt);
2004 MEDIA_UHD_MEDIA_ID = 0,
2005 MEDIA_UHD_STORAGE_ID,
2008 MEDIA_UHD_CONTENT_ID,
2009 MEDIA_UHD_CONTENT_TITLE,
2010 MEDIA_UHD_FILE_NAME,
2011 MEDIA_UHD_FOLDER_ID,
2012 MEDIA_UHD_RELEASE_DATE,
2013 MEDIA_UHD_MODIFIED_TIME,
2014 MEDIA_UHD_PLAYED_POSITION,
2016 MEDIA_UHD_PLAYED_COUNT,
2017 } media_uhd_field_e;
2019 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
2021 media_uhd_s *_uhd = (media_uhd_s*)uhd;
2023 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID)))
2024 _uhd->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
2026 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID)))
2027 _uhd->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
2029 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH)))
2030 _uhd->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
2032 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
2034 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID)))
2035 _uhd->content_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
2037 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE)))
2038 _uhd->content_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
2040 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME)))
2041 _uhd->file_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
2043 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE)))
2044 _uhd->release_date = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
2046 _uhd->modified_time = (int)sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
2047 _uhd->played_position = (int)sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
2048 _uhd->sub_type = (int)sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
2049 _uhd->played_count = (int)sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
2054 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
2056 int ret = MEDIA_CONTENT_ERROR_NONE;
2057 char select_query[DEFAULT_QUERY_SIZE] = {0, };
2058 char *condition_query = NULL;
2059 char *option_query = NULL;
2060 sqlite3_stmt *stmt = NULL;
2061 filter_s *_filter = (filter_s*)filter;
2063 memset(select_query, 0x00, sizeof(select_query));
2065 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
2066 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
2068 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
2070 ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
2071 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2073 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
2074 SAFE_FREE(condition_query);
2075 SAFE_FREE(option_query);
2076 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2078 while (sqlite3_step(stmt) == SQLITE_ROW) {
2079 media_uhd_s *_uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
2082 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2083 SQLITE3_FINALIZE(stmt);
2084 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2087 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
2089 if (callback((media_uhd_h)_uhd, user_data) == false) {
2090 media_uhd_destroy((media_uhd_h) _uhd);
2093 media_uhd_destroy((media_uhd_h) _uhd);
2096 SQLITE3_FINALIZE(stmt);