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 : [%d]", 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 : [%d]", 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 : [%d]", 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 : [%d]", 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 : [%d]", 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 : %d", 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: %d", title, album, artist, album_artist, duration, time_played);
1149                                 }
1150
1151                                 SAFE_FREE(title);
1152                                 SAFE_FREE(artist);
1153                                 SAFE_FREE(album);
1154                                 SAFE_FREE(album_artist);
1155
1156                                 ret = video_meta_destroy(video_handle);
1157                                 if (ret != MEDIA_CONTENT_ERROR_NONE)
1158                                         media_content_error("error video_meta_destroy : [%d]", ret);
1159                         }
1160
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!", ret);
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: %d\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 : %d\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. 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         else {
2719                 ret = media_info_start_face_detection(dst, face_detection_complete_cb, dst);
2720                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2721                         media_content_error("media_info_start_face_detection failed: %d", ret);
2722         }
2723
2724         /* fix prevent: Resource leak */
2725         SAFE_FREE(media_id);
2726
2727         return true;
2728 }
2729
2730 bool cancel_face_detection_cb(media_info_h media, void *user_data)
2731 {
2732         int ret = MEDIA_CONTENT_ERROR_NONE;
2733
2734         char *media_id = NULL;
2735         media_info_h dst = NULL;
2736
2737         g_cnt++;
2738
2739         if (media == NULL) {
2740                 media_content_debug("NO Item");
2741                 return true;
2742         }
2743
2744         ret = media_info_get_media_id(media, &media_id);
2745         if (ret != MEDIA_CONTENT_ERROR_NONE)
2746                 media_content_error("media_info_get_media_id failed: %d", ret);
2747         else
2748                 media_content_debug("media_id : [%s]", media_id);
2749
2750         ret = media_info_clone(&dst, media);
2751         if (ret != MEDIA_CONTENT_ERROR_NONE)
2752                 media_content_error("media_info_clone failed: %d", ret);
2753
2754         ret = media_info_cancel_face_detection(dst);
2755         if (ret != MEDIA_CONTENT_ERROR_NONE)
2756                 media_content_error("media_info_cancel_face_detection failed: %d", ret);
2757
2758         ret = media_info_destroy(dst);
2759         if (ret != MEDIA_CONTENT_ERROR_NONE)
2760                         media_content_error("media_info_destroy failed: %d", ret);
2761
2762         if (g_cnt == g_media_cnt)
2763                 g_main_loop_quit(g_loop);
2764
2765         /* fix prevent: Resource leak */
2766         SAFE_FREE(media_id);
2767
2768         return true;
2769 }
2770
2771 gboolean face_detection_start(gpointer data)
2772 {
2773         int ret = MEDIA_CONTENT_ERROR_NONE;
2774
2775         ret = media_info_foreach_media_from_db(g_filter, start_face_detection_cb, NULL);
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         return false;
2783 }
2784
2785 gboolean face_detection_cancel(gpointer data)
2786 {
2787         int ret = MEDIA_CONTENT_ERROR_NONE;
2788
2789         ret = media_info_foreach_media_from_db(g_filter, cancel_face_detection_cb, NULL);
2790
2791         if (ret == MEDIA_CONTENT_ERROR_NONE)
2792                 media_content_debug("media_info_foreach_media_from_db is success");
2793         else
2794                 media_content_error("media_info_foreach_media_from_db is failed");
2795
2796         return false;
2797 }
2798
2799 int test_start_face_detection(int cancel)
2800 {
2801         int ret = MEDIA_CONTENT_ERROR_NONE;
2802         GSource *source = NULL;
2803         GMainContext *context = NULL;
2804
2805         test_filter_create();
2806
2807         ret = media_info_get_media_count_from_db(g_filter, &g_media_cnt);
2808         if (ret != MEDIA_CONTENT_ERROR_NONE)
2809                 media_content_error("media_info_get_media_count_from_db failed: %d", ret);
2810         else
2811                 media_content_debug("media_count : [%d]", g_media_cnt);
2812
2813         if (g_media_cnt == 0)
2814                 goto END;
2815
2816         g_loop = g_main_loop_new(NULL, FALSE);
2817         context = g_main_loop_get_context(g_loop);
2818         source = g_idle_source_new();
2819         g_source_set_callback(source, face_detection_start, NULL, NULL);
2820         g_source_attach(source, context);
2821
2822         /* Logic to cancel */
2823         if (cancel) {
2824                 GSource *cancel_src = NULL;
2825                 cancel_src = g_idle_source_new();
2826                 g_source_set_callback(cancel_src, face_detection_cancel, NULL, NULL);
2827                 g_source_attach(cancel_src, context);
2828         }
2829
2830         g_main_loop_run(g_loop);
2831         g_main_loop_unref(g_loop);
2832
2833 END:
2834         test_filter_destroy();
2835
2836         return ret;
2837 }
2838
2839 int test_disconnect_database(void)
2840 {
2841         int ret = MEDIA_CONTENT_ERROR_NONE;
2842         media_content_debug("\n============DB Disconnection Test============\n\n");
2843
2844         ret = media_content_disconnect();
2845
2846         if (ret == MEDIA_CONTENT_ERROR_NONE)
2847                 media_content_debug("disconnection is success");
2848         else
2849                 media_content_error("disconnection is failed");
2850
2851         return ret;
2852 }
2853
2854 int test_request_update_db(void)
2855 {
2856         int ret = MEDIA_CONTENT_ERROR_NONE;
2857         media_info_h media = NULL;
2858         char *content_name = NULL;
2859         bool favorite = FALSE;
2860
2861         ret = media_info_get_media_from_db("71b19196-5b38-4ab1-ab34-bfe05c369614", &media);
2862         if (ret != MEDIA_CONTENT_ERROR_NONE)
2863                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2864
2865         ret = media_info_set_content_name(media, "TEST_content_name");
2866         if (ret != MEDIA_CONTENT_ERROR_NONE)
2867                 media_content_error("media_info_set_content_name failed: %d", ret);
2868
2869         ret = media_info_set_favorite(media, TRUE);
2870         if (ret != MEDIA_CONTENT_ERROR_NONE)
2871                 media_content_error("media_info_set_favorite failed: %d", ret);
2872
2873         ret = media_info_update_to_db(media);
2874         if (ret == MEDIA_CONTENT_ERROR_NONE)
2875                 media_content_debug("media_info_update_to_db is success");
2876         else
2877                 media_content_error("media_info_update_to_db is failed");
2878
2879         if (media != NULL)
2880                 media_info_destroy(media);
2881
2882         /*get the updated value*/
2883         ret = media_info_get_media_from_db("71b19196-5b38-4ab1-ab34-bfe05c369614", &media);
2884         if (ret != MEDIA_CONTENT_ERROR_NONE)
2885                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2886
2887         ret = media_info_get_content_name(media, &content_name);
2888         if (ret != MEDIA_CONTENT_ERROR_NONE)
2889                 media_content_error("media_info_get_content_name failed: %d", ret);
2890         else
2891                 media_content_debug("content name [%s]", content_name);
2892
2893         SAFE_FREE(content_name);
2894
2895         ret = media_info_get_favorite(media, &favorite);
2896         if (ret != MEDIA_CONTENT_ERROR_NONE)
2897                 media_content_error("media_info_get_favorite failed: %d", ret);
2898         else
2899                 media_content_debug("favorite [%d]", favorite);
2900
2901         ret = media_info_destroy(media);
2902
2903         return ret;
2904 }
2905
2906 int g_total_photo_size = 0;
2907 int g_total_video_size = 0;
2908 int g_total_mp3_size = 0;
2909 int g_total_voice_memo_size = 0;
2910
2911 bool dft_cb(media_info_h media, void *user_data)
2912 {
2913         unsigned long long file_size = 0;
2914         media_content_type_e media_type = -1;
2915         char *mime_type = NULL;
2916         int ret = MEDIA_CONTENT_ERROR_NONE;
2917
2918         if (media == NULL)
2919                 return true;
2920
2921         ret = media_info_get_media_type(media, &media_type);
2922         if (ret != MEDIA_CONTENT_ERROR_NONE)
2923                 media_content_error("media_info_get_media_type failed: %d", ret);
2924         ret = media_info_get_size(media, &file_size);
2925         if (ret != MEDIA_CONTENT_ERROR_NONE)
2926                 media_content_error("media_info_get_size failed: %d", ret);
2927         ret = media_info_get_mime_type(media, &mime_type);
2928         if (ret != MEDIA_CONTENT_ERROR_NONE)
2929                 media_content_error("media_info_get_mime_type failed: %d", ret);
2930
2931         if (media_type == MEDIA_CONTENT_TYPE_IMAGE)
2932                 g_total_photo_size += file_size;
2933         else if (media_type == MEDIA_CONTENT_TYPE_VIDEO)
2934                 g_total_video_size += file_size;
2935         else if (media_type == MEDIA_CONTENT_TYPE_SOUND)
2936                 g_total_voice_memo_size += file_size;
2937         else if (media_type == MEDIA_CONTENT_TYPE_MUSIC) {
2938                 if ((mime_type != NULL) && (!strcmp("audio/mpeg", mime_type)))
2939                         g_total_mp3_size += file_size;
2940                 else
2941                         g_total_voice_memo_size += file_size;
2942         } else
2943                 media_content_debug("invalid media_type");
2944
2945         if (mime_type != NULL)
2946                 free(mime_type);
2947
2948         return true;
2949
2950 }
2951
2952 int DFT_test(void)
2953 {
2954         int ret = MEDIA_CONTENT_ERROR_NONE;
2955         media_content_debug("\n============DFT_test============\n\n");
2956
2957         filter_h filter = NULL;
2958         int media_cnt = 0;
2959
2960         /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
2961
2962         ret = media_filter_create(&filter);
2963
2964 /*Internal Memory*/
2965         media_content_debug("[Internal Memory]\n");
2966         /*1. Photo ============================================================*/
2967         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
2968
2969         /*Get Photo Count*/
2970         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2971         media_content_debug("Photo count = [%d]\n", media_cnt);
2972
2973         /*Get Photo Size*/
2974         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2975         media_content_debug("Photo size = [%d]\n", g_total_photo_size);
2976
2977         /*2. Video ============================================================*/
2978         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
2979
2980         /*Get Video Count*/
2981         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2982         media_content_debug("Video count = [%d]\n", media_cnt);
2983
2984         /*Get Video Size*/
2985         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2986         media_content_debug("Video size = [%d]\n", g_total_video_size);
2987
2988         /*3. MP3 ============================================================*/
2989         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
2990
2991         /*Get MP3 Count*/
2992         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2993         media_content_debug("MP3 count = [%d]\n", media_cnt);
2994
2995         /*Get MP3 Size*/
2996         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2997         media_content_debug("MP3 size = [%d]\n", g_total_mp3_size);
2998
2999         /*4. Voice Memo ============================================================*/
3000         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);
3001
3002         /*Get Voice Memo Count*/
3003         ret = media_info_get_media_count_from_db(filter, &media_cnt);
3004         media_content_debug("Voice Memo count = [%d]\n", media_cnt);
3005
3006         /*Get Voice Memo Size*/
3007         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
3008         media_content_debug("Voice Memo size = [%d]\n", g_total_voice_memo_size);
3009
3010         g_total_photo_size = 0;
3011         g_total_video_size = 0;
3012         g_total_mp3_size = 0;
3013         g_total_voice_memo_size = 0;
3014
3015 /*External Memory*/
3016         media_content_debug("\n[External Memory]\n");
3017         /*1. Photo ============================================================*/
3018         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
3019
3020         /*Get Photo Count*/
3021         ret = media_info_get_media_count_from_db(filter, &media_cnt);
3022         media_content_debug("Photo count = [%d]\n", media_cnt);
3023
3024         /*Get Photo Size*/
3025         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
3026         media_content_debug("Photo size = [%d]\n", g_total_photo_size);
3027
3028         /*2. Video ============================================================*/
3029         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
3030
3031         /*Get Video Count*/
3032         ret = media_info_get_media_count_from_db(filter, &media_cnt);
3033         media_content_debug("Video count = [%d]\n", media_cnt);
3034
3035         /*Get Video Size*/
3036         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
3037         media_content_debug("Video size = [%d]\n", g_total_video_size);
3038
3039         /*3. MP3 ============================================================*/
3040         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
3041
3042         /*Get MP3 Count*/
3043         ret = media_info_get_media_count_from_db(filter, &media_cnt);
3044         media_content_debug("MP3 count = [%d]\n", media_cnt);
3045
3046         /*Get MP3 Size*/
3047         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
3048         media_content_debug("MP3 size = [%d]\n", g_total_mp3_size);
3049
3050         /*4. Voice Memo ============================================================*/
3051         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);
3052
3053         /*Get Voice Memo Count*/
3054         ret = media_info_get_media_count_from_db(filter, &media_cnt);
3055         media_content_debug("Voice Memo count = [%d]\n", media_cnt);
3056
3057         /*Get Voice Memo Size*/
3058         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
3059         media_content_debug("Voice Memo size = [%d]\n", g_total_voice_memo_size);
3060         ret = media_filter_destroy(filter);
3061
3062         return ret;
3063 }
3064
3065 void insert_batch_cb(media_content_error_e error, void * user_data)
3066 {
3067         media_content_debug("media_info_insert_batch_to_db completed!\n");
3068 }
3069
3070 int test_batch_operations()
3071 {
3072         int ret = -1;
3073         int i;
3074         char *file_list[10];
3075
3076         for (i = 0; i < 10; i++) {
3077                 char filepath[255] = {0,};
3078                 snprintf(filepath, sizeof(filepath), "%s%d.jpg", tzplatform_mkpath(TZ_USER_CONTENT, "test/image"), i+1);
3079                 media_content_debug("File : %s\n", filepath);
3080                 file_list[i] = strdup(filepath);
3081         }
3082
3083         ret = media_info_insert_batch_to_db((const char **)file_list, 10, insert_batch_cb, NULL);
3084         if (ret != MEDIA_CONTENT_ERROR_NONE)
3085                 media_content_error("media_info_insert_batch_to_db failed : %d\n", ret);
3086
3087         filter_h filter;
3088         char *condition = "MEDIA_PATH LIKE \'";
3089         strncat(condition, tzplatform_mkpath(TZ_USER_CONTENT, "test/image%%jpg\'"), 17);
3090         ret = media_filter_create(&filter);
3091         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3092                 media_content_error("Fail to create filter");
3093                 return ret;
3094         }
3095
3096         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
3097         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3098                 media_filter_destroy(filter);
3099                 media_content_error("Fail to set condition");
3100                 return ret;
3101         }
3102
3103         ret = media_info_delete_batch_from_db(filter);
3104         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3105                 media_filter_destroy(filter);
3106                 media_content_error("media_info_delete_batch_from_db failed : %d\n", ret);
3107                 return ret;
3108         }
3109
3110         ret = media_filter_destroy(filter);
3111
3112         return ret;
3113 }
3114
3115 void insert_burst_shot_cb(media_content_error_e error, void * user_data)
3116 {
3117         media_content_debug("media_info_insert_burst_shot_to_db completed![%d]\n", error);
3118         g_main_loop_quit(g_loop);
3119 }
3120
3121 gboolean test_insert_burst_shot_to_db_start(gpointer data)
3122 {
3123         int ret = MEDIA_CONTENT_ERROR_NONE;
3124         int i = 0;
3125         char *file_list[10];
3126
3127         for (i = 0; i < 10; i++) {
3128                 char filepath[255] = {0,};
3129                 snprintf(filepath, sizeof(filepath), "%s%d.jpg", tzplatform_mkpath(TZ_USER_CONTENT, "test/image"), i+1);
3130                 media_content_debug("File : %s\n", filepath);
3131                 file_list[i] = strdup(filepath);
3132         }
3133
3134         ret = media_info_insert_burst_shot_to_db((const char **)file_list, 10, insert_burst_shot_cb, NULL);
3135         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3136                 media_content_error("media_info_insert_burst_shot_to_db failed : %d\n", ret);
3137                 g_main_loop_quit(g_loop);
3138         }
3139
3140         return ret;
3141 }
3142
3143 int test_insert_burst_shot_to_db(void)
3144 {
3145         GSource *source = NULL;
3146         GMainContext *context = NULL;
3147
3148         g_loop = g_main_loop_new(NULL, FALSE);
3149         context = g_main_loop_get_context(g_loop);
3150         source = g_idle_source_new();
3151         g_source_set_callback(source, test_insert_burst_shot_to_db_start, NULL, NULL);
3152         g_source_attach(source, context);
3153
3154         g_main_loop_run(g_loop);
3155         g_main_loop_unref(g_loop);
3156
3157         return 0;
3158 }
3159
3160 void _scan_cb(media_content_error_e err, void *user_data)
3161 {
3162         media_content_debug("scan callback is called : %d\n", err);
3163         g_main_loop_quit(g_loop);
3164
3165         return;
3166 }
3167
3168 int test_scan_file()
3169 {
3170         int ret = -1;
3171
3172         const char *file_path = tzplatform_mkpath(TZ_USER_CONTENT, "test/image1.jpg");
3173         ret = media_content_scan_file(file_path);
3174         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3175                 media_content_error("Fail to media_content_scan_file : %d", ret);
3176                 return ret;
3177         }
3178
3179         return 0;
3180 }
3181
3182 gboolean test_scan_dir_start(gpointer data)
3183 {
3184         int ret = -1;
3185
3186         const char *dir_path = tzplatform_getenv(TZ_USER_CONTENT);
3187
3188         ret = media_content_scan_folder(dir_path, TRUE, _scan_cb, NULL);
3189
3190         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3191                 media_content_error("Fail to test_scan_dir_start : %d", ret);
3192                 return ret;
3193         }
3194
3195         return 0;
3196 }
3197
3198 gboolean cancel_scan_dir_start(gpointer data)
3199 {
3200         int ret = MEDIA_CONTENT_ERROR_NONE;
3201
3202         const char *dir_path = "/opt/usr/media/Images";
3203
3204         ret = media_content_cancel_scan_folder(dir_path);
3205
3206         if (ret == MEDIA_CONTENT_ERROR_NONE)
3207                 media_content_debug("media_content_cancel_scan_folder is success");
3208         else
3209                 media_content_error("media_content_cancel_scan_folder is failed");
3210
3211         return false;
3212 }
3213
3214 int test_scan_dir(int cancel)
3215 {
3216         GSource *source = NULL;
3217         GMainContext *context = NULL;
3218
3219         g_loop = g_main_loop_new(NULL, FALSE);
3220         context = g_main_loop_get_context(g_loop);
3221         source = g_idle_source_new();
3222         g_source_set_callback(source, test_scan_dir_start, NULL, NULL);
3223         g_source_attach(source, context);
3224
3225         if (cancel) {
3226                 GSource *cancel_src = NULL;
3227                 cancel_src = g_idle_source_new();
3228                 g_source_set_callback(cancel_src, cancel_scan_dir_start, NULL, NULL);
3229                 g_source_attach(cancel_src, context);
3230         }
3231
3232         g_main_loop_run(g_loop);
3233         g_main_loop_unref(g_loop);
3234
3235         return 0;
3236 }
3237
3238 void _noti_cb(media_content_error_e error,
3239                                 int pid,
3240                                 media_content_db_update_item_type_e update_item,
3241                                 media_content_db_update_type_e update_type,
3242                                 media_content_type_e media_type,
3243                                 char *uuid,
3244                                 char *path,
3245                                 char *mime_type,
3246                                 void *user_data)
3247 {
3248         if (error == 0)
3249                 media_content_debug("noti success! : %d\n", error);
3250         else
3251                 media_content_debug("error occured! : %d\n", error);
3252
3253         media_content_debug("Noti from PID(%d)\n", pid);
3254
3255         if (update_item == MEDIA_ITEM_FILE)
3256                 media_content_debug("Noti item : MEDIA_ITEM_FILE\n");
3257         else if (update_item == MEDIA_ITEM_DIRECTORY)
3258                 media_content_debug("Noti item : MEDIA_ITEM_DIRECTORY\n");
3259
3260         if (update_type == MEDIA_CONTENT_INSERT)
3261                 media_content_debug("Noti type : MEDIA_CONTENT_INSERT\n");
3262         else if (update_type == MEDIA_CONTENT_DELETE)
3263                 media_content_debug("Noti type : MEDIA_CONTENT_DELETE\n");
3264         else if (update_type == MEDIA_CONTENT_UPDATE)
3265                 media_content_debug("Noti type : MEDIA_CONTENT_UPDATE\n");
3266
3267         media_content_debug("content type : %d\n", media_type);
3268
3269         if (path)
3270                 media_content_debug("path : %s\n", path);
3271         else
3272                 media_content_debug("path not\n");
3273
3274         if (uuid)
3275                 media_content_debug("uuid : %s\n", uuid);
3276         else
3277                 media_content_debug("uuid not\n");
3278
3279         if (mime_type)
3280                 media_content_debug("mime_type : %s\n", mime_type);
3281         else
3282                 media_content_debug("mime not\n");
3283
3284         if (user_data) media_content_debug("String : %s\n", (char *)user_data);
3285
3286         return;
3287 }
3288
3289 void _noti_cb_2(media_content_error_e error,
3290                                 int pid,
3291                                 media_content_db_update_item_type_e update_item,
3292                                 media_content_db_update_type_e update_type,
3293                                 media_content_type_e media_type,
3294                                 char *uuid,
3295                                 char *path,
3296                                 char *mime_type,
3297                                 void *user_data)
3298 {
3299         if (error == 0)
3300                 media_content_debug("noti_2 success! : %d\n", error);
3301         else
3302                 media_content_debug("error occured! : %d\n", error);
3303
3304         media_content_debug("Noti_2 from PID(%d)\n", pid);
3305
3306         g_main_loop_quit(g_loop);
3307         return;
3308 }
3309
3310 static media_content_noti_h noti_h;
3311 static media_content_noti_h noti_h_2;
3312
3313 gboolean _send_noti_operations(gpointer data)
3314 {
3315         int ret = MEDIA_CONTENT_ERROR_NONE;
3316
3317         /* First of all, noti subscription */
3318         char *user_str = strdup("hi");
3319         media_content_add_db_updated_cb(_noti_cb, (void*)user_str, &noti_h);
3320         media_content_add_db_updated_cb(_noti_cb_2, (void*)user_str, &noti_h_2);
3321
3322         /* media_info_insert_to_db */
3323         media_info_h media_item = NULL;
3324         const char *path = tzplatform_mkpath(TZ_USER_CONTENT, "test/image1.jpg");
3325
3326         ret = media_info_insert_to_db(path, &media_item);
3327         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3328                 media_content_error("media_info_insert_to_db failed : %d", ret);
3329                 media_info_destroy(media_item);
3330                 return FALSE;
3331         }
3332
3333         media_content_debug("media_info_insert_to_db success");
3334
3335         /* media_info_delete_batch_from_db */
3336         filter_h filter;
3337         char condition[2048] = {0,};
3338         const char *temp = NULL;
3339         temp = tzplatform_mkpath(TZ_USER_CONTENT, "test/image%%\'");
3340         snprintf(condition, sizeof(condition), "MEDIA_PATH LIKE \'%s", temp);
3341
3342         ret = media_filter_create(&filter);
3343         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3344                 media_content_error("Fail to create filter");
3345                 media_info_destroy(media_item);
3346                 return ret;
3347         }
3348
3349         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
3350         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3351                 media_filter_destroy(filter);
3352                 media_info_destroy(media_item);
3353                 media_content_error("Fail to set condition");
3354                 return ret;
3355         }
3356         ret = media_info_delete_batch_from_db(filter);
3357         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3358                 media_filter_destroy(filter);
3359                 media_info_destroy(media_item);
3360                 media_content_error("media_info_delete_batch_from_db failed : %d\n", ret);
3361                 return ret;
3362         }
3363
3364         media_filter_destroy(filter);
3365
3366         media_content_remove_db_updated_cb(noti_h);
3367
3368         /* media_info_update_to_db */
3369         ret = media_info_update_to_db(media_item);
3370         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3371                 media_content_error("media_info_update_to_db failed : %d\n", ret);
3372                 media_info_destroy(media_item);
3373                 return ret;
3374         }
3375
3376         media_info_destroy(media_item);
3377
3378         return FALSE;
3379 }
3380
3381 int test_noti()
3382 {
3383         int ret = MEDIA_CONTENT_ERROR_NONE;
3384         GSource *source = NULL;
3385         GMainContext *context = NULL;
3386
3387         g_loop = g_main_loop_new(NULL, FALSE);
3388         context = g_main_loop_get_context(g_loop);
3389         source = g_idle_source_new();
3390         g_source_set_callback(source, _send_noti_operations, NULL, NULL);
3391         g_source_attach(source, context);
3392
3393         g_main_loop_run(g_loop);
3394         g_main_loop_unref(g_loop);
3395
3396         test_filter_destroy();
3397         media_content_remove_db_updated_cb(noti_h_2);
3398
3399         return ret;
3400 }
3401
3402 int test_create_handle(void)
3403 {
3404         int ret = MEDIA_CONTENT_ERROR_NONE;
3405         media_info_h media = NULL;
3406         const char *path = "/home/owner/content/test/test.txt";
3407         char *str_value = NULL;
3408         int int_value = -1;
3409         bool bool_value = FALSE;
3410         unsigned long long content_size = 0;
3411         time_t modified_time = 0;
3412         double double_value = 0.0;
3413
3414         ret = media_info_create(path, &media);
3415
3416         ret = media_info_set_title(media, "test_title");
3417         ret = media_info_set_album(media, "test_album");
3418         ret = media_info_set_artist(media, "test_artist");
3419         ret = media_info_set_genre(media, "test_genre");
3420         ret = media_info_set_recorded_date(media, "test_recorded_date");
3421         ret = media_info_set_age_rating(media, "test_age_rating");
3422         ret = media_info_set_author(media, "test_author");
3423         ret = media_info_set_category(media, "test_category");
3424         ret = media_info_set_content_name(media, "test_content_name");
3425         ret = media_info_set_description(media, "test_description");
3426         ret = media_info_set_display_name(media, "test_display_name");
3427         ret = media_info_set_keyword(media, "test_keyword");
3428         ret = media_info_set_location_tag(media, "test_location_tag");
3429         ret = media_info_set_weather(media, "test_weather");
3430         ret = media_info_set_provider(media, "test_provider");
3431
3432         ret = media_info_set_altitude(media, 100.10);
3433         ret = media_info_set_latitude(media, 200.20);
3434         ret = media_info_set_longitude(media, 300.30);
3435         ret = media_info_set_rating(media, 10);
3436         ret = media_info_set_played_time(media);
3437         ret = media_info_set_favorite(media, TRUE);
3438         ret = media_info_increase_played_count(media);
3439         ret = media_info_set_added_time(media, 12345);
3440
3441         ret = media_info_insert_to_db_with_data(media);
3442         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3443                 media_content_error("media_info_insert_to_db_with_data failed : %d\n", ret);
3444                 media_info_destroy(media);
3445                 return ret;
3446         }
3447
3448         ret = media_info_get_media_id(media, &str_value);
3449         media_content_debug("media_id = [%s]", str_value);
3450         SAFE_FREE(str_value);
3451
3452         ret = media_info_get_file_path(media, &str_value);
3453         media_content_debug("file_path = [%s]", str_value);
3454         SAFE_FREE(str_value);
3455
3456         ret = media_info_get_title(media, &str_value);
3457         media_content_debug("title = [%s]", str_value);
3458         SAFE_FREE(str_value);
3459
3460         ret = media_info_get_age_rating(media, &str_value);
3461         media_content_debug("age_rating = [%s]", str_value);
3462         SAFE_FREE(str_value);
3463
3464         ret = media_info_get_author(media, &str_value);
3465         media_content_debug("author = [%s]", str_value);
3466         SAFE_FREE(str_value);
3467
3468         ret = media_info_get_category(media, &str_value);
3469         media_content_debug("category = [%s]", str_value);
3470         SAFE_FREE(str_value);
3471
3472         ret = media_info_get_content_name(media, &str_value);
3473         media_content_debug("content_name = [%s]", str_value);
3474         SAFE_FREE(str_value);
3475
3476         ret = media_info_get_description(media, &str_value);
3477         media_content_debug("description = [%s]", str_value);
3478         SAFE_FREE(str_value);
3479
3480         ret = media_info_get_display_name(media, &str_value);
3481         media_content_debug("display_name = [%s]", str_value);
3482         SAFE_FREE(str_value);
3483
3484         ret = media_info_get_keyword(media, &str_value);
3485         media_content_debug("keyword = [%s]", str_value);
3486         SAFE_FREE(str_value);
3487
3488         ret = media_info_get_location_tag(media, &str_value);
3489         media_content_debug("location_tag = [%s]", str_value);
3490         SAFE_FREE(str_value);
3491
3492         ret = media_info_get_weather(media, &str_value);
3493         media_content_debug("weather = [%s]", str_value);
3494         SAFE_FREE(str_value);
3495
3496         ret = media_info_get_provider(media, &str_value);
3497         media_content_debug("provider = [%s]", str_value);
3498         SAFE_FREE(str_value);
3499
3500         ret = media_info_get_longitude(media, &double_value);
3501         media_content_debug("longitude = [%lf]", double_value);
3502
3503         ret = media_info_get_latitude(media, &double_value);
3504         media_content_debug("latitude = [%lf]", double_value);
3505
3506         ret = media_info_get_altitude(media, &double_value);
3507         media_content_debug("altitud = [%lf]", double_value);
3508
3509         ret = media_info_get_rating(media, &int_value);
3510         media_content_debug("rating = [%d]", int_value);
3511
3512         ret = media_info_get_favorite(media, &bool_value);
3513         media_content_debug("favorite = [%d]", bool_value);
3514
3515         ret = media_info_get_played_time(media, &modified_time);
3516         media_content_debug("played_time = [%d]", modified_time);
3517
3518         ret = media_info_get_played_count(media, &int_value);
3519         media_content_debug("played_count = [%d]", int_value);
3520
3521         ret = media_info_get_added_time(media, &modified_time);
3522         media_content_debug("added_time = [%d]", modified_time);
3523
3524         ret = media_info_get_size(media, &content_size);
3525         media_content_debug("size = [%d]", content_size);
3526
3527         ret = media_info_get_modified_time(media, &modified_time);
3528         media_content_debug("modified_time = [%d]", modified_time);
3529
3530         ret = media_info_get_media_type(media, (media_content_type_e *)&int_value);
3531         media_content_debug("media_type = [%d]", int_value);
3532
3533         ret = media_info_get_storage_type(media, (media_content_storage_e *)&int_value);
3534         media_content_debug("storage_type = [%d]", int_value);
3535
3536         media_info_destroy(media);
3537
3538         return ret;
3539
3540 }
3541
3542 bool media_face_test_cb(media_face_h face, void *user_data)
3543 {
3544         char *face_id = NULL;
3545         char *media_id = NULL;
3546         unsigned int rect_x = 0;
3547         unsigned int rect_y = 0;
3548         unsigned int rect_w = 0;
3549         unsigned int rect_h = 0;
3550         media_content_orientation_e orientation = 0;
3551         char *face_tag = NULL;
3552
3553         media_face_get_face_id(face, &face_id);
3554         media_face_get_media_id(face, &media_id);
3555         media_face_get_face_rect(face, &rect_x, &rect_y, &rect_w, &rect_h);
3556         media_face_get_orientation(face, &orientation);
3557         media_face_get_tag(face, &face_tag);
3558
3559         media_content_debug("face_id [%s] media_id [%s]", face_id, media_id);
3560         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);
3561         media_content_debug("tag [%s]", face_tag);
3562
3563         if (user_data != NULL) {
3564                 media_face_h new_face = NULL;
3565                 media_face_clone(&new_face, face);
3566
3567                 GList **list = (GList**)user_data;
3568                 *list = g_list_append(*list, new_face);
3569         }
3570
3571         SAFE_FREE(face_id);
3572         SAFE_FREE(media_id);
3573         SAFE_FREE(face_tag);
3574
3575         return true;
3576 }
3577
3578 int test_face(void)
3579 {
3580         int ret = MEDIA_CONTENT_ERROR_NONE;
3581         filter_h filter = NULL;
3582         GList *all_item_list = NULL;
3583         int i = 0;
3584
3585         ret = media_filter_create(&filter);
3586         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_filter_create");
3587
3588         ret = media_filter_set_condition(filter, "MEDIA_TYPE = 0", MEDIA_CONTENT_COLLATE_DEFAULT);
3589         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3590                 media_filter_destroy(filter);
3591                 media_content_error("Fail to set condition");
3592                 return ret;
3593         }
3594
3595         ret = media_info_foreach_media_from_db(filter, gallery_media_item_cb, &all_item_list);
3596         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3597                 media_content_error("media_info_foreach_media_from_db failed: %d", ret);
3598                 media_filter_destroy(filter);
3599                 return ret;
3600         }
3601
3602         for (i = 0; i < g_list_length(all_item_list); i++) {
3603                 media_info_h media_handle = NULL;
3604                 char *media_id = NULL;
3605                 int face_count = 0;
3606
3607                 media_handle = (media_info_h)g_list_nth_data(all_item_list, i);
3608
3609                 ret = media_info_get_media_id(media_handle, &media_id);
3610                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3611                         media_content_error("media_info_get_media_id failed: %d", ret);
3612
3613                 ret = media_info_get_face_count_from_db(media_id, filter, &face_count);
3614                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3615                         media_content_error("media_info_get_face_count_from_db failed: %d", ret);
3616
3617                 media_content_error("media_id [%s] face_count [%d]", media_id, face_count);
3618
3619                 ret = media_info_foreach_face_from_db(media_id, filter, media_face_test_cb, NULL);
3620                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3621                         media_content_error("media_info_foreach_face_from_db failed: %d", ret);
3622
3623                 media_info_destroy(media_handle);
3624         }
3625
3626         media_filter_destroy(filter);
3627
3628         return ret;
3629 }
3630
3631 int test_face_add_del(void)
3632 {
3633         int ret = MEDIA_CONTENT_ERROR_NONE;
3634         char *media_id = "ecca7366-e085-41d8-a12b-cbdfc2b9c5fc";
3635
3636         /* Insert Test */
3637         media_face_h face = NULL;
3638
3639         char *face_tag = "test_face_tag";
3640
3641         ret = media_face_create(media_id, &face);
3642         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_face_create");
3643
3644         ret = media_face_set_face_rect(face, 10, 12, 50, 100);
3645         ret = media_face_set_orientation(face, 5);
3646         ret = media_face_set_tag(face, face_tag);
3647
3648         ret = media_face_insert_to_db(face);
3649         ret = media_face_destroy(face);
3650
3651         /* Update Test */
3652         GList *all_item_list = NULL;
3653         filter_h filter = NULL;
3654         ret = media_filter_create(&filter);
3655         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_filter_create");
3656
3657         ret = media_filter_set_condition(filter, "MEDIA_FACE_TAG IS NOT NULL", MEDIA_CONTENT_COLLATE_DEFAULT);
3658         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3659                 media_filter_destroy(filter);
3660                 media_content_error("Fail to set condition");
3661                 return ret;
3662         }
3663
3664         ret = media_info_foreach_face_from_db(media_id, filter, media_face_test_cb, &all_item_list);
3665
3666         if (g_list_length(all_item_list) > 0) {
3667                 media_face_h face_handle = NULL;
3668                 face_handle = (media_face_h)g_list_nth_data(all_item_list, 0);
3669
3670                 ret = media_face_set_face_rect(face_handle, 20, 22, 70, 70);
3671                 ret = media_face_set_orientation(face_handle, 3);
3672                 ret = media_face_set_tag(face_handle, NULL);
3673                 ret = media_face_update_to_db(face_handle);
3674
3675                 media_face_destroy(face_handle);
3676         }
3677
3678         media_filter_destroy(filter);
3679
3680         /* Delete Test */
3681         char *face_id = "5e58a3a8-f0b2-4c29-b799-b49a70dc2313";
3682
3683         /* Delete Test*/
3684         ret = media_face_delete_from_db(face_id);
3685
3686         return ret;
3687 }
3688
3689 #ifdef _USE_TV_PROFILE
3690 filter_h g_tv_filter = NULL;
3691
3692 int test_tv_filter_create(void)
3693 {
3694         media_content_debug("\n============Filter Create============\n\n");
3695
3696         int ret = MEDIA_CONTENT_ERROR_NONE;
3697
3698         ret = media_filter_create(&g_tv_filter);
3699
3700         ret = media_filter_set_storage(g_tv_filter, "0a22a163-e634-4a2e-ba14-0469a969eea0");
3701
3702         ret = media_filter_set_order(g_tv_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_STORAGE_ID, MEDIA_CONTENT_COLLATE_DEFAULT);
3703
3704         return ret;
3705 }
3706
3707 int test_tv_filter_destroy(void)
3708 {
3709         media_content_debug("\n============Filter Destroy============\n\n");
3710
3711         int ret = MEDIA_CONTENT_ERROR_NONE;
3712
3713         ret = media_filter_destroy(g_tv_filter);
3714
3715         return ret;
3716 }
3717
3718 bool pvr_item_cb(media_pvr_h pvr, void *user_data)
3719 {
3720         int ret = MEDIA_CONTENT_ERROR_NONE;
3721         char *c_value = NULL;
3722         int i_value = 0;
3723         bool b_value = false;
3724         unsigned long long l_value = 0;
3725
3726         if (pvr == NULL) {
3727                 media_content_debug("NO Item");
3728                 return true;
3729         }
3730
3731         ret = media_pvr_get_media_id(pvr, &c_value);
3732         if (ret != MEDIA_CONTENT_ERROR_NONE)
3733                 media_content_error("Fail to media_pvr_get_media_id");
3734         media_content_debug("media_id [%s]", c_value);
3735         SAFE_FREE(c_value);
3736
3737         ret = media_pvr_get_channel_name(pvr, &c_value);
3738         if (ret != MEDIA_CONTENT_ERROR_NONE)
3739                 media_content_error("Fail to media_pvr_get_channel_name");
3740         media_content_debug("channel_name [%s]", c_value);
3741         SAFE_FREE(c_value);
3742
3743         ret = media_pvr_get_program_title(pvr, &c_value);
3744         if (ret != MEDIA_CONTENT_ERROR_NONE)
3745                 media_content_error("Fail to media_pvr_get_program_title");
3746         media_content_debug("program_title [%s]", c_value);
3747         SAFE_FREE(c_value);
3748
3749         ret = media_pvr_get_program_crid(pvr, &c_value);
3750         if (ret != MEDIA_CONTENT_ERROR_NONE)
3751                 media_content_error("Fail to media_pvr_get_program_crid");
3752         media_content_debug("program_crid [%s]", c_value);
3753         SAFE_FREE(c_value);
3754
3755         ret = media_pvr_get_guidance(pvr, &c_value);
3756         if (ret != MEDIA_CONTENT_ERROR_NONE)
3757                 media_content_error("Fail to media_pvr_get_guidance");
3758         media_content_debug("guidance [%s]", c_value);
3759         SAFE_FREE(c_value);
3760
3761         ret = media_pvr_get_synopsis(pvr, &c_value);
3762         if (ret != MEDIA_CONTENT_ERROR_NONE)
3763                 media_content_error("Fail to media_pvr_get_synopsis");
3764         media_content_debug("synopsis [%s]", c_value);
3765         SAFE_FREE(c_value);
3766
3767         ret = media_pvr_get_genre(pvr, &c_value);
3768         if (ret != MEDIA_CONTENT_ERROR_NONE)
3769                 media_content_error("Fail to media_pvr_get_synopsis");
3770         media_content_debug("genre [%s]", c_value);
3771         SAFE_FREE(c_value);
3772
3773         ret = media_pvr_get_language(pvr, &c_value);
3774         if (ret != MEDIA_CONTENT_ERROR_NONE)
3775                 media_content_error("Fail to media_pvr_get_language");
3776         media_content_debug("language [%s]", c_value);
3777         SAFE_FREE(c_value);
3778
3779         ret = media_pvr_get_path(pvr, &c_value);
3780         if (ret != MEDIA_CONTENT_ERROR_NONE)
3781                 media_content_error("Fail to media_pvr_get_path");
3782         media_content_debug("path [%s]", c_value);
3783         SAFE_FREE(c_value);
3784
3785         ret = media_pvr_get_storage_id(pvr, &c_value);
3786         if (ret != MEDIA_CONTENT_ERROR_NONE)
3787                 media_content_error("Fail to media_pvr_get_storage_id");
3788         media_content_debug("storage_id [%s]", c_value);
3789         SAFE_FREE(c_value);
3790
3791         ret = media_pvr_get_size(pvr, &l_value);
3792         if (ret != MEDIA_CONTENT_ERROR_NONE)
3793                 media_content_error("Fail to media_pvr_get_size");
3794         media_content_debug("size [%ld]", l_value);
3795
3796         ret = media_pvr_get_timezone(pvr, &i_value);
3797         if (ret != MEDIA_CONTENT_ERROR_NONE)
3798                 media_content_error("Fail to media_pvr_get_timezone");
3799         media_content_debug("timezone [%d]", i_value);
3800
3801         ret = media_pvr_get_ptc(pvr, &i_value);
3802         if (ret != MEDIA_CONTENT_ERROR_NONE)
3803                 media_content_error("Fail to media_pvr_get_ptc");
3804         media_content_debug("ptc [%d]", i_value);
3805
3806         ret = media_pvr_get_major(pvr, &i_value);
3807         if (ret != MEDIA_CONTENT_ERROR_NONE)
3808                 media_content_error("Fail to media_pvr_get_major");
3809         media_content_debug("[%d]", i_value);
3810
3811         ret = media_pvr_get_minor(pvr, &i_value);
3812         if (ret != MEDIA_CONTENT_ERROR_NONE)
3813                 media_content_error("Fail to media_pvr_get_minor");
3814         media_content_debug("minor [%d]", i_value);
3815
3816         ret = media_pvr_get_channel_type(pvr, &i_value);
3817         if (ret != MEDIA_CONTENT_ERROR_NONE)
3818                 media_content_error("Fail to media_pvr_get_channel_type");
3819         media_content_debug("channel_type [%d]", i_value);
3820
3821         ret = media_pvr_get_program_num(pvr, &i_value);
3822         if (ret != MEDIA_CONTENT_ERROR_NONE)
3823                 media_content_error("Fail to media_pvr_get_program_num");
3824         media_content_debug("program_num [%d]", i_value);
3825
3826         ret = media_pvr_get_duration(pvr, &i_value);
3827         if (ret != MEDIA_CONTENT_ERROR_NONE)
3828                 media_content_error("Fail to media_pvr_get_duration");
3829         media_content_debug("duration [%d]", i_value);
3830
3831         ret = media_pvr_get_embargo_time(pvr, &i_value);
3832         if (ret != MEDIA_CONTENT_ERROR_NONE)
3833                 media_content_error("Fail to media_pvr_get_embargo_time");
3834         media_content_debug("embargo_time [%d]", i_value);
3835
3836         ret = media_pvr_get_expiry_time(pvr, &i_value);
3837         if (ret != MEDIA_CONTENT_ERROR_NONE)
3838                 media_content_error("Fail to media_pvr_get_expiry_time");
3839         media_content_debug("expiry_time [%d]", i_value);
3840
3841         ret = media_pvr_get_parental_rating(pvr, &i_value);
3842         if (ret != MEDIA_CONTENT_ERROR_NONE)
3843                 media_content_error("Fail to media_pvr_get_parental_rating");
3844         media_content_debug("parental_rating [%d]", i_value);
3845
3846         ret = media_pvr_get_start_time(pvr, &i_value);
3847         if (ret != MEDIA_CONTENT_ERROR_NONE)
3848                 media_content_error("Fail to media_pvr_get_start_time");
3849         media_content_debug("start_time [%d]", i_value);
3850
3851         ret = media_pvr_get_program_start_time(pvr, &i_value);
3852         if (ret != MEDIA_CONTENT_ERROR_NONE)
3853                 media_content_error("Fail to media_pvr_get_program_start_time");
3854         media_content_debug("program_start_time [%d]", i_value);
3855
3856         ret = media_pvr_get_program_end_time(pvr, &i_value);
3857         if (ret != MEDIA_CONTENT_ERROR_NONE)
3858                 media_content_error("Fail to media_pvr_get_program_end_time");
3859         media_content_debug("program_end_time [%d]", i_value);
3860
3861         ret = media_pvr_get_program_date(pvr, &i_value);
3862         if (ret != MEDIA_CONTENT_ERROR_NONE)
3863                 media_content_error("Fail to media_pvr_get_program_date");
3864         media_content_debug("program_date [%d]", i_value);
3865
3866         ret = media_pvr_get_timer_record(pvr, &b_value);
3867         if (ret != MEDIA_CONTENT_ERROR_NONE)
3868                 media_content_error("Fail to media_pvr_get_timer_record");
3869         media_content_debug("timer_record [%d]", b_value);
3870
3871         ret = media_pvr_get_series_record(pvr, &b_value);
3872         if (ret != MEDIA_CONTENT_ERROR_NONE)
3873                 media_content_error("Fail to media_pvr_get_series_record");
3874         media_content_debug("series_record [%d]", b_value);
3875
3876         ret = media_pvr_get_hd(pvr, &i_value);
3877         if (ret != MEDIA_CONTENT_ERROR_NONE)
3878                 media_content_error("Fail to media_pvr_get_hd");
3879         media_content_debug("hd [%d]", i_value);
3880
3881         ret = media_pvr_get_subtitle(pvr, &b_value);
3882         if (ret != MEDIA_CONTENT_ERROR_NONE)
3883                 media_content_error("Fail to media_pvr_get_subtitle");
3884         media_content_debug("subtitle [%d]", b_value);
3885
3886         ret = media_pvr_get_ttx(pvr, &b_value);
3887         if (ret != MEDIA_CONTENT_ERROR_NONE)
3888                 media_content_error("Fail to media_pvr_get_ttx");
3889         media_content_debug("ttx [%d]", b_value);
3890
3891         ret = media_pvr_get_ad(pvr, &b_value);
3892         if (ret != MEDIA_CONTENT_ERROR_NONE)
3893                 media_content_error("Fail to media_pvr_get_ad");
3894         media_content_debug("ad [%d]", b_value);
3895
3896         ret = media_pvr_get_hard_of_hearing_radio(pvr, &b_value);
3897         if (ret != MEDIA_CONTENT_ERROR_NONE)
3898                 media_content_error("Fail to media_pvr_get_hard_of_hearing_radio");
3899         media_content_debug("hard_of_hearing_radio [%d]", b_value);
3900
3901         ret = media_pvr_get_data_service(pvr, &b_value);
3902         if (ret != MEDIA_CONTENT_ERROR_NONE)
3903                 media_content_error("Fail to media_pvr_get_data_service");
3904         media_content_debug("data_service [%d]", b_value);
3905
3906         ret = media_pvr_get_content_lock(pvr, &b_value);
3907         if (ret != MEDIA_CONTENT_ERROR_NONE)
3908                 media_content_error("Fail to media_pvr_get_content_lock");
3909         media_content_debug("content_lock [%d]", b_value);
3910
3911         ret = media_pvr_get_content_watch(pvr, &b_value);
3912         if (ret != MEDIA_CONTENT_ERROR_NONE)
3913                 media_content_error("Fail to media_pvr_get_content_watch");
3914         media_content_debug("content_watch [%d]", b_value);
3915
3916         ret = media_pvr_get_has_audio_only(pvr, &b_value);
3917         if (ret != MEDIA_CONTENT_ERROR_NONE)
3918                 media_content_error("Fail to media_pvr_get_has_audio_only");
3919         media_content_debug("has_audio_only [%d]", b_value);
3920
3921         ret = media_pvr_get_is_local_record(pvr, &b_value);
3922         if (ret != MEDIA_CONTENT_ERROR_NONE)
3923                 media_content_error("Fail to media_pvr_get_is_local_record");
3924         media_content_debug("is_local_record [%d]", b_value);
3925
3926         ret = media_pvr_get_resolution(pvr, (media_pvr_resolution_e*)&i_value);
3927         if (ret != MEDIA_CONTENT_ERROR_NONE)
3928                 media_content_error("Fail to media_pvr_get_resolution");
3929         media_content_debug("resolution [%d]", i_value);
3930
3931         ret = media_pvr_get_aspectratio(pvr, (media_pvr_aspectratio_e*)&i_value);
3932         if (ret != MEDIA_CONTENT_ERROR_NONE)
3933                 media_content_error("Fail to media_pvr_get_aspectratio");
3934         media_content_debug("aspectratio [%d]", i_value);
3935
3936         ret = media_pvr_get_highlight(pvr, &b_value);
3937         if (ret != MEDIA_CONTENT_ERROR_NONE)
3938                 media_content_error("Fail to media_pvr_get_highlight");
3939         media_content_debug("highlight [%d]", b_value);
3940
3941
3942         return TRUE;
3943 }
3944
3945 int test_pvr()
3946 {
3947         int ret = MEDIA_CONTENT_ERROR_NONE;
3948         int media_count = 0;
3949
3950         media_content_debug("\n============PVR Test============\n\n");
3951
3952         test_tv_filter_create();
3953
3954         ret = media_pvr_get_media_count_from_db(g_tv_filter, &media_count);
3955         if (ret != MEDIA_CONTENT_ERROR_NONE)
3956                 media_content_error("media_pvr_get_media_count_from_db failed: %d", ret);
3957         else
3958                 media_content_debug("media_count : [%d]", media_count);
3959
3960         ret = media_pvr_foreach_media_from_db(g_tv_filter, pvr_item_cb, NULL);
3961         if (ret != MEDIA_CONTENT_ERROR_NONE)
3962                 media_content_error("media_pvr_foreach_media_from_db is failed");
3963
3964         test_tv_filter_destroy();
3965
3966         return ret;
3967 }
3968
3969 int test_pvr_update_db(void)
3970 {
3971         int ret = MEDIA_CONTENT_ERROR_NONE;
3972         media_pvr_h pvr = NULL;
3973
3974         ret = media_pvr_get_pvr_from_db("ff9b5a9a-a7b4-47f4-8255-84e007e25f13", &pvr);
3975         if (ret != MEDIA_CONTENT_ERROR_NONE)
3976                 media_content_error("media_pvr_get_pvr_from_db failed: %d", ret);
3977
3978         ret = media_pvr_set_content_lock(pvr, TRUE);
3979         if (ret != MEDIA_CONTENT_ERROR_NONE)
3980                 media_content_error("Fail to media_pvr_set_content_lock");
3981
3982         ret = media_pvr_set_content_watch(pvr, TRUE);
3983         if (ret != MEDIA_CONTENT_ERROR_NONE)
3984                 media_content_error("Fail to media_pvr_set_content_watch");
3985
3986         ret = media_pvr_set_program_title(pvr, "TEST TITLE");
3987         if (ret != MEDIA_CONTENT_ERROR_NONE)
3988                 media_content_error("Fail to media_pvr_set_program_title");
3989
3990         ret = media_pvr_set_highlight(pvr, TRUE);
3991         if (ret != MEDIA_CONTENT_ERROR_NONE)
3992                 media_content_error("Fail to media_pvr_set_highlight");
3993
3994         ret = media_pvr_update_to_db(pvr);
3995         if (ret != MEDIA_CONTENT_ERROR_NONE)
3996                 media_content_error("Fail to media_pvr_update_to_db");
3997
3998         if (pvr != NULL)
3999                 media_pvr_destroy(pvr);
4000
4001         return ret;
4002 }
4003 #endif
4004
4005 int main(int argc, char *argv[])
4006 {
4007         int ret = MEDIA_CONTENT_ERROR_NONE;
4008
4009         media_content_debug("--- content manager test start ---\n\n");
4010
4011         ret = test_connect_database();
4012         if (ret != MEDIA_CONTENT_ERROR_NONE)
4013                 return MEDIA_CONTENT_ERROR_NONE;
4014 #ifdef _USE_TV_PROFILE
4015         test_pvr();
4016
4017         test_pvr_update_db();
4018
4019         test_pvr();
4020 #endif
4021
4022 #if 0
4023         ret = test_start_face_detection(FALSE);
4024         if (ret != MEDIA_CONTENT_ERROR_NONE)
4025                 return ret;
4026
4027         ret = test_move();
4028         if (ret != MEDIA_CONTENT_ERROR_NONE)
4029                 return ret;
4030
4031         ret = test_gallery_scenario();
4032         if (ret != MEDIA_CONTENT_ERROR_NONE)
4033                 return ret;
4034
4035         ret = test_get_all_music_files();
4036         if (ret != MEDIA_CONTENT_ERROR_NONE)
4037                 return ret;
4038
4039         ret = test_media_info_operation();
4040         if (ret != MEDIA_CONTENT_ERROR_NONE)
4041                 return ret;
4042
4043         ret = test_folder_operation();
4044         if (ret != MEDIA_CONTENT_ERROR_NONE)
4045                 return ret;
4046
4047         ret = test_folder_update();
4048         if (ret != MEDIA_CONTENT_ERROR_NONE)
4049                 return ret;
4050
4051         ret = test_playlist_operation();
4052         if (ret != MEDIA_CONTENT_ERROR_NONE)
4053                 return ret;
4054
4055         ret = test_tag_operation();
4056         if (ret != MEDIA_CONTENT_ERROR_NONE)
4057                 return ret;
4058
4059         ret = test_bookmark_operation();
4060         if (ret != MEDIA_CONTENT_ERROR_NONE)
4061                 return ret;
4062
4063         ret = test_album_list();
4064         if (ret != MEDIA_CONTENT_ERROR_NONE)
4065                 return ret;
4066
4067         ret = test_group_operation();
4068         if (ret != MEDIA_CONTENT_ERROR_NONE)
4069                 return ret;
4070
4071         ret = test_update_operation();
4072         if (ret != MEDIA_CONTENT_ERROR_NONE)
4073                 return ret;
4074
4075         ret = test_insert();
4076         if (ret != MEDIA_CONTENT_ERROR_NONE)
4077                 return ret;
4078
4079         ret = test_move();
4080         if (ret != MEDIA_CONTENT_ERROR_NONE)
4081                 return ret;
4082
4083         ret = test_create_thumbnail(TRUE);
4084         if (ret != MEDIA_CONTENT_ERROR_NONE)
4085                 return ret;
4086
4087         ret = test_extrace_face(TRUE);
4088         if (ret != MEDIA_CONTENT_ERROR_NONE)
4089                 return ret;
4090
4091         ret = test_request_update_db();
4092         if (ret != MEDIA_CONTENT_ERROR_NONE)
4093                 return ret;
4094
4095         ret = DFT_test();
4096         if (ret != MEDIA_CONTENT_ERROR_NONE)
4097                 return ret;
4098
4099         ret = test_batch_operations();
4100         if (ret != MEDIA_CONTENT_ERROR_NONE)
4101                 return MEDIA_CONTENT_ERROR_NONE;
4102
4103         ret = test_insert_burst_shot_to_db();
4104         if (ret != MEDIA_CONTENT_ERROR_NONE)
4105                 return MEDIA_CONTENT_ERROR_NONE;
4106
4107         ret = test_scan_file();
4108         if (ret != MEDIA_CONTENT_ERROR_NONE)
4109                 return MEDIA_CONTENT_ERROR_NONE;
4110
4111         ret = test_scan_dir(true);
4112         if (ret != MEDIA_CONTENT_ERROR_NONE)
4113                 return MEDIA_CONTENT_ERROR_NONE;
4114
4115         ret = test_noti();
4116         if (ret != MEDIA_CONTENT_ERROR_NONE)
4117                 return MEDIA_CONTENT_ERROR_NONE;
4118
4119         ret = test_create_handle();
4120         if (ret != MEDIA_CONTENT_ERROR_NONE)
4121                 return MEDIA_CONTENT_ERROR_NONE;
4122
4123         ret = test_face();
4124         if (ret != MEDIA_CONTENT_ERROR_NONE)
4125                 return MEDIA_CONTENT_ERROR_NONE;
4126
4127         ret = test_face_add_del();
4128         if (ret != MEDIA_CONTENT_ERROR_NONE)
4129                 return MEDIA_CONTENT_ERROR_NONE;
4130
4131         ret = test_playlist_operation_v2();
4132         if (ret != MEDIA_CONTENT_ERROR_NONE)
4133                 return MEDIA_CONTENT_ERROR_NONE;
4134
4135         ret = test_bookmark_operation_v2();
4136         if (ret != MEDIA_CONTENT_ERROR_NONE)
4137                 return MEDIA_CONTENT_ERROR_NONE;
4138
4139         ret = test_tag_operation_v2();
4140         if (ret != MEDIA_CONTENT_ERROR_NONE)
4141                 return MEDIA_CONTENT_ERROR_NONE;
4142 #endif
4143
4144         ret = test_disconnect_database();
4145         if (ret != MEDIA_CONTENT_ERROR_NONE)
4146                 return ret;
4147
4148         media_content_debug("--- content manager test end ---\n");
4149
4150         return ret;
4151 }