test/media-content_test.c

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