2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include <media_content.h>
19 #include <media_info_private.h>
20 #include <media_util_private.h>
22 static const char * __media_db_get_group_name(media_group_e group)
25 case MEDIA_CONTENT_GROUP_DISPLAY_NAME:
26 return DB_FIELD_MEDIA_DISPLAY_NAME;
27 case MEDIA_CONTENT_GROUP_TYPE:
28 return DB_FIELD_MEDIA_TYPE;
29 case MEDIA_CONTENT_GROUP_MIME_TYPE:
30 return DB_FIELD_MEDIA_MIME_TYPE;
31 case MEDIA_CONTENT_GROUP_SIZE:
32 return DB_FIELD_MEDIA_SIZE;
33 case MEDIA_CONTENT_GROUP_ADDED_TIME:
34 return DB_FIELD_MEDIA_ADDED_TIME;
35 case MEDIA_CONTENT_GROUP_MODIFIED_TIME:
36 return DB_FIELD_MEDIA_MODIFIED_TIME;
37 case MEDIA_CONTENT_GROUP_TITLE:
38 return DB_FIELD_MEDIA_TITLE;
39 case MEDIA_CONTENT_GROUP_ARTIST:
40 return DB_FIELD_MEDIA_ARTIST;
41 case MEDIA_CONTENT_GROUP_ALBUM_ARTIST:
42 return DB_FIELD_MEDIA_ALBUM_ARTIST;
43 case MEDIA_CONTENT_GROUP_GENRE:
44 return DB_FIELD_MEDIA_GENRE;
45 case MEDIA_CONTENT_GROUP_COMPOSER:
46 return DB_FIELD_MEDIA_COMPOSER;
47 case MEDIA_CONTENT_GROUP_YEAR:
48 return DB_FIELD_MEDIA_YEAR;
49 case MEDIA_CONTENT_GROUP_RECORDED_DATE:
50 return DB_FIELD_MEDIA_RECORDED_DATE;
51 case MEDIA_CONTENT_GROUP_COPYRIGHT:
52 return DB_FIELD_MEDIA_COPYRIGHT;
53 case MEDIA_CONTENT_GROUP_TRACK_NUM:
54 return DB_FIELD_MEDIA_TRACK_NUM;
55 case MEDIA_CONTENT_GROUP_DESCRIPTION:
56 return DB_FIELD_MEDIA_DESCRIPTION;
57 case MEDIA_CONTENT_GROUP_LONGITUDE:
58 return DB_FIELD_MEDIA_LONGITUDE;
59 case MEDIA_CONTENT_GROUP_LATITUDE:
60 return DB_FIELD_MEDIA_LATITUDE;
61 case MEDIA_CONTENT_GROUP_ALTITUDE:
62 return DB_FIELD_MEDIA_ALTITUDE;
63 case MEDIA_CONTENT_GROUP_RATING:
64 return DB_FIELD_MEDIA_RATING;
66 case MEDIA_CONTENT_GROUP_MODIFIED_MONTH:
67 return DB_FIELD_MEDIA_MODIFIED_DATE;
68 case MEDIA_CONTENT_GROUP_MODIFIED_DATE:
69 return DB_FIELD_MEDIA_MODIFIED_DATE;
71 #ifdef _USE_SENIOR_MODE
72 case MEDIA_CONTENT_GROUP_CONTACT:
73 return DB_FIELD_MEDIA_CONTACT;
76 case MEDIA_CONTENT_GROUP_ALBUM:
77 return DB_FIELD_MEDIA_ALBUM;
78 case MEDIA_PVR_GROUP_DURATION:
79 return DB_FIELD_PVR_DURATION;
80 case MEDIA_PVR_GROUP_TIME_ZONE:
81 return DB_FIELD_PVR_TIME_ZONE;
82 case MEDIA_PVR_GROUP_PTC:
83 return DB_FIELD_PVR_PTC;
84 case MEDIA_PVR_GROUP_MAJOR:
85 return DB_FIELD_PVR_MAJOR;
86 case MEDIA_PVR_GROUP_MINOR:
87 return DB_FIELD_PVR_MINOR;
88 case MEDIA_PVR_GROUP_CHANNEL_TYPE:
89 return DB_FIELD_PVR_CHANNEL_TYPE;
90 case MEDIA_PVR_GROUP_CHANNEL_NAME:
91 return DB_FIELD_PVR_CHANNEL_NAME;
92 case MEDIA_PVR_GROUP_CHANNEL_NUM:
93 return DB_FIELD_PVR_CHANNEL_NUM;
94 case MEDIA_PVR_GROUP_PROGRAM_TITLE:
95 return DB_FIELD_PVR_PROGRAM_TITLE;
96 case MEDIA_PVR_GROUP_PROGRAM_NUM:
97 return DB_FIELD_PVR_PROGRAM_NUM;
98 case MEDIA_PVR_GROUP_PROGRAM_CRID:
99 return DB_FIELD_PVR_PROGRAM_CRID;
100 case MEDIA_PVR_GROUP_GUIDANCE:
101 return DB_FIELD_PVR_GUIDANCE;
102 case MEDIA_PVR_GROUP_SYNOPSIS:
103 return DB_FIELD_PVR_SYNOPSIS;
104 case MEDIA_PVR_GROUP_GENRE:
105 return DB_FIELD_PVR_GENRE;
106 case MEDIA_PVR_GROUP_LANGUAGE:
107 return DB_FIELD_PVR_LANGUAGE;
108 case MEDIA_PVR_GROUP_EMBARGO_TIME:
109 return DB_FIELD_PVR_EMBARGO_TIME;
110 case MEDIA_PVR_GROUP_EXPIRY_TIME:
111 return DB_FIELD_PVR_EXPIRY_TIME;
112 case MEDIA_PVR_GROUP_START_TIME:
113 return DB_FIELD_PVR_START_TIME;
114 case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
115 return DB_FIELD_PVR_PROGRAM_START_TIME;
116 case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
117 return DB_FIELD_PVR_PROGRAM_END_TIME;
118 case MEDIA_PVR_GROUP_PROGRAM_DATE:
119 return DB_FIELD_PVR_PROGRAM_DATE;
120 case MEDIA_PVR_GROUP_PARENTAL_RATING:
121 return DB_FIELD_PVR_PARENTAL_RATING;
122 case MEDIA_PVR_GROUP_TIMER_RECORD:
123 return DB_FIELD_PVR_TIMER_RECORD;
124 case MEDIA_PVR_GROUP_SERIES_RECORD:
125 return DB_FIELD_PVR_SERIES_RECORD;
126 case MEDIA_PVR_GROUP_HD:
127 return DB_FIELD_PVR_HD;
128 case MEDIA_PVR_GROUP_SUBTITLE:
129 return DB_FIELD_PVR_SUBTITLE;
130 case MEDIA_PVR_GROUP_TTX:
131 return DB_FIELD_PVR_TTX;
132 case MEDIA_PVR_GROUP_AD:
133 return DB_FIELD_PVR_AD;
134 case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
135 return DB_FIELD_PVR_HARDOF_HEARINGRADIO;
136 case MEDIA_PVR_GROUP_DATA_SERVICE:
137 return DB_FIELD_PVR_DATA_SERVICE;
138 case MEDIA_PVR_GROUP_CONTENT_LOCK:
139 return DB_FIELD_PVR_CONTENT_LOCK;
140 case MEDIA_PVR_GROUP_CONTENT_WATCH:
141 return DB_FIELD_PVR_CONTENT_WATCH;
142 case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
143 return DB_FIELD_PVR_HAS_AUDIO_ONLY;
144 case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
145 return DB_FIELD_PVR_IS_LOCAL_RECORD;
146 case MEDIA_PVR_GROUP_RESOLUTION:
147 return DB_FIELD_PVR_RESOLUTION;
148 case MEDIA_PVR_GROUP_ASPECTRATIO:
149 return DB_FIELD_PVR_ASPECTRATIO;
150 case MEDIA_PVR_GROUP_MODIFIED_MONTH:
151 return DB_FIELD_PVR_MODIFIED_DATE;
152 case MEDIA_PVR_GROUP_MODIFIED_DATE:
153 return DB_FIELD_PVR_MODIFIED_DATE;
154 case MEDIA_PVR_GROUP_SPORTS_TYPE:
155 return DB_FIELD_PVR_SPORTS_TYPE;
156 case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
157 return DB_FIELD_PVR_GUIDANCE_LENGTH;
158 case MEDIA_PVR_GROUP_TVMODE:
159 return DB_FIELD_PVR_TVMODE;
160 case MEDIA_PVR_GROUP_PLAY_COUNT:
161 return DB_FIELD_PVR_PLAY_COUNT;
162 case MEDIA_PVR_GROUP_PRIVATE_DATA:
163 return DB_FIELD_PVR_PRIVATE_DATA;
164 case MEDIA_UHD_GROUP_CONTENT_TITLE:
165 return DB_FIELD_UHD_CONTENT_TITLE;
166 case MEDIA_UHD_GROUP_RELEASE_DATE:
167 return DB_FIELD_UHD_RELEASE_DATE;
168 case MEDIA_UHD_GROUP_SUB_TYPE:
169 return DB_FIELD_UHD_SUB_TYPE;
170 case MEDIA_UHD_GROUP_FILE_NAME:
171 return DB_FIELD_UHD_FILE_NAME;
172 case MEDIA_UHD_GROUP_PLAYED_COUNT:
173 return DB_FIELD_UHD_PLAYED_COUNT;
182 static int __media_db_make_query(filter_h filter, char **condition_query, char **option_query)
184 int ret = MEDIA_CONTENT_ERROR_NONE;
185 filter_s *_filter = (filter_s *)filter;
187 media_content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
189 if (STRING_VALID(_filter->condition)) {
190 ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
191 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
194 ret = _media_filter_build_option(filter, option_query);
195 if (ret != MEDIA_CONTENT_ERROR_NONE)
196 g_free(*condition_query);
201 #ifdef _USE_TVPD_MODE
202 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
204 int ret = MEDIA_CONTENT_ERROR_NONE;
205 sqlite3_stmt *stmt = NULL;
206 char select_query[MAX_QUERY_SIZE] = {0, };
207 char *condition_query = NULL;
208 char *option_query = NULL;
209 filter_s *_filter = (filter_s *)filter;
211 memset(select_query, 0x00, sizeof(select_query));
213 switch (group_type) {
214 case MEDIA_GROUP_ALBUM:
215 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
216 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, _filter->storage_id);
218 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
221 case MEDIA_GROUP_FOLDER:
222 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
223 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
225 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
228 case MEDIA_GROUP_PLAYLIST:
229 if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query))) {
230 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
231 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
234 case MEDIA_GROUP_TAG:
235 if (!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query))) {
236 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
237 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
240 case MEDIA_GROUP_BOOKMARK:
241 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
242 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, _filter->storage_id);
244 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
247 case MEDIA_GROUP_STORAGE:
248 if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_COUNT, sizeof(select_query))) {
249 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
250 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
253 case MEDIA_GROUP_FACE:
254 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
255 snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, _filter->storage_id);
257 snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, DB_VIEW_MEDIA);
260 media_content_error("Invalid group type [%d]", group_type);
261 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
264 ret = __media_db_make_query(filter, &condition_query, &option_query);
265 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
267 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
268 SAFE_FREE(condition_query);
269 SAFE_FREE(option_query);
270 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
272 if (sqlite3_step(stmt) == SQLITE_ROW)
273 *group_count = sqlite3_column_int(stmt, 0);
275 SQLITE3_FINALIZE(stmt);
280 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
282 int ret = MEDIA_CONTENT_ERROR_NONE;
283 sqlite3_stmt *stmt = NULL;
284 char select_query[MAX_QUERY_SIZE] = {0, };
285 char *condition_query = NULL;
286 char *option_query = NULL;
287 filter_s *_filter = (filter_s *)filter;
289 memset(select_query, 0x00, sizeof(select_query));
290 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
291 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
292 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
294 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
295 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
296 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
297 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
299 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
300 } else { /*uhd content*/
301 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
302 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
304 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
306 ret = __media_db_make_query(filter, &condition_query, &option_query);
307 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
309 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
310 if (STRING_VALID(condition_query)) {
311 SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
312 SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
314 if (STRING_VALID(option_query))
315 SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
316 SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
318 SAFE_FREE(condition_query);
319 SAFE_FREE(option_query);
321 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
322 SAFE_FREE(condition_query);
323 SAFE_FREE(option_query);
324 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
326 if (sqlite3_step(stmt) == SQLITE_ROW)
327 *group_count = sqlite3_column_int(stmt, 0);
329 SQLITE3_FINALIZE(stmt);
334 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
336 int ret = MEDIA_CONTENT_ERROR_NONE;
337 char select_query[MAX_QUERY_SIZE] = {0, };
338 char *condition_query = NULL;
339 char *option_query = NULL;
341 sqlite3_stmt *stmt = NULL;
342 filter_s *_filter = (filter_s *)filter;
343 memset(select_query, 0x00, sizeof(select_query));
344 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
345 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
346 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
348 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
349 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
350 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
351 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
353 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
354 } else { /* uhd content */
355 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
356 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
358 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
360 ret = __media_db_make_query(filter, &condition_query, &option_query);
361 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
363 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
364 SAFE_FREE(condition_query);
365 SAFE_FREE(option_query);
366 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
368 while (sqlite3_step(stmt) == SQLITE_ROW) {
369 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
371 if (callback(name, user_data) == false) {
379 SQLITE3_FINALIZE(stmt);
384 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
386 int ret = MEDIA_CONTENT_ERROR_NONE;
387 char select_query[DEFAULT_QUERY_SIZE] = {0, };
388 char group_query[DEFAULT_QUERY_SIZE] = {0, };
389 char *condition_query = NULL;
390 char *option_query = NULL;
392 sqlite3_stmt *stmt = NULL;
393 filter_s *_filter = (filter_s *)filter;
395 memset(select_query, 0x00, sizeof(select_query));
396 memset(group_query, 0x00, sizeof(group_query));
398 char* group_name = __media_db_get_group_name(group);
399 if (!STRING_VALID(group_name)) {
400 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
401 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
404 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
405 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
406 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
408 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
409 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
410 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
411 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
413 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
414 } else {/*uhd content*/
415 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
416 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
418 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
421 ret = __media_db_make_query(filter, &condition_query, &option_query);
422 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
424 if (STRING_VALID(option_query))
425 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
427 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
429 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
430 SAFE_FREE(condition_query);
431 SAFE_FREE(option_query);
432 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
434 while (sqlite3_step(stmt) == SQLITE_ROW) {
435 if (STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
436 name = strdup((const char *)sqlite3_column_text(stmt, 0));
438 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
446 SQLITE3_FINALIZE(stmt);
451 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
453 int ret = MEDIA_CONTENT_ERROR_NONE;
454 sqlite3_stmt *stmt = NULL;
455 char *select_query = NULL;
456 char *condition_query = NULL;
457 char *option_query = NULL;
458 filter_s *_filter = (filter_s *)filter;
460 switch (group_type) {
461 case MEDIA_GROUP_ALBUM:
462 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
463 select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
465 select_query = g_strdup(SELECT_ALBUM_COUNT);
468 case MEDIA_GROUP_FOLDER:
469 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
470 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
472 select_query = g_strdup(SELECT_FOLDER_COUNT);
475 case MEDIA_GROUP_PLAYLIST:
476 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
478 case MEDIA_GROUP_TAG:
479 select_query = g_strdup(SELECT_TAG_COUNT);
481 case MEDIA_GROUP_BOOKMARK:
482 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
483 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
485 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
488 case MEDIA_GROUP_STORAGE:
489 select_query = g_strdup(SELECT_STORAGE_COUNT);
491 case MEDIA_GROUP_FACE:
492 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
493 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
495 select_query = g_strdup(SELECT_FACE_COUNT);
498 media_content_error("Invalid group type [%d]", group_type);
499 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
502 ret = __media_db_make_query(filter, &condition_query, &option_query);
503 if (ret != MEDIA_CONTENT_ERROR_NONE) {
504 g_free(select_query);
508 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
509 g_free(select_query);
510 g_free(condition_query);
511 g_free(option_query);
512 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
514 if (sqlite3_step(stmt) == SQLITE_ROW)
515 *group_count = sqlite3_column_int(stmt, 0);
517 SQLITE3_FINALIZE(stmt);
522 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
524 int ret = MEDIA_CONTENT_ERROR_NONE;
525 sqlite3_stmt *stmt = NULL;
526 char *select_query = NULL;
527 char *condition_query = NULL;
528 char *option_query = NULL;
529 filter_s *_filter = (filter_s *)filter;
531 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
532 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);
534 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
536 ret = __media_db_make_query(filter, &condition_query, &option_query);
537 if (ret != MEDIA_CONTENT_ERROR_NONE) {
538 g_free(select_query);
542 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
543 g_free(select_query);
544 g_free(condition_query);
545 g_free(option_query);
546 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
548 if (sqlite3_step(stmt) == SQLITE_ROW)
549 *group_count = sqlite3_column_int(stmt, 0);
551 SQLITE3_FINALIZE(stmt);
556 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
558 int ret = MEDIA_CONTENT_ERROR_NONE;
559 char *select_query = NULL;
560 char *condition_query = NULL;
561 char *option_query = NULL;
563 sqlite3_stmt *stmt = NULL;
564 filter_s *_filter = (filter_s *)filter;
566 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
567 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
569 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
571 ret = __media_db_make_query(filter, &condition_query, &option_query);
572 if (ret != MEDIA_CONTENT_ERROR_NONE) {
573 g_free(select_query);
577 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
578 g_free(select_query);
579 g_free(condition_query);
580 g_free(option_query);
581 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
583 while (sqlite3_step(stmt) == SQLITE_ROW) {
584 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
586 if (callback(name, user_data) == false) {
594 SQLITE3_FINALIZE(stmt);
600 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
602 int ret = MEDIA_CONTENT_ERROR_NONE;
603 char select_query[MAX_QUERY_SIZE] = {0, };
604 char *condition_query = NULL;
605 char *option_query = NULL;
606 sqlite3_stmt *stmt = NULL;
607 filter_s *_filter = (filter_s *)filter;
609 memset(select_query, 0x00, sizeof(select_query));
610 #ifdef _USE_TVPD_MODE
611 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
612 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
614 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
616 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
617 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
619 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
621 ret = __media_db_make_query(filter, &condition_query, &option_query);
622 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
624 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
625 SAFE_FREE(condition_query);
626 SAFE_FREE(option_query);
627 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
629 while (sqlite3_step(stmt) == SQLITE_ROW) {
630 media_album_s *album = (media_album_s*)calloc(1, sizeof(media_album_s));
633 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
634 SQLITE3_FINALIZE(stmt);
635 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
638 album->album_id = sqlite3_column_int(stmt, 0);
639 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
640 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
641 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
643 if (callback((media_album_h)album, user_data) == false) {
644 media_album_destroy((media_album_h)album);
648 media_album_destroy((media_album_h)album);
651 SQLITE3_FINALIZE(stmt);
656 int _media_db_get_folder(filter_h filter, media_folder_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_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
670 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
672 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
673 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
675 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
677 ret = __media_db_make_query(filter, &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_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
688 if (_folder == NULL) {
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 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
695 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
696 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
697 _folder->storage_type = sqlite3_column_int(stmt, 3);
698 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
700 if (callback((media_folder_h)_folder, user_data) == false) {
701 media_folder_destroy((media_folder_h) _folder);
705 media_folder_destroy((media_folder_h) _folder);
708 SQLITE3_FINALIZE(stmt);
713 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
715 int ret = MEDIA_CONTENT_ERROR_NONE;
716 char *condition_query = NULL;
717 char *option_query = NULL;
718 sqlite3_stmt *stmt = NULL;
720 ret = __media_db_make_query(filter, &condition_query, &option_query);
721 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
723 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
724 SAFE_FREE(condition_query);
725 SAFE_FREE(option_query);
726 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
728 while (sqlite3_step(stmt) == SQLITE_ROW) {
729 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
731 if (_playlist == NULL) {
732 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
733 SQLITE3_FINALIZE(stmt);
734 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
737 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
738 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
739 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
741 if (callback((media_playlist_h)_playlist, user_data) == false) {
742 media_playlist_destroy((media_playlist_h)_playlist);
745 media_playlist_destroy((media_playlist_h)_playlist);
748 SQLITE3_FINALIZE(stmt);
753 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
755 int ret = MEDIA_CONTENT_ERROR_NONE;
756 char *select_query = NULL;
757 char *condition_query = NULL;
758 char *option_query = NULL;
759 sqlite3_stmt *stmt = NULL;
761 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
763 ret = __media_db_make_query(filter, &condition_query, &option_query);
764 if (ret != MEDIA_CONTENT_ERROR_NONE) {
765 g_free(select_query);
769 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
770 g_free(select_query);
771 g_free(condition_query);
772 g_free(option_query);
773 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
775 while (sqlite3_step(stmt) == SQLITE_ROW) {
776 int playlist_member_id = 0;
777 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
779 media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
781 if (_media == NULL) {
782 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
783 SQLITE3_FINALIZE(stmt);
784 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
787 _media_info_item_get_detail(stmt, (media_info_h)_media);
789 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
790 media_info_destroy((media_info_h)_media);
793 media_info_destroy((media_info_h)_media);
797 SQLITE3_FINALIZE(stmt);
802 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
804 int ret = MEDIA_CONTENT_ERROR_NONE;
805 char *select_query = NULL;
806 char *condition_query = NULL;
807 char *option_query = NULL;
808 sqlite3_stmt *stmt = NULL;
810 if (STRING_VALID(media_id))
811 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
813 select_query = g_strdup(SELECT_TAG_LIST);
815 ret = __media_db_make_query(filter, &condition_query, &option_query);
816 if (ret != MEDIA_CONTENT_ERROR_NONE) {
817 g_free(select_query);
821 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
822 g_free(select_query);
823 g_free(condition_query);
824 g_free(option_query);
825 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
827 while (sqlite3_step(stmt) == SQLITE_ROW) {
828 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
831 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
832 SQLITE3_FINALIZE(stmt);
833 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
836 _tag->tag_id = sqlite3_column_int(stmt, 0);
837 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
839 if (callback((media_tag_h)_tag, user_data) == false) {
840 media_tag_destroy((media_tag_h)_tag);
843 media_tag_destroy((media_tag_h)_tag);
846 SQLITE3_FINALIZE(stmt);
851 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
853 int ret = MEDIA_CONTENT_ERROR_NONE;
854 char select_query[MAX_QUERY_SIZE] = {0, };
855 char *condition_query = NULL;
856 char *option_query = NULL;
857 sqlite3_stmt *stmt = NULL;
858 filter_s *_filter = (filter_s *)filter;
860 memset(select_query, 0x00, sizeof(select_query));
861 #ifdef _USE_TVPD_MODE
862 if (STRING_VALID(media_id)) { //get bookmark by media_id
863 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
864 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
866 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
868 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
869 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, _filter->storage_id);
871 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
874 if (STRING_VALID(media_id)) { //get bookmark by media_id
875 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
877 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
878 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
880 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
884 ret = __media_db_make_query(filter, &condition_query, &option_query);
885 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
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_bookmark_s *bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
895 if (bookmark == NULL) {
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 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
902 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
903 bookmark->marked_time = sqlite3_column_int(stmt, 2);
904 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
905 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
907 if (callback((media_bookmark_h)bookmark, user_data) == false) {
908 media_bookmark_destroy((media_bookmark_h)bookmark);
912 media_bookmark_destroy((media_bookmark_h)bookmark);
915 SQLITE3_FINALIZE(stmt);
921 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
923 int ret = MEDIA_CONTENT_ERROR_NONE;
924 char select_query[MAX_QUERY_SIZE] = {0, };
925 char *condition_query = NULL;
926 char *option_query = NULL;
927 sqlite3_stmt *stmt = NULL;
928 filter_s *_filter = (filter_s *)filter;
930 memset(select_query, 0x00, sizeof(select_query));
931 #ifdef _USE_TVPD_MODE
932 if (STRING_VALID(media_id)) { //get face by media_id
933 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
934 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
936 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
938 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
939 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, _filter->storage_id);
941 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
944 if (STRING_VALID(media_id)) { //get face by media_id
945 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
947 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
948 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
950 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
953 ret = __media_db_make_query(filter, &condition_query, &option_query);
954 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
956 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
957 SAFE_FREE(condition_query);
958 SAFE_FREE(option_query);
959 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
961 while (sqlite3_step(stmt) == SQLITE_ROW) {
962 media_face_s *face = (media_face_s*)calloc(1, sizeof(media_face_s));
965 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
966 SQLITE3_FINALIZE(stmt);
967 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
970 face->face_id = sqlite3_column_int(stmt, 0);
971 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
972 face->face_rect_x = sqlite3_column_int(stmt, 2);
973 face->face_rect_y = sqlite3_column_int(stmt, 3);
974 face->face_rect_w = sqlite3_column_int(stmt, 4);
975 face->face_rect_h = sqlite3_column_int(stmt, 5);
976 face->orientation = sqlite3_column_int(stmt, 6);
977 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
979 if (callback((media_face_h)face, user_data) == false) {
980 media_face_destroy((media_face_h)face);
984 media_face_destroy((media_face_h)face);
987 SQLITE3_FINALIZE(stmt);
993 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
995 int ret = MEDIA_CONTENT_ERROR_NONE;
996 sqlite3_stmt *stmt = NULL;
997 char select_query[MAX_QUERY_SIZE] = {0, };
998 char *condition_query = NULL;
999 char *option_query = NULL;
1000 filter_s *_filter = (filter_s *)filter;
1002 memset(select_query, 0x00, sizeof(select_query));
1004 if (group_type == MEDIA_GROUP_ALBUM) {
1005 #ifdef _USE_TVPD_MODE
1006 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1007 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
1009 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1011 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1012 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1014 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
1016 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1017 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
1018 } else if (group_type == MEDIA_GROUP_TAG) {
1019 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
1021 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1022 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1025 ret = __media_db_make_query(filter, &condition_query, &option_query);
1026 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1028 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1029 SAFE_FREE(condition_query);
1030 SAFE_FREE(option_query);
1031 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1033 if (sqlite3_step(stmt) == SQLITE_ROW)
1034 *item_count = sqlite3_column_int(stmt, 0);
1036 SQLITE3_FINALIZE(stmt);
1041 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
1043 int ret = MEDIA_CONTENT_ERROR_NONE;
1044 sqlite3_stmt *stmt = NULL;
1045 char select_query[MAX_QUERY_SIZE] = {0, };
1046 char *tmp_query = NULL;
1047 char *condition_query = NULL;
1048 char *option_query = NULL;
1049 bool is_simple = FALSE;
1050 filter_s *_filter = (filter_s *)filter;
1052 memset(select_query, 0x00, sizeof(select_query));
1054 if (group_type == MEDIA_GROUP_NONE) {
1055 /* There are 2 ways to get count for media table for performance
1056 If user wants to set offset and count, use SQL SELECT_MEDIA_COUNT_FROM_MEDIA.
1057 If user wants to get count without setting count, SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE */
1058 if (_filter && ((_filter->offset < 0) && (_filter->count < 0))) {
1059 #ifdef _USE_TVPD_MODE
1060 if (STRING_VALID(_filter->storage_id))
1061 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1063 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1065 if (STRING_VALID(_filter->storage_id))
1066 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1068 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1072 #ifdef _USE_TVPD_MODE
1073 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1075 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
1078 } else if (group_type == MEDIA_GROUP_FOLDER) {
1079 #ifdef _USE_TVPD_MODE
1080 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1081 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1083 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1085 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1086 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1088 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1090 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1091 } else if (group_type == MEDIA_GROUP_TAG_BY_MEDIA_ID) {
1092 snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1093 } else if (group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID) {
1094 #ifdef _USE_TVPD_MODE
1095 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1096 tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1098 tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1100 tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1102 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1103 } else if (group_type == MEDIA_GROUP_STORAGE) {
1104 #ifdef _USE_TVPD_MODE
1105 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1107 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1109 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1110 } else if (group_type == MEDIA_GROUP_FACE_BY_MEDIA_ID) {
1111 #ifdef _USE_TVPD_MODE
1112 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1113 tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1115 tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1117 tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1119 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1120 #ifdef _USE_TVPD_MODE
1121 } else if (group_type == MEDIA_GROUP_PVR) {
1122 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1123 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1125 SAFE_STRLCAT(select_query, SELECT_PVR_COUNT, sizeof(select_query));
1126 } else if (group_type == MEDIA_GROUP_UHD) {
1127 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1128 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1130 SAFE_STRLCAT(select_query, SELECT_UHD_COUNT, sizeof(select_query));
1133 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1134 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1137 ret = __media_db_make_query(filter, &condition_query, &option_query);
1138 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1139 if (tmp_query != NULL)
1140 SQLITE3_SAFE_FREE(tmp_query);
1144 if (group_type == MEDIA_GROUP_NONE) {
1145 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
1146 if (STRING_VALID(condition_query)) {
1147 SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
1148 SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
1150 if (STRING_VALID(option_query))
1151 SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
1154 SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
1156 SAFE_FREE(condition_query);
1157 SAFE_FREE(option_query);
1160 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1161 if (tmp_query != NULL)
1162 SQLITE3_SAFE_FREE(tmp_query);
1163 SAFE_FREE(condition_query);
1164 SAFE_FREE(option_query);
1165 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1167 if (sqlite3_step(stmt) == SQLITE_ROW)
1168 *item_count = sqlite3_column_int(stmt, 0);
1170 SQLITE3_FINALIZE(stmt);
1175 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)
1177 int ret = MEDIA_CONTENT_ERROR_NONE;
1178 char select_query[MAX_QUERY_SIZE] = {0, };
1179 char *condition_query = NULL;
1180 char *option_query = NULL;
1181 sqlite3_stmt *stmt = NULL;
1182 filter_s *_filter = (filter_s *)filter;
1184 memset(select_query, 0x00, sizeof(select_query));
1186 #ifdef _USE_TVPD_MODE
1187 if (group_type == MEDIA_GROUP_ALBUM) {
1188 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1189 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1191 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1192 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1193 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1194 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1196 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1197 } else if (group_type == MEDIA_GROUP_TAG) {
1198 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1199 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1201 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1203 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1204 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1207 if (group_type == MEDIA_GROUP_ALBUM) {
1208 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1209 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1211 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
1212 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1213 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1214 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1216 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
1217 } else if (group_type == MEDIA_GROUP_TAG) {
1218 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1219 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1221 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
1223 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1224 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1227 ret = __media_db_make_query(filter, &condition_query, &option_query);
1228 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1230 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1231 SAFE_FREE(condition_query);
1232 SAFE_FREE(option_query);
1233 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1235 while (sqlite3_step(stmt) == SQLITE_ROW) {
1236 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1238 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1239 SQLITE3_FINALIZE(stmt);
1240 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1243 _media_info_item_get_detail(stmt, (media_info_h)item);
1245 if (callback((media_info_h)item, user_data) == false) {
1246 media_info_destroy((media_info_h)item);
1250 media_info_destroy((media_info_h)item);
1253 SQLITE3_FINALIZE(stmt);
1258 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)
1260 int ret = MEDIA_CONTENT_ERROR_NONE;
1261 char select_query[MAX_QUERY_SIZE] = {0, };
1262 char *condition_query = NULL;
1263 char *option_query = NULL;
1264 sqlite3_stmt *stmt = NULL;
1265 filter_s *_filter = (filter_s *)filter;
1267 memset(select_query, 0x00, sizeof(select_query));
1268 #ifdef _USE_TVPD_MODE
1269 if (group_type == MEDIA_GROUP_NONE) {
1270 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1271 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
1273 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1274 } else if (group_type == MEDIA_GROUP_FOLDER) {
1275 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1276 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1278 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1279 } else if (group_type == MEDIA_GROUP_STORAGE) {
1280 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1282 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1283 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1286 if (group_type == MEDIA_GROUP_NONE) {
1287 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1288 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1290 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
1291 } else if (group_type == MEDIA_GROUP_FOLDER) {
1292 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
1293 } else if (group_type == MEDIA_GROUP_STORAGE) {
1294 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
1296 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1297 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1300 ret = __media_db_make_query(filter, &condition_query, &option_query);
1301 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1303 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1304 SAFE_FREE(condition_query);
1305 SAFE_FREE(option_query);
1306 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1308 while (sqlite3_step(stmt) == SQLITE_ROW) {
1309 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1311 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1312 SQLITE3_FINALIZE(stmt);
1313 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1316 _media_info_item_get_detail(stmt, (media_info_h)item);
1318 if (callback((media_info_h)item, user_data) == false) {
1319 media_info_destroy((media_info_h)item);
1323 media_info_destroy((media_info_h)item);
1326 SQLITE3_FINALIZE(stmt);
1331 #ifdef _USE_SENIOR_MODE
1332 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)
1334 int ret = MEDIA_CONTENT_ERROR_NONE;
1335 char select_query1[MAX_QUERY_SIZE] = {0, };
1336 char *condition_query1 = NULL;
1337 char *option_query1 = NULL;
1338 char select_query2[MAX_QUERY_SIZE] = {0, };
1339 char *condition_query2 = NULL;
1340 char *option_query2 = NULL;
1341 sqlite3_stmt *stmt = NULL;
1342 filter_s *_filter1 = (filter_s *)filter1;
1343 filter_s *_filter2 = (filter_s *)filter2;
1345 memset(select_query1, 0x00, sizeof(select_query1));
1347 if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
1348 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, _filter1->storage_id, group_name);
1350 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1352 ret = __media_db_make_query(filter, &condition_query, &option_query);
1353 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1354 SAFE_FREE(condition_query1);
1355 SAFE_FREE(option_query1);
1356 media_content_error("create select_query1 failed");
1360 memset(select_query2, 0x00, sizeof(select_query2));
1362 if ((_filter2 != NULL) && STRING_VALID(_filter2->storage_id))
1363 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, _filter2->storage_id, group_name);
1365 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1367 ret = __media_db_make_query(filter, &condition_query, &option_query);
1368 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1369 SAFE_FREE(condition_query1);
1370 SAFE_FREE(option_query1);
1371 SAFE_FREE(condition_query2);
1372 SAFE_FREE(option_query2);
1373 media_content_error("create select_query2 failed");
1377 ret = _content_query_prepare_by_union_select(&stmt, select_query1, condition_query1, option_query1, select_query2, condition_query2, option_query2);
1378 SAFE_FREE(condition_query1);
1379 SAFE_FREE(option_query1);
1380 SAFE_FREE(condition_query2);
1381 SAFE_FREE(option_query2);
1382 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1384 while (sqlite3_step(stmt) == SQLITE_ROW) {
1385 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1387 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1388 SQLITE3_FINALIZE(stmt);
1389 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1392 _media_info_item_get_detail(stmt, (media_info_h)item);
1394 if (callback((media_info_h)item, user_data) == false) {
1395 media_info_destroy((media_info_h)item);
1399 media_info_destroy((media_info_h)item);
1402 SQLITE3_FINALIZE(stmt);
1408 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1410 int ret = MEDIA_CONTENT_ERROR_NONE;
1411 sqlite3_stmt *stmt = NULL;
1412 char select_query[MAX_QUERY_SIZE] = {0, };
1413 char *tmp_query = NULL;
1414 char *condition_query = NULL;
1415 char *option_query = NULL;
1416 filter_s *_filter = (filter_s *)filter;
1418 memset(select_query, 0x00, sizeof(select_query));
1419 #ifdef _USE_TVPD_MODE
1420 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1421 if (group_name != NULL) {
1422 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1423 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1425 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1427 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1429 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1430 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1432 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1434 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1435 if (group_name != NULL) {
1436 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1437 tmp_query = sqlite3_mprintf(SELECT_PVR_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1439 tmp_query = sqlite3_mprintf(SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1441 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1443 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1444 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1446 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1448 } else {/*uhd content*/
1449 if (group_name != NULL) {
1450 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1451 tmp_query = sqlite3_mprintf(SELECT_UHD_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1453 tmp_query = sqlite3_mprintf(SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1455 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1457 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1458 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1460 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1464 if (group_name != NULL) {
1465 if ((_filter != NULL) && STRING_VALID(_filter->storage_id)) {
1466 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1467 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1469 tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1470 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1473 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1474 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1476 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1479 ret = __media_db_make_query(filter, &condition_query, &option_query);
1480 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1481 if (tmp_query != NULL)
1482 SQLITE3_SAFE_FREE(tmp_query);
1486 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
1487 if (STRING_VALID(condition_query)) {
1488 SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
1489 SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
1491 if (STRING_VALID(option_query))
1492 SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
1493 SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
1495 SAFE_FREE(condition_query);
1496 SAFE_FREE(option_query);
1498 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1499 if (tmp_query != NULL)
1500 SQLITE3_SAFE_FREE(tmp_query);
1501 SAFE_FREE(condition_query);
1502 SAFE_FREE(option_query);
1503 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1505 if (sqlite3_step(stmt) == SQLITE_ROW)
1506 *item_count = sqlite3_column_int(stmt, 0);
1508 SQLITE3_FINALIZE(stmt);
1513 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)
1515 int ret = MEDIA_CONTENT_ERROR_NONE;
1516 char select_query[MAX_QUERY_SIZE] = {0, };
1517 char *tmp_query = NULL;
1518 char *condition_query = NULL;
1519 char *option_query = NULL;
1520 sqlite3_stmt *stmt = NULL;
1521 filter_s *_filter = (filter_s *)filter;
1523 memset(select_query, 0x00, sizeof(select_query));
1524 #ifdef _USE_TVPD_MODE
1525 if (group_name != NULL) {
1526 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1527 tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1529 tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1531 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1533 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1534 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1536 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1539 if (group_name != NULL) {
1540 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1541 tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1543 tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1545 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1547 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1548 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1550 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1553 ret = __media_db_make_query(filter, &condition_query, &option_query);
1554 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1555 if (tmp_query != NULL)
1556 SQLITE3_SAFE_FREE(tmp_query);
1560 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1561 if (tmp_query != NULL)
1562 SQLITE3_SAFE_FREE(tmp_query);
1563 SAFE_FREE(condition_query);
1564 SAFE_FREE(option_query);
1565 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1567 while (sqlite3_step(stmt) == SQLITE_ROW) {
1568 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1570 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1571 SQLITE3_FINALIZE(stmt);
1572 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1575 _media_info_item_get_detail(stmt, (media_info_h)item);
1577 if (callback((media_info_h)item, user_data) == false) {
1578 media_info_destroy((media_info_h)item);
1582 media_info_destroy((media_info_h)item);
1585 SQLITE3_FINALIZE(stmt);
1590 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1592 int ret = MEDIA_CONTENT_ERROR_NONE;
1593 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1594 char *condition_query = NULL;
1595 char *option_query = NULL;
1596 sqlite3_stmt *stmt = NULL;
1598 memset(select_query, 0x00, sizeof(select_query));
1600 if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_LIST, sizeof(select_query))) {
1601 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1602 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1605 ret = __media_db_make_query(filter, &condition_query, &option_query);
1606 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1608 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1609 SAFE_FREE(condition_query);
1610 SAFE_FREE(option_query);
1611 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1613 while (sqlite3_step(stmt) == SQLITE_ROW) {
1614 media_storage_s *_storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
1616 if (_storage == NULL) {
1617 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1618 SQLITE3_FINALIZE(stmt);
1619 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1622 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1623 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1624 _storage->storage_type = sqlite3_column_int(stmt, 2);
1626 if (callback((media_storage_h)_storage, user_data) == false) {
1627 media_storage_destroy((media_storage_h) _storage);
1631 media_storage_destroy((media_storage_h) _storage);
1634 SQLITE3_FINALIZE(stmt);
1639 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1641 int ret = MEDIA_CONTENT_ERROR_NONE;
1642 sqlite3_stmt *stmt = NULL;
1643 char *select_query = NULL;
1645 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1647 ret = _content_get_result(select_query, &stmt);
1648 SQLITE3_SAFE_FREE(select_query);
1649 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1651 if (sqlite3_step(stmt) == SQLITE_ROW) {
1652 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1654 media_content_error("Invalid media_id[%s]", media_id);
1655 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1658 SQLITE3_FINALIZE(stmt);
1663 #ifdef _USE_TVPD_MODE
1664 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)
1666 int ret = MEDIA_CONTENT_ERROR_NONE;
1667 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1668 char *tmp_query = NULL;
1669 char *condition_query = NULL;
1670 char *option_query = NULL;
1671 sqlite3_stmt *stmt = NULL;
1672 filter_s *_filter = (filter_s *)filter;
1674 memset(select_query, 0x00, sizeof(select_query));
1676 if (group_name != NULL) {
1677 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1678 tmp_query = sqlite3_mprintf(SELECT_PVR_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1680 tmp_query = sqlite3_mprintf(SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1682 SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
1684 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1685 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1687 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1690 ret = __media_db_make_query(filter, &condition_query, &option_query);
1691 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1692 if (tmp_query != NULL)
1693 sqlite3_free(tmp_query);
1697 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1698 if (tmp_query != NULL)
1699 sqlite3_free(tmp_query);
1700 SAFE_FREE(condition_query);
1701 SAFE_FREE(option_query);
1702 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1704 while (sqlite3_step(stmt) == SQLITE_ROW) {
1705 media_pvr_s *item = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1707 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1708 SQLITE3_FINALIZE(stmt);
1709 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1712 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1714 if (callback((media_pvr_h)item, user_data) == false) {
1715 media_info_destroy((media_pvr_h)item);
1719 media_pvr_destroy((media_pvr_h)item);
1722 SQLITE3_FINALIZE(stmt);
1728 MEDIA_PVR_MEDIA_ID = 0,
1729 MEDIA_PVR_STORAGE_ID,
1733 MEDIA_PVR_TIME_ZONE,
1737 MEDIA_PVR_CHANNEL_TYPE,
1738 MEDIA_PVR_CHANNEL_NAME,
1739 MEDIA_PVR_CHANNEL_NUM,
1740 MEDIA_PVR_SERVICE_PROFILE,
1741 MEDIA_PVR_PROGRAM_TITLE,
1742 MEDIA_PVR_PROGRAM_NUM,
1743 MEDIA_PVR_PROGRAM_CRID,
1748 MEDIA_PVR_EMBARGO_TIME,
1749 MEDIA_PVR_EXPIRY_TIME,
1750 MEDIA_PVR_START_TIME,
1751 MEDIA_PVR_PROGRAM_START_TIME,
1752 MEDIA_PVR_PROGRAM_END_TIME,
1753 MEDIA_PVR_PROGRAM_DATE,
1754 MEDIA_PVR_PARENTAL_RATING,
1755 MEDIA_PVR_TIMER_RECORD,
1756 MEDIA_PVR_SERIES_RECORD,
1761 MEDIA_PVR_HARDOF_HEARINGRADIO,
1762 MEDIA_PVR_DATA_SERVICE,
1763 MEDIA_PVR_CONTENT_LOCK,
1764 MEDIA_PVR_CONTENT_WATCH,
1765 MEDIA_PVR_HAS_AUDIO_ONLY,
1766 MEDIA_PVR_IS_LOCAL_RECORDED,
1767 MEDIA_PVR_RESOLUTION,
1768 MEDIA_PVR_ASPECTRATIO,
1769 MEDIA_PVR_MODIFIED_MONTH,
1770 MEDIA_PVR_SPORTS_TYPE,
1771 MEDIA_PVR_GUIDANCE_LENGTH,
1773 MEDIA_PVR_PLAY_COUNT,
1774 MEDIA_PVR_PRIVATE_DATA,
1775 MEDIA_PVR_HIGHLIGHT,
1776 } media_pvr_field_e;
1778 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1780 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1782 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID)))
1783 _pvr->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1785 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID)))
1786 _pvr->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1788 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH)))
1789 _pvr->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1791 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1793 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1795 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1797 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1799 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1801 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1803 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1805 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1807 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME)))
1808 _pvr->channel_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1810 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM)))
1811 _pvr->channel_num = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1813 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE)))
1814 _pvr->program_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1816 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1818 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID)))
1819 _pvr->program_crid = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1821 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE)))
1822 _pvr->guidance = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1824 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS)))
1825 _pvr->synopsis = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1827 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE)))
1828 _pvr->genre = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1830 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE)))
1831 _pvr->language = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1833 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH)))
1834 _pvr->modified_month = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1836 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA)))
1837 _pvr->private_data = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1839 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1841 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1843 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1845 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1847 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1849 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1851 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1853 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1855 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1857 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1859 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1861 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1863 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1865 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1867 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1869 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1871 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1873 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1875 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1877 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1879 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1881 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1883 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1885 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1887 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1889 _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1894 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1896 int ret = MEDIA_CONTENT_ERROR_NONE;
1897 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1898 char *condition_query = NULL;
1899 char *option_query = NULL;
1900 sqlite3_stmt *stmt = NULL;
1901 filter_s *_filter = (filter_s *)filter;
1903 memset(select_query, 0x00, sizeof(select_query));
1905 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1906 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1908 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1910 ret = __media_db_make_query(filter, &condition_query, &option_query);
1911 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1913 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1914 SAFE_FREE(condition_query);
1915 SAFE_FREE(option_query);
1916 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1918 while (sqlite3_step(stmt) == SQLITE_ROW) {
1919 media_pvr_s *_pvr = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1922 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1923 SQLITE3_FINALIZE(stmt);
1924 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1927 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1929 if (callback((media_pvr_h)_pvr, user_data) == false) {
1930 media_pvr_destroy((media_pvr_h) _pvr);
1934 media_pvr_destroy((media_pvr_h) _pvr);
1937 SQLITE3_FINALIZE(stmt);
1943 MEDIA_UHD_MEDIA_ID = 0,
1944 MEDIA_UHD_STORAGE_ID,
1947 MEDIA_UHD_CONTENT_ID,
1948 MEDIA_UHD_CONTENT_TITLE,
1949 MEDIA_UHD_FILE_NAME,
1950 MEDIA_UHD_FOLDER_ID,
1951 MEDIA_UHD_RELEASE_DATE,
1952 MEDIA_UHD_MODIFIED_TIME,
1953 MEDIA_UHD_PLAYED_POSITION,
1955 MEDIA_UHD_PLAYED_COUNT,
1956 } media_uhd_field_e;
1958 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1960 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1962 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID)))
1963 _uhd->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1965 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID)))
1966 _uhd->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1968 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH)))
1969 _uhd->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1971 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1973 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID)))
1974 _uhd->content_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1976 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE)))
1977 _uhd->content_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1979 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME)))
1980 _uhd->file_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1982 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE)))
1983 _uhd->release_date = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1985 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1986 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1987 _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1988 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1993 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1995 int ret = MEDIA_CONTENT_ERROR_NONE;
1996 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1997 char *condition_query = NULL;
1998 char *option_query = NULL;
1999 sqlite3_stmt *stmt = NULL;
2000 filter_s *_filter = (filter_s *)filter;
2002 memset(select_query, 0x00, sizeof(select_query));
2004 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
2005 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
2007 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
2009 ret = __media_db_make_query(filter, &condition_query, &option_query);
2010 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2012 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
2013 SAFE_FREE(condition_query);
2014 SAFE_FREE(option_query);
2015 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2017 while (sqlite3_step(stmt) == SQLITE_ROW) {
2018 media_uhd_s *_uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
2021 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2022 SQLITE3_FINALIZE(stmt);
2023 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2026 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
2028 if (callback((media_uhd_h)_uhd, user_data) == false) {
2029 media_uhd_destroy((media_uhd_h) _uhd);
2032 media_uhd_destroy((media_uhd_h) _uhd);
2035 SQLITE3_FINALIZE(stmt);