test/media-content_test.c

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