test/media-content_test.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 #include <sys/time.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <media_content.h>
  22 #include <media_info_private.h>
  23 #include <dlog.h>
  24 #include <pthread.h>
  25 #include <glib.h>
  26 #include <tzplatform_config.h>
  27
  28 filter_h g_filter = NULL;
  29 filter_h g_filter_g = NULL;     //filter for group like folder, tag, playlist, album, year ...
  30
  31 GMainLoop *g_loop = NULL;
  32 static int g_cnt = 0;
  33 static int g_media_cnt = 0;
  34
  35 #define test_audio_id   "0f999626-6218-450c-a4ad-181a3bab6ebf"
  36 #define test_video_id   "c1a92494-cc5b-4d74-aa7d-253199234548"
  37 #define test_image_id "db1c184c-6f31-43b4-b924-8c00ac5b6197"
  38 media_folder_h g_folder = NULL;
  39
  40 bool get_audio_meta(audio_meta_h audio)
  41 {
  42         char *c_value = NULL;
  43         int i_value = 0;
  44         time_t t_value = 0;
  45         int ret = MEDIA_CONTENT_ERROR_NONE;
  46
  47         media_content_debug("=== audio meta ===");
  48
  49         ret = audio_meta_get_media_id(audio, &c_value);
  50         if (ret != MEDIA_CONTENT_ERROR_NONE)
  51                 media_content_error("error when get meta : [%d]", ret);
  52         media_content_debug("audio_id : [%s]", c_value);
  53         SAFE_FREE(c_value);
  54
  55         ret = audio_meta_get_album(audio, &c_value);
  56         if (ret != MEDIA_CONTENT_ERROR_NONE)
  57                 media_content_error("error when get meta : [%d]", ret);
  58         media_content_debug("album : [%s]", c_value);
  59         SAFE_FREE(c_value);
  60
  61         ret = audio_meta_get_artist(audio, &c_value);
  62         if (ret != MEDIA_CONTENT_ERROR_NONE)
  63                 media_content_error("error when get meta : [%d]", ret);
  64         media_content_debug("artist : [%s]", c_value);
  65         SAFE_FREE(c_value);
  66
  67         ret = audio_meta_get_album_artist(audio, &c_value);
  68         if (ret != MEDIA_CONTENT_ERROR_NONE)
  69                 media_content_error("error when get meta : [%d]", ret);
  70         media_content_debug("album_artist : [%s]", c_value);
  71         SAFE_FREE(c_value);
  72
  73         ret = audio_meta_get_genre(audio, &c_value);
  74         if (ret != MEDIA_CONTENT_ERROR_NONE)
  75                 media_content_error("error when get meta : [%d]", ret);
  76         media_content_debug("genre : [%s]", c_value);
  77         SAFE_FREE(c_value);
  78
  79         ret = audio_meta_get_composer(audio, &c_value);
  80         if (ret != MEDIA_CONTENT_ERROR_NONE)
  81                 media_content_error("error when get meta : [%d]", ret);
  82         media_content_debug("composer : [%s]", c_value);
  83         SAFE_FREE(c_value);
  84
  85         ret = audio_meta_get_year(audio, &c_value);
  86         if (ret != MEDIA_CONTENT_ERROR_NONE)
  87                 media_content_error("error when get meta : [%d]", ret);
  88         media_content_debug("year : [%s]", c_value);
  89         SAFE_FREE(c_value);
  90
  91         ret = audio_meta_get_recorded_date(audio, &c_value);
  92         if (ret != MEDIA_CONTENT_ERROR_NONE)
  93                 media_content_error("error when get meta : [%d]", ret);
  94         media_content_debug("recorded_date : [%s]", c_value);
  95         SAFE_FREE(c_value);
  96
  97         ret = audio_meta_get_copyright(audio, &c_value);
  98         if (ret != MEDIA_CONTENT_ERROR_NONE)
  99                 media_content_error("error when get meta : [%d]", ret);
 100         media_content_debug("copyright : [%s]", c_value);
 101         SAFE_FREE(c_value);
 102
 103         ret = audio_meta_get_track_num(audio, &c_value);
 104         if (ret != MEDIA_CONTENT_ERROR_NONE)
 105                 media_content_error("error when get meta : [%d]", ret);
 106         media_content_debug("track_num : [%s]", c_value);
 107         SAFE_FREE(c_value);
 108
 109         ret = audio_meta_get_bit_rate(audio, &i_value);
 110         if (ret != MEDIA_CONTENT_ERROR_NONE)
 111                 media_content_error("error when get meta : [%d]", ret);
 112         media_content_debug("bitrate : [%d]", i_value);
 113
 114         ret = audio_meta_get_sample_rate(audio, &i_value);
 115         if (ret != MEDIA_CONTENT_ERROR_NONE)
 116                 media_content_error("error when get meta : [%d]", ret);
 117         media_content_debug("samplerate : [%d]", i_value);
 118
 119         ret = audio_meta_get_channel(audio, &i_value);
 120         if (ret != MEDIA_CONTENT_ERROR_NONE)
 121                 media_content_error("error when get meta : [%d]", ret);
 122         media_content_debug("channel : [%d]", i_value);
 123
 124         ret = audio_meta_get_duration(audio, &i_value);
 125         if (ret != MEDIA_CONTENT_ERROR_NONE)
 126                 media_content_error("error when get meta : [%d]", ret);
 127         media_content_debug("duration : [%d]", i_value);
 128
 129         ret = audio_meta_get_played_count(audio, &i_value);
 130         if (ret != MEDIA_CONTENT_ERROR_NONE)
 131                 media_content_error("error when get meta : [%d]", ret);
 132         media_content_debug("played_count : [%d]", i_value);
 133
 134         ret = audio_meta_get_played_time(audio, &t_value);
 135         if (ret != MEDIA_CONTENT_ERROR_NONE)
 136                 media_content_error("error when get meta : [%d]", ret);
 137         media_content_debug("played_time : [%d]", t_value);
 138
 139         ret = audio_meta_get_played_position(audio, &i_value);
 140         if (ret != MEDIA_CONTENT_ERROR_NONE)
 141                 media_content_error("error when get meta : [%d]", ret);
 142         media_content_debug("played_position : [%d]", i_value);
 143
 144         return true;
 145 }
 146
 147 bool get_video_meta(video_meta_h video)
 148 {
 149         char *c_value = NULL;
 150         int i_value = 0;
 151         time_t t_value = 0;
 152         int ret = MEDIA_CONTENT_ERROR_NONE;
 153
 154         media_content_debug("=== video meta ===");
 155
 156         ret = video_meta_get_media_id(video, &c_value);
 157         if (ret != MEDIA_CONTENT_ERROR_NONE)
 158                 media_content_error("error when get meta : [%d]", ret);
 159         media_content_debug("video_id : [%s]", c_value);
 160         SAFE_FREE(c_value);
 161
 162         ret = video_meta_get_album(video, &c_value);
 163         if (ret != MEDIA_CONTENT_ERROR_NONE)
 164                 media_content_error("error when get meta : [%d]", ret);
 165         media_content_debug("album : [%s]", c_value);
 166         SAFE_FREE(c_value);
 167
 168         ret = video_meta_get_artist(video, &c_value);
 169         if (ret != MEDIA_CONTENT_ERROR_NONE)
 170                 media_content_error("error when get meta : [%d]", ret);
 171         media_content_debug("artist : [%s]", c_value);
 172         SAFE_FREE(c_value);
 173
 174         ret = video_meta_get_album_artist(video, &c_value);
 175         if (ret != MEDIA_CONTENT_ERROR_NONE)
 176                 media_content_error("error when get meta : [%d]", ret);
 177         media_content_debug("album_artist : [%s]", c_value);
 178         SAFE_FREE(c_value);
 179
 180         ret = video_meta_get_genre(video, &c_value);
 181         if (ret != MEDIA_CONTENT_ERROR_NONE)
 182                 media_content_error("error when get meta : [%d]", ret);
 183         media_content_debug("genre : [%s]", c_value);
 184         SAFE_FREE(c_value);
 185
 186         ret = video_meta_get_composer(video, &c_value);
 187         if (ret != MEDIA_CONTENT_ERROR_NONE)
 188                 media_content_error("error when get meta : [%d]", ret);
 189         media_content_debug("omposer : [%s]", c_value);
 190         SAFE_FREE(c_value);
 191
 192         ret = video_meta_get_year(video, &c_value);
 193         if (ret != MEDIA_CONTENT_ERROR_NONE)
 194                 media_content_error("error when get meta : [%d]", ret);
 195         media_content_debug("year : [%s]", c_value);
 196         SAFE_FREE(c_value);
 197
 198         ret = video_meta_get_recorded_date(video, &c_value);
 199         if (ret != MEDIA_CONTENT_ERROR_NONE)
 200                 media_content_error("error when get meta : [%d]", ret);
 201         media_content_debug("recorded_date : [%s]", c_value);
 202         SAFE_FREE(c_value);
 203
 204         ret = video_meta_get_copyright(video, &c_value);
 205         if (ret != MEDIA_CONTENT_ERROR_NONE)
 206                 media_content_error("error when get meta : [%d]", ret);
 207         media_content_debug("copyright : [%s]", c_value);
 208         SAFE_FREE(c_value);
 209
 210         ret = video_meta_get_track_num(video, &c_value);
 211         if (ret != MEDIA_CONTENT_ERROR_NONE)
 212                 media_content_error("error when get meta : [%d]", ret);
 213         media_content_debug("track_num : [%s]", c_value);
 214         SAFE_FREE(c_value);
 215
 216         ret = video_meta_get_bit_rate(video, &i_value);
 217         if (ret != MEDIA_CONTENT_ERROR_NONE)
 218                 media_content_error("error when get meta : [%d]", ret);
 219         media_content_debug("bitrate : [%d]", i_value);
 220
 221         ret = video_meta_get_duration(video, &i_value);
 222         if (ret != MEDIA_CONTENT_ERROR_NONE)
 223                 media_content_error("error when get meta : [%d]", ret);
 224         media_content_debug("duration : [%d]", i_value);
 225
 226         ret = video_meta_get_width(video, &i_value);
 227         if (ret != MEDIA_CONTENT_ERROR_NONE)
 228                 media_content_error("error when get meta : [%d]", ret);
 229         media_content_debug("width : [%d]", i_value);
 230
 231         ret = video_meta_get_height(video, &i_value);
 232         if (ret != MEDIA_CONTENT_ERROR_NONE)
 233                 media_content_error("error when get meta : [%d]", ret);
 234         media_content_debug("height : [%d]", i_value);
 235
 236         ret = video_meta_get_played_count(video, &i_value);
 237         if (ret != MEDIA_CONTENT_ERROR_NONE)
 238                 media_content_error("error when get meta : [%d]", ret);
 239         media_content_debug("played_count : [%d]", i_value);
 240
 241         ret = video_meta_get_played_time(video, &t_value);
 242         if (ret != MEDIA_CONTENT_ERROR_NONE)
 243                 media_content_error("error when get meta : [%d]", ret);
 244         media_content_debug("played_time : [%d]", t_value);
 245
 246         ret = video_meta_get_played_position(video, &i_value);
 247         if (ret != MEDIA_CONTENT_ERROR_NONE)
 248                 media_content_error("error when get meta : [%d]", ret);
 249         media_content_debug("played_position : [%d]", i_value);
 250
 251         return true;
 252 }
 253
 254 bool gallery_folder_list_cb(media_folder_h folder, void *user_data)
 255 {
 256         media_folder_h new_folder = NULL;
 257         media_folder_clone(&new_folder, folder);
 258
 259         GList **list = (GList**)user_data;
 260         *list = g_list_append(*list, new_folder);
 261
 262         return true;
 263 }
 264
 265 bool gallery_media_item_cb(media_info_h media, void *user_data)
 266 {
 267         media_info_h new_media = NULL;
 268         media_info_clone(&new_media, media);
 269
 270         GList **list = (GList**)user_data;
 271         *list = g_list_append(*list, new_media);
 272
 273         return true;
 274 }
 275
 276 bool gallery_tag_item_cb(media_tag_h tag, void *user_data)
 277 {
 278         media_tag_h new_tag = NULL;
 279         media_tag_clone(&new_tag, tag);
 280
 281         GList **list = (GList**)user_data;
 282         *list = g_list_append(*list, new_tag);
 283
 284         return true;
 285 }
 286
 287 bool gallery_bookmarks_cb(media_bookmark_h bookmark, void *user_data)
 288 {
 289         media_bookmark_h new_bm = NULL;
 290         int ret = MEDIA_CONTENT_ERROR_NONE;
 291
 292         ret = media_bookmark_clone(&new_bm, bookmark);
 293         if (ret != MEDIA_CONTENT_ERROR_NONE)
 294                 media_content_error("error media_bookmark_clone : [%d]", ret);
 295
 296         GList **list = (GList**)user_data;
 297         *list = g_list_append(*list, new_bm);
 298
 299         return true;
 300 }
 301
 302 bool media_item_cb(media_info_h media, void *user_data)
 303 {
 304         char *c_value = NULL;
 305         char *media_id = NULL;
 306         media_content_type_e media_type = 0;
 307         int ret = MEDIA_CONTENT_ERROR_NONE;
 308
 309         if (media == NULL) {
 310                 media_content_debug("NO Item");
 311                 return true;
 312         }
 313
 314         ret = media_info_get_media_type(media, &media_type);
 315         if (ret != MEDIA_CONTENT_ERROR_NONE)
 316                 media_content_error("error when get info : [%d]", ret);
 317         media_content_debug("media_type : [%d]", media_type);
 318
 319         ret = media_info_get_media_id(media, &media_id);
 320         if (ret != MEDIA_CONTENT_ERROR_NONE)
 321                 media_content_error("error when get info : [%d]", ret);
 322         media_content_debug("media_id : [%s]", media_id);
 323
 324         ret = media_info_get_file_path(media, &c_value);
 325         if (ret != MEDIA_CONTENT_ERROR_NONE)
 326                 media_content_error("error when get info : [%d]", ret);
 327         media_content_debug("file_path : [%s]", c_value);
 328         SAFE_FREE(c_value);
 329
 330 #if 0
 331         int i_value = 0;
 332         time_t t_value = 0;
 333         bool b_value = false;
 334         unsigned long long size = 0;
 335
 336         if (media_type == MEDIA_CONTENT_TYPE_MUSIC) {
 337                 audio_meta_h audio;
 338
 339                 if (media_info_get_audio(media, &audio) == MEDIA_CONTENT_ERROR_NONE) {
 340                         get_audio_meta(audio);
 341                         ret = audio_meta_destroy(audio);
 342                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 343                                 media_content_error("error audio_meta_destroy : [%d]", ret);
 344                 } else
 345                         media_content_error("[audio_error]");
 346
 347         } else if (media_type == MEDIA_CONTENT_TYPE_IMAGE) {
 348                 image_meta_h image;
 349                 media_content_orientation_e orientation = 0;
 350                 bool is_burst_shot = false;
 351                 char *burst_id = NULL;
 352                 char *weather = NULL;
 353
 354                 if (media_info_get_image(media, &image) == MEDIA_CONTENT_ERROR_NONE) {
 355                         ret = image_meta_get_orientation(image, &orientation);
 356                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 357                                 media_content_error("error image_meta_get_orientation : [%d]", ret);
 358                         else
 359                                 media_content_debug("[image] orientation : %d", orientation);
 360
 361                         ret = image_meta_is_burst_shot(image, &is_burst_shot);
 362                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 363                                 media_content_error("error image_meta_is_burst_shot : [%d]", ret);
 364                         if (is_burst_shot) {
 365                                 ret = image_meta_get_burst_id(image, &burst_id);
 366                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
 367                                         media_content_error("error image_meta_get_burst_id : [%d]", ret);
 368                                 else
 369                                         media_content_debug("[image] burst_id : [%s]", burst_id);
 370
 371                                 SAFE_FREE(burst_id);
 372                         }
 373
 374                         ret = image_meta_destroy(image);
 375                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 376                                 media_content_error("error image_meta_destroy : [%d]", ret);
 377                 } else
 378                         media_content_error("[image_error]");
 379
 380         } else if (media_type == MEDIA_CONTENT_TYPE_VIDEO) {
 381                 video_meta_h video;
 382
 383                 if (media_info_get_video(media, &video) == MEDIA_CONTENT_ERROR_NONE) {
 384                         get_video_meta(video);
 385                         ret = video_meta_destroy(video);
 386                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 387                                 media_content_error("error video_meta_destroy : [%d]", ret);
 388                 } else
 389                         media_content_error("[video_error]");
 390
 391         } else {
 392                 media_content_debug("Other Content");
 393         }
 394
 395         media_content_debug("=== media_info ===");
 396         ret = media_info_get_file_path(media, &c_value);
 397         if (ret != MEDIA_CONTENT_ERROR_NONE)
 398                 media_content_error("error when get info : [%d]", ret);
 399         media_content_debug("file_path : [%s]", c_value);
 400         SAFE_FREE(c_value);
 401
 402         ret = media_info_get_display_name(media, &c_value);
 403         if (ret != MEDIA_CONTENT_ERROR_NONE)
 404                 media_content_error("error when get info : [%d]", ret);
 405         media_content_debug("display_name : [%s]", c_value);
 406         SAFE_FREE(c_value);
 407
 408         ret = media_info_get_mime_type(media, &c_value);
 409         if (ret != MEDIA_CONTENT_ERROR_NONE)
 410                 media_content_error("error when get info : [%d]", ret);
 411         media_content_debug("mime_type : [%s]", c_value);
 412         SAFE_FREE(c_value);
 413
 414         ret = media_info_get_thumbnail_path(media, &c_value);
 415         if (ret != MEDIA_CONTENT_ERROR_NONE)
 416                 media_content_error("error when get info : [%d]", ret);
 417         media_content_debug("thumbnail_path : [%s]", c_value);
 418         SAFE_FREE(c_value);
 419
 420         ret = media_info_get_description(media, &c_value);
 421         if (ret != MEDIA_CONTENT_ERROR_NONE)
 422                 media_content_error("error when get info : [%d]", ret);
 423         media_content_debug("description : [%s]", c_value);
 424         SAFE_FREE(c_value);
 425
 426         ret = media_info_get_author(media, &c_value);
 427         if (ret != MEDIA_CONTENT_ERROR_NONE)
 428                 media_content_error("error when get info : [%d]", ret);
 429         media_content_debug("author : [%s]", c_value);
 430         SAFE_FREE(c_value);
 431
 432         ret = media_info_get_provider(media, &c_value);
 433         if (ret != MEDIA_CONTENT_ERROR_NONE)
 434                 media_content_error("error when get info : [%d]", ret);
 435         media_content_debug("provider : [%s]", c_value);
 436         SAFE_FREE(c_value);
 437
 438         ret = media_info_get_content_name(media, &c_value);
 439         if (ret != MEDIA_CONTENT_ERROR_NONE)
 440                 media_content_error("error when get info : [%d]", ret);
 441         media_content_debug("content_name : [%s]", c_value);
 442         SAFE_FREE(c_value);
 443
 444         ret = media_info_get_category(media, &c_value);
 445         if (ret != MEDIA_CONTENT_ERROR_NONE)
 446                 media_content_error("error when get info : [%d]", ret);
 447         media_content_debug("category : [%s]", c_value);
 448         SAFE_FREE(c_value);
 449
 450         ret = media_info_get_location_tag(media, &c_value);
 451         if (ret != MEDIA_CONTENT_ERROR_NONE)
 452                 media_content_error("error when get info : [%d]", ret);
 453         media_content_debug("location_tag : [%s]", c_value);
 454         SAFE_FREE(c_value);
 455
 456         ret = media_info_get_age_rating(media, &c_value);
 457         if (ret != MEDIA_CONTENT_ERROR_NONE)
 458                 media_content_error("error when get info : [%d]", ret);
 459         media_content_debug("age_rating : [%s]", c_value);
 460         SAFE_FREE(c_value);
 461
 462         ret = media_info_get_keyword(media, &c_value);
 463         if (ret != MEDIA_CONTENT_ERROR_NONE)
 464                 media_content_error("error when get info : [%d]", ret);
 465         media_content_debug("keyword : [%s]", c_value);
 466         SAFE_FREE(c_value);
 467
 468         ret = media_info_get_size(media, &size);
 469         if (ret != MEDIA_CONTENT_ERROR_NONE)
 470                 media_content_error("error when get info : [%d]", ret);
 471         media_content_debug("size : [%lld]", size);
 472
 473         ret = media_info_get_added_time(media, &t_value);
 474         if (ret != MEDIA_CONTENT_ERROR_NONE)
 475                 media_content_error("error when get info : [%d]", ret);
 476         media_content_debug("added_time : [%d]", t_value);
 477
 478         ret = media_info_get_modified_time(media, &t_value);
 479         if (ret != MEDIA_CONTENT_ERROR_NONE)
 480                 media_content_error("error when get info : [%d]", ret);
 481         media_content_debug("modified_time : [%d]", t_value);
 482
 483         ret = media_info_get_timeline(media, &t_value);
 484         if (ret != MEDIA_CONTENT_ERROR_NONE)
 485                 media_content_error("error when get info : [%d]", ret);
 486         media_content_debug("timeline : [%d]", t_value);
 487
 488         ret = media_info_get_rating(media, &i_value);
 489         if (ret != MEDIA_CONTENT_ERROR_NONE)
 490                 media_content_error("error when get info : [%d]", ret);
 491         media_content_debug("rating : [%d]", i_value);
 492
 493         ret = media_info_get_favorite(media, &b_value);
 494         if (ret != MEDIA_CONTENT_ERROR_NONE)
 495                 media_content_error("error when get info : [%d]", ret);
 496         media_content_debug("favorite : [%d]", b_value);
 497
 498         ret = media_info_is_drm(media, &b_value);
 499         if (ret != MEDIA_CONTENT_ERROR_NONE)
 500                 media_content_error("error when get info : [%d]", ret);
 501         media_content_debug("is_drm : [%d]", b_value);
 502
 503         ret = media_info_set_weather(media, "Sunny");
 504         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 505                 media_content_error("Fail to set weather");
 506                 return ret;
 507
 508         ret = media_info_get_weather(media, &c_value);
 509         if (ret != MEDIA_CONTENT_ERROR_NONE)
 510                 media_content_error("error when get info : [%d]", ret);
 511         media_content_debug("weather : [%s]", c_value);
 512         SAFE_FREE(c_value);
 513
 514         /* Media server can't update when another db handle holds DB connection by sqlite3_prepare */
 515         //ret = media_info_set_location_tag(media, "Test location tag");
 516         //media_info_update_to_db(media);
 517         SAFE_FREE(media_id);
 518 #endif
 519         SAFE_FREE(media_id);
 520         return true;
 521 }
 522
 523 bool folder_list_cb(media_folder_h folder, void *user_data)
 524 {
 525         int item_count = 0;
 526         char *folder_id = NULL;
 527         char *str_val = NULL;
 528         int int_val = -1;
 529         media_content_storage_e storage_type;
 530         bool ret;
 531         media_folder_h *_folder = (media_folder_h*)user_data;
 532
 533         media_content_debug("===========================");
 534         if (folder != NULL) {
 535                 if (_folder != NULL)
 536                         media_folder_clone(_folder, folder);
 537
 538                 if (media_folder_get_folder_id(folder, &folder_id) != MEDIA_CONTENT_ERROR_NONE) {
 539                         media_content_error("[ERROR] media_folder_get_folder_id is failed");
 540                         return false;
 541                 }
 542                 media_content_debug("folder_id = [%s]", folder_id);
 543
 544                 if (media_folder_get_parent_folder_id(folder, &str_val) != MEDIA_CONTENT_ERROR_NONE) {
 545                         media_content_error("[ERROR] media_folder_get_parent_folder_id is failed");
 546                         return false;
 547                 }
 548                 media_content_debug("parent_folder_id = [%s]", str_val);
 549
 550                 if (media_folder_get_path(folder, &str_val) != MEDIA_CONTENT_ERROR_NONE) {
 551                         SAFE_FREE(folder_id);
 552                         media_content_error("[ERROR] media_folder_get_path is failed");
 553                         return false;
 554                 }
 555                 media_content_debug("folder_path = [%s]", str_val);
 556                 SAFE_FREE(str_val);
 557
 558                 if (media_folder_get_name(folder, &str_val) != MEDIA_CONTENT_ERROR_NONE) {
 559                         SAFE_FREE(folder_id);
 560                         media_content_error("[ERROR] media_folder_get_name is failed");
 561                         return false;
 562                 }
 563                 media_content_debug("folder_name = [%s]", str_val);
 564                 SAFE_FREE(str_val);
 565
 566                 if (media_folder_get_storage_type(folder, &storage_type) != MEDIA_CONTENT_ERROR_NONE) {
 567                         SAFE_FREE(folder_id);
 568                         media_content_error("[ERROR] media_folder_get_storage_type is failed");
 569                         return false;
 570                 }
 571                 media_content_debug("storage_type = [%d]", storage_type);
 572
 573                 if (media_folder_get_storage_id(folder, &str_val) != MEDIA_CONTENT_ERROR_NONE) {
 574                         SAFE_FREE(folder_id);
 575                         media_content_error("[ERROR] media_folder_get_name is failed");
 576                         return false;
 577                 }
 578                 media_content_debug("storage_id = [%s]", str_val);
 579
 580                 if (media_folder_get_order(folder, &int_val) != MEDIA_CONTENT_ERROR_NONE) {
 581                         media_content_error("[ERROR] media_folder_get_order is failed");
 582                         return false;
 583                 }
 584                 media_content_debug("folder_order = [%d]", int_val);
 585 #if 1
 586                 if (media_folder_get_media_count_from_db(folder_id, g_filter, &item_count) != MEDIA_CONTENT_ERROR_NONE) {
 587                         SAFE_FREE(folder_id);
 588                         media_content_error("[ERROR] media_folder_get_media_count_from_db is failed");
 589                         return false;
 590                 }
 591
 592                 if (media_folder_foreach_media_from_db(folder_id, g_filter, media_item_cb, NULL) != MEDIA_CONTENT_ERROR_NONE) {
 593                         SAFE_FREE(folder_id);
 594                         media_content_error("[ERROR] media_folder_foreach_media_from_db is failed");
 595                         return false;
 596                 }
 597 #endif
 598                 SAFE_FREE(folder_id);
 599                 ret = true;
 600         } else {
 601                 ret = false;
 602         }
 603
 604         return ret;
 605 }
 606
 607 bool test_album_from_db(int album_id)
 608 {
 609         int ret = MEDIA_CONTENT_ERROR_NONE;
 610         media_album_h album_h;
 611         int test_album_id = 0;
 612         char *album_name = NULL;
 613         char *artist = NULL;
 614
 615         ret = media_album_get_album_from_db(album_id, &album_h);
 616         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 617                 media_content_error("error when get album");
 618                 return false;
 619         }
 620
 621         if (media_album_get_album_id(album_h, &test_album_id) != MEDIA_CONTENT_ERROR_NONE) {
 622                 media_album_destroy(album_h);
 623                 return false;
 624         }
 625
 626         media_content_debug("test_album_id : [%d]", test_album_id);
 627
 628         if (media_album_get_name(album_h, &album_name) != MEDIA_CONTENT_ERROR_NONE) {
 629                 media_album_destroy(album_h);
 630                 return false;
 631         }
 632
 633         media_content_debug("album_name : [%s]", album_name);
 634
 635         if (media_album_get_artist(album_h, &artist) != MEDIA_CONTENT_ERROR_NONE) {
 636                 media_album_destroy(album_h);
 637                 /* fix prevent: Resource Leak */
 638                 SAFE_FREE(album_name);
 639                 return false;
 640         }
 641
 642         media_content_debug("artist : [%s]", artist);
 643
 644         SAFE_FREE(album_name);
 645         SAFE_FREE(artist);
 646
 647         media_album_destroy(album_h);
 648
 649         return true;
 650 }
 651
 652 bool playlist_list_cb(media_playlist_h playlist, void *user_data)
 653 {
 654         int playlist_id = 0;
 655         char *playlist_name = NULL;
 656         media_playlist_h playlist_h;
 657         char *playlist_thumbnail_path = NULL;
 658
 659         media_content_debug("playlist_list_cb ======");
 660 #if 0
 661         GList **list = (GList**)user_data;
 662 #endif
 663
 664         if (playlist == NULL) {
 665                 media_content_debug(" playlist handle is NULL");
 666                 return false;
 667         }
 668
 669         media_playlist_get_playlist_id(playlist, &playlist_id);
 670         media_content_debug("playlist_id : %d", playlist_id);
 671         /* 64bit build issue */
 672 #if 0
 673         if (user_data != NULL)
 674                 *list = g_list_append(*list, (gpointer)playlist_id);
 675 #endif
 676         media_playlist_get_name(playlist, &playlist_name);
 677         media_content_debug("playlist_name : %s", playlist_name);
 678         SAFE_FREE(playlist_name);
 679
 680         media_playlist_get_thumbnail_path(playlist, &playlist_thumbnail_path);
 681         media_content_debug("playlist_thumbnail_path : %s", playlist_thumbnail_path);
 682         SAFE_FREE(playlist_thumbnail_path);
 683
 684         media_playlist_get_playlist_from_db(playlist_id, &playlist_h);
 685
 686         media_playlist_destroy(playlist_h);
 687
 688         return true;
 689 }
 690
 691 bool tag_list_cb(media_tag_h tag, void *user_data)
 692 {
 693         int tag_id = 0;
 694         char *tag_name = NULL;
 695         int ret = MEDIA_CONTENT_ERROR_NONE;
 696
 697         if (tag == NULL) {
 698                 media_content_debug(" tag handle is NULL");
 699                 return false;
 700         }
 701
 702         ret = media_tag_get_tag_id(tag, &tag_id);
 703         if (ret != MEDIA_CONTENT_ERROR_NONE)
 704                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
 705         else
 706                 media_content_debug("tag_id : %d", tag_id);
 707
 708         ret = media_tag_get_name(tag, &tag_name);
 709         if (ret != MEDIA_CONTENT_ERROR_NONE)
 710                 media_content_error("error media_tag_get_name : [%d]", ret);
 711         else
 712                 media_content_debug("tag_name : %s", tag_name);
 713         SAFE_FREE(tag_name);
 714
 715         return true;
 716 }
 717
 718 bool bookmarks_cb(media_bookmark_h bookmark, void *user_data)
 719 {
 720         media_bookmark_h *_bookmark = (media_bookmark_h*)bookmark;
 721         int ret = MEDIA_CONTENT_ERROR_NONE;
 722
 723         if (_bookmark != NULL) {
 724                 char *name = NULL;
 725                 time_t time = 0;
 726                 int bookmark_id = 0;
 727
 728                 ret = media_bookmark_get_bookmark_id(bookmark, &bookmark_id);
 729                 if (ret != MEDIA_CONTENT_ERROR_NONE)
 730                         media_content_error("error media_bookmark_get_bookmark_id : [%d]", ret);
 731                 else
 732                         media_content_debug("bookmark_id : %d", bookmark_id);
 733
 734                 ret = media_bookmark_get_thumbnail_path(bookmark, &name);
 735                 if (ret != MEDIA_CONTENT_ERROR_NONE)
 736                         media_content_error("error media_bookmark_get_thumbnail_path : [%d]", ret);
 737                 else
 738                         media_content_debug("bookmark thumbnail_path : %s", name);
 739                 SAFE_FREE(name);
 740
 741                 ret = media_bookmark_get_marked_time(bookmark, &time);
 742                 if (ret != MEDIA_CONTENT_ERROR_NONE)
 743                         media_content_error("error media_bookmark_get_marked_time : [%d]", ret);
 744                 else
 745                         media_content_debug("bookmark marked_time : %d", time);
 746         }
 747
 748         return true;
 749 }
 750
 751 bool album_list_cb(media_album_h album, void *user_data)
 752 {
 753         int album_id = 0;
 754         char *album_name = NULL;
 755         char *artist = NULL;
 756         char *album_art = NULL;
 757         int media_count = 0;
 758         int ret = MEDIA_CONTENT_ERROR_NONE;
 759         filter_h filter = NULL;
 760
 761         /*Set Filter*/
 762         const char *condition = "MEDIA_TYPE=3"; /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
 763
 764         ret = media_filter_create(&filter);
 765         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 766                 media_content_error("Fail to create filter");
 767                 return ret;
 768         }
 769         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
 770         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 771                 media_filter_destroy(filter);
 772                 media_content_error("Fail to set condition");
 773                 return ret;
 774         }
 775         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_TITLE, MEDIA_CONTENT_COLLATE_NOCASE);
 776         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 777                 media_filter_destroy(filter);
 778                 media_content_error("Fail to set order");
 779                 return ret;
 780         }
 781
 782         if (album != NULL) {
 783                 if (media_album_get_album_id(album, &album_id) != MEDIA_CONTENT_ERROR_NONE) {
 784                         media_filter_destroy(filter);
 785                         return false;
 786                 }
 787
 788                 media_content_debug("album_id : [%d]", album_id);
 789
 790                 if (media_album_get_name(album, &album_name) != MEDIA_CONTENT_ERROR_NONE) {
 791                         media_filter_destroy(filter);
 792                         return false;
 793                 }
 794
 795                 media_content_debug("album_name : [%s]", album_name);
 796                 SAFE_FREE(album_name);
 797
 798                 if (media_album_get_artist(album, &artist) != MEDIA_CONTENT_ERROR_NONE) {
 799                         media_filter_destroy(filter);
 800                         return false;
 801                 }
 802
 803                 media_content_debug("artist : [%s]", artist);
 804                 SAFE_FREE(artist);
 805
 806                 if (media_album_get_album_art(album, &album_art) != MEDIA_CONTENT_ERROR_NONE) {
 807                         media_filter_destroy(filter);
 808                         return false;
 809                 }
 810
 811                 media_content_debug("album_art : [%s]", album_art);
 812                 SAFE_FREE(album_art);
 813
 814                 if (media_album_get_media_count_from_db(album_id, filter, &media_count) != MEDIA_CONTENT_ERROR_NONE) {
 815                         media_filter_destroy(filter);
 816                         return false;
 817                 }
 818
 819                 media_content_debug("media_count : [%d]", media_count);
 820
 821                 if (media_album_foreach_media_from_db(album_id, filter, media_item_cb, NULL) != MEDIA_CONTENT_ERROR_NONE) {
 822                         media_filter_destroy(filter);
 823                         return false;
 824                 }
 825
 826                 test_album_from_db(album_id);
 827         } else {
 828                 media_content_error("album item not Found!!");
 829         }
 830
 831         media_filter_destroy(filter);
 832
 833         return true;
 834 }
 835
 836 bool group_list_cb(const char *group_name, void *user_data)
 837 {
 838         int media_count = 0;
 839         int *idx = user_data;
 840
 841         media_content_debug("group item : [%s] [%d]", group_name, *idx);
 842
 843         if (media_group_get_media_count_from_db(group_name, *idx, g_filter, &media_count) != MEDIA_CONTENT_ERROR_NONE)
 844                 return false;
 845
 846         media_content_debug("media_count : [%d]", media_count);
 847
 848         if (media_group_foreach_media_from_db(group_name, *idx, g_filter, media_item_cb, NULL) != MEDIA_CONTENT_ERROR_NONE)
 849                 return false;
 850
 851         return true;
 852 }
 853
 854 bool playlist_item_cb(int playlist_member_id, media_info_h media, void *user_data)
 855 {
 856         media_content_debug("playlist_member_id : [%d]", playlist_member_id);
 857         /* 64bit build issue */
 858 #if 0
 859         GList **list = (GList**)user_data;
 860
 861         *list = g_list_append(*list, (gpointer)playlist_member_id);
 862 #endif
 863         //media_item_cb(media, user_data);
 864
 865         return true;
 866 }
 867
 868 int test_filter_create(void)
 869 {
 870         media_content_debug("\n============Filter Create============\n\n");
 871
 872         int ret = MEDIA_CONTENT_ERROR_NONE;
 873
 874         /* Filter for media */
 875         const char *condition = "MEDIA_TYPE=3"; /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
 876         //const char *condition = "MEDIA_TYPE IS NOT 0 AND MEDIA_DESCRIPTION IS NOT NULL";      /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
 877
 878         ret = media_filter_create(&g_filter);
 879
 880         /* Set condition and collate
 881          * Condition string : You can make where statement of sql.
 882          * Colation : You can use collation when comparing.
 883          * Ex) In case of FILE_NAME='Samsung' as condition string,
 884          *      if you want to compare with NOCASE collation,
 885          *      call media_filter_set_condition(g_filter, condition, MEDIA_CONTENT_COLLATE_NOCASE);
 886          *      if you want to compare in case-sensitive,
 887          *      call media_filter_set_condition(g_filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
 888          */
 889         ret = media_filter_set_condition(g_filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
 890
 891         /* Collation of ordering
 892          * If you want to get list, which is sorted by NOCASE,
 893          * call media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ARTIST, MEDIA_CONTENT_COLLATE_NOCASE);
 894          * Or,
 895          * call media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ARTIST, MEDIA_CONTENT_COLLATE_DEFAULT);
 896          */
 897         /* Able to set multi column to set order */
 898         //ret = media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, "MEDIA_MODIFIED_TIME, MEDIA_DISPLAY_NAME", MEDIA_CONTENT_COLLATE_DEFAULT);
 899         //ret = media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ARTIST, MEDIA_CONTENT_COLLATE_DEFAULT);
 900         //ret = media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_TRACK_NUM_INT, MEDIA_CONTENT_COLLATE_DEFAULT);
 901         //ret = media_filter_set_storage(g_filter, "cfbf3d2c-71c5-4611-bccc-7cbac890146e");
 902
 903         /* Filter for group */
 904         //const char *g_condition = "TAG_NAME like \"\%my\%\"";
 905         //const char *g_condition = "BOOKMARK_MARKED_TIME > 300";
 906
 907         ret = media_filter_create(&g_filter_g);
 908
 909         //ret = media_filter_set_condition(g_filter_g, g_condition, MEDIA_CONTENT_COLLATE_DEFAULT);
 910         ret = media_filter_set_order(g_filter_g, MEDIA_CONTENT_ORDER_DESC, TAG_NAME, MEDIA_CONTENT_COLLATE_DEFAULT);
 911
 912         return ret;
 913 }
 914
 915 int test_filter_destroy(void)
 916 {
 917         media_content_debug("\n============Filter Create============\n\n");
 918
 919         int ret = MEDIA_CONTENT_ERROR_NONE;
 920
 921         ret = media_filter_destroy(g_filter);
 922
 923         return ret;
 924 }
 925
 926 int test_connect_database(void)
 927 {
 928         int ret = MEDIA_CONTENT_ERROR_NONE;
 929
 930         media_content_debug("\n============DB Connection Test============\n\n");
 931
 932         ret = media_content_connect();
 933
 934         if (ret == MEDIA_CONTENT_ERROR_NONE)
 935                 media_content_debug("connection is success\n\n");
 936         else
 937                 media_content_error("connection is failed\n\n");
 938
 939         return ret;
 940 }
 941
 942 int test_gallery_scenario(void)
 943 {
 944         int ret = MEDIA_CONTENT_ERROR_NONE;
 945         unsigned int i = 0;
 946         filter_h filter = NULL;
 947
 948         int count;
 949         GList *folder_list = NULL;
 950         media_folder_h folder_handle = NULL;
 951
 952         /* First, Get folder list */
 953         ret = media_folder_foreach_folder_from_db(filter, gallery_folder_list_cb, &folder_list);
 954         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 955                 media_content_error("media_folder_foreach_folder_from_db failed: %d", ret);
 956                 return -1;
 957         } else {
 958                 media_content_debug("media_folder_foreach_folder_from_db success!!");
 959                 char *folder_id = NULL;
 960                 char *folder_name = NULL;
 961                 char *folder_path = NULL;
 962
 963                 for (i = 0; i < g_list_length(folder_list); i++) {
 964                         folder_handle = (media_folder_h)g_list_nth_data(folder_list, i);
 965
 966                         ret = media_folder_get_folder_id(folder_handle, &folder_id);
 967                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 968                                 media_content_error("media_folder_get_folder_id failed: %d", ret);
 969                         ret = media_folder_get_name(folder_handle, &folder_name);
 970                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 971                                 media_content_error("media_folder_get_name failed: %d", ret);
 972                         ret = media_folder_get_path(folder_handle, &folder_path);
 973                         if (ret != MEDIA_CONTENT_ERROR_NONE)
 974                                 media_content_error("media_folder_get_path failed: %d", ret);
 975
 976                         media_content_debug("folder_id [%d] : %s", i, folder_id);
 977                         media_content_debug("folder_name [%d] : %s", i, folder_name);
 978                         media_content_debug("folder_path [%d] : %s", i, folder_path);
 979
 980                         ret = media_folder_get_media_count_from_db(folder_id, filter, &count);
 981                         /* User should free these string */
 982                         SAFE_FREE(folder_id);
 983                         SAFE_FREE(folder_name);
 984                         SAFE_FREE(folder_path);
 985                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 986                                 media_content_error("media_folder_get_media_count_from_db failed: %d", ret);
 987                                 return -1;
 988                         } else {
 989                                 media_content_debug("media count [%d] : %d", i, count);
 990                         }
 991                 }
 992         }
 993
 994         /* To check performance */
 995         struct timeval start, end;
 996         gettimeofday(&start, NULL);
 997
 998         /* Second, Get all item list */
 999         media_info_h media_handle = NULL;
1000         GList *all_item_list = NULL;
1001
1002         media_content_collation_e collate_type = MEDIA_CONTENT_COLLATE_NOCASE;
1003         media_content_order_e order_type = MEDIA_CONTENT_ORDER_DESC;
1004         ret = media_filter_create(&filter);
1005         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1006                 media_content_error("Fail to create filter");
1007                 return ret;
1008         }
1009         ret = media_filter_set_condition(filter, "MEDIA_TYPE = 0", collate_type);
1010         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1011                 media_filter_destroy(filter);
1012                 media_content_error("Fail to set condition");
1013                 return ret;
1014         }
1015         ret = media_filter_set_order(filter, order_type, MEDIA_DISPLAY_NAME, collate_type);
1016         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1017                 media_filter_destroy(filter);
1018                 media_content_error("Fail to set order");
1019                 return ret;
1020         }
1021
1022         ret = media_info_foreach_media_from_db(filter, gallery_media_item_cb, &all_item_list);
1023         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1024                 media_content_error("media_info_foreach_media_from_db failed: %d", ret);
1025                 media_filter_destroy(filter);
1026                 return -1;
1027         } else {
1028                 media_content_debug("media_info_foreach_media_from_db success");
1029                 media_content_type_e media_type;
1030                 char *media_id = NULL;
1031                 char *media_name = NULL;
1032                 char *media_path = NULL;
1033
1034                 for (i = 0; i < g_list_length(all_item_list); i++) {
1035                         media_handle = (media_info_h)g_list_nth_data(all_item_list, i);
1036
1037                         ret = media_info_get_media_id(media_handle, &media_id);
1038                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1039                                 media_content_error("media_info_get_media_id failed: %d", ret);
1040                         ret = media_info_get_media_type(media_handle, &media_type);
1041                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1042                                 media_content_error("media_info_get_media_type failed: %d", ret);
1043                         ret = media_info_get_display_name(media_handle, &media_name);
1044                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1045                                 media_content_error("media_info_get_display_name failed: %d", ret);
1046                         ret = media_info_get_file_path(media_handle, &media_path);
1047                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1048                                 media_content_error("media_info_get_file_path failed: %d", ret);
1049
1050                         if (media_type == MEDIA_CONTENT_TYPE_IMAGE) {
1051                                 image_meta_h image_handle;
1052                                 int width = 0, height = 0;
1053                                 media_content_orientation_e orientation = 0;
1054                                 char *datetaken = NULL;
1055                                 char *burst_id = NULL;
1056
1057                                 ret = media_info_get_image(media_handle, &image_handle);
1058                                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1059                                         media_content_error("media_info_get_image failed: %d", ret);
1060                                 } else {
1061                                         ret = image_meta_get_width(image_handle, &width);
1062                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1063                                                 media_content_error("error image_meta_get_width : [%d]", ret);
1064                                         ret = image_meta_get_height(image_handle, &height);
1065                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1066                                                 media_content_error("error image_meta_get_height : [%d]", ret);
1067                                         ret = image_meta_get_orientation(image_handle, &orientation);
1068                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1069                                                 media_content_error("error image_meta_get_orientation : [%d]", ret);
1070                                         ret = image_meta_get_date_taken(image_handle, &datetaken);
1071                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1072                                                 media_content_error("error image_meta_get_date_taken : [%d]", ret);
1073                                         ret = image_meta_get_burst_id(image_handle, &burst_id);
1074                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1075                                                 media_content_error("error image_meta_get_burst_id : [%d]", ret);
1076
1077                                         media_content_debug("This is Image");
1078                                         media_content_debug("Width : %d, Height : %d, Orientation : %d, Date taken : %s", width, height, orientation, datetaken);
1079                                 }
1080
1081                                 SAFE_FREE(datetaken);
1082                                 SAFE_FREE(burst_id);
1083                                 ret = image_meta_destroy(image_handle);
1084                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1085                                         media_content_error("error image_meta_destroy : [%d]", ret);
1086
1087                         } else if (media_type == MEDIA_CONTENT_TYPE_VIDEO) {
1088                                 video_meta_h video_handle;
1089                                 char *title = NULL, *artist = NULL, *album = NULL, *album_artist = NULL;
1090                                 int duration = 0;
1091                                 time_t time_played = 0;
1092
1093                                 ret = media_info_get_video(media_handle, &video_handle);
1094                                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1095                                         media_content_error("media_info_get_video failed: %d", ret);
1096                                 } else {
1097                                         ret = video_meta_get_artist(video_handle, &artist);
1098                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1099                                                 media_content_error("error video_meta_get_artist : [%d]", ret);
1100                                         ret = video_meta_get_album(video_handle, &album);
1101                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1102                                                 media_content_error("error video_meta_get_album : [%d]", ret);
1103                                         ret = video_meta_get_album_artist(video_handle, &album_artist);
1104                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1105                                                 media_content_error("error video_meta_get_album_artist : [%d]", ret);
1106                                         ret = video_meta_get_duration(video_handle, &duration);
1107                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1108                                                 media_content_error("error video_meta_get_duration : [%d]", ret);
1109                                         ret = video_meta_get_played_time(video_handle, &time_played);
1110                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1111                                                 media_content_error("error video_meta_get_played_time : [%d]", ret);
1112
1113                                         media_content_debug("This is Video");
1114                                         media_content_debug("Title: %s, Album: %s, Artist: %s, Album_artist: %s \n Duration: %d, Played time: %d", title, album, artist, album_artist, duration, time_played);
1115                                 }
1116
1117                                 SAFE_FREE(title);
1118                                 SAFE_FREE(artist);
1119                                 SAFE_FREE(album);
1120                                 SAFE_FREE(album_artist);
1121
1122                                 ret = video_meta_destroy(video_handle);
1123                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1124                                         media_content_error("error video_meta_destroy : [%d]", ret);
1125                         }
1126                         //media_content_debug("media_id [%d] : %s", i, media_id);
1127                         //media_content_debug("media_name [%d] : %s", i, media_name);
1128                         //media_content_debug("media_path [%d] : %s", i, media_path);
1129
1130                         SAFE_FREE(media_id);
1131                         SAFE_FREE(media_name);
1132                         SAFE_FREE(media_path);
1133                 }
1134         }
1135
1136         media_filter_destroy(filter);
1137         filter = NULL;
1138
1139         /* To check performance */
1140         gettimeofday(&end, NULL);
1141         long time = (end.tv_sec * 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
1142         media_content_debug("Time : %ld\n", time);
1143
1144         /* Third, Get item list of a folder */
1145         GList *item_list = NULL;
1146
1147         for (i = 0; i < g_list_length(folder_list); i++) {
1148                 unsigned int j = 0;
1149                 char *folder_id = NULL;
1150                 char *folder_name = NULL;
1151                 folder_handle = (media_folder_h)g_list_nth_data(folder_list, i);
1152
1153                 media_folder_get_folder_id(folder_handle, &folder_id);
1154                 media_folder_get_name(folder_handle, &folder_name);
1155
1156                 ret = media_folder_foreach_media_from_db(folder_id, filter, gallery_media_item_cb, &item_list);
1157                 SAFE_FREE(folder_id);
1158                 SAFE_FREE(folder_name);
1159
1160                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1161                         media_content_error("media_folder_foreach_media_from_db failed: %d", ret);
1162                         return -1;
1163                 } else {
1164                         media_content_error("media_folder_foreach_media_from_db success!", ret);
1165                         char *media_id = NULL;
1166                         char *media_name = NULL;
1167                         char *media_path = NULL;
1168                         media_content_type_e media_type = 0;
1169
1170                         for (j = 0; j < g_list_length(item_list); j++) {
1171                                 media_handle = (media_info_h)g_list_nth_data(item_list, j);
1172
1173                                 ret = media_info_get_media_id(media_handle, &media_id);
1174                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1175                                         media_content_error("media_info_get_media_id failed: %d", ret);
1176                                 ret = media_info_get_display_name(media_handle, &media_name);
1177                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1178                                         media_content_error("media_info_get_display_name failed: %d", ret);
1179                                 ret = media_info_get_file_path(media_handle, &media_path);
1180                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1181                                         media_content_error("media_info_get_file_path failed: %d", ret);
1182                                 ret = media_info_get_media_type(media_handle, &media_type);
1183                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1184                                         media_content_error("media_info_get_media_type failed: %d", ret);
1185
1186                                 media_content_debug("[%s] media_id [%d] : %s", folder_name, j, media_id);
1187                                 media_content_debug("[%s] media_type [%d] : %d", folder_name, j, media_type);
1188                                 media_content_debug("[%s] media_name [%d] : %s", folder_name, j, media_name);
1189                                 media_content_debug("[%s] media_path [%d] : %s", folder_name, j, media_path);
1190
1191                                 if (media_type == MEDIA_CONTENT_TYPE_IMAGE) {
1192                                         image_meta_h image_handle;
1193                                         int width = 0, height = 0;
1194                                         media_content_orientation_e orientation = 0;
1195                                         char *datetaken = NULL;
1196
1197                                         ret = media_info_get_image(media_handle, &image_handle);
1198                                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1199                                                 media_content_error("media_info_get_image failed: %d", ret);
1200                                         } else {
1201                                                 ret = image_meta_get_width(image_handle, &width);
1202                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1203                                                         media_content_error("error image_meta_get_width : [%d]", ret);
1204                                                 ret = image_meta_get_height(image_handle, &height);
1205                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1206                                                         media_content_error("error image_meta_get_height : [%d]", ret);
1207                                                 ret = image_meta_get_orientation(image_handle, &orientation);
1208                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1209                                                         media_content_error("error image_meta_get_orientation : [%d]", ret);
1210                                                 ret = image_meta_get_date_taken(image_handle, &datetaken);
1211                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1212                                                         media_content_error("error image_meta_get_date_taken : [%d]", ret);
1213
1214                                                 media_content_debug("This is Image");
1215                                                 media_content_debug("Width : %d, Height : %d, Orientation : %d, Date taken : %s", width, height, orientation, datetaken);
1216                                         }
1217
1218                                         SAFE_FREE(datetaken);
1219                                         ret = image_meta_destroy(image_handle);
1220                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1221                                                 media_content_error("error image_meta_destroy : [%d]", ret);
1222
1223                                 } else if (media_type == MEDIA_CONTENT_TYPE_VIDEO) {
1224                                         video_meta_h video_handle;
1225                                         char *title = NULL, *artist = NULL, *album = NULL, *album_artist = NULL;;
1226                                         int duration = 0;
1227                                         time_t time_played;
1228
1229                                         ret = media_info_get_video(media_handle, &video_handle);
1230                                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1231                                                 media_content_error("media_info_get_video failed: %d", ret);
1232                                         } else {
1233                                                 ret = video_meta_get_artist(video_handle, &artist);
1234                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1235                                                         media_content_error("error video_meta_get_artist : [%d]", ret);
1236                                                 ret = video_meta_get_album(video_handle, &album);
1237                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1238                                                         media_content_error("error video_meta_get_album : [%d]", ret);
1239                                                 ret = video_meta_get_album_artist(video_handle, &album_artist);
1240                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1241                                                         media_content_error("error video_meta_get_album_artist : [%d]", ret);
1242                                                 ret = video_meta_get_duration(video_handle, &duration);
1243                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1244                                                         media_content_error("error video_meta_get_duration : [%d]", ret);
1245                                                 ret = video_meta_get_played_time(video_handle, &time_played);
1246                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1247                                                         media_content_error("error video_meta_get_played_time : [%d]", ret);
1248
1249                                                 media_content_debug("This is Video");
1250                                                 media_content_debug("Title: %s, Album: %s, Artist: %s, Album_artist: %s \n Duration: %d, Played time: %d\n", title, album, artist, album_artist, duration, time_played);
1251                                         }
1252
1253                                         SAFE_FREE(title);
1254                                         SAFE_FREE(artist);
1255                                         SAFE_FREE(album);
1256                                         SAFE_FREE(album_artist);
1257
1258                                         ret = video_meta_destroy(video_handle);
1259                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1260                                                 media_content_error("error video_meta_destroy : [%d]", ret);
1261
1262                                         /* Get bookmar list in case of video */
1263                                         media_bookmark_h bm_handle;
1264                                         GList *bm_list = NULL;
1265
1266                                         ret = media_info_foreach_bookmark_from_db(media_id, filter, gallery_bookmarks_cb, &bm_list);
1267                                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1268                                                 media_content_error("media_info_foreach_bookmark_from_db failed: %d", ret);
1269                                         } else {
1270                                                 media_content_debug("media_info_foreach_bookmark_from_db success");
1271
1272                                                 unsigned int k = 0;
1273
1274                                                 for (k = 0; k < g_list_length(bm_list); k++) {
1275                                                         bm_handle = (media_bookmark_h)g_list_nth_data(bm_list, k);
1276                                                         time_t marked_time;
1277                                                         char *thumb_path = NULL;
1278
1279                                                         ret = media_bookmark_get_marked_time(bm_handle, &marked_time);
1280                                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1281                                                                 media_content_error("error media_bookmark_get_marked_time : [%d]", ret);
1282                                                         ret = media_bookmark_get_thumbnail_path(bm_handle, &thumb_path);
1283                                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1284                                                                 media_content_error("error media_bookmark_get_thumbnail_path : [%d]", ret);
1285
1286                                                         media_content_debug("Bookmark time : %d\nBookmar thumb: %s", marked_time, thumb_path);
1287                                                         SAFE_FREE(thumb_path);
1288                                                 }
1289
1290                                                 /* Remove bookmark list */
1291                                                 unsigned int l = 0;
1292                                                 if (bm_list) {
1293                                                         for (l = 0; l < g_list_length(bm_list); l++) {
1294                                                                 bm_handle = (media_bookmark_h)g_list_nth_data(bm_list, l);
1295                                                                 ret = media_bookmark_destroy(bm_handle);
1296                                                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1297                                                                         media_content_error("error media_bookmark_destroy : [%d]", ret);
1298                                                         }
1299
1300                                                         g_list_free(bm_list);
1301                                                 }
1302
1303                                         }
1304                                 }
1305
1306                                 SAFE_FREE(media_id);
1307                                 SAFE_FREE(media_name);
1308                                 SAFE_FREE(media_path);
1309                         }
1310                 }
1311         }
1312
1313         /* Get tag list */
1314         media_tag_h tag_handle = NULL;
1315         GList *tag_list = NULL;
1316         GList *media_list_in_tag = NULL;
1317
1318         ret = media_tag_foreach_tag_from_db(filter, gallery_tag_item_cb, &tag_list);
1319
1320         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1321                 media_content_error("media_tag_foreach_tag_from_db failed: %d", ret);
1322                 return -1;
1323         } else {
1324                 media_content_error("media_tag_foreach_tag_from_db success");
1325                 char *tag_name = NULL;
1326                 int tag_id;
1327
1328                 for (i = 0; i < g_list_length(tag_list); i++) {
1329                         tag_handle = (media_tag_h)g_list_nth_data(tag_list, i);
1330                         media_tag_get_tag_id(tag_handle, &tag_id);
1331                         media_tag_get_name(tag_handle, &tag_name);
1332
1333                         media_content_debug("[%d] %s", tag_id, tag_name);
1334
1335                         ret = media_tag_foreach_media_from_db(tag_id, filter, gallery_media_item_cb, &media_list_in_tag);
1336                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1337                                 media_content_error("media_tag_foreach_media_from_db failed: %d", ret);
1338                                 return -1;
1339                         } else {
1340                                 media_content_error("media_tag_foreach_media_from_db success");
1341                                 unsigned int j = 0;
1342                                 media_info_h tag_media_handle;
1343                                 char *media_id = NULL;
1344                                 char *media_name = NULL;
1345                                 char *media_path = NULL;
1346                                 media_content_type_e media_type = 0;
1347
1348                                 for (j = 0; j < g_list_length(media_list_in_tag); j++) {
1349                                         tag_media_handle = (media_info_h)g_list_nth_data(media_list_in_tag, j);
1350                                         ret = media_info_get_media_id(tag_media_handle, &media_id);
1351                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1352                                                 media_content_error("media_info_get_media_id failed: %d", ret);
1353                                         ret = media_info_get_display_name(tag_media_handle, &media_name);
1354                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1355                                                 media_content_error("media_info_get_display_name failed: %d", ret);
1356                                         ret = media_info_get_file_path(tag_media_handle, &media_path);
1357                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1358                                                 media_content_error("media_info_get_file_path failed: %d", ret);
1359                                         ret = media_info_get_media_type(tag_media_handle, &media_type);
1360                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1361                                                 media_content_error("media_info_get_media_type failed: %d", ret);
1362
1363                                         media_content_debug("[%s] media_id [%d] : %s", tag_name, j, media_id);
1364                                         media_content_debug("[%s] media_type [%d] : %d", tag_name, j, media_type);
1365                                         media_content_debug("[%s] media_name [%d] : %s", tag_name, j, media_name);
1366                                         media_content_debug("[%s] media_path [%d] : %s", tag_name, j, media_path);
1367                                 }
1368                                 SAFE_FREE(media_id);
1369                                 SAFE_FREE(media_name);
1370                                 SAFE_FREE(media_path);
1371                         }
1372                         SAFE_FREE(tag_name);
1373                 }
1374         }
1375
1376         /* Remove folder list */
1377         if (folder_list) {
1378                 for (i = 0; i < g_list_length(folder_list); i++) {
1379                         folder_handle = (media_folder_h)g_list_nth_data(folder_list, i);
1380                         media_folder_destroy(folder_handle);
1381                 }
1382
1383                 g_list_free(folder_list);
1384         }
1385
1386         /* Remove all items list */
1387         if (all_item_list) {
1388                 for (i = 0; i < g_list_length(all_item_list); i++) {
1389                         media_handle = (media_info_h)g_list_nth_data(all_item_list, i);
1390                         ret = media_info_destroy(media_handle);
1391                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1392                                 media_content_error("media_info_destroy failed: %d", ret);
1393                 }
1394
1395                 g_list_free(all_item_list);
1396         }
1397
1398         /* Remove items list */
1399         if (item_list) {
1400                 for (i = 0; i < g_list_length(item_list); i++) {
1401                         media_handle = (media_info_h)g_list_nth_data(item_list, i);
1402                         ret = media_info_destroy(media_handle);
1403                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1404                                 media_content_error("media_info_destroy failed: %d", ret);
1405                 }
1406
1407                 g_list_free(item_list);
1408         }
1409
1410         /* Remove tag list */
1411         if (tag_list) {
1412                 for (i = 0; i < g_list_length(tag_list); i++) {
1413                         tag_handle = (media_tag_h)g_list_nth_data(tag_list, i);
1414                         ret = media_tag_destroy(tag_handle);
1415                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1416                                 media_content_error("error media_tag_destroy : [%d]", ret);
1417                 }
1418
1419                 g_list_free(tag_list);
1420         }
1421
1422         /* Remove media list in a tag */
1423         if (media_list_in_tag) {
1424                 for (i = 0; i < g_list_length(media_list_in_tag); i++) {
1425                         media_handle = (media_info_h)g_list_nth_data(media_list_in_tag, i);
1426                         ret = media_info_destroy(media_handle);
1427                         if (ret != MEDIA_CONTENT_ERROR_NONE)
1428                                 media_content_error("media_info_destroy failed: %d", ret);
1429                 }
1430
1431                 g_list_free(media_list_in_tag);
1432         }
1433
1434         return MEDIA_CONTENT_ERROR_NONE;
1435 }
1436
1437 /*Get All Music file. sort by Title and not case sensitive*/
1438 int test_get_all_music_files(void)
1439 {
1440         int ret = MEDIA_CONTENT_ERROR_NONE;
1441         int media_count = 0;
1442         filter_h filter;
1443
1444         /*Set Filter*/
1445         const char *condition = "MEDIA_TYPE=3"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/
1446
1447         ret = media_filter_create(&filter);
1448         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1449                 media_content_error("Fail to create filter");
1450                 return ret;
1451         }
1452         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_LOCALIZED);
1453         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1454                 media_filter_destroy(filter);
1455                 media_content_error("Fail to set condition");
1456                 return ret;
1457         }
1458         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_TITLE, MEDIA_CONTENT_COLLATE_LOCALIZED);
1459         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1460                 media_filter_destroy(filter);
1461                 media_content_error("Fail to set order");
1462                 return ret;
1463         }
1464
1465         /*Get Media Count*/
1466         ret = media_info_get_media_count_from_db(filter, &media_count);
1467         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1468                 media_filter_destroy(filter);
1469                 media_content_error("Fail to get media count");
1470                 return ret;
1471         }
1472
1473         media_content_debug("media_count : [%d]", media_count);
1474
1475         ret = media_info_foreach_media_from_db(filter, media_item_cb, NULL);
1476         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1477                 media_filter_destroy(filter);
1478                 media_content_error("Fail to get media");
1479                 return ret;
1480         }
1481
1482         ret = media_filter_destroy(filter);
1483
1484         return ret;
1485 }
1486
1487 int test_media_info_operation(void)
1488 {
1489         int ret = MEDIA_CONTENT_ERROR_NONE;
1490         int media_count = 0;
1491
1492         media_content_debug("\n============Media info Test============\n\n");
1493
1494         test_filter_create();
1495
1496         ret = media_info_get_media_count_from_db(g_filter, &media_count);
1497         if (ret != MEDIA_CONTENT_ERROR_NONE)
1498                 media_content_error("media_info_get_media_count_from_db failed: %d", ret);
1499         else
1500                 media_content_debug("media_count : [%d]", media_count);
1501
1502         ret = media_info_foreach_media_from_db(g_filter, media_item_cb, NULL);
1503         if (ret == MEDIA_CONTENT_ERROR_NONE)
1504                 media_content_debug("media_info_foreach_media_from_db is success");
1505         else
1506                 media_content_error("media_info_foreach_media_from_db is failed");
1507
1508         test_filter_destroy();
1509
1510         return ret;
1511 }
1512
1513 int test_media_info_operation_2(void)
1514 {
1515         int ret = MEDIA_CONTENT_ERROR_NONE;
1516         int bookmark_count = 0;
1517
1518         media_content_debug("\n============Media info Test 2============\n\n");
1519
1520         test_filter_create();
1521
1522 #if 0
1523         /* Bookmark */
1524         char *thumbnail_path1 = tzplatform_mkpath(TZ_USER_CONTENT, "Images and videos/My video clips/teat11.jpg"));
1525         media_bookmark_insert_to_db(test_video_id, 100, thumbnail_path1);
1526         media_bookmark_insert_to_db(test_video_id, 200, thumbnail_path1);
1527
1528         media_info_get_bookmark_count_from_db(test_video_id, g_filter_g, &bookmark_count);
1529
1530         media_content_debug("bookmark_count : [%d]", bookmark_count);
1531
1532         ret = media_info_foreach_bookmark_from_db(test_video_id, g_filter_g, bookmarks_cb, NULL);
1533 #endif
1534
1535         /* Tag */
1536         ret = media_info_get_tag_count_from_db(test_audio_id, g_filter_g, &bookmark_count);
1537         if (ret != MEDIA_CONTENT_ERROR_NONE)
1538                 media_content_error("media_info_get_tag_count_from_db failed: %d", ret);
1539         else
1540                 media_content_debug("tag_count : [%d]", bookmark_count);
1541
1542         ret = media_info_foreach_tag_from_db(test_audio_id, g_filter_g, tag_list_cb, NULL);
1543         if (ret != MEDIA_CONTENT_ERROR_NONE)
1544                 media_content_error("media_info_foreach_tag_from_db failed: %d", ret);
1545
1546         test_filter_destroy();
1547
1548         return ret;
1549 }
1550
1551 int test_folder_operation(void)
1552 {
1553         int ret = MEDIA_CONTENT_ERROR_NONE;
1554         filter_h filter = NULL;
1555         media_folder_h folder = NULL;
1556         char *folder_id = NULL;
1557         int count = 0;
1558
1559         media_content_debug("\n============Folder Test============\n\n");
1560
1561         test_filter_create();
1562
1563         ret = media_filter_create(&filter);
1564         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1565                 media_content_error("[ERROR] media_folder_filter_create is failed");
1566                 return ret;
1567         }
1568
1569         media_filter_set_condition(filter, "(MEDIA_TYPE = 0 or MEDIA_TYPE = 1) and MEDIA_STORAGE_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);       /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
1570         media_filter_set_offset(filter, 0, 5);
1571         media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, MEDIA_PATH, MEDIA_CONTENT_COLLATE_NOCASE);
1572         media_filter_set_storage(filter, "cfbf3d2c-71c5-4611-bccc-7cbac890146e");
1573
1574         ret = media_folder_get_folder_count_from_db(filter, &count);
1575         media_content_debug("Folder count : [%d]", count);
1576
1577         ret = media_folder_foreach_folder_from_db(filter, folder_list_cb, &folder);
1578
1579         //test.3 get the media list in first folder
1580         filter_h m_filter = NULL;
1581
1582         ret = media_filter_create(&m_filter);
1583         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1584                 test_filter_destroy();
1585                 media_filter_destroy(filter);
1586                 media_content_error("[ERROR] media_info_filter_create is failed");
1587                 return ret;
1588         }
1589
1590         media_filter_set_condition(m_filter, "MEDIA_TYPE=1 and MEDIA_STORAGE_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);   /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
1591         media_filter_set_offset(m_filter, 0, 5);
1592         media_filter_set_order(m_filter, MEDIA_CONTENT_ORDER_DESC, MEDIA_PATH, MEDIA_CONTENT_COLLATE_NOCASE);
1593
1594         ret = media_folder_foreach_media_from_db(folder_id, m_filter, media_item_cb, NULL);
1595         if (ret != MEDIA_CONTENT_ERROR_NONE)
1596                 media_content_error("[ERROR] media_folder_foreach_media_from_db is failed, error code : %d", ret);
1597
1598         media_filter_destroy(filter);
1599         media_filter_destroy(m_filter);
1600
1601         test_filter_destroy();
1602
1603         /* fix prevent: Resource Leak */
1604         SAFE_FREE(folder_id);
1605
1606         return ret;
1607 }
1608
1609 bool folder_update_cb(media_folder_h folder, void *user_data)
1610 {
1611         char *folder_id = NULL;
1612         char *folder_path = NULL;
1613         char *folder_name = NULL;
1614         int folder_order = -1;
1615         bool ret = true;
1616
1617         if (folder != NULL) {
1618                 ret = media_folder_get_folder_id(folder, &folder_id);
1619                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1620                 media_content_debug("folder_id = [%s]", folder_id);
1621                 SAFE_FREE(folder_id);
1622
1623                 ret = media_folder_get_path(folder, &folder_path);
1624                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1625                 media_content_debug("folder_path = [%s]", folder_path);
1626                 SAFE_FREE(folder_path);
1627
1628                 ret = media_folder_get_name(folder, &folder_name);
1629                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1630                 media_content_debug("folder_name = [%s]", folder_name);
1631                 SAFE_FREE(folder_name);
1632
1633                 ret = media_folder_get_order(folder, &folder_order);
1634                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1635                 media_content_debug("folder_order = [%d]", folder_order);
1636
1637                 ret = media_folder_clone(&g_folder, folder);
1638                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1639
1640                 ret = true;
1641         } else {
1642                 ret = false;
1643         }
1644
1645         return ret;
1646 }
1647
1648
1649 int test_folder_update(void)
1650 {
1651         int ret = MEDIA_CONTENT_ERROR_NONE;
1652         filter_h filter;
1653         int folder_count = 0;
1654
1655         media_content_debug("\n============Folder Update Test============\n\n");
1656
1657         ret = media_filter_create(&filter);
1658         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1659
1660         ret = media_filter_set_condition(filter, "MEDIA_TYPE=0 and MEDIA_STORAGE_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);       /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
1661         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, FOLDER_ORDER, MEDIA_CONTENT_COLLATE_NOCASE);
1662
1663         ret = media_folder_get_folder_count_from_db(filter, &folder_count);
1664
1665         media_content_debug("Folder count : %d", folder_count);
1666
1667         ret = media_folder_foreach_folder_from_db(filter, folder_update_cb, NULL);
1668
1669         media_filter_destroy(filter);
1670
1671         ret = media_folder_set_name(g_folder, "test_folder");
1672
1673         ret = media_folder_set_order(g_folder, 200);
1674
1675         ret = media_folder_update_to_db(g_folder);
1676
1677         ret = media_folder_destroy(g_folder);
1678
1679         return ret;
1680 }
1681
1682 int test_playlist_operation(void)
1683 {
1684         int ret = MEDIA_CONTENT_ERROR_NONE;
1685         media_playlist_h playlist_1 = NULL;
1686         media_playlist_h playlist_2 = NULL;
1687         media_playlist_h playlist_3 = NULL;
1688         media_playlist_h playlist_4 = NULL;
1689         int playlist_id_1 = 0;
1690         int playlist_id_2 = 0;
1691         int playlist_id_3 = 0;
1692         const char *playlist_name_1 = "myPlaylist_1";
1693         const char *playlist_name_2 = "myPlaylist_2";
1694         const char *playlist_name_3 = "myPlaylist_3";
1695         int playlist_count = 0;
1696         int media_count = 0;
1697         int order_1 = 0;
1698         int order_2 = 0;
1699         int order_3 = 0;
1700         int order_4 = 0;
1701         int order_5 = 0;
1702         filter_h filter = NULL;
1703         filter_h m_filter = NULL;
1704
1705         media_content_debug("\n============Playlist Test============\n\n");
1706
1707         /* Filter for playlist */
1708
1709         const char *condition = "(MEDIA_TYPE=1 or MEDIA_TYPE=3)";       /*0-image, 1-video, 2-sound, 3-music, 4-other*/
1710
1711         ret = media_filter_create(&filter);
1712         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_NOCASE);
1713         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, PLAYLIST_NAME, MEDIA_CONTENT_COLLATE_NOCASE);
1714
1715         /* Create Playlist */
1716         media_playlist_insert_to_db(playlist_name_1, &playlist_1);
1717         media_playlist_insert_to_db(playlist_name_2, &playlist_2);
1718         media_playlist_insert_to_db(playlist_name_3, &playlist_3);
1719
1720         if (playlist_1 != NULL) {
1721                 /* Add media to Playlist */
1722                 media_playlist_add_media(playlist_1, test_audio_id);
1723                 media_playlist_add_media(playlist_1, test_audio_id);
1724                 media_playlist_add_media(playlist_1, test_video_id);
1725
1726                 #if 0
1727                 char *playlist_thumb_path = tzplatform_mkpath(TZ_USER_CONTENT, "Images/Default.jpg"));
1728                 media_playlist_set_thumbnail_path(playlist_1, playlist_thumb_path);
1729                 #endif
1730
1731                 media_playlist_update_to_db(playlist_1);
1732         }
1733
1734         if (playlist_2 != NULL) {
1735                 media_playlist_add_media(playlist_2, test_audio_id);
1736                 media_playlist_add_media(playlist_2, test_audio_id);
1737                 media_playlist_update_to_db(playlist_2);
1738         }
1739
1740         /* Get Playlist Count*/
1741         ret = media_playlist_get_playlist_count_from_db(filter, &playlist_count);
1742         if (ret == 0)
1743                 media_content_debug("playlist_count [%d]", playlist_count);
1744
1745         /* Get Playlist*/
1746         GList *playlist_id_list = NULL;
1747         media_playlist_foreach_playlist_from_db(filter, playlist_list_cb, &playlist_id_list);
1748         /* 64bit build issue */
1749 #if 0
1750         /* Get Playlist id*/
1751         playlist_id_1 = (int)g_list_nth_data(playlist_id_list, 0);
1752         playlist_id_2 = (int)g_list_nth_data(playlist_id_list, 1);
1753         playlist_id_3 = (int)g_list_nth_data(playlist_id_list, 2);
1754 #endif
1755         media_content_debug("playlist_id_1 [%d]", playlist_id_1);
1756         media_content_debug("playlist_id_2 [%d]", playlist_id_2);
1757         media_content_debug("playlist_id_3 [%d]", playlist_id_3);
1758
1759         /* Export and import playlist */
1760         media_playlist_export_to_file(playlist_3, "/opt/usr/media/Music/playlist.m3u");
1761         media_playlist_import_from_file("/opt/usr/media/Music/playlist.m3u", "playlist_4", &playlist_4);
1762
1763         /* Filter for media*/
1764         ret = media_filter_create(&m_filter);
1765
1766         ret = media_filter_set_condition(m_filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
1767
1768         ret = media_filter_set_order(m_filter, MEDIA_CONTENT_ORDER_ASC, PLAYLIST_MEMBER_ORDER, MEDIA_CONTENT_COLLATE_DEFAULT);
1769
1770         /* Get media count */
1771         media_playlist_get_media_count_from_db(playlist_id_1, m_filter, &media_count);
1772         media_content_debug("playlist_1_media_count [%d]", media_count);
1773
1774         media_playlist_get_media_count_from_db(playlist_id_2, m_filter, &media_count);
1775         media_content_debug("playlist_2_media_count [%d]", media_count);
1776
1777         media_playlist_get_media_count_from_db(playlist_id_3, m_filter, &media_count);
1778         media_content_debug("playlist_3_media_count [%d]", media_count);
1779
1780         /* Get media of playlist */
1781         GList *playlist_member_id_list = NULL;
1782         GList *playlist_member_id_list_1 = NULL;
1783
1784         media_playlist_foreach_media_from_db(playlist_id_1, m_filter, playlist_item_cb, &playlist_member_id_list);
1785         media_playlist_foreach_media_from_db(playlist_id_2, m_filter, playlist_item_cb, &playlist_member_id_list_1);
1786
1787         int playlist_member_id_1_1 = 0;
1788         int playlist_member_id_1_2 = 0;
1789         int playlist_member_id_1_3 = 0;
1790         int playlist_member_id_2_1 = 0;
1791         int playlist_member_id_2_2 = 0;
1792         /* 64bit build issue */
1793 #if 0
1794         playlist_member_id_1_1 = (int)g_list_nth_data(playlist_member_id_list, 0);
1795         playlist_member_id_1_2 = (int)g_list_nth_data(playlist_member_id_list, 1);
1796         playlist_member_id_1_3 = (int)g_list_nth_data(playlist_member_id_list, 2);
1797         playlist_member_id_2_1 = (int)g_list_nth_data(playlist_member_id_list_1, 0);
1798         playlist_member_id_2_2 = (int)g_list_nth_data(playlist_member_id_list_1, 1);
1799 #endif
1800         media_content_debug("playlist_member_id_1_1 [%d]", playlist_member_id_1_1);
1801         media_content_debug("playlist_member_id_1_2 [%d]", playlist_member_id_1_2);
1802         media_content_debug("playlist_member_id_1_3 [%d]", playlist_member_id_1_3);
1803         media_content_debug("playlist_member_id_2_1 [%d]", playlist_member_id_2_1);
1804         media_content_debug("playlist_member_id_2_2 [%d]", playlist_member_id_2_2);
1805
1806         media_playlist_get_play_order(playlist_1, playlist_member_id_1_1, &order_1);
1807         media_playlist_get_play_order(playlist_1, playlist_member_id_1_2, &order_2);
1808         media_playlist_get_play_order(playlist_1, playlist_member_id_1_3, &order_3);
1809         media_playlist_get_play_order(playlist_2, playlist_member_id_2_1, &order_4);
1810         media_playlist_get_play_order(playlist_2, playlist_member_id_2_2, &order_5);
1811         media_content_debug("order_1 [%d] order_2 [%d] order_3 [%d] order_4 [%d] order_5 [%d]", order_1, order_2, order_3, order_4, order_5);
1812
1813         /* Update Playlist */
1814         media_playlist_remove_media(playlist_2, playlist_member_id_2_1);
1815         media_playlist_add_media(playlist_2, test_video_id);
1816         media_playlist_set_name(playlist_2, "test_playlist");
1817         media_playlist_set_play_order(playlist_2, playlist_member_id_2_2, order_5+100);
1818         media_playlist_update_to_db(playlist_2);
1819
1820         /* Get Updated Playlist*/
1821         media_playlist_foreach_playlist_from_db(filter, playlist_list_cb, NULL);
1822
1823         /* deletes the playlist */
1824         //media_playlist_delete_from_db(playlist_id_1);
1825         //media_playlist_delete_from_db(playlist_id_2);
1826
1827         if (playlist_1 != NULL)
1828                 media_playlist_destroy(playlist_1);
1829         if (playlist_2 != NULL)
1830                 media_playlist_destroy(playlist_2);
1831         if (playlist_3 != NULL)
1832                 media_playlist_destroy(playlist_3);
1833         if (playlist_4 != NULL)
1834                 media_playlist_destroy(playlist_4);
1835
1836         g_list_free(playlist_id_list);
1837         g_list_free(playlist_member_id_list);
1838         g_list_free(playlist_member_id_list_1);
1839
1840         if (filter != NULL)
1841                 ret = media_filter_destroy(filter);
1842         if (m_filter != NULL)
1843                 ret = media_filter_destroy(m_filter);
1844
1845         return ret;
1846 }
1847
1848 int test_tag_operation(void)
1849 {
1850         int ret = MEDIA_CONTENT_ERROR_NONE;
1851         media_tag_h tag_1;
1852         media_tag_h tag_2;
1853         media_tag_h tag_3;
1854         int tag_id_1 = 0;
1855         int tag_id_2 = 0;
1856         int tag_id_3 = 0;
1857         const char *tag_name_1 = "myTag_1";
1858         const char *tag_name_2 = "myTag_2";
1859         const char *tag_name_3 = "myTag_3";
1860         int tag_count = 0;
1861         int media_count = 0;
1862         filter_h filter;
1863
1864         media_content_debug("\n============Tag Test============\n\n");
1865
1866         const char *g_condition = "TAG_NAME like \"%%my%%\"";
1867
1868         ret = media_filter_create(&filter);
1869
1870         ret = media_filter_set_condition(filter, g_condition, MEDIA_CONTENT_COLLATE_DEFAULT);
1871
1872         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, TAG_NAME, MEDIA_CONTENT_COLLATE_DEFAULT);
1873
1874         /* Create Tag */
1875         ret = media_tag_insert_to_db(tag_name_1, &tag_1);
1876         if (ret != MEDIA_CONTENT_ERROR_NONE)
1877                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1878         ret = media_tag_insert_to_db(tag_name_2, &tag_2);
1879         if (ret != MEDIA_CONTENT_ERROR_NONE)
1880                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1881         ret = media_tag_insert_to_db(tag_name_3, &tag_3);
1882         if (ret != MEDIA_CONTENT_ERROR_NONE)
1883                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1884
1885         /* Add media to Tag */
1886         ret = media_tag_add_media(tag_1, test_audio_id);
1887         if (ret != MEDIA_CONTENT_ERROR_NONE)
1888                 media_content_error("error media_tag_add_media : [%d]", ret);
1889         ret = media_tag_add_media(tag_1, test_video_id);
1890         if (ret != MEDIA_CONTENT_ERROR_NONE)
1891                 media_content_error("error media_tag_add_media : [%d]", ret);
1892         ret = media_tag_update_to_db(tag_1);
1893         if (ret != MEDIA_CONTENT_ERROR_NONE)
1894                 media_content_error("error media_tag_update_to_db : [%d]", ret);
1895
1896         ret = media_tag_add_media(tag_2, test_audio_id);
1897         if (ret != MEDIA_CONTENT_ERROR_NONE)
1898                 media_content_error("error media_tag_add_media : [%d]", ret);
1899         ret = media_tag_update_to_db(tag_2);
1900         if (ret != MEDIA_CONTENT_ERROR_NONE)
1901                 media_content_error("error media_tag_update_to_db : [%d]", ret);
1902
1903         /* Get Tag Count*/
1904         ret = media_tag_get_tag_count_from_db(filter, &tag_count);
1905         if (ret != MEDIA_CONTENT_ERROR_NONE)
1906                 media_content_error("error media_tag_get_tag_count_from_db : [%d]", ret);
1907         else
1908                 media_content_debug("tag_count [%d]", tag_count);
1909
1910         /* Get Tag*/
1911         ret = media_tag_foreach_tag_from_db(filter, tag_list_cb, NULL);
1912         if (ret != MEDIA_CONTENT_ERROR_NONE)
1913                 media_content_error("error media_tag_foreach_tag_from_db : [%d]", ret);
1914
1915         /* Get Tag id*/
1916         ret = media_tag_get_tag_id(tag_1, &tag_id_1);
1917         if (ret != MEDIA_CONTENT_ERROR_NONE)
1918                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1919         else
1920                 media_content_debug("tag_id_1 [%d]", tag_id_1);
1921
1922         ret = media_tag_get_tag_id(tag_2, &tag_id_2);
1923         if (ret != MEDIA_CONTENT_ERROR_NONE)
1924                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1925         else
1926                 media_content_debug("tag_id_2 [%d]", tag_id_2);
1927
1928         ret = media_tag_get_tag_id(tag_3, &tag_id_3);
1929         if (ret != MEDIA_CONTENT_ERROR_NONE)
1930                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1931         else
1932                 media_content_debug("tag_id_3 [%d]", tag_id_3);
1933
1934         /* Get media count */
1935         ret = media_tag_get_media_count_from_db(tag_id_1, NULL, &media_count);
1936         if (ret != MEDIA_CONTENT_ERROR_NONE)
1937                 media_content_error("error media_tag_get_media_count_from_db : [%d]", ret);
1938         else
1939                 media_content_debug("tag_1_media_count [%d]", media_count);
1940
1941         ret = media_tag_get_media_count_from_db(tag_id_2, NULL, &media_count);
1942         if (ret != MEDIA_CONTENT_ERROR_NONE)
1943                 media_content_error("error media_tag_get_media_count_from_db : [%d]", ret);
1944         else
1945                 media_content_debug("tag_2_media_count [%d]", media_count);
1946
1947         /* Get media of Tag */
1948         ret = media_tag_foreach_media_from_db(tag_id_1, NULL, media_item_cb, NULL);
1949         if (ret != MEDIA_CONTENT_ERROR_NONE)
1950                 media_content_error("error media_tag_foreach_media_from_db : [%d]", ret);
1951
1952         ret = media_tag_foreach_media_from_db(tag_id_2, NULL, media_item_cb, NULL);
1953         if (ret != MEDIA_CONTENT_ERROR_NONE)
1954                 media_content_error("error media_tag_foreach_media_from_db : [%d]", ret);
1955
1956         /* Update Tag */
1957         ret = media_tag_add_media(tag_2, test_video_id);
1958         if (ret != MEDIA_CONTENT_ERROR_NONE)
1959                 media_content_error("error media_tag_add_media : [%d]", ret);
1960         ret = media_tag_set_name(tag_2, (char *)"test_tag");
1961         if (ret != MEDIA_CONTENT_ERROR_NONE)
1962                 media_content_error("error media_tag_set_name : [%d]", ret);
1963         ret = media_tag_update_to_db(tag_2);
1964         if (ret != MEDIA_CONTENT_ERROR_NONE)
1965                 media_content_error("error media_tag_update_to_db : [%d]", ret);
1966
1967         /* Get Updated Tag*/
1968         ret = media_tag_foreach_tag_from_db(filter, tag_list_cb, NULL);
1969         if (ret != MEDIA_CONTENT_ERROR_NONE)
1970                 media_content_error("error media_tag_foreach_tag_from_db : [%d]", ret);
1971
1972         /* deletes the tag */
1973         ret = media_tag_delete_from_db(tag_id_1);
1974         if (ret != MEDIA_CONTENT_ERROR_NONE)
1975                 media_content_error("error media_tag_delete_from_db : [%d]", ret);
1976         ret = media_tag_delete_from_db(tag_id_2);
1977         if (ret != MEDIA_CONTENT_ERROR_NONE)
1978                 media_content_error("error media_tag_delete_from_db : [%d]", ret);
1979
1980         ret = media_tag_destroy(tag_1);
1981         if (ret != MEDIA_CONTENT_ERROR_NONE)
1982                 media_content_error("error media_tag_destroy : [%d]", ret);
1983         ret = media_tag_destroy(tag_2);
1984         if (ret != MEDIA_CONTENT_ERROR_NONE)
1985                 media_content_error("error media_tag_destroy : [%d]", ret);
1986         ret = media_filter_destroy(filter);
1987         if (ret != MEDIA_CONTENT_ERROR_NONE)
1988                 media_content_error("error media_filter_destroy : [%d]", ret);
1989
1990         return ret;
1991 }
1992
1993
1994 int test_bookmark_operation(void)
1995 {
1996         //bookmark is only supported for video information.
1997         int ret = MEDIA_CONTENT_ERROR_NONE;
1998         int bookmark_count = 0;
1999         filter_h filter;
2000
2001         media_content_debug("\n============Bookmark Test============\n\n");
2002
2003         const char *g_condition = "BOOKMARK_MARKED_TIME > 300";
2004
2005         ret = media_filter_create(&filter);
2006         if (ret != MEDIA_CONTENT_ERROR_NONE)
2007                 media_content_error("error media_filter_create : [%d]", ret);
2008
2009         ret = media_filter_set_condition(filter, g_condition, MEDIA_CONTENT_COLLATE_DEFAULT);
2010         if (ret != MEDIA_CONTENT_ERROR_NONE)
2011                 media_content_error("error media_filter_set_condition : [%d]", ret);
2012
2013         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, BOOKMARK_MARKED_TIME, MEDIA_CONTENT_COLLATE_DEFAULT);
2014         if (ret != MEDIA_CONTENT_ERROR_NONE)
2015                 media_content_error("error media_filter_set_order : [%d]", ret);
2016
2017         //insert bookmark to video
2018         const char *thumbnail_path1 = tzplatform_mkpath(TZ_USER_CONTENT, "Images and videos/My video clips/teat11.jpg");
2019         ret = media_bookmark_insert_to_db(test_video_id, 400, thumbnail_path1);
2020         if (ret != MEDIA_CONTENT_ERROR_NONE)
2021                 media_content_error("error media_bookmark_insert_to_db : [%d]", ret);
2022
2023         ret = media_bookmark_insert_to_db(test_video_id, 600, thumbnail_path1);
2024         if (ret != MEDIA_CONTENT_ERROR_NONE)
2025                 media_content_error("error media_bookmark_insert_to_db : [%d]", ret);
2026
2027         ret = media_bookmark_get_bookmark_count_from_db(filter, &bookmark_count);
2028         if (ret != MEDIA_CONTENT_ERROR_NONE)
2029                 media_content_error("error media_bookmark_get_bookmark_count_from_db : [%d]", ret);
2030         else
2031                 media_content_debug("bookmark_count = [%d]", bookmark_count);
2032
2033         ret = media_filter_destroy(filter);
2034         if (ret != MEDIA_CONTENT_ERROR_NONE)
2035                 media_content_error("error media_filter_destroy : [%d]", ret);
2036
2037         return ret;
2038 }
2039
2040 int test_album_list(void)
2041 {
2042         media_content_debug("\n============Album Test============\n\n");
2043
2044         int ret = MEDIA_CONTENT_ERROR_NONE;
2045         int album_count = 0;
2046         filter_h filter;
2047
2048         /*Set Filter*/
2049         const char *condition = "MEDIA_TYPE=3"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/
2050
2051         ret = media_filter_create(&filter);
2052         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2053                 media_content_error("Fail to create filter");
2054                 return ret;
2055         }
2056         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
2057         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2058                 media_filter_destroy(filter);
2059                 media_content_error("Fail to set condition");
2060                 return ret;
2061         }
2062         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ALBUM, MEDIA_CONTENT_COLLATE_NOCASE);
2063         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2064                 media_filter_destroy(filter);
2065                 media_content_error("Fail to set order");
2066                 return ret;
2067         }
2068
2069         ret = media_album_get_album_count_from_db(filter, &album_count);
2070         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2071                 media_filter_destroy(filter);
2072                 return ret;
2073         } else {
2074                 media_content_debug("album_count [%d]", album_count);
2075         }
2076
2077         ret = media_album_foreach_album_from_db(filter, album_list_cb, NULL);
2078         if (ret != MEDIA_CONTENT_ERROR_NONE)
2079                 media_content_error("error media_album_foreach_album_from_db : [%d]", ret);
2080
2081         ret = media_filter_destroy(filter);
2082         if (ret != MEDIA_CONTENT_ERROR_NONE)
2083                 media_content_error("error media_filter_destroy : [%d]", ret);
2084
2085         return ret;
2086 }
2087
2088 int test_group_operation(void)
2089 {
2090         media_content_debug("\n============Group Test============\n\n");
2091
2092         int ret = MEDIA_CONTENT_ERROR_NONE;
2093         int group_count = 0;
2094         int idx = 0;
2095
2096         ret = test_filter_create();
2097         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2098                 media_content_error("[error(0x%08x)", ret);
2099                 return ret;
2100         }
2101
2102         for (idx = 0; idx < MEDIA_CONTENT_GROUP_MAX; idx++) {
2103                 ret = media_group_get_group_count_from_db(g_filter, idx, &group_count);
2104                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
2105                         test_filter_destroy();
2106                         media_content_error("media_group_get_group_count_from_db fail. idx=[%d]", ret, idx);
2107                         return ret;
2108                 } else {
2109                         media_content_debug("[%2d]group_count [%d]", idx, group_count);
2110                 }
2111
2112                 ret = media_group_foreach_group_from_db(g_filter, idx, group_list_cb, &idx);
2113         }
2114         ret = test_filter_destroy();
2115
2116         return ret;
2117 }
2118
2119 int test_update_operation()
2120 {
2121         int ret = MEDIA_CONTENT_ERROR_NONE;
2122         unsigned int i = 0;
2123         media_info_h media_handle = NULL;
2124         GList *all_item_list = NULL;
2125
2126         /* Get all item list */
2127         ret = media_info_foreach_media_from_db(NULL, gallery_media_item_cb, &all_item_list);
2128         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2129                 media_content_error("media_info_foreach_media_from_db failed: %d", ret);
2130                 return -1;
2131         } else {
2132                 media_content_debug("media_info_foreach_media_from_db success");
2133                 char *media_id = NULL;
2134                 char *media_path = NULL;
2135                 media_content_type_e media_type = 0;
2136
2137                 for (i = 0; i < g_list_length(all_item_list); i++) {
2138                         media_handle = (media_info_h)g_list_nth_data(all_item_list, i);
2139
2140                         ret = media_info_get_media_id(media_handle, &media_id);
2141                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2142                                 media_content_error("media_info_get_media_id failed: %d", ret);
2143                         ret = media_info_get_file_path(media_handle, &media_path);
2144                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2145                                 media_content_error("media_info_get_file_path failed: %d", ret);
2146                         ret = media_info_get_media_type(media_handle, &media_type);
2147                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2148                                 media_content_error("media_info_get_media_type failed: %d", ret);
2149
2150                         media_content_debug("media_id [%d] : %s", i, media_id);
2151                         media_content_debug("media_type [%d] : %d", i, media_type);
2152                         media_content_debug("media_path [%d] : %s", i, media_path);
2153 #if 0
2154                         if (media_type == MEDIA_CONTENT_TYPE_IMAGE) {
2155                                 image_meta_h image_handle;
2156                                 media_content_orientation_e orientation;
2157
2158                                 ret = media_info_get_image(media_handle, &image_handle);
2159                                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
2160                                         media_content_error("media_info_get_image failed: %d", ret);
2161                                 } else {
2162                                         media_content_debug("media_info_get_image success");
2163
2164                                         //update image meta
2165                                         orientation = MEDIA_CONTENT_ORIENTATION_ROT_180;
2166                                         image_meta_set_orientation(image_handle, orientation);
2167
2168                                         ret = image_meta_update_to_db(image_handle);
2169                                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2170                                                 media_content_error("image_meta_update_to_db failed: %d", ret);
2171                                         } else {
2172                                                 media_content_debug("image_meta_update_to_db success");
2173                                         }
2174                                 }
2175
2176                         } else if (media_type == MEDIA_CONTENT_TYPE_VIDEO) {
2177                                 video_meta_h video_handle;
2178
2179                                 ret = media_info_get_video(media_handle, &video_handle);
2180                                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
2181                                         media_content_error("media_info_get_video failed: %d", ret);
2182                                 } else {
2183                                         media_content_debug("media_info_get_video success");
2184
2185                                         //update video meta
2186                                         video_meta_set_played_count(video_handle, 5);
2187                                         video_meta_set_played_time(video_handle, 5);
2188                                         video_meta_set_played_position(video_handle, 5);
2189                                         video_meta_update_to_db(video_handle);
2190
2191                                         ret = video_meta_update_to_db(video_handle);
2192                                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2193                                                 media_content_error("video_meta_update_to_db failed: %d", ret);
2194                                         } else {
2195                                                 media_content_debug("video_meta_update_to_db success");
2196                                         }
2197                                 }
2198                         } else if (media_type == MEDIA_CONTENT_TYPE_MUSIC) {//update audio meta
2199                                 audio_meta_h audio_handle = NULL;
2200                                 ret = media_info_get_audio(media_handle, &audio_handle);
2201                                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
2202                                         media_content_error("media_info_get_audio failed: %d", ret);
2203                                 } else {
2204                                         media_content_debug("media_info_get_audio success");
2205
2206                                         audio_meta_set_played_count(audio_handle, 5);
2207                                         audio_meta_set_played_time(audio_handle, 1000);
2208                                         audio_meta_set_played_position(audio_handle, 180);
2209
2210                                         ret = audio_meta_update_to_db(audio_handle);
2211                                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2212                                                 media_content_error("audio_meta_update_to_db failed: %d", ret);
2213                                         } else {
2214                                                 media_content_debug("audio_meta_update_to_db success");
2215                                         }
2216                                 }
2217
2218                         }
2219 #endif
2220                 }
2221
2222                 /* fix prevent: Resource Leak */
2223                 SAFE_FREE(media_id);
2224                 SAFE_FREE(media_path);
2225         }
2226
2227         return MEDIA_CONTENT_ERROR_NONE;
2228 }
2229
2230 int test_insert(void)
2231 {
2232         int ret = MEDIA_CONTENT_ERROR_NONE;
2233         const char *path = "/opt/usr/media/Images/Default.jpg";
2234         //const char *path = "/opt/usr/media/Others/other.txt";
2235         //char *path = NULL;
2236         media_info_h media_item = NULL;
2237         media_content_debug("\n============DB Insert Test============\n\n");
2238
2239         ret = media_info_insert_to_db(path, &media_item);
2240
2241         if ((ret == MEDIA_CONTENT_ERROR_NONE) && (media_item != NULL)) {
2242                 media_content_debug("Insertion is success");
2243         } else {
2244                 media_content_error("Insertion is failed");
2245                 ret = media_info_destroy(media_item);
2246                 return ret;
2247         }
2248
2249         char *media_id = NULL;
2250
2251         ret = media_info_get_media_id(media_item, &media_id);
2252         if (ret != MEDIA_CONTENT_ERROR_NONE)
2253                 media_content_error("media_info_get_media_id failed: %d", ret);
2254         else
2255                 media_content_debug("Media ID: %s", media_id);
2256
2257         SAFE_FREE(media_id);
2258
2259         ret = media_info_update_to_db(media_item);
2260         if (ret == MEDIA_CONTENT_ERROR_NONE)
2261                 media_content_debug("media_info_update_to_db is success");
2262         else
2263                 media_content_error("media_info_update_to_db is failed");
2264
2265         ret = media_info_destroy(media_item);
2266         if (ret != MEDIA_CONTENT_ERROR_NONE)
2267                 media_content_error("media_info_destroy failed: %d", ret);
2268
2269         return ret;
2270 }
2271
2272 int test_move(void)
2273 {
2274         int ret = MEDIA_CONTENT_ERROR_NONE;
2275         const char *move_media_id = "60aea677-4742-408e-b5f7-f2628062d06d";
2276         const char *dst_path = tzplatform_mkpath(TZ_USER_CONTENT, "Images/XX/Default1.jpg");
2277         media_info_h move_media = NULL;
2278
2279         ret = media_info_get_media_from_db(move_media_id, &move_media);
2280         if (ret == MEDIA_CONTENT_ERROR_NONE)
2281                 media_content_debug("media_info_get_media_from_db success");
2282         else
2283                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2284
2285         media_content_debug("\n============DB Move Test============\n\n");
2286
2287         if (move_media) {
2288                 ret = media_info_move_to_db(move_media, dst_path);
2289
2290                 if (ret == MEDIA_CONTENT_ERROR_NONE)
2291                         media_content_debug("Move is success");
2292                 else
2293                         media_content_error("Move is failed");
2294
2295                 ret = media_info_destroy(move_media);
2296         } else {
2297                 media_content_debug("There is no item : %s", move_media_id);
2298         }
2299
2300         return ret;
2301 }
2302
2303 void thumbnail_completed_cb(media_content_error_e error, const char *path, void *user_data)
2304 {
2305         char *thumbnail_path = NULL;
2306         int ret = MEDIA_CONTENT_ERROR_NONE;
2307         g_cnt++;
2308
2309         media_content_debug("=================[%d][%d]", g_media_cnt, g_cnt);
2310         media_content_debug("error_code [%d]", error);
2311         media_content_debug("thumbnail_path [%s]", path);
2312         if (user_data != NULL) {
2313                 media_info_h media = (media_info_h)user_data;
2314                 ret = media_info_get_thumbnail_path(media, &thumbnail_path);
2315                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2316                         media_content_error("media_info_get_thumbnail_path failed: %d", ret);
2317                 else
2318                         media_content_debug("thumbnail_path get from media[%s]", thumbnail_path);
2319                 SAFE_FREE(thumbnail_path);
2320                 ret = media_info_destroy(media);
2321                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2322                         media_content_error("media_info_destroy failed: %d", ret);
2323         }
2324
2325         if (g_cnt == g_media_cnt)
2326                 g_main_loop_quit(g_loop);
2327
2328         return;
2329 }
2330
2331 bool thumbnail_create_cb(media_info_h media, void *user_data)
2332 {
2333         char *media_id = NULL;
2334         media_info_h dst = NULL;
2335         int ret = MEDIA_CONTENT_ERROR_NONE;
2336
2337         if (media == NULL) {
2338                 media_content_debug("NO Item");
2339                 return true;
2340         }
2341
2342         ret = media_info_get_media_id(media, &media_id);
2343         if (ret != MEDIA_CONTENT_ERROR_NONE)
2344                 media_content_error("media_info_get_media_id failed: %d", ret);
2345         else
2346                 media_content_debug("media_id : [%s]", media_id);
2347
2348         ret = media_info_clone(&dst, media);
2349         if (ret != MEDIA_CONTENT_ERROR_NONE)
2350                 media_content_error("media_info_clone failed: %d", ret);
2351         else {
2352                 ret = media_info_create_thumbnail(dst, thumbnail_completed_cb, dst);
2353                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2354                         media_content_error("media_info_create_thumbnail failed: %d", ret);
2355         }
2356
2357         /* fix prevent: Resource leak */
2358         SAFE_FREE(media_id);
2359
2360         return true;
2361 }
2362
2363 bool thumbnail_cancel_cb(media_info_h media, void *user_data)
2364 {
2365         int ret = MEDIA_CONTENT_ERROR_NONE;
2366
2367         char *media_id = NULL;
2368         media_info_h dst = NULL;
2369
2370         g_cnt++;
2371
2372         if (media == NULL) {
2373                 media_content_debug("NO Item");
2374                 return true;
2375         }
2376
2377         ret = media_info_get_media_id(media, &media_id);
2378         if (ret != MEDIA_CONTENT_ERROR_NONE)
2379                 media_content_error("media_info_get_media_id failed: %d", ret);
2380         else
2381                 media_content_debug("media_id : [%s]", media_id);
2382
2383         ret = media_info_clone(&dst, media);
2384         if (ret != MEDIA_CONTENT_ERROR_NONE)
2385                 media_content_error("media_info_clone failed: %d", ret);
2386
2387         ret = media_info_cancel_thumbnail(dst);
2388         if (ret != MEDIA_CONTENT_ERROR_NONE)
2389                 media_content_error("media_info_cancel_thumbnail failed: %d", ret);
2390
2391         ret = media_info_destroy(dst);
2392         if (ret != MEDIA_CONTENT_ERROR_NONE)
2393                         media_content_error("media_info_destroy failed: %d", ret);
2394
2395         if (g_cnt == g_media_cnt)
2396                 g_main_loop_quit(g_loop);
2397
2398         /* fix prevent: Resource leak */
2399         SAFE_FREE(media_id);
2400
2401         return true;
2402 }
2403
2404 gboolean create_thumbnail_start(gpointer data)
2405 {
2406         int ret = MEDIA_CONTENT_ERROR_NONE;
2407
2408         ret = media_info_foreach_media_from_db(g_filter, thumbnail_create_cb, NULL);
2409
2410         if (ret == MEDIA_CONTENT_ERROR_NONE)
2411                 media_content_debug("media_info_foreach_media_from_db is success");
2412         else
2413                 media_content_error("media_info_foreach_media_from_db is failed");
2414
2415         return false;
2416 }
2417
2418 gboolean cancel_thumbnail_start(gpointer data)
2419 {
2420         int ret = MEDIA_CONTENT_ERROR_NONE;
2421
2422         ret = media_info_foreach_media_from_db(g_filter, thumbnail_cancel_cb, NULL);
2423
2424         if (ret == MEDIA_CONTENT_ERROR_NONE)
2425                 media_content_debug("media_info_foreach_media_from_db is success");
2426         else
2427                 media_content_error("media_info_foreach_media_from_db is failed");
2428
2429         return false;
2430 }
2431
2432 int test_create_thumbnail(int cancel)
2433 {
2434         int ret = MEDIA_CONTENT_ERROR_NONE;
2435         GSource *source = NULL;
2436         GMainContext *context = NULL;
2437
2438         test_filter_create();
2439
2440         ret = media_info_get_media_count_from_db(g_filter, &g_media_cnt);
2441         if (ret != MEDIA_CONTENT_ERROR_NONE)
2442                 media_content_error("media_info_get_media_count_from_db failed: %d", ret);
2443         else
2444                 media_content_debug("media_count : [%d]", g_media_cnt);
2445
2446         g_loop = g_main_loop_new(NULL, FALSE);
2447         context = g_main_loop_get_context(g_loop);
2448         source = g_idle_source_new();
2449         g_source_set_callback(source, create_thumbnail_start, NULL, NULL);
2450         g_source_attach(source, context);
2451
2452         /* Logic to cancel */
2453         if (cancel) {
2454                 GSource *cancel_src = NULL;
2455                 cancel_src = g_idle_source_new();
2456                 g_source_set_callback(cancel_src, cancel_thumbnail_start, NULL, NULL);
2457                 g_source_attach(cancel_src, context);
2458         }
2459
2460         g_main_loop_run(g_loop);
2461         g_main_loop_unref(g_loop);
2462
2463         test_filter_destroy();
2464
2465         return ret;
2466 }
2467
2468 int test_disconnect_database(void)
2469 {
2470         int ret = MEDIA_CONTENT_ERROR_NONE;
2471         media_content_debug("\n============DB Disconnection Test============\n\n");
2472
2473         ret = media_content_disconnect();
2474
2475         if (ret == MEDIA_CONTENT_ERROR_NONE)
2476                 media_content_debug("disconnection is success");
2477         else
2478                 media_content_error("disconnection is failed");
2479
2480         return ret;
2481 }
2482
2483 int test_request_update_db(void)
2484 {
2485         int ret = MEDIA_CONTENT_ERROR_NONE;
2486         media_info_h media = NULL;
2487         char *content_name = NULL;
2488         bool favorite = FALSE;
2489
2490         //get the content of Over the horizon
2491         ret = media_info_get_media_from_db("71b19196-5b38-4ab1-ab34-bfe05c369614", &media);
2492         if (ret != MEDIA_CONTENT_ERROR_NONE)
2493                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2494
2495         ret = media_info_set_content_name(media, "TEST_content_name");
2496         if (ret != MEDIA_CONTENT_ERROR_NONE)
2497                 media_content_error("media_info_set_content_name failed: %d", ret);
2498
2499         ret = media_info_set_favorite(media, TRUE);
2500         if (ret != MEDIA_CONTENT_ERROR_NONE)
2501                 media_content_error("media_info_set_favorite failed: %d", ret);
2502
2503         ret = media_info_update_to_db(media);
2504         if (ret == MEDIA_CONTENT_ERROR_NONE)
2505                 media_content_debug("media_info_update_to_db is success");
2506         else
2507                 media_content_error("media_info_update_to_db is failed");
2508
2509         if (media != NULL)
2510                 media_info_destroy(media);
2511
2512         /*get the updated value*/
2513         ret = media_info_get_media_from_db("71b19196-5b38-4ab1-ab34-bfe05c369614", &media);
2514         if (ret != MEDIA_CONTENT_ERROR_NONE)
2515                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2516
2517         ret = media_info_get_content_name(media, &content_name);
2518         if (ret != MEDIA_CONTENT_ERROR_NONE)
2519                 media_content_error("media_info_get_content_name failed: %d", ret);
2520         else
2521                 media_content_debug("content name [%s]", content_name);
2522
2523         SAFE_FREE(content_name);
2524
2525         ret = media_info_get_favorite(media, &favorite);
2526         if (ret != MEDIA_CONTENT_ERROR_NONE)
2527                 media_content_error("media_info_get_favorite failed: %d", ret);
2528         else
2529                 media_content_debug("favorite [%d]", favorite);
2530
2531         ret = media_info_destroy(media);
2532
2533         return ret;
2534 }
2535
2536 int g_total_photo_size = 0;
2537 int g_total_video_size = 0;
2538 int g_total_mp3_size = 0;
2539 int g_total_voice_memo_size = 0;
2540
2541 bool dft_cb(media_info_h media, void *user_data)
2542 {
2543         unsigned long long file_size = 0;
2544         media_content_type_e media_type = -1;
2545         char *mime_type = NULL;
2546         int ret = MEDIA_CONTENT_ERROR_NONE;
2547
2548         if (media == NULL)
2549                 return true;
2550
2551         ret = media_info_get_media_type(media, &media_type);
2552         if (ret != MEDIA_CONTENT_ERROR_NONE)
2553                 media_content_error("media_info_get_media_type failed: %d", ret);
2554         ret = media_info_get_size(media, &file_size);
2555         if (ret != MEDIA_CONTENT_ERROR_NONE)
2556                 media_content_error("media_info_get_size failed: %d", ret);
2557         ret = media_info_get_mime_type(media, &mime_type);
2558         if (ret != MEDIA_CONTENT_ERROR_NONE)
2559                 media_content_error("media_info_get_mime_type failed: %d", ret);
2560
2561         if (media_type == MEDIA_CONTENT_TYPE_IMAGE)
2562                 g_total_photo_size += file_size;
2563         else if (media_type == MEDIA_CONTENT_TYPE_VIDEO)
2564                 g_total_video_size += file_size;
2565         else if (media_type == MEDIA_CONTENT_TYPE_SOUND)
2566                 g_total_voice_memo_size += file_size;
2567         else if (media_type == MEDIA_CONTENT_TYPE_MUSIC) {
2568                 if ((mime_type != NULL) && (!strcmp("audio/mpeg", mime_type)))
2569                         g_total_mp3_size += file_size;
2570                 else
2571                         g_total_voice_memo_size += file_size;
2572         } else
2573                 media_content_debug("invalid media_type");
2574
2575         if (mime_type != NULL)
2576                 free(mime_type);
2577
2578         return true;
2579
2580 }
2581
2582 int DFT_test(void)
2583 {
2584         int ret = MEDIA_CONTENT_ERROR_NONE;
2585         media_content_debug("\n============DFT_test============\n\n");
2586
2587         filter_h filter = NULL;
2588         int media_cnt = 0;
2589
2590         /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
2591
2592         ret = media_filter_create(&filter);
2593
2594 /*Internal Memory*/
2595         media_content_debug("[Internal Memory]\n");
2596         /*1. Photo ============================================================*/
2597         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
2598
2599         /*Get Photo Count*/
2600         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2601         media_content_debug("Photo count = [%d]\n", media_cnt);
2602
2603         /*Get Photo Size*/
2604         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2605         media_content_debug("Photo size = [%d]\n", g_total_photo_size);
2606
2607         /*2. Video ============================================================*/
2608         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
2609
2610         /*Get Video Count*/
2611         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2612         media_content_debug("Video count = [%d]\n", media_cnt);
2613
2614         /*Get Video Size*/
2615         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2616         media_content_debug("Video size = [%d]\n", g_total_video_size);
2617
2618         /*3. MP3 ============================================================*/
2619         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
2620
2621         /*Get MP3 Count*/
2622         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2623         media_content_debug("MP3 count = [%d]\n", media_cnt);
2624
2625         /*Get MP3 Size*/
2626         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2627         media_content_debug("MP3 size = [%d]\n", g_total_mp3_size);
2628
2629         /*4. Voice Memo ============================================================*/
2630         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND (MEDIA_MIME_TYPE=\"audio/AMR\" OR MEDIA_MIME_TYPE=\"audio/mp4\")", MEDIA_CONTENT_COLLATE_DEFAULT);
2631
2632         /*Get Voice Memo Count*/
2633         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2634         media_content_debug("Voice Memo count = [%d]\n", media_cnt);
2635
2636         /*Get Voice Memo Size*/
2637         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2638         media_content_debug("Voice Memo size = [%d]\n", g_total_voice_memo_size);
2639
2640         g_total_photo_size = 0;
2641         g_total_video_size = 0;
2642         g_total_mp3_size = 0;
2643         g_total_voice_memo_size = 0;
2644
2645 /*External Memory*/
2646         media_content_debug("\n[External Memory]\n");
2647         /*1. Photo ============================================================*/
2648         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
2649
2650         /*Get Photo Count*/
2651         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2652         media_content_debug("Photo count = [%d]\n", media_cnt);
2653
2654         /*Get Photo Size*/
2655         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2656         media_content_debug("Photo size = [%d]\n", g_total_photo_size);
2657
2658         /*2. Video ============================================================*/
2659         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
2660
2661         /*Get Video Count*/
2662         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2663         media_content_debug("Video count = [%d]\n", media_cnt);
2664
2665         /*Get Video Size*/
2666         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2667         media_content_debug("Video size = [%d]\n", g_total_video_size);
2668
2669         /*3. MP3 ============================================================*/
2670         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
2671
2672         /*Get MP3 Count*/
2673         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2674         media_content_debug("MP3 count = [%d]\n", media_cnt);
2675
2676         /*Get MP3 Size*/
2677         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2678         media_content_debug("MP3 size = [%d]\n", g_total_mp3_size);
2679
2680         /*4. Voice Memo ============================================================*/
2681         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND (MEDIA_MIME_TYPE=\"audio/AMR\" OR MEDIA_MIME_TYPE=\"audio/mp4\")", MEDIA_CONTENT_COLLATE_DEFAULT);
2682
2683         /*Get Voice Memo Count*/
2684         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2685         media_content_debug("Voice Memo count = [%d]\n", media_cnt);
2686
2687         /*Get Voice Memo Size*/
2688         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2689         media_content_debug("Voice Memo size = [%d]\n", g_total_voice_memo_size);
2690         ret = media_filter_destroy(filter);
2691
2692         return ret;
2693 }
2694
2695 void insert_batch_cb(media_content_error_e error, void * user_data)
2696 {
2697         media_content_debug("media_info_insert_batch_to_db completed!\n");
2698 }
2699
2700 int test_batch_operations()
2701 {
2702         int ret = -1;
2703         int i;
2704         char *file_list[10];
2705
2706         for (i = 0; i < 10; i++) {
2707                 char filepath[255] = {0,};
2708                 snprintf(filepath, sizeof(filepath), "%s%d.jpg", tzplatform_mkpath(TZ_USER_CONTENT, "test/image"), i+1);
2709                 media_content_debug("File : %s\n", filepath);
2710                 file_list[i] = strdup(filepath);
2711         }
2712
2713         ret = media_info_insert_batch_to_db((const char **)file_list, 10, insert_batch_cb, NULL);
2714         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2715                 media_content_error("media_info_insert_batch_to_db failed : %d\n", ret);
2716         }
2717
2718         filter_h filter;
2719         char *condition = "MEDIA_PATH LIKE \'";
2720         strncat(condition, tzplatform_mkpath(TZ_USER_CONTENT, "test/image%%jpg\'"), 17);
2721         ret = media_filter_create(&filter);
2722         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2723                 media_content_error("Fail to create filter");
2724                 return ret;
2725         }
2726
2727         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
2728         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2729                 media_filter_destroy(filter);
2730                 media_content_error("Fail to set condition");
2731                 return ret;
2732         }
2733
2734         ret = media_info_delete_batch_from_db(filter);
2735         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2736                 media_filter_destroy(filter);
2737                 media_content_error("media_info_delete_batch_from_db failed : %d\n", ret);
2738                 return ret;
2739         }
2740
2741         ret = media_filter_destroy(filter);
2742
2743         return ret;
2744 }
2745
2746 void insert_burst_shot_cb(media_content_error_e error, void * user_data)
2747 {
2748         media_content_debug("media_info_insert_burst_shot_to_db completed![%d]\n", error);
2749         g_main_loop_quit(g_loop);
2750 }
2751
2752 gboolean test_insert_burst_shot_to_db_start(gpointer data)
2753 {
2754         int ret = MEDIA_CONTENT_ERROR_NONE;
2755         int i = 0;
2756         char *file_list[10];
2757
2758         for (i = 0; i < 10; i++) {
2759                 char filepath[255] = {0,};
2760                 snprintf(filepath, sizeof(filepath), "%s%d.jpg", tzplatform_mkpath(TZ_USER_CONTENT, "test/image"), i+1);
2761                 media_content_debug("File : %s\n", filepath);
2762                 file_list[i] = strdup(filepath);
2763         }
2764
2765         ret = media_info_insert_burst_shot_to_db((const char **)file_list, 10, insert_burst_shot_cb, NULL);
2766         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2767                 media_content_error("media_info_insert_burst_shot_to_db failed : %d\n", ret);
2768         }
2769
2770         return ret;
2771 }
2772
2773 int test_insert_burst_shot_to_db(void)
2774 {
2775         GSource *source = NULL;
2776         GMainContext *context = NULL;
2777
2778         g_loop = g_main_loop_new(NULL, FALSE);
2779         context = g_main_loop_get_context(g_loop);
2780         source = g_idle_source_new();
2781         g_source_set_callback(source, test_insert_burst_shot_to_db_start, NULL, NULL);
2782         g_source_attach(source, context);
2783
2784         g_main_loop_run(g_loop);
2785         g_main_loop_unref(g_loop);
2786
2787         return 0;
2788 }
2789
2790 void _scan_cb(media_content_error_e err, void *user_data)
2791 {
2792         media_content_debug("scan callback is called : %d\n", err);
2793         g_main_loop_quit(g_loop);
2794
2795         return;
2796 }
2797
2798 int test_scan_file()
2799 {
2800         int ret = -1;
2801
2802         const char *file_path = tzplatform_mkpath(TZ_USER_CONTENT, "test/image1.jpg");
2803         ret = media_content_scan_file(file_path);
2804         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2805                 media_content_error("Fail to media_content_scan_file : %d", ret);
2806                 return ret;
2807         }
2808
2809         return 0;
2810 }
2811
2812 gboolean test_scan_dir_start(gpointer data)
2813 {
2814         int ret = -1;
2815
2816         const char *dir_path = tzplatform_getenv(TZ_USER_CONTENT);
2817
2818         ret = media_content_scan_folder(dir_path, TRUE, _scan_cb, NULL);
2819
2820         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2821                 media_content_error("Fail to test_scan_dir_start : %d", ret);
2822                 return ret;
2823         }
2824
2825         return 0;
2826 }
2827
2828 gboolean cancel_scan_dir_start(gpointer data)
2829 {
2830         int ret = MEDIA_CONTENT_ERROR_NONE;
2831
2832         const char *dir_path = "/opt/usr/media/Images";
2833
2834         ret = media_content_cancel_scan_folder(dir_path);
2835
2836         if (ret == MEDIA_CONTENT_ERROR_NONE)
2837                 media_content_debug("media_content_cancel_scan_folder is success");
2838         else
2839                 media_content_error("media_content_cancel_scan_folder is failed");
2840
2841         return false;
2842 }
2843
2844 int test_scan_dir(int cancel)
2845 {
2846         GSource *source = NULL;
2847         GMainContext *context = NULL;
2848
2849         g_loop = g_main_loop_new(NULL, FALSE);
2850         context = g_main_loop_get_context(g_loop);
2851         source = g_idle_source_new();
2852         g_source_set_callback(source, test_scan_dir_start, NULL, NULL);
2853         g_source_attach(source, context);
2854
2855         if (cancel) {
2856                 GSource *cancel_src = NULL;
2857                 cancel_src = g_idle_source_new();
2858                 g_source_set_callback(cancel_src, cancel_scan_dir_start, NULL, NULL);
2859                 g_source_attach(cancel_src, context);
2860         }
2861
2862         g_main_loop_run(g_loop);
2863         g_main_loop_unref(g_loop);
2864
2865         return 0;
2866 }
2867
2868 void _noti_cb(media_content_error_e error,
2869                                 int pid,
2870                                 media_content_db_update_item_type_e update_item,
2871                                 media_content_db_update_type_e update_type,
2872                                 media_content_type_e media_type,
2873                                 char *uuid,
2874                                 char *path,
2875                                 char *mime_type,
2876                                 void *user_data)
2877 {
2878         if (error == 0) {
2879                 media_content_debug("noti success! : %d\n", error);
2880         } else {
2881                 media_content_debug("error occured! : %d\n", error);
2882         }
2883
2884         media_content_debug("Noti from PID(%d)\n", pid);
2885
2886         if (update_item == MEDIA_ITEM_FILE) {
2887                 media_content_debug("Noti item : MEDIA_ITEM_FILE\n");
2888         } else if (update_item == MEDIA_ITEM_DIRECTORY) {
2889                 media_content_debug("Noti item : MEDIA_ITEM_DIRECTORY\n");
2890         }
2891
2892         if (update_type == MEDIA_CONTENT_INSERT) {
2893                 media_content_debug("Noti type : MEDIA_CONTENT_INSERT\n");
2894         } else if (update_type == MEDIA_CONTENT_DELETE) {
2895                 media_content_debug("Noti type : MEDIA_CONTENT_DELETE\n");
2896         } else if (update_type == MEDIA_CONTENT_UPDATE) {
2897                 media_content_debug("Noti type : MEDIA_CONTENT_UPDATE\n");
2898         }
2899
2900         media_content_debug("content type : %d\n", media_type);
2901
2902         if (path)
2903                 media_content_debug("path : %s\n", path);
2904         else
2905                 media_content_debug("path not\n");
2906
2907         if (uuid)
2908                 media_content_debug("uuid : %s\n", uuid);
2909         else
2910                 media_content_debug("uuid not\n");
2911
2912         if (mime_type)
2913                 media_content_debug("mime_type : %s\n", mime_type);
2914         else
2915                 media_content_debug("mime not\n");
2916
2917         if (user_data) media_content_debug("String : %s\n", (char *)user_data);
2918
2919 //      g_main_loop_quit(g_loop);
2920         return;
2921 }
2922
2923 void _noti_cb_2(media_content_error_e error,
2924                                 int pid,
2925                                 media_content_db_update_item_type_e update_item,
2926                                 media_content_db_update_type_e update_type,
2927                                 media_content_type_e media_type,
2928                                 char *uuid,
2929                                 char *path,
2930                                 char *mime_type,
2931                                 void *user_data)
2932 {
2933         if (error == 0) {
2934                 media_content_debug("noti_2 success! : %d\n", error);
2935         } else {
2936                 media_content_debug("error occured! : %d\n", error);
2937         }
2938
2939         media_content_debug("Noti_2 from PID(%d)\n", pid);
2940
2941         g_main_loop_quit(g_loop);
2942         return;
2943 }
2944
2945 static media_content_noti_h noti_h;
2946 static media_content_noti_h noti_h_2;
2947
2948 gboolean _send_noti_operations(gpointer data)
2949 {
2950         int ret = MEDIA_CONTENT_ERROR_NONE;
2951
2952         /* First of all, noti subscription */
2953         char *user_str = strdup("hi");
2954         media_content_add_db_updated_cb(_noti_cb, (void*)user_str, &noti_h);
2955         media_content_add_db_updated_cb(_noti_cb_2, (void*)user_str, &noti_h_2);
2956
2957         /* media_info_insert_to_db */
2958         media_info_h media_item = NULL;
2959         const char *path = tzplatform_mkpath(TZ_USER_CONTENT, "test/image1.jpg");
2960
2961         ret = media_info_insert_to_db(path, &media_item);
2962         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2963                 media_content_error("media_info_insert_to_db failed : %d", ret);
2964                 media_info_destroy(media_item);
2965                 return FALSE;
2966         }
2967
2968         media_content_debug("media_info_insert_to_db success");
2969
2970         /* media_info_delete_batch_from_db */
2971         filter_h filter;
2972         char condition[2048] = {0,};
2973         const char *temp=  NULL;
2974         temp = tzplatform_mkpath(TZ_USER_CONTENT, "test/image%%\'");
2975         snprintf(condition, sizeof(condition), "MEDIA_PATH LIKE \'%s", temp);
2976 //      strncat(condition, temp, strlen(temp));
2977
2978         ret = media_filter_create(&filter);
2979         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2980                 media_content_error("Fail to create filter");
2981                 media_info_destroy(media_item);
2982                 return ret;
2983         }
2984
2985         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
2986         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2987                 media_filter_destroy(filter);
2988                 media_info_destroy(media_item);
2989                 media_content_error("Fail to set condition");
2990                 return ret;
2991         }
2992         ret = media_info_delete_batch_from_db(filter);
2993         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2994                 media_filter_destroy(filter);
2995                 media_info_destroy(media_item);
2996                 media_content_error("media_info_delete_batch_from_db failed : %d\n", ret);
2997                 return ret;
2998         }
2999
3000         media_filter_destroy(filter);
3001
3002         media_content_remove_db_updated_cb(noti_h);
3003
3004         /* media_info_update_to_db */
3005         ret = media_info_update_to_db(media_item);
3006         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3007                 media_content_error("media_info_update_to_db failed : %d\n", ret);
3008                 media_info_destroy(media_item);
3009                 return ret;
3010         }
3011
3012         media_info_destroy(media_item);
3013
3014         return FALSE;
3015 }
3016
3017 int test_noti()
3018 {
3019         int ret = MEDIA_CONTENT_ERROR_NONE;
3020         GSource *source = NULL;
3021         GMainContext *context = NULL;
3022
3023         g_loop = g_main_loop_new(NULL, FALSE);
3024         context = g_main_loop_get_context(g_loop);
3025         source = g_idle_source_new();
3026         g_source_set_callback(source, _send_noti_operations, NULL, NULL);
3027         g_source_attach(source, context);
3028
3029         g_main_loop_run(g_loop);
3030         g_main_loop_unref(g_loop);
3031
3032         test_filter_destroy();
3033         media_content_remove_db_updated_cb(noti_h_2);
3034
3035         return ret;
3036 }
3037
3038 int test_create_handle(void)
3039 {
3040         int ret = MEDIA_CONTENT_ERROR_NONE;
3041         media_info_h media = NULL;
3042         const char *path = "/home/owner/content/test/test.txt";
3043         char *str_value = NULL;
3044         int int_value = -1;
3045         bool bool_value = FALSE;
3046         unsigned long long content_size = 0;
3047         time_t modified_time = 0;
3048         double double_value = 0.0;
3049
3050         ret = media_info_create(path, &media);
3051
3052         ret = media_info_set_title(media, "test_title");
3053         ret = media_info_set_album(media, "test_album");
3054         ret = media_info_set_artist(media, "test_artist");
3055         ret = media_info_set_genre(media, "test_genre");
3056         ret = media_info_set_recorded_date(media, "test_recorded_date");
3057         ret = media_info_set_age_rating(media, "test_age_rating");
3058         ret = media_info_set_author(media, "test_author");
3059         ret = media_info_set_category(media, "test_category");
3060         ret = media_info_set_content_name(media, "test_content_name");
3061         ret = media_info_set_description(media, "test_description");
3062         ret = media_info_set_display_name(media, "test_display_name");
3063         ret = media_info_set_keyword(media, "test_keyword");
3064         ret = media_info_set_location_tag(media, "test_location_tag");
3065         ret = media_info_set_weather(media, "test_weather");
3066         ret = media_info_set_provider(media, "test_provider");
3067
3068         ret = media_info_set_altitude(media, 100.10);
3069         ret = media_info_set_latitude(media, 200.20);
3070         ret = media_info_set_longitude(media, 300.30);
3071         ret = media_info_set_rating(media, 10);
3072         ret = media_info_set_played_time(media);
3073         ret = media_info_set_favorite(media, TRUE);
3074         ret = media_info_increase_played_count(media);
3075         ret = media_info_set_added_time(media, 12345);
3076
3077         ret = media_info_insert_to_db_with_data(media);
3078         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3079                 media_content_error("media_info_insert_to_db_with_data failed : %d\n", ret);
3080                 media_info_destroy(media);
3081                 return ret;
3082         }
3083
3084         ret = media_info_get_media_id(media, &str_value);
3085         media_content_debug("media_id = [%s]", str_value);
3086         SAFE_FREE(str_value);
3087
3088         ret = media_info_get_file_path(media, &str_value);
3089         media_content_debug("file_path = [%s]", str_value);
3090         SAFE_FREE(str_value);
3091
3092         ret = media_info_get_title(media, &str_value);
3093         media_content_debug("title = [%s]", str_value);
3094         SAFE_FREE(str_value);
3095
3096         ret = media_info_get_age_rating(media, &str_value);
3097         media_content_debug("age_rating = [%s]", str_value);
3098         SAFE_FREE(str_value);
3099
3100         ret = media_info_get_author(media, &str_value);
3101         media_content_debug("author = [%s]", str_value);
3102         SAFE_FREE(str_value);
3103
3104         ret = media_info_get_category(media, &str_value);
3105         media_content_debug("category = [%s]", str_value);
3106         SAFE_FREE(str_value);
3107
3108         ret = media_info_get_content_name(media, &str_value);
3109         media_content_debug("content_name = [%s]", str_value);
3110         SAFE_FREE(str_value);
3111
3112         ret = media_info_get_description(media, &str_value);
3113         media_content_debug("description = [%s]", str_value);
3114         SAFE_FREE(str_value);
3115
3116         ret = media_info_get_display_name(media, &str_value);
3117         media_content_debug("display_name = [%s]", str_value);
3118         SAFE_FREE(str_value);
3119
3120         ret = media_info_get_keyword(media, &str_value);
3121         media_content_debug("keyword = [%s]", str_value);
3122         SAFE_FREE(str_value);
3123
3124         ret = media_info_get_location_tag(media, &str_value);
3125         media_content_debug("location_tag = [%s]", str_value);
3126         SAFE_FREE(str_value);
3127
3128         ret = media_info_get_weather(media, &str_value);
3129         media_content_debug("weather = [%s]", str_value);
3130         SAFE_FREE(str_value);
3131
3132         ret = media_info_get_provider(media, &str_value);
3133         media_content_debug("provider = [%s]", str_value);
3134         SAFE_FREE(str_value);
3135
3136         ret = media_info_get_longitude(media, &double_value);
3137         media_content_debug("longitude = [%lf]", double_value);
3138
3139         ret = media_info_get_latitude(media, &double_value);
3140         media_content_debug("latitude = [%lf]", double_value);
3141
3142         ret = media_info_get_altitude(media, &double_value);
3143         media_content_debug("altitud = [%lf]", double_value);
3144
3145         ret = media_info_get_rating(media, &int_value);
3146         media_content_debug("rating = [%d]", int_value);
3147
3148         ret = media_info_get_favorite(media, &bool_value);
3149         media_content_debug("favorite = [%d]", bool_value);
3150
3151         ret = media_info_get_played_time(media, &modified_time);
3152         media_content_debug("played_time = [%d]", modified_time);
3153
3154         ret = media_info_get_played_count(media, &int_value);
3155         media_content_debug("played_count = [%d]", int_value);
3156
3157         ret = media_info_get_added_time(media, &modified_time);
3158         media_content_debug("added_time = [%d]", modified_time);
3159
3160         ret = media_info_get_size(media, &content_size);
3161         media_content_debug("size = [%d]", content_size);
3162
3163         ret = media_info_get_modified_time(media, &modified_time);
3164         media_content_debug("modified_time = [%d]", modified_time);
3165
3166         ret = media_info_get_media_type(media, (media_content_type_e *)&int_value);
3167         media_content_debug("media_type = [%d]", int_value);
3168
3169         ret = media_info_get_storage_type(media, (media_content_storage_e *)&int_value);
3170         media_content_debug("storage_type = [%d]", int_value);
3171
3172         media_info_destroy(media);
3173
3174         return ret;
3175
3176 }
3177
3178 bool media_face_test_cb(media_face_h face, void *user_data)
3179 {
3180         char *face_id = NULL;
3181         char *media_id = NULL;
3182         unsigned int rect_x = 0;
3183         unsigned int rect_y = 0;
3184         unsigned int rect_w = 0;
3185         unsigned int rect_h = 0;
3186         media_content_orientation_e orientation = 0;
3187         char *face_tag = NULL;
3188
3189         media_face_get_face_id(face, &face_id);
3190         media_face_get_media_id(face, &media_id);
3191         media_face_get_face_rect(face, &rect_x, &rect_y, &rect_w, &rect_h);
3192         media_face_get_orientation(face, &orientation);
3193         media_face_get_tag(face, &face_tag);
3194
3195         media_content_debug("face_id [%s] media_id [%s]", face_id, media_id);
3196         media_content_debug("rect_x [%d] rect_y [%d] rect_w [%d] rect_h [%d] orientation [%d]", rect_x, rect_y, rect_w, rect_h, orientation);
3197         media_content_debug("tag [%s]", face_tag);
3198
3199         if (user_data != NULL) {
3200                 media_face_h new_face = NULL;
3201                 media_face_clone(&new_face, face);
3202
3203                 GList **list = (GList**)user_data;
3204                 *list = g_list_append(*list, new_face);
3205         }
3206
3207         SAFE_FREE(face_id);
3208         SAFE_FREE(media_id);
3209         SAFE_FREE(face_tag);
3210
3211         return true;
3212 }
3213
3214 int test_face(void)
3215 {
3216         int ret = MEDIA_CONTENT_ERROR_NONE;
3217         filter_h filter = NULL;
3218         GList *all_item_list = NULL;
3219         int i = 0;
3220
3221         ret = media_filter_create(&filter);
3222         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_filter_create");
3223
3224         ret = media_filter_set_condition(filter, "MEDIA_TYPE = 0", MEDIA_CONTENT_COLLATE_DEFAULT);
3225         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3226                 media_filter_destroy(filter);
3227                 media_content_error("Fail to set condition");
3228                 return ret;
3229         }
3230
3231         ret = media_info_foreach_media_from_db(filter, gallery_media_item_cb, &all_item_list);
3232         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3233                 media_content_error("media_info_foreach_media_from_db failed: %d", ret);
3234                 media_filter_destroy(filter);
3235                 return ret;
3236         }
3237
3238         for (i = 0; i < g_list_length(all_item_list); i++) {
3239                 media_info_h media_handle = NULL;
3240                 char *media_id = NULL;
3241                 int face_count = 0;
3242
3243                 media_handle = (media_info_h)g_list_nth_data(all_item_list, i);
3244
3245                 ret = media_info_get_media_id(media_handle, &media_id);
3246                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3247                         media_content_error("media_info_get_media_id failed: %d", ret);
3248
3249                 ret = media_info_get_face_count_from_db(media_id, filter, &face_count);
3250                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3251                         media_content_error("media_info_get_face_count_from_db failed: %d", ret);
3252
3253                 media_content_error("media_id [%s] face_count [%d]", media_id, face_count);
3254
3255                 ret = media_info_foreach_face_from_db(media_id, filter, media_face_test_cb, NULL);
3256                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3257                         media_content_error("media_info_foreach_face_from_db failed: %d", ret);
3258
3259                 media_info_destroy(media_handle);
3260         }
3261
3262         media_filter_destroy(filter);
3263
3264         return ret;
3265 }
3266
3267 int test_face_add_del(void)
3268 {
3269         int ret = MEDIA_CONTENT_ERROR_NONE;
3270         char *media_id = "ecca7366-e085-41d8-a12b-cbdfc2b9c5fc";
3271
3272         /* Insert Test */
3273         media_face_h face = NULL;
3274
3275         char *face_tag = "test_face_tag";
3276
3277         ret = media_face_create(media_id, &face);
3278         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_face_create");
3279
3280         ret = media_face_set_face_rect(face, 10, 12, 50, 100);
3281         ret = media_face_set_orientation(face, 5);
3282         ret = media_face_set_tag(face, face_tag);
3283
3284         ret = media_face_insert_to_db(face);
3285         ret = media_face_destroy(face);
3286
3287         /* Update Test */
3288         GList *all_item_list = NULL;
3289         filter_h filter = NULL;
3290         ret = media_filter_create(&filter);
3291         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_filter_create");
3292
3293         ret = media_filter_set_condition(filter, "MEDIA_FACE_TAG IS NOT NULL", MEDIA_CONTENT_COLLATE_DEFAULT);
3294         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3295                 media_filter_destroy(filter);
3296                 media_content_error("Fail to set condition");
3297                 return ret;
3298         }
3299
3300         ret = media_info_foreach_face_from_db(media_id, filter, media_face_test_cb, &all_item_list);
3301
3302         if (g_list_length(all_item_list) > 0) {
3303                 media_face_h face_handle = NULL;
3304                 face_handle = (media_face_h)g_list_nth_data(all_item_list, 0);
3305
3306                 ret = media_face_set_face_rect(face_handle, 20, 22, 70, 70);
3307                 ret = media_face_set_orientation(face_handle, 3);
3308                 ret = media_face_set_tag(face_handle, NULL);
3309                 ret = media_face_update_to_db(face_handle);
3310
3311                 media_face_destroy(face_handle);
3312         }
3313
3314         media_filter_destroy(filter);
3315
3316         /* Delete Test */
3317         char *face_id = "5e58a3a8-f0b2-4c29-b799-b49a70dc2313";
3318
3319         /* Delete Test*/
3320         ret = media_face_delete_from_db(face_id);
3321
3322         return ret;
3323 }
3324
3325 int main(int argc, char *argv[])
3326 {
3327         int ret = MEDIA_CONTENT_ERROR_NONE;
3328
3329         media_content_debug("--- content manager test start ---\n\n");
3330
3331         ret = test_connect_database();
3332         if (ret != MEDIA_CONTENT_ERROR_NONE)
3333                 return MEDIA_CONTENT_ERROR_NONE;
3334
3335 #if 0
3336         ret = test_move();
3337         if (ret != MEDIA_CONTENT_ERROR_NONE)
3338                 return ret;
3339
3340         ret = test_gallery_scenario();
3341         if (ret != MEDIA_CONTENT_ERROR_NONE)
3342                 return ret;
3343
3344         ret = test_get_all_music_files();
3345         if (ret != MEDIA_CONTENT_ERROR_NONE)
3346                 return ret;
3347
3348         ret = test_media_info_operation();
3349         if (ret != MEDIA_CONTENT_ERROR_NONE)
3350                 return ret;
3351
3352         ret = test_folder_operation();
3353         if (ret != MEDIA_CONTENT_ERROR_NONE)
3354                 return ret;
3355
3356         ret = test_folder_update();
3357         if (ret != MEDIA_CONTENT_ERROR_NONE)
3358                 return ret;
3359
3360         ret = test_playlist_operation();
3361         if (ret != MEDIA_CONTENT_ERROR_NONE)
3362                 return ret;
3363
3364         ret = test_tag_operation();
3365         if (ret != MEDIA_CONTENT_ERROR_NONE)
3366                 return ret;
3367
3368         ret = test_bookmark_operation();
3369         if (ret != MEDIA_CONTENT_ERROR_NONE)
3370                 return ret;
3371
3372         ret = test_album_list();
3373         if (ret != MEDIA_CONTENT_ERROR_NONE)
3374                 return ret;
3375
3376         ret = test_group_operation();
3377         if (ret != MEDIA_CONTENT_ERROR_NONE)
3378                 return ret;
3379
3380         ret = test_update_operation();
3381         if (ret != MEDIA_CONTENT_ERROR_NONE)
3382                 return ret;
3383
3384         ret = test_insert();
3385         if (ret != MEDIA_CONTENT_ERROR_NONE)
3386                 return ret;
3387
3388         ret = test_move();
3389         if (ret != MEDIA_CONTENT_ERROR_NONE)
3390                 return ret;
3391
3392         ret = test_create_thumbnail(TRUE);
3393         if (ret != MEDIA_CONTENT_ERROR_NONE)
3394                 return ret;
3395
3396         ret = test_request_update_db();
3397         if (ret != MEDIA_CONTENT_ERROR_NONE)
3398                 return ret;
3399
3400         ret = DFT_test();
3401         if (ret != MEDIA_CONTENT_ERROR_NONE)
3402                 return ret;
3403
3404         ret = test_batch_operations();
3405         if (ret != MEDIA_CONTENT_ERROR_NONE)
3406                 return MEDIA_CONTENT_ERROR_NONE;
3407
3408         ret = test_insert_burst_shot_to_db();
3409         if (ret != MEDIA_CONTENT_ERROR_NONE)
3410                 return MEDIA_CONTENT_ERROR_NONE;
3411
3412         ret = test_scan_file();
3413         if (ret != MEDIA_CONTENT_ERROR_NONE)
3414                 return MEDIA_CONTENT_ERROR_NONE;
3415
3416         ret = test_scan_dir(true);
3417         if (ret != MEDIA_CONTENT_ERROR_NONE)
3418                 return MEDIA_CONTENT_ERROR_NONE;
3419
3420         ret = test_noti();
3421         if (ret != MEDIA_CONTENT_ERROR_NONE)
3422                 return MEDIA_CONTENT_ERROR_NONE;
3423
3424         ret = test_create_handle();
3425         if (ret != MEDIA_CONTENT_ERROR_NONE)
3426                 return MEDIA_CONTENT_ERROR_NONE;
3427
3428         ret = test_face();
3429         if (ret != MEDIA_CONTENT_ERROR_NONE)
3430                 return MEDIA_CONTENT_ERROR_NONE;
3431
3432         ret = test_face_add_del();
3433         if (ret != MEDIA_CONTENT_ERROR_NONE)
3434                 return MEDIA_CONTENT_ERROR_NONE;
3435 #endif
3436
3437         ret = test_disconnect_database();
3438         if (ret != MEDIA_CONTENT_ERROR_NONE)
3439                 return ret;
3440
3441         media_content_debug("--- content manager test end ---\n");
3442
3443         return ret;
3444 }