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