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