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