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_DATE:
67 return DB_FIELD_MEDIA_MODIFIED_DATE;
68 case MEDIA_CONTENT_GROUP_ALBUM:
69 return DB_FIELD_MEDIA_ALBUM;
70 case MEDIA_PVR_GROUP_DURATION:
71 return DB_FIELD_PVR_DURATION;
72 case MEDIA_PVR_GROUP_TIME_ZONE:
73 return DB_FIELD_PVR_TIME_ZONE;
74 case MEDIA_PVR_GROUP_PTC:
75 return DB_FIELD_PVR_PTC;
76 case MEDIA_PVR_GROUP_MAJOR:
77 return DB_FIELD_PVR_MAJOR;
78 case MEDIA_PVR_GROUP_MINOR:
79 return DB_FIELD_PVR_MINOR;
80 case MEDIA_PVR_GROUP_CHANNEL_TYPE:
81 return DB_FIELD_PVR_CHANNEL_TYPE;
82 case MEDIA_PVR_GROUP_CHANNEL_NAME:
83 return DB_FIELD_PVR_CHANNEL_NAME;
84 case MEDIA_PVR_GROUP_CHANNEL_NUM:
85 return DB_FIELD_PVR_CHANNEL_NUM;
86 case MEDIA_PVR_GROUP_PROGRAM_TITLE:
87 return DB_FIELD_PVR_PROGRAM_TITLE;
88 case MEDIA_PVR_GROUP_PROGRAM_NUM:
89 return DB_FIELD_PVR_PROGRAM_NUM;
90 case MEDIA_PVR_GROUP_PROGRAM_CRID:
91 return DB_FIELD_PVR_PROGRAM_CRID;
92 case MEDIA_PVR_GROUP_GUIDANCE:
93 return DB_FIELD_PVR_GUIDANCE;
94 case MEDIA_PVR_GROUP_SYNOPSIS:
95 return DB_FIELD_PVR_SYNOPSIS;
96 case MEDIA_PVR_GROUP_GENRE:
97 return DB_FIELD_PVR_GENRE;
98 case MEDIA_PVR_GROUP_LANGUAGE:
99 return DB_FIELD_PVR_LANGUAGE;
100 case MEDIA_PVR_GROUP_EMBARGO_TIME:
101 return DB_FIELD_PVR_EMBARGO_TIME;
102 case MEDIA_PVR_GROUP_EXPIRY_TIME:
103 return DB_FIELD_PVR_EXPIRY_TIME;
104 case MEDIA_PVR_GROUP_START_TIME:
105 return DB_FIELD_PVR_START_TIME;
106 case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
107 return DB_FIELD_PVR_PROGRAM_START_TIME;
108 case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
109 return DB_FIELD_PVR_PROGRAM_END_TIME;
110 case MEDIA_PVR_GROUP_PROGRAM_DATE:
111 return DB_FIELD_PVR_PROGRAM_DATE;
112 case MEDIA_PVR_GROUP_PARENTAL_RATING:
113 return DB_FIELD_PVR_PARENTAL_RATING;
114 case MEDIA_PVR_GROUP_TIMER_RECORD:
115 return DB_FIELD_PVR_TIMER_RECORD;
116 case MEDIA_PVR_GROUP_SERIES_RECORD:
117 return DB_FIELD_PVR_SERIES_RECORD;
118 case MEDIA_PVR_GROUP_HD:
119 return DB_FIELD_PVR_HD;
120 case MEDIA_PVR_GROUP_SUBTITLE:
121 return DB_FIELD_PVR_SUBTITLE;
122 case MEDIA_PVR_GROUP_TTX:
123 return DB_FIELD_PVR_TTX;
124 case MEDIA_PVR_GROUP_AD:
125 return DB_FIELD_PVR_AD;
126 case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
127 return DB_FIELD_PVR_HARDOF_HEARINGRADIO;
128 case MEDIA_PVR_GROUP_DATA_SERVICE:
129 return DB_FIELD_PVR_DATA_SERVICE;
130 case MEDIA_PVR_GROUP_CONTENT_LOCK:
131 return DB_FIELD_PVR_CONTENT_LOCK;
132 case MEDIA_PVR_GROUP_CONTENT_WATCH:
133 return DB_FIELD_PVR_CONTENT_WATCH;
134 case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
135 return DB_FIELD_PVR_HAS_AUDIO_ONLY;
136 case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
137 return DB_FIELD_PVR_IS_LOCAL_RECORD;
138 case MEDIA_PVR_GROUP_RESOLUTION:
139 return DB_FIELD_PVR_RESOLUTION;
140 case MEDIA_PVR_GROUP_ASPECTRATIO:
141 return DB_FIELD_PVR_ASPECTRATIO;
142 case MEDIA_PVR_GROUP_MODIFIED_MONTH:
143 return DB_FIELD_PVR_MODIFIED_DATE;
144 case MEDIA_PVR_GROUP_MODIFIED_DATE:
145 return DB_FIELD_PVR_MODIFIED_DATE;
146 case MEDIA_PVR_GROUP_SPORTS_TYPE:
147 return DB_FIELD_PVR_SPORTS_TYPE;
148 case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
149 return DB_FIELD_PVR_GUIDANCE_LENGTH;
150 case MEDIA_PVR_GROUP_TVMODE:
151 return DB_FIELD_PVR_TVMODE;
152 case MEDIA_PVR_GROUP_PLAY_COUNT:
153 return DB_FIELD_PVR_PLAY_COUNT;
154 case MEDIA_PVR_GROUP_PRIVATE_DATA:
155 return DB_FIELD_PVR_PRIVATE_DATA;
156 case MEDIA_UHD_GROUP_CONTENT_TITLE:
157 return DB_FIELD_UHD_CONTENT_TITLE;
158 case MEDIA_UHD_GROUP_RELEASE_DATE:
159 return DB_FIELD_UHD_RELEASE_DATE;
160 case MEDIA_UHD_GROUP_FILE_NAME:
161 return DB_FIELD_UHD_FILE_NAME;
162 case MEDIA_UHD_GROUP_PLAYED_COUNT:
163 return DB_FIELD_UHD_PLAYED_COUNT;
172 static int __media_db_make_query(filter_h filter, char **condition_query, char **option_query)
174 int ret = MEDIA_CONTENT_ERROR_NONE;
175 filter_s *_filter = (filter_s *)filter;
177 content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
179 if (STRING_VALID(_filter->condition)) {
180 ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
181 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
184 ret = _media_filter_build_option(filter, option_query);
185 if (ret != MEDIA_CONTENT_ERROR_NONE)
186 g_free(*condition_query);
191 #ifdef _USE_TVPD_MODE
192 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
194 int ret = MEDIA_CONTENT_ERROR_NONE;
195 sqlite3_stmt *stmt = NULL;
196 char *select_query = NULL;
197 char *condition_query = NULL;
198 char *option_query = NULL;
199 filter_s *_filter = (filter_s *)filter;
201 switch (group_type) {
202 case MEDIA_GROUP_ALBUM:
203 if (_filter && STRING_VALID(_filter->storage_id))
204 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, _filter->storage_id);
206 select_query = g_strdup_printf(SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
209 case MEDIA_GROUP_FOLDER:
210 if (_filter && STRING_VALID(_filter->storage_id))
211 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
213 select_query = g_strdup_printf(SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
216 case MEDIA_GROUP_PLAYLIST:
217 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
220 case MEDIA_GROUP_TAG:
221 select_query = g_strdup(SELECT_TAG_COUNT);
224 case MEDIA_GROUP_BOOKMARK:
225 if (_filter && STRING_VALID(_filter->storage_id))
226 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, _filter->storage_id);
228 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
232 case MEDIA_GROUP_FACE:
233 if (_filter && STRING_VALID(_filter->storage_id))
234 select_query = g_strdup_printf(SELECT_FACE_COUNT, _filter->storage_id);
236 select_query = g_strdup_printf(SELECT_FACE_COUNT, DB_VIEW_MEDIA);
240 content_error("Invalid group type [%d]", group_type);
241 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
244 ret = __media_db_make_query(filter, &condition_query, &option_query);
245 if (ret != MEDIA_CONTENT_ERROR_NONE) {
246 g_free(select_query);
250 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
251 g_free(select_query);
252 g_free(condition_query);
253 g_free(option_query);
254 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
256 if (sqlite3_step(stmt) == SQLITE_ROW)
257 *group_count = sqlite3_column_int(stmt, 0);
259 SQLITE3_FINALIZE(stmt);
264 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
266 int ret = MEDIA_CONTENT_ERROR_NONE;
267 sqlite3_stmt *stmt = NULL;
268 char select_query[MAX_QUERY_SIZE] = {0, };
269 char *condition_query = NULL;
270 char *option_query = NULL;
271 char *tmp_option = NULL;
272 filter_s *_filter = (filter_s *)filter;
274 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
275 if (_filter && STRING_VALID(_filter->storage_id))
276 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
278 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
279 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
280 if (_filter && STRING_VALID(_filter->storage_id))
281 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
283 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
284 } else { /*uhd content*/
285 if (_filter && STRING_VALID(_filter->storage_id))
286 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
288 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
290 ret = __media_db_make_query(filter, &condition_query, &option_query);
291 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
294 tmp_option = g_strconcat(option_query, ")", NULL);
295 g_free(option_query);
296 option_query = tmp_option;
298 g_strlcat(select_query, ")", sizeof(select_query));
301 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
302 g_free(condition_query);
303 g_free(option_query);
304 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
306 if (sqlite3_step(stmt) == SQLITE_ROW)
307 *group_count = sqlite3_column_int(stmt, 0);
309 SQLITE3_FINALIZE(stmt);
314 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
316 int ret = MEDIA_CONTENT_ERROR_NONE;
317 char select_query[MAX_QUERY_SIZE] = {0, };
318 char *condition_query = NULL;
319 char *option_query = NULL;
321 sqlite3_stmt *stmt = NULL;
322 filter_s *_filter = (filter_s *)filter;
324 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
325 if (_filter && STRING_VALID(_filter->storage_id))
326 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
328 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
329 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
330 if (_filter && STRING_VALID(_filter->storage_id))
331 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
333 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
334 } else { /* uhd content */
335 if (_filter && STRING_VALID(_filter->storage_id))
336 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
338 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
340 ret = __media_db_make_query(filter, &condition_query, &option_query);
341 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
343 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
344 g_free(condition_query);
345 g_free(option_query);
346 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
348 while (sqlite3_step(stmt) == SQLITE_ROW) {
349 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
351 if (callback(name, user_data) == false) {
359 SQLITE3_FINALIZE(stmt);
364 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
366 int ret = MEDIA_CONTENT_ERROR_NONE;
367 char select_query[DEFAULT_QUERY_SIZE] = {0, };
368 char group_query[DEFAULT_QUERY_SIZE] = {0, };
369 char *condition_query = NULL;
370 char *option_query = NULL;
372 sqlite3_stmt *stmt = NULL;
373 filter_s *_filter = (filter_s *)filter;
375 const char* group_name = __media_db_get_group_name(group);
376 content_retip_if_fail(STRING_VALID(group_name));
378 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
379 if (_filter && STRING_VALID(_filter->storage_id))
380 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
382 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
383 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
384 if (_filter && STRING_VALID(_filter->storage_id))
385 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
387 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
388 } else {/*uhd content*/
389 if (_filter && STRING_VALID(_filter->storage_id))
390 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
392 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
395 ret = __media_db_make_query(filter, &condition_query, &option_query);
396 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
398 if (STRING_VALID(option_query))
399 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
401 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
403 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
404 g_free(condition_query);
405 g_free(option_query);
406 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
408 while (sqlite3_step(stmt) == SQLITE_ROW) {
409 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
411 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
419 SQLITE3_FINALIZE(stmt);
424 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
426 int ret = MEDIA_CONTENT_ERROR_NONE;
427 sqlite3_stmt *stmt = NULL;
428 char *select_query = NULL;
429 char *condition_query = NULL;
430 char *option_query = NULL;
432 switch (group_type) {
433 case MEDIA_GROUP_ALBUM:
434 select_query = g_strdup(SELECT_ALBUM_COUNT);
437 case MEDIA_GROUP_FOLDER:
438 select_query = g_strdup(SELECT_FOLDER_COUNT);
441 case MEDIA_GROUP_PLAYLIST:
442 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
445 case MEDIA_GROUP_TAG:
446 select_query = g_strdup(SELECT_TAG_COUNT);
449 case MEDIA_GROUP_BOOKMARK:
450 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
453 case MEDIA_GROUP_FACE:
454 select_query = g_strdup(SELECT_FACE_COUNT);
458 content_error("Invalid group type [%d]", group_type);
459 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
462 ret = __media_db_make_query(filter, &condition_query, &option_query);
463 if (ret != MEDIA_CONTENT_ERROR_NONE) {
464 g_free(select_query);
468 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
469 g_free(select_query);
470 g_free(condition_query);
471 g_free(option_query);
472 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
474 if (sqlite3_step(stmt) == SQLITE_ROW)
475 *group_count = sqlite3_column_int(stmt, 0);
477 SQLITE3_FINALIZE(stmt);
482 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
484 int ret = MEDIA_CONTENT_ERROR_NONE;
485 sqlite3_stmt *stmt = NULL;
486 char *select_query = NULL;
487 char *condition_query = NULL;
488 char *option_query = NULL;
490 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
492 ret = __media_db_make_query(filter, &condition_query, &option_query);
493 if (ret != MEDIA_CONTENT_ERROR_NONE) {
494 g_free(select_query);
498 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
499 g_free(select_query);
500 g_free(condition_query);
501 g_free(option_query);
502 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
504 if (sqlite3_step(stmt) == SQLITE_ROW)
505 *group_count = sqlite3_column_int(stmt, 0);
507 SQLITE3_FINALIZE(stmt);
512 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
514 int ret = MEDIA_CONTENT_ERROR_NONE;
515 char *select_query = NULL;
516 char *condition_query = NULL;
517 char *option_query = NULL;
519 sqlite3_stmt *stmt = NULL;
521 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
523 ret = __media_db_make_query(filter, &condition_query, &option_query);
524 if (ret != MEDIA_CONTENT_ERROR_NONE) {
525 g_free(select_query);
529 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
530 g_free(select_query);
531 g_free(condition_query);
532 g_free(option_query);
533 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
535 while (sqlite3_step(stmt) == SQLITE_ROW) {
536 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
538 if (callback(name, user_data) == false) {
546 SQLITE3_FINALIZE(stmt);
552 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
554 int ret = MEDIA_CONTENT_ERROR_NONE;
555 char *select_query = NULL;
556 char *condition_query = NULL;
557 char *option_query = NULL;
558 sqlite3_stmt *stmt = NULL;
559 #ifdef _USE_TVPD_MODE
560 filter_s *_filter = (filter_s *)filter;
561 if (_filter && STRING_VALID(_filter->storage_id))
562 select_query = g_strdup_printf(SELECT_ALBUM_LIST, _filter->storage_id);
564 select_query = g_strdup_printf(SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
566 select_query = g_strdup(SELECT_ALBUM_LIST);
568 ret = __media_db_make_query(filter, &condition_query, &option_query);
569 if (ret != MEDIA_CONTENT_ERROR_NONE) {
570 g_free(select_query);
574 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
575 g_free(select_query);
576 g_free(condition_query);
577 g_free(option_query);
578 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
580 while (sqlite3_step(stmt) == SQLITE_ROW) {
581 media_album_s *album = g_new0(media_album_s, 1);
583 album->album_id = sqlite3_column_int(stmt, 0);
584 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
585 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
586 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
588 if (callback((media_album_h)album, user_data) == false) {
589 media_album_destroy((media_album_h)album);
593 media_album_destroy((media_album_h)album);
596 SQLITE3_FINALIZE(stmt);
601 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
603 int ret = MEDIA_CONTENT_ERROR_NONE;
604 char *select_query = NULL;
605 char *condition_query = NULL;
606 char *option_query = NULL;
607 sqlite3_stmt *stmt = NULL;
608 #ifdef _USE_TVPD_MODE
609 filter_s *_filter = (filter_s *)filter;
610 if (_filter && STRING_VALID(_filter->storage_id))
611 select_query = g_strdup_printf(SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
613 select_query = g_strdup_printf(SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
615 select_query = g_strdup(SELECT_FOLDER_LIST);
617 ret = __media_db_make_query(filter, &condition_query, &option_query);
618 if (ret != MEDIA_CONTENT_ERROR_NONE) {
619 g_free(select_query);
623 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
624 g_free(select_query);
625 g_free(condition_query);
626 g_free(option_query);
627 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
629 while (sqlite3_step(stmt) == SQLITE_ROW) {
630 media_folder_s *_folder = g_new0(media_folder_s, 1);
631 _folder->folder_id = g_strdup_printf("%lld", sqlite3_column_int64(stmt, 0));
632 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
633 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
634 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 3));
636 if (callback((media_folder_h)_folder, user_data) == false) {
637 media_folder_destroy((media_folder_h) _folder);
641 media_folder_destroy((media_folder_h) _folder);
644 SQLITE3_FINALIZE(stmt);
649 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
651 int ret = MEDIA_CONTENT_ERROR_NONE;
652 char *condition_query = NULL;
653 char *option_query = NULL;
654 sqlite3_stmt *stmt = NULL;
656 ret = __media_db_make_query(filter, &condition_query, &option_query);
657 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
659 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
660 g_free(condition_query);
661 g_free(option_query);
662 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
664 while (sqlite3_step(stmt) == SQLITE_ROW) {
665 media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
667 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
668 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
669 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
671 if (callback((media_playlist_h)_playlist, user_data) == false) {
672 media_playlist_destroy((media_playlist_h)_playlist);
675 media_playlist_destroy((media_playlist_h)_playlist);
678 SQLITE3_FINALIZE(stmt);
683 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
685 int ret = MEDIA_CONTENT_ERROR_NONE;
686 char *select_query = NULL;
687 char *condition_query = NULL;
688 char *option_query = NULL;
689 sqlite3_stmt *stmt = NULL;
691 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
693 ret = __media_db_make_query(filter, &condition_query, &option_query);
694 if (ret != MEDIA_CONTENT_ERROR_NONE) {
695 g_free(select_query);
699 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
700 g_free(select_query);
701 g_free(condition_query);
702 g_free(option_query);
703 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
705 while (sqlite3_step(stmt) == SQLITE_ROW) {
706 int playlist_member_id = 0;
707 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
709 media_info_s *_media = g_new0(media_info_s, 1);
711 _media_info_item_get_detail(stmt, (media_info_h)_media);
713 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
714 media_info_destroy((media_info_h)_media);
717 media_info_destroy((media_info_h)_media);
721 SQLITE3_FINALIZE(stmt);
726 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
728 int ret = MEDIA_CONTENT_ERROR_NONE;
729 char *select_query = NULL;
730 char *condition_query = NULL;
731 char *option_query = NULL;
732 sqlite3_stmt *stmt = NULL;
734 if (STRING_VALID(media_id))
735 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
737 select_query = g_strdup(SELECT_TAG_LIST);
739 ret = __media_db_make_query(filter, &condition_query, &option_query);
740 if (ret != MEDIA_CONTENT_ERROR_NONE) {
741 g_free(select_query);
745 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
746 g_free(select_query);
747 g_free(condition_query);
748 g_free(option_query);
749 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
751 while (sqlite3_step(stmt) == SQLITE_ROW) {
752 media_tag_s *_tag = g_new0(media_tag_s, 1);
754 _tag->tag_id = sqlite3_column_int(stmt, 0);
755 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
757 if (callback((media_tag_h)_tag, user_data) == false) {
758 media_tag_destroy((media_tag_h)_tag);
761 media_tag_destroy((media_tag_h)_tag);
764 SQLITE3_FINALIZE(stmt);
769 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
771 int ret = MEDIA_CONTENT_ERROR_NONE;
772 char *select_query = NULL;
773 char *condition_query = NULL;
774 char *option_query = NULL;
775 sqlite3_stmt *stmt = NULL;
776 #ifdef _USE_TVPD_MODE
777 filter_s *_filter = (filter_s *)filter;
778 if (STRING_VALID(media_id)) { //get bookmark by media_id
779 if (_filter && STRING_VALID(_filter->storage_id))
780 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
782 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
784 if (_filter && STRING_VALID(_filter->storage_id))
785 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, _filter->storage_id);
787 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
790 if (STRING_VALID(media_id))
791 select_query = g_strdup_printf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
793 select_query = g_strdup(SELECT_BOOKMARK_LIST);
796 ret = __media_db_make_query(filter, &condition_query, &option_query);
797 if (ret != MEDIA_CONTENT_ERROR_NONE) {
798 g_free(select_query);
802 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
803 g_free(select_query);
804 g_free(condition_query);
805 g_free(option_query);
806 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
808 while (sqlite3_step(stmt) == SQLITE_ROW) {
809 media_bookmark_s *bookmark = g_new0(media_bookmark_s, 1);
811 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
812 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
813 bookmark->marked_time = sqlite3_column_int(stmt, 2);
814 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
815 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
817 if (callback((media_bookmark_h)bookmark, user_data) == false) {
818 media_bookmark_destroy((media_bookmark_h)bookmark);
822 media_bookmark_destroy((media_bookmark_h)bookmark);
825 SQLITE3_FINALIZE(stmt);
831 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
833 int ret = MEDIA_CONTENT_ERROR_NONE;
834 char *select_query = NULL;
835 char *condition_query = NULL;
836 char *option_query = NULL;
837 sqlite3_stmt *stmt = NULL;
838 #ifdef _USE_TVPD_MODE
839 filter_s *_filter = (filter_s *)filter;
840 if (STRING_VALID(media_id)) { //get face by media_id
841 if (_filter && STRING_VALID(_filter->storage_id))
842 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
844 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
846 if (_filter && STRING_VALID(_filter->storage_id))
847 select_query = g_strdup_printf(SELECT_FACE_LIST, _filter->storage_id);
849 select_query = g_strdup_printf(SELECT_FACE_LIST, DB_VIEW_MEDIA);
852 if (STRING_VALID(media_id))
853 select_query = g_strdup_printf(SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
855 select_query = g_strdup(SELECT_FACE_LIST);
857 ret = __media_db_make_query(filter, &condition_query, &option_query);
858 if (ret != MEDIA_CONTENT_ERROR_NONE) {
859 g_free(select_query);
863 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
864 g_free(select_query);
865 g_free(condition_query);
866 g_free(option_query);
867 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
869 while (sqlite3_step(stmt) == SQLITE_ROW) {
870 media_face_s *face = g_new0(media_face_s, 1);
872 face->face_id = sqlite3_column_int(stmt, 0);
873 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
874 face->face_rect_x = sqlite3_column_int(stmt, 2);
875 face->face_rect_y = sqlite3_column_int(stmt, 3);
876 face->face_rect_w = sqlite3_column_int(stmt, 4);
877 face->face_rect_h = sqlite3_column_int(stmt, 5);
878 face->orientation = sqlite3_column_int(stmt, 6);
879 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
881 if (callback((media_face_h)face, user_data) == false) {
882 media_face_destroy((media_face_h)face);
886 media_face_destroy((media_face_h)face);
889 SQLITE3_FINALIZE(stmt);
895 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
897 int ret = MEDIA_CONTENT_ERROR_NONE;
898 sqlite3_stmt *stmt = NULL;
899 char *select_query = NULL;
900 char *condition_query = NULL;
901 char *option_query = NULL;
902 #ifdef _USE_TVPD_MODE
903 filter_s *_filter = (filter_s *)filter;
905 switch (group_type) {
906 case MEDIA_GROUP_ALBUM:
907 #ifdef _USE_TVPD_MODE
908 if (_filter && STRING_VALID(_filter->storage_id))
909 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
911 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
913 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
917 case MEDIA_GROUP_PLAYLIST:
918 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
921 case MEDIA_GROUP_TAG:
922 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_TAG, group_id);
926 content_error("INVALID_PARAMETER");
927 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
930 ret = __media_db_make_query(filter, &condition_query, &option_query);
931 if (ret != MEDIA_CONTENT_ERROR_NONE) {
932 g_free(select_query);
936 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
937 g_free(select_query);
938 g_free(condition_query);
939 g_free(option_query);
940 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
942 if (sqlite3_step(stmt) == SQLITE_ROW)
943 *item_count = sqlite3_column_int(stmt, 0);
945 SQLITE3_FINALIZE(stmt);
950 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
952 int ret = MEDIA_CONTENT_ERROR_NONE;
953 sqlite3_stmt *stmt = NULL;
954 char *select_query = NULL;
955 char *condition_query = NULL;
956 char *option_query = NULL;
957 char *tmp_option = NULL;
958 bool need_bracket = false;
959 filter_s *_filter = (filter_s *)filter;
961 switch (group_type) {
962 case MEDIA_GROUP_NONE:
964 #ifdef _USE_TVPD_MODE
965 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
967 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
972 if (_filter->offset < 0 && _filter->count < 0) {
973 #ifdef _USE_TVPD_MODE
974 if (STRING_VALID(_filter->storage_id))
975 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
977 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
979 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
982 #ifdef _USE_TVPD_MODE
983 if (STRING_VALID(_filter->storage_id))
984 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
986 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
988 select_query = g_strdup(SELECT_MEDIA_COUNT_FROM_MEDIA);
994 case MEDIA_GROUP_FOLDER:
995 #ifdef _USE_TVPD_MODE
996 if (_filter && STRING_VALID(_filter->storage_id))
997 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
999 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1001 select_query = g_strdup_printf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1005 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1006 select_query = g_strdup_printf(SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1009 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1010 #ifdef _USE_TVPD_MODE
1011 if (_filter && STRING_VALID(_filter->storage_id))
1012 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1014 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1016 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1020 case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1021 #ifdef _USE_TVPD_MODE
1022 if (_filter && STRING_VALID(_filter->storage_id))
1023 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1025 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1027 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1032 content_error("INVALID_PARAMETER");
1033 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1036 ret = __media_db_make_query(filter, &condition_query, &option_query);
1037 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1038 g_free(select_query);
1043 tmp_option = g_strconcat(option_query, ")", NULL);
1044 g_free(option_query);
1045 option_query = tmp_option;
1048 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1049 g_free(select_query);
1050 g_free(condition_query);
1051 g_free(option_query);
1052 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1054 if (sqlite3_step(stmt) == SQLITE_ROW)
1055 *item_count = sqlite3_column_int(stmt, 0);
1057 SQLITE3_FINALIZE(stmt);
1062 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)
1064 int ret = MEDIA_CONTENT_ERROR_NONE;
1065 char *select_query = NULL;
1066 char *condition_query = NULL;
1067 char *option_query = NULL;
1068 sqlite3_stmt *stmt = NULL;
1069 #ifdef _USE_TVPD_MODE
1070 filter_s *_filter = (filter_s *)filter;
1073 switch (group_type) {
1074 case MEDIA_GROUP_ALBUM:
1075 #ifdef _USE_TVPD_MODE
1076 if (_filter && STRING_VALID(_filter->storage_id))
1077 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1079 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1081 select_query = g_strdup_printf(SELECT_MEDIA_FROM_ALBUM, group_id);
1085 case MEDIA_GROUP_PLAYLIST:
1086 #ifdef _USE_TVPD_MODE
1087 if (_filter && STRING_VALID(_filter->storage_id))
1088 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1090 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1092 select_query = g_strdup_printf(SELECT_MEDIA_FROM_PLAYLIST, group_id);
1096 case MEDIA_GROUP_TAG:
1097 #ifdef _USE_TVPD_MODE
1098 if (_filter && STRING_VALID(_filter->storage_id))
1099 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1101 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1103 select_query = g_strdup_printf(SELECT_MEDIA_FROM_TAG, group_id);
1108 content_error("INVALID_PARAMETER");
1109 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1112 ret = __media_db_make_query(filter, &condition_query, &option_query);
1113 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1114 g_free(select_query);
1118 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1119 g_free(select_query);
1120 g_free(condition_query);
1121 g_free(option_query);
1122 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1124 while (sqlite3_step(stmt) == SQLITE_ROW) {
1125 media_info_s *item = g_new0(media_info_s, 1);
1127 _media_info_item_get_detail(stmt, (media_info_h)item);
1129 if (callback((media_info_h)item, user_data) == false) {
1130 media_info_destroy((media_info_h)item);
1134 media_info_destroy((media_info_h)item);
1137 SQLITE3_FINALIZE(stmt);
1142 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)
1144 int ret = MEDIA_CONTENT_ERROR_NONE;
1145 char *select_query = NULL;
1146 char *condition_query = NULL;
1147 char *option_query = NULL;
1148 sqlite3_stmt *stmt = NULL;
1149 #ifdef _USE_TVPD_MODE
1150 filter_s *_filter = (filter_s *)filter;
1153 switch (group_type) {
1154 case MEDIA_GROUP_NONE:
1155 #ifdef _USE_TVPD_MODE
1156 if (_filter && STRING_VALID(_filter->storage_id))
1157 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, _filter->storage_id);
1159 select_query = g_strdup_printf(SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1161 select_query = g_strdup(SELECT_MEDIA_ITEM);
1165 case MEDIA_GROUP_FOLDER:
1166 #ifdef _USE_TVPD_MODE
1167 if (_filter && STRING_VALID(_filter->storage_id))
1168 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1170 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1172 select_query = g_strdup_printf(SELECT_MEDIA_FROM_FOLDER, group_name);
1177 content_error("INVALID_PARAMETER");
1178 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1181 ret = __media_db_make_query(filter, &condition_query, &option_query);
1182 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1183 g_free(select_query);
1187 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1188 g_free(select_query);
1189 g_free(condition_query);
1190 g_free(option_query);
1191 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1193 while (sqlite3_step(stmt) == SQLITE_ROW) {
1194 media_info_s *item = g_new0(media_info_s, 1);
1196 _media_info_item_get_detail(stmt, (media_info_h)item);
1198 if (callback((media_info_h)item, user_data) == false) {
1199 media_info_destroy((media_info_h)item);
1203 media_info_destroy((media_info_h)item);
1206 SQLITE3_FINALIZE(stmt);
1211 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1213 int ret = MEDIA_CONTENT_ERROR_NONE;
1214 sqlite3_stmt *stmt = NULL;
1215 char select_query[MAX_QUERY_SIZE] = {0, };
1216 char *tmp_option = NULL;
1217 char *condition_query = NULL;
1218 char *option_query = NULL;
1219 #ifdef _USE_TVPD_MODE
1220 filter_s *_filter = (filter_s *)filter;
1221 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1223 if (_filter && STRING_VALID(_filter->storage_id))
1224 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1226 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1228 if (_filter && STRING_VALID(_filter->storage_id))
1229 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1231 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1233 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1235 if (_filter && STRING_VALID(_filter->storage_id))
1236 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1238 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1240 if (_filter && STRING_VALID(_filter->storage_id))
1241 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1243 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1245 } else {/*uhd content*/
1247 if (_filter && STRING_VALID(_filter->storage_id))
1248 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1250 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1252 if (_filter && STRING_VALID(_filter->storage_id))
1253 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1255 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1260 sqlite3_snprintf(MAX_QUERY_SIZE, select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1262 snprintf(select_query, MAX_QUERY_SIZE, SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1264 ret = __media_db_make_query(filter, &condition_query, &option_query);
1265 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1267 /* If 'filter' is not NULL, 'option_query' must be created. */
1269 tmp_option = g_strconcat(option_query, ")", NULL);
1270 g_free(option_query);
1271 option_query = tmp_option;
1273 g_strlcat(select_query, ")", sizeof(select_query));
1276 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1277 g_free(condition_query);
1278 g_free(option_query);
1279 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1281 if (sqlite3_step(stmt) == SQLITE_ROW)
1282 *item_count = sqlite3_column_int(stmt, 0);
1284 SQLITE3_FINALIZE(stmt);
1289 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)
1291 int ret = MEDIA_CONTENT_ERROR_NONE;
1292 char select_query[MAX_QUERY_SIZE] = {0, };
1293 char *condition_query = NULL;
1294 char *option_query = NULL;
1295 sqlite3_stmt *stmt = NULL;
1296 #ifdef _USE_TVPD_MODE
1297 filter_s *_filter = (filter_s *)filter;
1299 if (_filter && STRING_VALID(_filter->storage_id))
1300 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1302 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1304 if (_filter && STRING_VALID(_filter->storage_id))
1305 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1307 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1311 sqlite3_snprintf(MAX_QUERY_SIZE, select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1313 snprintf(select_query, MAX_QUERY_SIZE, SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1315 ret = __media_db_make_query(filter, &condition_query, &option_query);
1316 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1318 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1319 g_free(condition_query);
1320 g_free(option_query);
1321 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1323 while (sqlite3_step(stmt) == SQLITE_ROW) {
1324 media_info_s *item = g_new0(media_info_s, 1);
1326 _media_info_item_get_detail(stmt, (media_info_h)item);
1328 if (callback((media_info_h)item, user_data) == false) {
1329 media_info_destroy((media_info_h)item);
1333 media_info_destroy((media_info_h)item);
1336 SQLITE3_FINALIZE(stmt);
1341 #ifdef _USE_TVPD_MODE
1342 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1344 int ret = MEDIA_CONTENT_ERROR_NONE;
1345 sqlite3_stmt *stmt = NULL;
1346 char *select_query = NULL;
1348 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1350 ret = _content_get_result(select_query, &stmt);
1351 SQLITE3_SAFE_FREE(select_query);
1352 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1354 if (sqlite3_step(stmt) == SQLITE_ROW) {
1355 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1357 content_error("Invalid media_id[%s]", media_id);
1358 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1361 SQLITE3_FINALIZE(stmt);
1367 MEDIA_PVR_MEDIA_ID = 0,
1368 MEDIA_PVR_STORAGE_ID,
1372 MEDIA_PVR_TIME_ZONE,
1376 MEDIA_PVR_CHANNEL_TYPE,
1377 MEDIA_PVR_CHANNEL_NAME,
1378 MEDIA_PVR_CHANNEL_NUM,
1379 MEDIA_PVR_SERVICE_PROFILE,
1380 MEDIA_PVR_PROGRAM_TITLE,
1381 MEDIA_PVR_PROGRAM_NUM,
1382 MEDIA_PVR_PROGRAM_CRID,
1387 MEDIA_PVR_EMBARGO_TIME,
1388 MEDIA_PVR_EXPIRY_TIME,
1389 MEDIA_PVR_START_TIME,
1390 MEDIA_PVR_PROGRAM_START_TIME,
1391 MEDIA_PVR_PROGRAM_END_TIME,
1392 MEDIA_PVR_PROGRAM_DATE,
1393 MEDIA_PVR_PARENTAL_RATING,
1394 MEDIA_PVR_TIMER_RECORD,
1395 MEDIA_PVR_SERIES_RECORD,
1400 MEDIA_PVR_HARDOF_HEARINGRADIO,
1401 MEDIA_PVR_DATA_SERVICE,
1402 MEDIA_PVR_CONTENT_LOCK,
1403 MEDIA_PVR_CONTENT_WATCH,
1404 MEDIA_PVR_HAS_AUDIO_ONLY,
1405 MEDIA_PVR_IS_LOCAL_RECORDED,
1406 MEDIA_PVR_RESOLUTION,
1407 MEDIA_PVR_ASPECTRATIO,
1408 MEDIA_PVR_MODIFIED_MONTH,
1409 MEDIA_PVR_SPORTS_TYPE,
1410 MEDIA_PVR_GUIDANCE_LENGTH,
1412 MEDIA_PVR_PLAY_COUNT,
1413 MEDIA_PVR_PRIVATE_DATA,
1414 } media_pvr_field_e;
1416 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1418 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1420 _pvr->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1421 _pvr->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1422 _pvr->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1423 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1424 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1425 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1426 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1427 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1428 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1429 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1430 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1431 _pvr->channel_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1432 _pvr->channel_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1433 _pvr->program_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1434 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1435 _pvr->program_crid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1436 _pvr->guidance = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1437 _pvr->synopsis = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1438 _pvr->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1439 _pvr->language = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1440 _pvr->modified_month = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1441 _pvr->private_data = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1442 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1443 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1444 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1445 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1446 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1447 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1448 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1449 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1450 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1451 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1452 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1453 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1454 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1455 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1456 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1457 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1458 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1459 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1460 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1461 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1462 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1463 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1464 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1465 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1466 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1471 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1473 int ret = MEDIA_CONTENT_ERROR_NONE;
1474 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1475 char *condition_query = NULL;
1476 char *option_query = NULL;
1477 sqlite3_stmt *stmt = NULL;
1478 filter_s *_filter = (filter_s *)filter;
1480 if (_filter && STRING_VALID(_filter->storage_id))
1481 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1483 g_strlcat(select_query, SELECT_PVR_LIST, sizeof(select_query));
1485 ret = __media_db_make_query(filter, &condition_query, &option_query);
1486 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1488 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1489 g_free(condition_query);
1490 g_free(option_query);
1491 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1493 while (sqlite3_step(stmt) == SQLITE_ROW) {
1494 media_pvr_s *_pvr = g_new0(media_pvr_s, 1);
1496 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1498 if (callback((media_pvr_h)_pvr, user_data) == false) {
1499 media_pvr_destroy((media_pvr_h) _pvr);
1503 media_pvr_destroy((media_pvr_h) _pvr);
1506 SQLITE3_FINALIZE(stmt);
1512 MEDIA_UHD_MEDIA_ID = 0,
1513 MEDIA_UHD_STORAGE_ID,
1516 MEDIA_UHD_CONTENT_ID,
1517 MEDIA_UHD_CONTENT_TITLE,
1518 MEDIA_UHD_FILE_NAME,
1519 MEDIA_UHD_FOLDER_ID,
1520 MEDIA_UHD_RELEASE_DATE,
1521 MEDIA_UHD_MODIFIED_TIME,
1522 MEDIA_UHD_PLAYED_POSITION,
1523 MEDIA_UHD_PLAYED_COUNT,
1524 } media_uhd_field_e;
1526 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1528 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1530 _uhd->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1531 _uhd->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1532 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1533 _uhd->content_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1534 _uhd->content_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1535 _uhd->file_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1536 _uhd->release_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1537 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1538 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1539 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1544 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1546 int ret = MEDIA_CONTENT_ERROR_NONE;
1547 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1548 char *condition_query = NULL;
1549 char *option_query = NULL;
1550 sqlite3_stmt *stmt = NULL;
1551 filter_s *_filter = (filter_s *)filter;
1553 if (_filter && STRING_VALID(_filter->storage_id))
1554 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1556 g_strlcat(select_query, SELECT_UHD_LIST, sizeof(select_query));
1558 ret = __media_db_make_query(filter, &condition_query, &option_query);
1559 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1561 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1562 g_free(condition_query);
1563 g_free(option_query);
1564 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1566 while (sqlite3_step(stmt) == SQLITE_ROW) {
1567 media_uhd_s *_uhd = g_new0(media_uhd_s, 1);
1569 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1571 if (callback((media_uhd_h)_uhd, user_data) == false) {
1572 media_uhd_destroy((media_uhd_h) _uhd);
1575 media_uhd_destroy((media_uhd_h) _uhd);
1578 SQLITE3_FINALIZE(stmt);
1583 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1585 int ret = MEDIA_CONTENT_ERROR_NONE;
1586 char *condition_query = NULL;
1587 char *option_query = NULL;
1588 sqlite3_stmt *stmt = NULL;
1590 ret = __media_db_make_query(filter, &condition_query, &option_query);
1591 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1593 ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1594 g_free(condition_query);
1595 g_free(option_query);
1596 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1598 while (sqlite3_step(stmt) == SQLITE_ROW) {
1599 media_storage_s *_storage = g_new0(media_storage_s, 1);
1601 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1602 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1604 if (callback((media_storage_h)_storage, user_data) == false) {
1605 media_storage_destroy((media_storage_h) _storage);
1609 media_storage_destroy((media_storage_h) _storage);
1612 SQLITE3_FINALIZE(stmt);