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