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