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