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