src/media_content.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   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
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  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.
  15 */
  16
  17
  18 #include <media_content.h>
  19 #include <media_info_private.h>
  20 #include <media_util_private.h>
  21 #include <media_content_internal.h>
  22
  23 #include <unicode/uscript.h>
  24 #include <unicode/uloc.h>
  25 #include <unicode/ucol.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30
  31 static attribute_h g_attr_handle = NULL;
  32 static attribute_h g_alias_attr_handle = NULL;
  33 static MediaSvcHandle *db_handle = NULL;
  34 static int ref_count = 0;
  35 static GMutex db_mutex;
  36
  37 static __thread media_noti_cb_s *g_noti_info = NULL;
  38
  39 static int __media_content_create_attr_handle(void);
  40 static int __media_content_create_alias_attr_handle(void);
  41 static int __media_content_create_attribute_handle(void);
  42 static int __media_content_destroy_attribute_handle(void);
  43
  44 static int __media_content_create_attr_handle(void)
  45 {
  46         int ret = MEDIA_CONTENT_ERROR_NONE;
  47
  48         ret = _media_filter_attribute_create(&g_attr_handle);
  49         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  50
  51         /* Media Info */
  52         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ID, DB_FIELD_MEDIA_ID);
  53         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  54
  55         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_PATH, DB_FIELD_MEDIA_PATH);
  56         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  57
  58         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_DISPLAY_NAME, DB_FIELD_MEDIA_DISPLAY_NAME);
  59         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  60
  61         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_TYPE, DB_FIELD_MEDIA_TYPE);
  62         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  63
  64         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_MIME_TYPE, DB_FIELD_MEDIA_MIME_TYPE);
  65         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  66
  67         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_SIZE, DB_FIELD_MEDIA_SIZE);
  68         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  69
  70         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ADDED_TIME, DB_FIELD_MEDIA_ADDED_TIME);
  71         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  72
  73         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_MODIFIED_TIME, DB_FIELD_MEDIA_MODIFIED_TIME);
  74         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  75
  76         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_TIMELINE, DB_FIELD_MEDIA_TIMELINE);
  77         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  78
  79         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_THUMBNAIL_PATH, DB_FIELD_MEDIA_THUMBNAIL_PATH);
  80         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  81
  82         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_TITLE, DB_FIELD_MEDIA_TITLE);
  83         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  84
  85         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ALBUM, DB_FIELD_MEDIA_ALBUM);
  86         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  87
  88         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ARTIST, DB_FIELD_MEDIA_ARTIST);
  89         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  90
  91         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ALBUM_ARTIST, DB_FIELD_MEDIA_ALBUM_ARTIST);
  92         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  93
  94         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_GENRE, DB_FIELD_MEDIA_GENRE);
  95         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  96
  97         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_COMPOSER, DB_FIELD_MEDIA_COMPOSER);
  98         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  99
 100         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_YEAR, DB_FIELD_MEDIA_YEAR);
 101         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 102
 103         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_RECORDED_DATE, DB_FIELD_MEDIA_RECORDED_DATE);
 104         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 105
 106         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_COPYRIGHT, DB_FIELD_MEDIA_COPYRIGHT);
 107         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 108
 109         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_TRACK_NUM, DB_FIELD_MEDIA_TRACK_NUM);
 110         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 111
 112         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_DESCRIPTION, DB_FIELD_MEDIA_DESCRIPTION);
 113         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 114
 115         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_BITRATE, DB_FIELD_MEDIA_BITRATE);
 116         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 117
 118         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_BITPERSAMPLE, DB_FIELD_MEDIA_BITPERSAMPLE);
 119         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 120
 121         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_SAMPLERATE, DB_FIELD_MEDIA_SAMPLERATE);
 122         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 123
 124         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_CHANNEL, DB_FIELD_MEDIA_CHANNEL);
 125         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 126
 127         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_DURATION, DB_FIELD_MEDIA_DURATION);
 128         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 129
 130         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_LONGITUDE, DB_FIELD_MEDIA_LONGITUDE);
 131         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 132
 133         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_LATITUDE, DB_FIELD_MEDIA_LATITUDE);
 134         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 135
 136         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ALTITUDE, DB_FIELD_MEDIA_ALTITUDE);
 137         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 138
 139         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_WIDTH, DB_FIELD_MEDIA_WIDTH);
 140         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 141
 142         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_HEIGHT, DB_FIELD_MEDIA_HEIGHT);
 143         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 144
 145         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_DATETAKEN, DB_FIELD_MEDIA_DATETAKEN);
 146         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 147
 148         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ORIENTATION, DB_FIELD_MEDIA_ORIENTATION);
 149         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 150
 151         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_BURST_ID, DB_FIELD_MEDIA_BURST_ID);
 152         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 153
 154         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_PLAYED_COUNT, DB_FIELD_MEDIA_PLAYED_COUNT);
 155         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 156
 157         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_LAST_PLAYED_TIME, DB_FIELD_MEDIA_LAST_PLAYED_TIME);
 158         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 159
 160         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_LAST_PLAYED_POSITION, DB_FIELD_MEDIA_LAST_PLAYED_POSITION);
 161         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 162
 163         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_RATING, DB_FIELD_MEDIA_RATING);
 164         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 165
 166         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_FAVOURITE, DB_FIELD_MEDIA_FAVOURITE);
 167         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 168
 169         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_AUTHOR, DB_FIELD_MEDIA_AUTHOR);
 170         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 171
 172         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_PROVIDER, DB_FIELD_MEDIA_PROVIDER);
 173         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 174
 175         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_CONTENT_NAME, DB_FIELD_MEDIA_CONTENT_NAME);
 176         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 177
 178         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_CATEGORY, DB_FIELD_MEDIA_CATEGORY);
 179         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 180
 181         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_LOCATION_TAG, DB_FIELD_MEDIA_LOCATION_TAG);
 182         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 183
 184         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_AGE_RATING, DB_FIELD_MEDIA_AGE_RATING);
 185         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 186
 187         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_KEYWORD, DB_FIELD_MEDIA_KEYWORD);
 188         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 189
 190         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_WEATHER, DB_FIELD_MEDIA_WEATHER);
 191         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 192
 193         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_IS_DRM, DB_FIELD_MEDIA_IS_DRM);
 194         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 195
 196         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_STORAGE_TYPE, DB_FIELD_MEDIA_STORAGE_TYPE);
 197         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 198
 199         /* Pinyin*/
 200         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_FILE_NAME_PINYIN, DB_FIELD_MEDIA_FILE_NAME_PINYIN);
 201         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 202
 203         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_TITLE_PINYIN, DB_FIELD_MEDIA_TITLE_PINYIN);
 204         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 205
 206         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ALBUM_PINYIN, DB_FIELD_MEDIA_ALBUM_PINYIN);
 207         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 208
 209         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ARTIST_PINYIN, DB_FIELD_MEDIA_ARTIST_PINYIN);
 210         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 211
 212         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ALBUM_ARTIST_PINYIN, DB_FIELD_MEDIA_ALBUM_ARTIST_PINYIN);
 213         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 214
 215         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_GENRE_PINYIN, DB_FIELD_MEDIA_GENRE_PINYIN);
 216         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 217
 218         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_COMPOSER_PINYIN, DB_FIELD_MEDIA_COMPOSER_PINYIN);
 219         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 220
 221         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_COPYRIGHT_PINYIN, DB_FIELD_MEDIA_COPYRIGHT_PINYIN);
 222         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 223
 224         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_DESCRIPTION_PINYIN, DB_FIELD_MEDIA_DESCRIPTION_PINYIN);
 225         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 226
 227         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_AUTHOR_PINYIN, DB_FIELD_MEDIA_AUTHOR_PINYIN);
 228         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 229
 230         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_PROVIDER_PINYIN, DB_FIELD_MEDIA_PROVIDER_PINYIN);
 231         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 232
 233         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_CONTENT_NAME_PINYIN, DB_FIELD_MEDIA_CONTENT_NAME_PINYIN);
 234         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 235
 236         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_CATEGORY_PINYIN, DB_FIELD_MEDIA_CATEGORY_PINYIN);
 237         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 238
 239         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_LOCATION_TAG_PINYIN, DB_FIELD_MEDIA_LOCATION_TAG_PINYIN);
 240         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 241
 242         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_AGE_RATING_PINYIN, DB_FIELD_MEDIA_AGE_RATING_PINYIN);
 243         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 244
 245         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_KEYWORD_PINYIN, DB_FIELD_MEDIA_KEYWORD_PINYIN);
 246         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 247
 248         /* Playlist*/
 249         ret = _media_filter_attribute_add(g_attr_handle, PLAYLIST_NAME, DB_FIELD_PLAYLIST_NAME);
 250         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 251
 252         ret = _media_filter_attribute_add(g_attr_handle, PLAYLIST_MEMBER_ORDER, DB_FIELD_PLAYLIST_MEMBER_ORDER);
 253         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 254
 255         /* Playlist View */
 256         ret = _media_filter_attribute_add(g_attr_handle, PLAYLIST_MEDIA_COUNT, DB_FIELD_PLAYLIST_MEDIA_COUNT);
 257         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 258
 259         /* Tag*/
 260         ret = _media_filter_attribute_add(g_attr_handle, TAG_NAME, DB_FIELD_TAG_NAME);
 261         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 262
 263         /* Tag View */
 264         ret = _media_filter_attribute_add(g_attr_handle, TAG_MEDIA_COUNT, DB_FIELD_TAG_MEDIA_COUNT);
 265         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 266
 267         /* Bookmark*/
 268         ret = _media_filter_attribute_add(g_attr_handle, BOOKMARK_MARKED_TIME, DB_FIELD_BOOKMARK_MARKED_TIME);
 269         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 270
 271         /* Storage*/
 272         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_STORAGE_ID, DB_FIELD_STORAGE_ID);
 273         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 274
 275         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_STORAGE_PATH, DB_FIELD_STORAGE_PATH);
 276         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 277
 278         /* Face */
 279         ret = _media_filter_attribute_add(g_attr_handle, MEDIA_FACE_TAG, DB_FIELD_FACE_TAG);
 280         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 281
 282         return ret;
 283 }
 284
 285 static int __media_content_create_alias_attr_handle(void)
 286 {
 287         int ret = MEDIA_CONTENT_ERROR_NONE;
 288
 289         ret = _media_filter_attribute_create(&g_alias_attr_handle);
 290         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 291
 292         /* Media Info */
 293         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ID, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ID);
 294         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 295
 296         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_PATH, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_PATH);
 297         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 298
 299         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_DISPLAY_NAME, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_DISPLAY_NAME);
 300         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 301
 302         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_TYPE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_TYPE);
 303         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 304
 305         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_MIME_TYPE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_MIME_TYPE);
 306         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 307
 308         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_SIZE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_SIZE);
 309         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 310
 311         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ADDED_TIME, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ADDED_TIME);
 312         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 313
 314         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_MODIFIED_TIME, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_MODIFIED_TIME);
 315         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 316
 317         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_TIMELINE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_TIMELINE);
 318         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 319
 320         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_THUMBNAIL_PATH, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_THUMBNAIL_PATH);
 321         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 322
 323         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_TITLE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_TITLE);
 324         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 325
 326         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ALBUM, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ALBUM);
 327         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 328
 329         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ARTIST, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ARTIST);
 330         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 331
 332         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ALBUM_ARTIST, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ALBUM_ARTIST);
 333         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 334
 335         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_GENRE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_GENRE);
 336         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 337
 338         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_COMPOSER, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_COMPOSER);
 339         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 340
 341         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_YEAR, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_YEAR);
 342         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 343
 344         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_RECORDED_DATE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_RECORDED_DATE);
 345         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 346
 347         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_COPYRIGHT, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_COPYRIGHT);
 348         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 349
 350         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_TRACK_NUM, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_TRACK_NUM);
 351         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 352
 353         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_DESCRIPTION, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_DESCRIPTION);
 354         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 355
 356         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_BITRATE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_BITRATE);
 357         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 358
 359         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_BITPERSAMPLE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_BITPERSAMPLE);
 360         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 361
 362         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_SAMPLERATE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_SAMPLERATE);
 363         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 364
 365         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_CHANNEL, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_CHANNEL);
 366         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 367
 368         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_DURATION, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_DURATION);
 369         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 370
 371         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_LONGITUDE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_LONGITUDE);
 372         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 373
 374         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_LATITUDE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_LATITUDE);
 375         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 376
 377         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ALTITUDE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ALTITUDE);
 378         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 379
 380         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_WIDTH, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_WIDTH);
 381         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 382
 383         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_HEIGHT, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_HEIGHT);
 384         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 385
 386         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_DATETAKEN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_DATETAKEN);
 387         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 388
 389         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ORIENTATION, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ORIENTATION);
 390         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 391
 392         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_BURST_ID, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_BURST_ID);
 393         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 394
 395         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_PLAYED_COUNT, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_PLAYED_COUNT);
 396         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 397
 398         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_LAST_PLAYED_TIME, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_LAST_PLAYED_TIME);
 399         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 400
 401         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_LAST_PLAYED_POSITION, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_LAST_PLAYED_POSITION);
 402         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 403
 404         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_RATING, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_RATING);
 405         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 406
 407         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_FAVOURITE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_FAVOURITE);
 408         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 409
 410         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_AUTHOR, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_AUTHOR);
 411         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 412
 413         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_PROVIDER, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_PROVIDER);
 414         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 415
 416         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_CONTENT_NAME, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_CONTENT_NAME);
 417         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 418
 419         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_CATEGORY, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_CATEGORY);
 420         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 421
 422         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_LOCATION_TAG, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_LOCATION_TAG);
 423         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 424
 425         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_AGE_RATING, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_AGE_RATING);
 426         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 427
 428         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_KEYWORD, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_KEYWORD);
 429         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 430
 431         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_WEATHER, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_WEATHER);
 432         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 433
 434         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_IS_DRM, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_IS_DRM);
 435         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 436
 437         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_STORAGE_TYPE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_STORAGE_TYPE);
 438         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 439
 440         /* Pinyin*/
 441         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_FILE_NAME_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_FILE_NAME_PINYIN);
 442         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 443
 444         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_TITLE_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_TITLE_PINYIN);
 445         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 446
 447         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ALBUM_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ALBUM_PINYIN);
 448         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 449
 450         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ARTIST_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ARTIST_PINYIN);
 451         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 452
 453         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ALBUM_ARTIST_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ALBUM_ARTIST_PINYIN);
 454         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 455
 456         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_GENRE_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_GENRE_PINYIN);
 457         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 458
 459         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_COMPOSER_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_COMPOSER_PINYIN);
 460         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 461
 462         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_COPYRIGHT_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_COPYRIGHT_PINYIN);
 463         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 464
 465         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_DESCRIPTION_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_DESCRIPTION_PINYIN);
 466         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 467
 468         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_AUTHOR_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_AUTHOR_PINYIN);
 469         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 470
 471         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_PROVIDER_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_PROVIDER_PINYIN);
 472         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 473
 474         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_CONTENT_NAME_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_CONTENT_NAME_PINYIN);
 475         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 476
 477         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_CATEGORY_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_CATEGORY_PINYIN);
 478         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 479
 480         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_LOCATION_TAG_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_LOCATION_TAG_PINYIN);
 481         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 482
 483         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_AGE_RATING_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_AGE_RATING_PINYIN);
 484         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 485
 486         ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_KEYWORD_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_KEYWORD_PINYIN);
 487         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 488
 489         /* Folder */
 490         ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_ID, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_ID);
 491         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 492
 493         ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_PATH, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_PATH);
 494         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 495
 496         ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_NAME, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_NAME);
 497         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 498
 499         ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_MODIFIED_TIME, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_MODIFIED_TIME);
 500         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 501
 502         ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_STORAGE_TYPE, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_STORAGE_TYPE);
 503         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 504
 505         ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_NAME_PINYIN, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_NAME_PINYIN);
 506         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 507
 508         ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_ORDER, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_ORDER);
 509         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 510
 511         ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_PARENT_FOLDER_ID, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_PARENT_FOLDER_ID);
 512         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 513         /* Playlist*/
 514         ret = _media_filter_attribute_add(g_alias_attr_handle, PLAYLIST_NAME, DB_TABLE_ALIAS_PLAYLIST"."DB_FIELD_PLAYLIST_NAME);
 515         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 516
 517         ret = _media_filter_attribute_add(g_alias_attr_handle, PLAYLIST_MEMBER_ORDER, DB_TABLE_ALIAS_PLAYLIST_MAP"."DB_FIELD_PLAYLIST_MEMBER_ORDER);
 518         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 519
 520         /* Tag*/
 521         ret = _media_filter_attribute_add(g_alias_attr_handle, TAG_NAME, DB_TABLE_ALIAS_TAG"."DB_FIELD_TAG_NAME);
 522         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 523
 524         /* Bookmark*/
 525         ret = _media_filter_attribute_add(g_alias_attr_handle, BOOKMARK_MARKED_TIME, DB_TABLE_ALIAS_BOOKMARK"."DB_FIELD_BOOKMARK_MARKED_TIME);
 526         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 527
 528         return ret;
 529 }
 530
 531 static int __media_content_create_attribute_handle(void)
 532 {
 533         int ret = MEDIA_CONTENT_ERROR_NONE;
 534
 535         ret = __media_content_create_attr_handle();
 536         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 537
 538         ret = __media_content_create_alias_attr_handle();
 539         if (ret != MEDIA_CONTENT_ERROR_NONE)
 540                 _media_filter_attribute_destory(g_attr_handle);
 541
 542         return ret;
 543 }
 544
 545 static int __media_content_destroy_attribute_handle(void)
 546 {
 547         int ret = MEDIA_CONTENT_ERROR_NONE;
 548
 549         ret = _media_filter_attribute_destory(g_attr_handle);
 550         ret = _media_filter_attribute_destory(g_alias_attr_handle);
 551
 552         g_attr_handle = NULL;
 553         g_alias_attr_handle = NULL;
 554
 555         return ret;
 556 }
 557
 558 attribute_h _content_get_attirbute_handle(void)
 559 {
 560         return g_attr_handle;
 561 }
 562
 563 attribute_h _content_get_alias_attirbute_handle(void)
 564 {
 565         return g_alias_attr_handle;
 566 }
 567
 568 MediaSvcHandle* _content_get_db_handle(void)
 569 {
 570         return db_handle;
 571 }
 572
 573 int _content_query_prepare(sqlite3_stmt **stmt, char *select_query, char *condition_query, char *option_query)
 574 {
 575         int len = 0;
 576         int err = MEDIA_CONTENT_ERROR_NONE;
 577         char query[MAX_QUERY_SIZE] = {0, };
 578         memset(query, '\0', sizeof(query));
 579
 580         media_content_retvm_if(db_handle == NULL, MEDIA_CONTENT_ERROR_DB_FAILED, "database is not connected");
 581         media_content_retvm_if(!STRING_VALID(select_query), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid select_query");
 582
 583         if (!STRING_VALID(condition_query)) {
 584                 condition_query = (char *)" ";
 585         }
 586
 587         if (!STRING_VALID(option_query)) {
 588                 option_query = (char *)" ";
 589
 590         }
 591
 592         //query = sqlite3_mprintf("%s %s %s", select_query, condition_query, option_query);
 593         len = snprintf(query, sizeof(query), "%s %s %s", select_query, condition_query, option_query);
 594         if (len > 0 && len < MAX_QUERY_SIZE) {
 595                 query[len] = '\0';
 596         } else if (len >= MAX_QUERY_SIZE) {
 597                 query[MAX_QUERY_SIZE -1] = '\0';
 598         } else {
 599                 media_content_error("snprintf failed");
 600                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 601         }
 602
 603         media_content_sec_debug("Query : [%s]", query);
 604
 605         err = sqlite3_prepare_v2((sqlite3*)db_handle, query, strlen(query), stmt, NULL);
 606         if (err != SQLITE_OK) {
 607                 media_content_error("DB_FAILED(0x%08x) fail to sqlite3_prepare(), %s", MEDIA_CONTENT_ERROR_DB_FAILED, sqlite3_errmsg((sqlite3*)db_handle));
 608
 609                 if (err == SQLITE_BUSY) {
 610                         media_content_error(" BUSY ERROR");
 611                         return MEDIA_CONTENT_ERROR_DB_BUSY;
 612                 } else if (err == SQLITE_PERM) {
 613                         media_content_error("PERMISSION EROR");
 614                         return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
 615                 } else {
 616                         media_content_error("OTHER ERROR");
 617                         return MEDIA_CONTENT_ERROR_DB_FAILED;
 618                 }
 619         }
 620
 621         return MEDIA_CONTENT_ERROR_NONE;
 622 }
 623
 624 int _content_error_capi(int type, int content_error)
 625 {
 626         if (content_error != MEDIA_CONTENT_ERROR_NONE) {
 627                 media_content_error("[type : %d] content_error : %d ", type, content_error);
 628         }
 629
 630         /*Error None*/
 631         if (content_error == MS_MEDIA_ERR_NONE)
 632                 return MEDIA_CONTENT_ERROR_NONE;
 633
 634         /* Internal operation error*/
 635         else if ((content_error == MS_MEDIA_ERR_INVALID_PARAMETER) ||
 636                 (content_error == MS_MEDIA_ERR_INVALID_PATH) ||
 637                 (content_error == MS_MEDIA_ERR_THUMB_DUPLICATED_REQUEST))
 638                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 639
 640         else if (content_error == MS_MEDIA_ERR_OUT_OF_MEMORY)
 641                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 642
 643         /* DB operation error*/
 644         else if (content_error == MS_MEDIA_ERR_DB_BUSY_FAIL)
 645                 return MEDIA_CONTENT_ERROR_DB_BUSY;
 646
 647         else if ((content_error <= MS_MEDIA_ERR_DB_CONNECT_FAIL) && (content_error >= MS_MEDIA_ERR_DB_INTERNAL))
 648                 return MEDIA_CONTENT_ERROR_DB_FAILED;
 649
 650         /* IPC operation error*/
 651         else if ((content_error <= MS_MEDIA_ERR_SOCKET_CONN) && (content_error >= MS_MEDIA_ERR_SOCKET_INTERNAL))
 652                 return MEDIA_CONTENT_ERROR_NETWORK;
 653
 654         /* MEDIA SERVER error*/
 655         else if (content_error == MS_MEDIA_ERR_PERMISSION_DENIED)
 656                 return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
 657
 658         /* Thumbnail error*/
 659         else if (content_error == MS_MEDIA_ERR_THUMB_TOO_BIG)
 660                         return MEDIA_CONTENT_ERROR_UNSUPPORTED_CONTENT;
 661
 662         /*ETC*/
 663         return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 664 }
 665
 666 int _content_query_sql(char *query_str)
 667 {
 668         int ret = MEDIA_CONTENT_ERROR_NONE;
 669
 670         //DB will be updated by Media Server.
 671         ret = media_svc_request_update_db(query_str, tzplatform_getuid(TZ_USER_NAME));
 672
 673         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 674 }
 675
 676 int media_content_connect(void)
 677 {
 678         int ret = MEDIA_CONTENT_ERROR_NONE;
 679
 680         if (g_mutex_trylock(&db_mutex)) {
 681                 media_content_info("ref count : %d", ref_count);
 682
 683                 if (ref_count == 0) {
 684                         if (db_handle == NULL) {
 685                                 ret = __media_content_create_attribute_handle();
 686                                 if (ret == MEDIA_CONTENT_ERROR_NONE) {
 687                                         ret = media_svc_connect(&db_handle, tzplatform_getuid(TZ_USER_NAME), false);
 688                                         ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 689                                         if (ret == MEDIA_CONTENT_ERROR_NONE) {
 690                                                 ref_count++;
 691                                         } else {
 692                                                 __media_content_destroy_attribute_handle();
 693                                         }
 694                                 } else {
 695                                         media_content_error("Internal DB Connection Error");
 696                                 }
 697                         } else {
 698                                 media_content_error("Wrong DB Connection status");
 699                                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 700                         }
 701                 } else {
 702                         if (db_handle != NULL) {
 703                                 ref_count++;
 704                         } else {
 705                                 media_content_error("Wrong DB Handle status");
 706                                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 707                         }
 708                 }
 709
 710                 media_content_info("ref count changed to: %d", ref_count);
 711                 g_mutex_unlock(&db_mutex);
 712         } else {
 713                 media_content_error("mutex is NULL");
 714                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 715         }
 716
 717         return ret;
 718 }
 719
 720 int media_content_disconnect(void)
 721 {
 722         int ret = MEDIA_CONTENT_ERROR_NONE;
 723
 724         if (g_mutex_trylock(&db_mutex)) {
 725                 media_content_debug("ref count : %d", ref_count);
 726                 if (ref_count > 0) {
 727                         if (db_handle != NULL) {
 728                                 ref_count--;
 729                         } else {
 730                                 media_content_error("Wrong DB Handle status");
 731                                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 732                         }
 733                 } else {
 734                         media_content_error("DB_FAILED(0x%08x) database is not connected", MEDIA_CONTENT_ERROR_DB_FAILED);
 735                         g_mutex_unlock(&db_mutex);
 736                         return MEDIA_CONTENT_ERROR_DB_FAILED;
 737                 }
 738
 739                 if (ref_count == 0) {
 740                         if (db_handle != NULL) {
 741                                 ret = media_svc_disconnect(db_handle);
 742                                 ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 743                                 if (ret == MEDIA_CONTENT_ERROR_NONE) {
 744                                         ret = __media_content_destroy_attribute_handle();
 745                                         db_handle = NULL;
 746                                 } else {
 747                                         media_content_error("database disconnect fail");
 748                                         ref_count++;
 749                                 }
 750                         } else {
 751                                 media_content_error("Wrong DB Handle status");
 752                                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 753                         }
 754
 755                         g_mutex_unlock(&db_mutex);
 756
 757                         media_content_info("ref count changed to: %d", ref_count);
 758
 759                         return ret;
 760                 }
 761
 762                 g_mutex_unlock(&db_mutex);
 763         } else {
 764                 media_content_error("mutex is NULL");
 765                 ret = MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 766         }
 767
 768         media_content_info("ref count changed to: %d", ref_count);
 769
 770         return ret;
 771 }
 772
 773 int media_content_scan_file(const char *path)
 774 {
 775         int ret = MEDIA_CONTENT_ERROR_NONE;
 776         bool ignore_file = FALSE;
 777         bool ignore_dir = FALSE;
 778         char *folder_path = NULL;
 779         int check_file = MEDIA_CONTENT_ERROR_NONE;
 780         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
 781
 782         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 783
 784         media_content_sec_debug("Path : %s", path);
 785
 786         ret = _media_util_check_ignore_file(path, &ignore_file);
 787         media_content_retvm_if(ignore_file == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
 788
 789         memset(storage_id, 0x00, sizeof(storage_id));
 790         ret = media_svc_get_storage_id(_content_get_db_handle(), path, storage_id);
 791         if (ret != MS_MEDIA_ERR_NONE) {
 792                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 793                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 794         }
 795
 796         check_file = _media_util_check_file_exist(path);
 797         if (check_file == MEDIA_CONTENT_ERROR_NONE) {
 798                 /* This means this path has to be inserted or refreshed */
 799                 folder_path = g_path_get_dirname(path);
 800                 ret = _media_util_check_ignore_dir(folder_path, &ignore_dir);
 801                 SAFE_FREE(folder_path);
 802
 803                 media_content_retvm_if(ignore_dir == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 804
 805                 media_svc_storage_type_e storage_type;
 806
 807                 ret = media_svc_get_storage_type(path, &storage_type, tzplatform_getuid(TZ_USER_NAME));
 808                 if (ret != MS_MEDIA_ERR_NONE) {
 809                         media_content_sec_error("media_svc_get_storage_type failed : %d (%s)", ret, path);
 810                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 811                 }
 812                 ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), storage_id, path);
 813                 if (ret == MS_MEDIA_ERR_NONE) {
 814                         /* Refresh */
 815                         ret = media_svc_refresh_item(_content_get_db_handle(), storage_id, storage_type, path, tzplatform_getuid(TZ_USER_NAME));
 816                         if (ret != MS_MEDIA_ERR_NONE) {
 817                                 media_content_error("media_svc_refresh_item failed : %d", ret);
 818                                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 819                         }
 820
 821                 } else if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 822                         /* Insert */
 823                         ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_id, storage_type, path, tzplatform_getuid(TZ_USER_NAME));
 824                         if (ret != MS_MEDIA_ERR_NONE) {
 825                                 if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 826                                         media_content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", path);
 827                                         ret = MEDIA_CONTENT_ERROR_NONE;
 828                                 } else {
 829                                         media_content_sec_error("media_svc_insert_item_immediately failed : %d (%s)", ret, path);
 830                                 }
 831
 832                                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 833                         }
 834                 } else {
 835                         media_content_error("media_svc_check_item_exist_by_path failed : %d", ret);
 836                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 837                 }
 838         } else if (check_file == MEDIA_CONTENT_ERROR_PERMISSION_DENIED) {
 839                 media_content_error("You have no permission for this file %d", ret);
 840                 return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
 841         } else {
 842                 /* This means this path has to be deleted */
 843                 media_content_debug("This path doesn't exists in file system... So now start to delete it from DB");
 844                 ret = media_svc_delete_item_by_path(_content_get_db_handle(), storage_id, path, tzplatform_getuid(TZ_USER_NAME));
 845                 if (ret != MS_MEDIA_ERR_NONE) {
 846                         media_content_error("media_svc_delete_item_by_path failed : %d", ret);
 847                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 848                 }
 849         }
 850
 851         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 852 }
 853
 854 void _media_content_scan_cb(media_request_result_s* result, void *user_data)
 855 {
 856         int err = -1;
 857         media_content_scan_cb_data *cb_data = user_data;
 858
 859         err = result->result;
 860
 861         if (cb_data && cb_data->callback) {
 862                 media_content_debug("User callback is being called now");
 863                 cb_data->callback(err, cb_data->user_data);
 864         }
 865
 866         SAFE_FREE(cb_data);
 867
 868         return;
 869 }
 870
 871 static int __media_content_check_dir(const char *path)
 872 {
 873         DIR *dp = NULL;
 874
 875         dp = opendir(path);
 876         if (dp == NULL) {
 877                 media_content_sec_error("path [%s]", path);
 878                 media_content_stderror("open dir fail");
 879
 880                 if (errno == EACCES || errno == EPERM) {
 881                         return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
 882                 } else {
 883                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 884                 }
 885         }
 886
 887         closedir(dp);
 888
 889         return MEDIA_CONTENT_ERROR_NONE;
 890 }
 891
 892 int media_content_scan_folder(const char *path, bool is_recursive, media_scan_completed_cb callback, void *user_data)
 893 {
 894         int ret = MEDIA_CONTENT_ERROR_NONE;
 895         bool ignore_dir = FALSE;
 896         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 897
 898         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
 899         memset(storage_id, 0x00, sizeof(storage_id));
 900
 901         ret = __media_content_check_dir(path);
 902         media_content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied");
 903
 904         if (ret == MEDIA_CONTENT_ERROR_NONE) {
 905                 /* If directory exist check that's ignore directory or not*/
 906         ret = _media_util_check_ignore_dir(path, &ignore_dir);
 907                 media_content_retvm_if(ignore_dir == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 908         } else {
 909                 /* This means this folder has to be deleted */
 910                 media_content_debug("This path doesn't exists in file system... So will be deleted it from DB");
 911         }
 912
 913         media_content_scan_cb_data *cb_data = NULL;
 914         cb_data = (media_content_scan_cb_data *)malloc(sizeof(media_content_scan_cb_data));
 915         media_content_retvm_if(cb_data == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 916
 917         cb_data->callback = callback;
 918         cb_data->user_data = user_data;
 919
 920         ret = media_svc_get_storage_id(_content_get_db_handle(), path, storage_id);
 921         /*FIX ME. need to check ret value?*/
 922
 923         ret = media_directory_scanning_async(path, storage_id, is_recursive, _media_content_scan_cb, cb_data, tzplatform_getuid(TZ_USER_NAME));
 924         if (ret != MS_MEDIA_ERR_NONE) {
 925                 media_content_error("media_directory_scanning_async failed : %d", ret);
 926         }
 927
 928         return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
 929 }
 930
 931 int media_content_cancel_scan_folder(const char *path)
 932 {
 933         int ret = MEDIA_CONTENT_ERROR_NONE;
 934
 935         ret = media_directory_scanning_cancel(path, tzplatform_getuid(TZ_USER_NAME));
 936         if (ret != MS_MEDIA_ERR_NONE) {
 937                 media_content_error("media_directory_scanning_async failed : %d", ret);
 938         }
 939
 940         return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
 941 }
 942
 943 void _media_content_db_update_noti_cb(
 944                                                         int pid,
 945                                                         media_item_type_e item,
 946                                                         media_item_update_type_e update_type,
 947                                                         char* path,
 948                                                         char* uuid,
 949                                                         media_type_e content_type,
 950                                                         char *mime_type,
 951                                                         void *user_data)
 952 {
 953         int error_value = MEDIA_CONTENT_ERROR_NONE;
 954
 955         media_noti_cb_s *_noti_info = (media_noti_cb_s *)user_data;
 956
 957         if (_noti_info != NULL) {
 958                 if (_noti_info->update_noti_cb)
 959                         _noti_info->update_noti_cb(error_value, pid, item, update_type, content_type, uuid, path, mime_type, _noti_info->user_data);
 960         }
 961
 962         return;
 963 }
 964
 965 int media_content_set_db_updated_cb(media_content_db_update_cb callback, void *user_data)
 966 {
 967         int ret = MEDIA_CONTENT_ERROR_NONE;
 968
 969         media_content_retvm_if(callback == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid callback");
 970         media_content_retvm_if(g_noti_info != NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "Noti callback is already set");
 971
 972         g_noti_info = (media_noti_cb_s *)calloc(1, sizeof(media_noti_cb_s));
 973         media_content_retvm_if(g_noti_info == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 974
 975         g_noti_info->update_noti_cb = callback;
 976         g_noti_info->user_data = user_data;
 977
 978         ret = media_db_update_subscribe(_media_content_db_update_noti_cb, (void *)g_noti_info);
 979
 980         return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
 981 }
 982
 983 int media_content_unset_db_updated_cb(void)
 984 {
 985         int ret = MEDIA_CONTENT_ERROR_NONE;
 986
 987         SAFE_FREE(g_noti_info);
 988         ret = media_db_update_unsubscribe();
 989
 990         return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
 991 }
 992
 993 int media_content_set_db_updated_cb_v2(media_content_noti_h *noti_handle, media_content_db_update_cb callback, void *user_data)
 994 {
 995         int ret = MEDIA_CONTENT_ERROR_NONE;
 996         media_noti_cb_s *noti_info = NULL;
 997
 998         if (noti_handle == NULL) {
 999                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1000                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1001         }
1002
1003         if (callback == NULL) {
1004                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1005                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1006         }
1007
1008         noti_info = (media_noti_cb_s *)calloc(1, sizeof(media_noti_cb_s));
1009         if (noti_info == NULL) {
1010                 media_content_error("Failed to create noti info");
1011                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1012         }
1013
1014         noti_info->update_noti_cb = callback;
1015         noti_info->user_data = user_data;
1016
1017         ret = media_db_update_subscribe_internal((MediaNotiHandle*)noti_handle, _media_content_db_update_noti_cb, (void *)noti_info);
1018
1019         return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
1020 }
1021
1022 int media_content_add_db_updated_cb(media_content_db_update_cb callback, void *user_data, media_content_noti_h *noti_handle)
1023 {
1024         int ret = MEDIA_CONTENT_ERROR_NONE;
1025         media_noti_cb_s *noti_info = NULL;
1026
1027         if (noti_handle == NULL) {
1028                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1029                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1030         }
1031
1032         if (callback == NULL) {
1033                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1034                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1035         }
1036
1037         noti_info = (media_noti_cb_s *)calloc(1, sizeof(media_noti_cb_s));
1038         if (noti_info == NULL) {
1039                 media_content_error("Failed to create noti info");
1040                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1041         }
1042
1043         noti_info->update_noti_cb = callback;
1044         noti_info->user_data = user_data;
1045
1046         ret = media_db_update_subscribe_internal((MediaNotiHandle*)noti_handle, _media_content_db_update_noti_cb, (void *)noti_info);
1047
1048         return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
1049 }
1050
1051 void __media_content_clear_user_data(void *user_data)
1052 {
1053         media_noti_cb_s *noti_info = user_data;
1054
1055         SAFE_FREE(noti_info);
1056
1057         return;
1058 }
1059
1060 int media_content_unset_db_updated_cb_v2(media_content_noti_h noti_handle)
1061 {
1062         int ret = MEDIA_CONTENT_ERROR_NONE;
1063
1064         ret = media_db_update_unsubscribe_internal((MediaNotiHandle)noti_handle, __media_content_clear_user_data);
1065
1066         return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
1067 }
1068
1069
1070 int media_content_remove_db_updated_cb(media_content_noti_h noti_handle)
1071 {
1072         int ret = MEDIA_CONTENT_ERROR_NONE;
1073
1074         ret = media_db_update_unsubscribe_internal((MediaNotiHandle)noti_handle, __media_content_clear_user_data);
1075
1076         return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
1077 }
1078