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   "0f999626-6218-450c-a4ad-181a3bab6ebf"
  38 #define test_video_id   "22aa5ba1-8b54-4a62-b0e4-d15f7169f7d3"
  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
1887         media_content_debug("\n============Playlist Test V2============\n\n");
1888
1889         ret = media_playlist_create(playlist_name_1, &playlist_1);
1890         if (ret != MEDIA_CONTENT_ERROR_NONE)
1891                 media_content_error("error media_playlist_create : [%d]", ret);
1892
1893         ret = media_playlist_set_thumbnail_path(playlist_1, playlist_thumb_path);
1894         if (ret != MEDIA_CONTENT_ERROR_NONE)
1895                 media_content_error("error media_playlist_set_thumbnail_path : [%d]", ret);
1896
1897         ret = media_playlist_insert_to_db_v2(playlist_1);
1898         if (ret != MEDIA_CONTENT_ERROR_NONE)
1899                 media_content_error("error media_playlist_insert_to_db_v2 : [%d]", ret);
1900
1901         ret = media_playlist_set_name(playlist_1, "myPlaylist_3");
1902         if (ret != MEDIA_CONTENT_ERROR_NONE)
1903                 media_content_error("error media_playlist_set_name : [%d]", ret);
1904
1905         ret = media_playlist_update_to_db(playlist_1);
1906         if (ret != MEDIA_CONTENT_ERROR_NONE)
1907                 media_content_error("error media_playlist_update_to_db : [%d]", ret);
1908
1909         ret = media_playlist_destroy(playlist_1);
1910         if (ret != MEDIA_CONTENT_ERROR_NONE)
1911                 media_content_error("error media_playlist_destroy : [%d]", ret);
1912
1913         return ret;
1914 }
1915
1916 int test_tag_operation(void)
1917 {
1918         int ret = MEDIA_CONTENT_ERROR_NONE;
1919         media_tag_h tag_1;
1920         media_tag_h tag_2;
1921         media_tag_h tag_3;
1922         int tag_id_1 = 0;
1923         int tag_id_2 = 0;
1924         int tag_id_3 = 0;
1925         const char *tag_name_1 = "myTag_1";
1926         const char *tag_name_2 = "myTag_2";
1927         const char *tag_name_3 = "myTag_3";
1928         int tag_count = 0;
1929         int media_count = 0;
1930         filter_h filter;
1931
1932         media_content_debug("\n============Tag Test============\n\n");
1933
1934         const char *g_condition = "TAG_NAME like \"%%my%%\"";
1935
1936         ret = media_filter_create(&filter);
1937
1938         ret = media_filter_set_condition(filter, g_condition, MEDIA_CONTENT_COLLATE_DEFAULT);
1939
1940         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, TAG_NAME, MEDIA_CONTENT_COLLATE_DEFAULT);
1941
1942         /* Create Tag */
1943         ret = media_tag_insert_to_db(tag_name_1, &tag_1);
1944         if (ret != MEDIA_CONTENT_ERROR_NONE)
1945                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1946         ret = media_tag_insert_to_db(tag_name_2, &tag_2);
1947         if (ret != MEDIA_CONTENT_ERROR_NONE)
1948                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1949         ret = media_tag_insert_to_db(tag_name_3, &tag_3);
1950         if (ret != MEDIA_CONTENT_ERROR_NONE)
1951                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1952
1953         /* Add media to Tag */
1954         ret = media_tag_add_media(tag_1, test_audio_id);
1955         if (ret != MEDIA_CONTENT_ERROR_NONE)
1956                 media_content_error("error media_tag_add_media : [%d]", ret);
1957         ret = media_tag_add_media(tag_1, test_video_id);
1958         if (ret != MEDIA_CONTENT_ERROR_NONE)
1959                 media_content_error("error media_tag_add_media : [%d]", ret);
1960         ret = media_tag_update_to_db(tag_1);
1961         if (ret != MEDIA_CONTENT_ERROR_NONE)
1962                 media_content_error("error media_tag_update_to_db : [%d]", ret);
1963
1964         ret = media_tag_add_media(tag_2, test_audio_id);
1965         if (ret != MEDIA_CONTENT_ERROR_NONE)
1966                 media_content_error("error media_tag_add_media : [%d]", ret);
1967         ret = media_tag_update_to_db(tag_2);
1968         if (ret != MEDIA_CONTENT_ERROR_NONE)
1969                 media_content_error("error media_tag_update_to_db : [%d]", ret);
1970
1971         /* Get Tag Count*/
1972         ret = media_tag_get_tag_count_from_db(filter, &tag_count);
1973         if (ret != MEDIA_CONTENT_ERROR_NONE)
1974                 media_content_error("error media_tag_get_tag_count_from_db : [%d]", ret);
1975         else
1976                 media_content_debug("tag_count [%d]", tag_count);
1977
1978         /* Get Tag*/
1979         ret = media_tag_foreach_tag_from_db(filter, tag_list_cb, NULL);
1980         if (ret != MEDIA_CONTENT_ERROR_NONE)
1981                 media_content_error("error media_tag_foreach_tag_from_db : [%d]", ret);
1982
1983         /* Get Tag id*/
1984         ret = media_tag_get_tag_id(tag_1, &tag_id_1);
1985         if (ret != MEDIA_CONTENT_ERROR_NONE)
1986                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1987         else
1988                 media_content_debug("tag_id_1 [%d]", tag_id_1);
1989
1990         ret = media_tag_get_tag_id(tag_2, &tag_id_2);
1991         if (ret != MEDIA_CONTENT_ERROR_NONE)
1992                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1993         else
1994                 media_content_debug("tag_id_2 [%d]", tag_id_2);
1995
1996         ret = media_tag_get_tag_id(tag_3, &tag_id_3);
1997         if (ret != MEDIA_CONTENT_ERROR_NONE)
1998                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1999         else
2000                 media_content_debug("tag_id_3 [%d]", tag_id_3);
2001
2002         /* Get media count */
2003         ret = media_tag_get_media_count_from_db(tag_id_1, NULL, &media_count);
2004         if (ret != MEDIA_CONTENT_ERROR_NONE)
2005                 media_content_error("error media_tag_get_media_count_from_db : [%d]", ret);
2006         else
2007                 media_content_debug("tag_1_media_count [%d]", media_count);
2008
2009         ret = media_tag_get_media_count_from_db(tag_id_2, NULL, &media_count);
2010         if (ret != MEDIA_CONTENT_ERROR_NONE)
2011                 media_content_error("error media_tag_get_media_count_from_db : [%d]", ret);
2012         else
2013                 media_content_debug("tag_2_media_count [%d]", media_count);
2014
2015         /* Get media of Tag */
2016         ret = media_tag_foreach_media_from_db(tag_id_1, NULL, media_item_cb, NULL);
2017         if (ret != MEDIA_CONTENT_ERROR_NONE)
2018                 media_content_error("error media_tag_foreach_media_from_db : [%d]", ret);
2019
2020         ret = media_tag_foreach_media_from_db(tag_id_2, NULL, media_item_cb, NULL);
2021         if (ret != MEDIA_CONTENT_ERROR_NONE)
2022                 media_content_error("error media_tag_foreach_media_from_db : [%d]", ret);
2023
2024         /* Update Tag */
2025         ret = media_tag_add_media(tag_2, test_video_id);
2026         if (ret != MEDIA_CONTENT_ERROR_NONE)
2027                 media_content_error("error media_tag_add_media : [%d]", ret);
2028         ret = media_tag_set_name(tag_2, (char *)"test_tag");
2029         if (ret != MEDIA_CONTENT_ERROR_NONE)
2030                 media_content_error("error media_tag_set_name : [%d]", ret);
2031         ret = media_tag_update_to_db(tag_2);
2032         if (ret != MEDIA_CONTENT_ERROR_NONE)
2033                 media_content_error("error media_tag_update_to_db : [%d]", ret);
2034
2035         /* Get Updated Tag*/
2036         ret = media_tag_foreach_tag_from_db(filter, tag_list_cb, NULL);
2037         if (ret != MEDIA_CONTENT_ERROR_NONE)
2038                 media_content_error("error media_tag_foreach_tag_from_db : [%d]", ret);
2039
2040         /* deletes the tag */
2041         ret = media_tag_delete_from_db(tag_id_1);
2042         if (ret != MEDIA_CONTENT_ERROR_NONE)
2043                 media_content_error("error media_tag_delete_from_db : [%d]", ret);
2044         ret = media_tag_delete_from_db(tag_id_2);
2045         if (ret != MEDIA_CONTENT_ERROR_NONE)
2046                 media_content_error("error media_tag_delete_from_db : [%d]", ret);
2047
2048         ret = media_tag_destroy(tag_1);
2049         if (ret != MEDIA_CONTENT_ERROR_NONE)
2050                 media_content_error("error media_tag_destroy : [%d]", ret);
2051         ret = media_tag_destroy(tag_2);
2052         if (ret != MEDIA_CONTENT_ERROR_NONE)
2053                 media_content_error("error media_tag_destroy : [%d]", ret);
2054         ret = media_filter_destroy(filter);
2055         if (ret != MEDIA_CONTENT_ERROR_NONE)
2056                 media_content_error("error media_filter_destroy : [%d]", ret);
2057
2058         return ret;
2059 }
2060
2061
2062 int test_bookmark_operation(void)
2063 {
2064         /* bookmark is only supported for video information. */
2065         int ret = MEDIA_CONTENT_ERROR_NONE;
2066         int bookmark_count = 0;
2067         filter_h filter;
2068         GList *all_item_list = NULL;
2069         int idx = 0;
2070
2071         media_content_debug("\n============Bookmark Test============\n\n");
2072
2073         const char *g_condition = "BOOKMARK_MARKED_TIME > 300";
2074
2075         ret = media_filter_create(&filter);
2076         if (ret != MEDIA_CONTENT_ERROR_NONE)
2077                 media_content_error("error media_filter_create : [%d]", ret);
2078
2079         ret = media_filter_set_condition(filter, g_condition, MEDIA_CONTENT_COLLATE_DEFAULT);
2080         if (ret != MEDIA_CONTENT_ERROR_NONE)
2081                 media_content_error("error media_filter_set_condition : [%d]", ret);
2082
2083         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, BOOKMARK_MARKED_TIME, MEDIA_CONTENT_COLLATE_DEFAULT);
2084         if (ret != MEDIA_CONTENT_ERROR_NONE)
2085                 media_content_error("error media_filter_set_order : [%d]", ret);
2086
2087         /* insert bookmark to video */
2088         const char *thumbnail_path1 = tzplatform_mkpath(TZ_USER_CONTENT, "Images and videos/My video clips/teat11.jpg");
2089         ret = media_bookmark_insert_to_db(test_video_id, 400, thumbnail_path1);
2090         if (ret != MEDIA_CONTENT_ERROR_NONE)
2091                 media_content_error("error media_bookmark_insert_to_db : [%d]", ret);
2092
2093         ret = media_bookmark_insert_to_db(test_video_id, 600, thumbnail_path1);
2094         if (ret != MEDIA_CONTENT_ERROR_NONE)
2095                 media_content_error("error media_bookmark_insert_to_db : [%d]", ret);
2096
2097         ret = media_bookmark_get_bookmark_count_from_db(filter, &bookmark_count);
2098         if (ret != MEDIA_CONTENT_ERROR_NONE)
2099                 media_content_error("error media_bookmark_get_bookmark_count_from_db : [%d]", ret);
2100         else
2101                 media_content_debug("bookmark_count = [%d]", bookmark_count);
2102
2103         ret = media_info_foreach_bookmark_from_db(test_video_id, NULL, bookmarks_cb, &all_item_list);
2104         if (ret != MEDIA_CONTENT_ERROR_NONE)
2105                 media_content_error("error media_info_foreach_bookmark_from_db : [%d]", ret);
2106
2107         for (idx = 0; idx < g_list_length(all_item_list); idx++) {
2108                 media_bookmark_h bookmark_handle;
2109                 bookmark_handle = (media_bookmark_h)g_list_nth_data(all_item_list, idx);
2110
2111                 ret = media_bookmark_set_name(bookmark_handle, "test 1");
2112                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2113                         media_content_error("error media_bookmark_set_name : [%d]", ret);
2114
2115                 ret = media_bookmark_update_to_db(bookmark_handle);
2116         }
2117
2118         ret = media_info_foreach_bookmark_from_db(test_video_id, NULL, bookmarks_cb, NULL);
2119         if (ret != MEDIA_CONTENT_ERROR_NONE)
2120                 media_content_error("error media_info_foreach_bookmark_from_db : [%d]", ret);
2121
2122         ret = media_filter_destroy(filter);
2123         if (ret != MEDIA_CONTENT_ERROR_NONE)
2124                 media_content_error("error media_filter_destroy : [%d]", ret);
2125
2126         return ret;
2127 }
2128
2129 int test_bookmark_operation_v2(void)
2130 {
2131         media_content_debug("\n============Bookmark Test V2============\n\n");
2132
2133         int ret = MEDIA_CONTENT_ERROR_NONE;
2134         media_bookmark_h bookmark = NULL;
2135         const char *thumbnail_path1 = tzplatform_mkpath(TZ_USER_CONTENT, "Images and videos/My video clips/teat11.jpg");
2136
2137         ret = media_bookmark_create(test_video_id, 400, &bookmark);
2138         if (ret != MEDIA_CONTENT_ERROR_NONE)
2139                 media_content_error("error media_bookmark_create : [%d]", ret);
2140
2141         ret = media_bookmark_set_name(bookmark, "test bookmark");
2142         if (ret != MEDIA_CONTENT_ERROR_NONE)
2143                 media_content_error("error media_bookmark_set_name : [%d]", ret);
2144
2145         ret = media_bookmark_set_thumbnail_path(bookmark, thumbnail_path1);
2146         if (ret != MEDIA_CONTENT_ERROR_NONE)
2147                 media_content_error("error media_bookmark_set_thumbnail_path : [%d]", ret);
2148
2149         ret = media_bookmark_insert_to_db_v2(bookmark);
2150         if (ret != MEDIA_CONTENT_ERROR_NONE)
2151                 media_content_error("error media_bookmark_insert_to_db_v2 : [%d]", ret);
2152
2153         ret = media_bookmark_set_name(bookmark, "test bookmark 2");
2154         if (ret != MEDIA_CONTENT_ERROR_NONE)
2155                 media_content_error("error media_bookmark_set_name : [%d]", ret);
2156
2157         ret = media_bookmark_update_to_db(bookmark);
2158         if (ret != MEDIA_CONTENT_ERROR_NONE)
2159                 media_content_error("error media_bookmark_update_to_db : [%d]", ret);
2160
2161         ret = media_bookmark_destroy(bookmark);
2162         if (ret != MEDIA_CONTENT_ERROR_NONE)
2163                 media_content_error("error media_bookmark_destroy : [%d]", ret);
2164
2165         return ret;
2166 }
2167
2168 int test_album_list(void)
2169 {
2170         media_content_debug("\n============Album Test============\n\n");
2171
2172         int ret = MEDIA_CONTENT_ERROR_NONE;
2173         int album_count = 0;
2174         filter_h filter;
2175
2176         /*Set Filter*/
2177         const char *condition = "MEDIA_TYPE=3"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/
2178
2179         ret = media_filter_create(&filter);
2180         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2181                 media_content_error("Fail to create filter");
2182                 return ret;
2183         }
2184         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
2185         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2186                 media_filter_destroy(filter);
2187                 media_content_error("Fail to set condition");
2188                 return ret;
2189         }
2190         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ALBUM, MEDIA_CONTENT_COLLATE_NOCASE);
2191         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2192                 media_filter_destroy(filter);
2193                 media_content_error("Fail to set order");
2194                 return ret;
2195         }
2196
2197         ret = media_album_get_album_count_from_db(filter, &album_count);
2198         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2199                 media_filter_destroy(filter);
2200                 return ret;
2201         } else {
2202                 media_content_debug("album_count [%d]", album_count);
2203         }
2204
2205         ret = media_album_foreach_album_from_db(filter, album_list_cb, NULL);
2206         if (ret != MEDIA_CONTENT_ERROR_NONE)
2207                 media_content_error("error media_album_foreach_album_from_db : [%d]", ret);
2208
2209         ret = media_filter_destroy(filter);
2210         if (ret != MEDIA_CONTENT_ERROR_NONE)
2211                 media_content_error("error media_filter_destroy : [%d]", ret);
2212
2213         return ret;
2214 }
2215
2216 int test_group_operation(void)
2217 {
2218         media_content_debug("\n============Group Test============\n\n");
2219
2220         int ret = MEDIA_CONTENT_ERROR_NONE;
2221         int group_count = 0;
2222         int idx = 0;
2223
2224         ret = test_filter_create();
2225         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2226                 media_content_error("[error(0x%08x)", ret);
2227                 return ret;
2228         }
2229
2230         for (idx = 0; idx < MEDIA_CONTENT_GROUP_MAX; idx++) {
2231                 ret = media_group_get_group_count_from_db(g_filter, idx, &group_count);
2232                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
2233                         test_filter_destroy();
2234                         media_content_error("media_group_get_group_count_from_db fail. idx=[%d]", ret, idx);
2235                         return ret;
2236                 } else {
2237                         media_content_debug("[%2d]group_count [%d]", idx, group_count);
2238                 }
2239
2240                 ret = media_group_foreach_group_from_db(g_filter, idx, group_list_cb, &idx);
2241         }
2242         ret = test_filter_destroy();
2243
2244         return ret;
2245 }
2246
2247 int test_update_operation()
2248 {
2249         int ret = MEDIA_CONTENT_ERROR_NONE;
2250         unsigned int i = 0;
2251         media_info_h media_handle = NULL;
2252         GList *all_item_list = NULL;
2253
2254         /* Get all item list */
2255         ret = media_info_foreach_media_from_db(NULL, gallery_media_item_cb, &all_item_list);
2256         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2257                 media_content_error("media_info_foreach_media_from_db failed: %d", ret);
2258                 return -1;
2259         } else {
2260                 media_content_debug("media_info_foreach_media_from_db success");
2261                 char *media_id = NULL;
2262                 char *media_path = NULL;
2263                 media_content_type_e media_type = 0;
2264
2265                 for (i = 0; i < g_list_length(all_item_list); i++) {
2266                         media_handle = (media_info_h)g_list_nth_data(all_item_list, i);
2267
2268                         ret = media_info_get_media_id(media_handle, &media_id);
2269                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2270                                 media_content_error("media_info_get_media_id failed: %d", ret);
2271                         ret = media_info_get_file_path(media_handle, &media_path);
2272                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2273                                 media_content_error("media_info_get_file_path failed: %d", ret);
2274                         ret = media_info_get_media_type(media_handle, &media_type);
2275                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2276                                 media_content_error("media_info_get_media_type failed: %d", ret);
2277
2278                         media_content_debug("media_id [%d] : %s", i, media_id);
2279                         media_content_debug("media_type [%d] : %d", i, media_type);
2280                         media_content_debug("media_path [%d] : %s", i, media_path);
2281 #if 0
2282                         if (media_type == MEDIA_CONTENT_TYPE_IMAGE) {
2283                                 image_meta_h image_handle;
2284                                 media_content_orientation_e orientation;
2285
2286                                 ret = media_info_get_image(media_handle, &image_handle);
2287                                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
2288                                         media_content_error("media_info_get_image failed: %d", ret);
2289                                 } else {
2290                                         media_content_debug("media_info_get_image success");
2291
2292                                         /* update image meta */
2293                                         orientation = MEDIA_CONTENT_ORIENTATION_ROT_180;
2294                                         image_meta_set_orientation(image_handle, orientation);
2295
2296                                         ret = image_meta_update_to_db(image_handle);
2297                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2298                                                 media_content_error("image_meta_update_to_db failed: %d", ret);
2299                                         else
2300                                                 media_content_debug("image_meta_update_to_db success");
2301                                 }
2302
2303                         } else if (media_type == MEDIA_CONTENT_TYPE_VIDEO) {
2304                                 video_meta_h video_handle;
2305
2306                                 ret = media_info_get_video(media_handle, &video_handle);
2307                                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
2308                                         media_content_error("media_info_get_video failed: %d", ret);
2309                                 } else {
2310                                         media_content_debug("media_info_get_video success");
2311
2312                                         /* update video meta */
2313                                         video_meta_set_played_count(video_handle, 5);
2314                                         video_meta_set_played_time(video_handle, 5);
2315                                         video_meta_set_played_position(video_handle, 5);
2316                                         video_meta_update_to_db(video_handle);
2317
2318                                         ret = video_meta_update_to_db(video_handle);
2319                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2320                                                 media_content_error("video_meta_update_to_db failed: %d", ret);
2321                                         else
2322                                                 media_content_debug("video_meta_update_to_db success");
2323                                 }
2324                         } else if (media_type == MEDIA_CONTENT_TYPE_MUSIC) {
2325                                 audio_meta_h audio_handle = NULL;
2326                                 ret = media_info_get_audio(media_handle, &audio_handle);
2327                                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
2328                                         media_content_error("media_info_get_audio failed: %d", ret);
2329                                 } else {
2330                                         media_content_debug("media_info_get_audio success");
2331
2332                                         audio_meta_set_played_count(audio_handle, 5);
2333                                         audio_meta_set_played_time(audio_handle, 1000);
2334                                         audio_meta_set_played_position(audio_handle, 180);
2335
2336                                         ret = audio_meta_update_to_db(audio_handle);
2337                                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2338                                                 media_content_error("audio_meta_update_to_db failed: %d", ret);
2339                                         else
2340                                                 media_content_debug("audio_meta_update_to_db success");
2341                                 }
2342
2343                         }
2344 #endif
2345                 }
2346
2347                 /* fix prevent: Resource Leak */
2348                 SAFE_FREE(media_id);
2349                 SAFE_FREE(media_path);
2350         }
2351
2352         return MEDIA_CONTENT_ERROR_NONE;
2353 }
2354
2355 int test_insert(void)
2356 {
2357         int ret = MEDIA_CONTENT_ERROR_NONE;
2358         const char *path = "/opt/usr/media/Images/Default.jpg";
2359 #if 0
2360         const char *path = "/opt/usr/media/Others/other.txt";
2361         char *path = NULL;
2362 #endif
2363         media_info_h media_item = NULL;
2364         media_content_debug("\n============DB Insert Test============\n\n");
2365
2366         ret = media_info_insert_to_db(path, &media_item);
2367
2368         if ((ret == MEDIA_CONTENT_ERROR_NONE) && (media_item != NULL)) {
2369                 media_content_debug("Insertion is success");
2370         } else {
2371                 media_content_error("Insertion is failed");
2372                 ret = media_info_destroy(media_item);
2373                 return ret;
2374         }
2375
2376         char *media_id = NULL;
2377
2378         ret = media_info_get_media_id(media_item, &media_id);
2379         if (ret != MEDIA_CONTENT_ERROR_NONE)
2380                 media_content_error("media_info_get_media_id failed: %d", ret);
2381         else
2382                 media_content_debug("Media ID: %s", media_id);
2383
2384         SAFE_FREE(media_id);
2385
2386         ret = media_info_update_to_db(media_item);
2387         if (ret == MEDIA_CONTENT_ERROR_NONE)
2388                 media_content_debug("media_info_update_to_db is success");
2389         else
2390                 media_content_error("media_info_update_to_db is failed");
2391
2392         ret = media_info_destroy(media_item);
2393         if (ret != MEDIA_CONTENT_ERROR_NONE)
2394                 media_content_error("media_info_destroy failed: %d", ret);
2395
2396         return ret;
2397 }
2398
2399 int test_move(void)
2400 {
2401         int ret = MEDIA_CONTENT_ERROR_NONE;
2402         const char *move_media_id = "60aea677-4742-408e-b5f7-f2628062d06d";
2403         const char *dst_path = tzplatform_mkpath(TZ_USER_CONTENT, "Images/XX/Default1.jpg");
2404         media_info_h move_media = NULL;
2405
2406         ret = media_info_get_media_from_db(move_media_id, &move_media);
2407         if (ret == MEDIA_CONTENT_ERROR_NONE)
2408                 media_content_debug("media_info_get_media_from_db success");
2409         else
2410                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2411
2412         media_content_debug("\n============DB Move Test============\n\n");
2413
2414         if (move_media) {
2415                 ret = media_info_move_to_db(move_media, dst_path);
2416
2417                 if (ret == MEDIA_CONTENT_ERROR_NONE)
2418                         media_content_debug("Move is success");
2419                 else
2420                         media_content_error("Move is failed");
2421
2422                 ret = media_info_destroy(move_media);
2423         } else {
2424                 media_content_debug("There is no item : %s", move_media_id);
2425         }
2426
2427         return ret;
2428 }
2429
2430 void thumbnail_completed_cb(media_content_error_e error, const char *path, void *user_data)
2431 {
2432         char *thumbnail_path = NULL;
2433         int ret = MEDIA_CONTENT_ERROR_NONE;
2434         g_cnt++;
2435
2436         media_content_debug("=================[%d][%d]", g_media_cnt, g_cnt);
2437         media_content_debug("error_code [%d]", error);
2438         media_content_debug("thumbnail_path [%s]", path);
2439         if (user_data != NULL) {
2440                 media_info_h media = (media_info_h)user_data;
2441                 ret = media_info_get_thumbnail_path(media, &thumbnail_path);
2442                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2443                         media_content_error("media_info_get_thumbnail_path failed: %d", ret);
2444                 else
2445                         media_content_debug("thumbnail_path get from media[%s]", thumbnail_path);
2446                 SAFE_FREE(thumbnail_path);
2447                 ret = media_info_destroy(media);
2448                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2449                         media_content_error("media_info_destroy failed: %d", ret);
2450         }
2451
2452         if (g_cnt == g_media_cnt)
2453                 g_main_loop_quit(g_loop);
2454
2455         return;
2456 }
2457
2458 bool thumbnail_create_cb(media_info_h media, void *user_data)
2459 {
2460         char *media_id = NULL;
2461         media_info_h dst = NULL;
2462         int ret = MEDIA_CONTENT_ERROR_NONE;
2463
2464         if (media == NULL) {
2465                 media_content_debug("NO Item");
2466                 return true;
2467         }
2468
2469         ret = media_info_get_media_id(media, &media_id);
2470         if (ret != MEDIA_CONTENT_ERROR_NONE)
2471                 media_content_error("media_info_get_media_id failed: %d", ret);
2472         else
2473                 media_content_debug("media_id : [%s]", media_id);
2474
2475         ret = media_info_clone(&dst, media);
2476         if (ret != MEDIA_CONTENT_ERROR_NONE)
2477                 media_content_error("media_info_clone failed: %d", ret);
2478         else {
2479                 ret = media_info_create_thumbnail(dst, thumbnail_completed_cb, dst);
2480                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2481                         media_content_error("media_info_create_thumbnail failed: %d", ret);
2482         }
2483
2484         /* fix prevent: Resource leak */
2485         SAFE_FREE(media_id);
2486
2487         return true;
2488 }
2489
2490 bool thumbnail_cancel_cb(media_info_h media, void *user_data)
2491 {
2492         int ret = MEDIA_CONTENT_ERROR_NONE;
2493
2494         char *media_id = NULL;
2495         media_info_h dst = NULL;
2496
2497         g_cnt++;
2498
2499         if (media == NULL) {
2500                 media_content_debug("NO Item");
2501                 return true;
2502         }
2503
2504         ret = media_info_get_media_id(media, &media_id);
2505         if (ret != MEDIA_CONTENT_ERROR_NONE)
2506                 media_content_error("media_info_get_media_id failed: %d", ret);
2507         else
2508                 media_content_debug("media_id : [%s]", media_id);
2509
2510         ret = media_info_clone(&dst, media);
2511         if (ret != MEDIA_CONTENT_ERROR_NONE)
2512                 media_content_error("media_info_clone failed: %d", ret);
2513
2514         ret = media_info_cancel_thumbnail(dst);
2515         if (ret != MEDIA_CONTENT_ERROR_NONE)
2516                 media_content_error("media_info_cancel_thumbnail failed: %d", ret);
2517
2518         ret = media_info_destroy(dst);
2519         if (ret != MEDIA_CONTENT_ERROR_NONE)
2520                         media_content_error("media_info_destroy failed: %d", ret);
2521
2522         if (g_cnt == g_media_cnt)
2523                 g_main_loop_quit(g_loop);
2524
2525         /* fix prevent: Resource leak */
2526         SAFE_FREE(media_id);
2527
2528         return true;
2529 }
2530
2531 gboolean create_thumbnail_start(gpointer data)
2532 {
2533         int ret = MEDIA_CONTENT_ERROR_NONE;
2534
2535         ret = media_info_foreach_media_from_db(g_filter, thumbnail_create_cb, NULL);
2536
2537         if (ret == MEDIA_CONTENT_ERROR_NONE)
2538                 media_content_debug("media_info_foreach_media_from_db is success");
2539         else
2540                 media_content_error("media_info_foreach_media_from_db is failed");
2541
2542         return false;
2543 }
2544
2545 gboolean cancel_thumbnail_start(gpointer data)
2546 {
2547         int ret = MEDIA_CONTENT_ERROR_NONE;
2548
2549         ret = media_info_foreach_media_from_db(g_filter, thumbnail_cancel_cb, NULL);
2550
2551         if (ret == MEDIA_CONTENT_ERROR_NONE)
2552                 media_content_debug("media_info_foreach_media_from_db is success");
2553         else
2554                 media_content_error("media_info_foreach_media_from_db is failed");
2555
2556         return false;
2557 }
2558
2559 int test_create_thumbnail(int cancel)
2560 {
2561         int ret = MEDIA_CONTENT_ERROR_NONE;
2562         GSource *source = NULL;
2563         GMainContext *context = NULL;
2564
2565         test_filter_create();
2566
2567         ret = media_info_get_media_count_from_db(g_filter, &g_media_cnt);
2568         if (ret != MEDIA_CONTENT_ERROR_NONE)
2569                 media_content_error("media_info_get_media_count_from_db failed: %d", ret);
2570         else
2571                 media_content_debug("media_count : [%d]", g_media_cnt);
2572
2573         g_loop = g_main_loop_new(NULL, FALSE);
2574         context = g_main_loop_get_context(g_loop);
2575         source = g_idle_source_new();
2576         g_source_set_callback(source, create_thumbnail_start, NULL, NULL);
2577         g_source_attach(source, context);
2578
2579         /* Logic to cancel */
2580         if (cancel) {
2581                 GSource *cancel_src = NULL;
2582                 cancel_src = g_idle_source_new();
2583                 g_source_set_callback(cancel_src, cancel_thumbnail_start, NULL, NULL);
2584                 g_source_attach(cancel_src, context);
2585         }
2586
2587         g_main_loop_run(g_loop);
2588         g_main_loop_unref(g_loop);
2589
2590         test_filter_destroy();
2591
2592         return ret;
2593 }
2594
2595 bool face_cb(media_face_h face, void *user_data)
2596 {
2597         if (user_data != NULL) {
2598                 unsigned x, y, rect_w, rect_h;
2599                 media_face_get_face_rect(face, &x, &y, &rect_w, &rect_h);
2600                 media_content_debug("face(%p) x = %d, y = %d [%d, %d]", face, x, y, rect_w, rect_h);
2601                 return TRUE;
2602         }
2603         return FALSE;
2604 }
2605
2606 void face_detection_complete_cb(media_content_error_e error, int count, void *user_data)
2607 {
2608         int ret = MEDIA_CONTENT_ERROR_NONE;
2609         g_cnt++;
2610
2611         media_content_debug("=================[%d][%d]", g_media_cnt, g_cnt);
2612         media_content_debug("error_code [%d]", error);
2613         media_content_debug("face_count [%d]", count);
2614         if (count == 0) {
2615                 media_content_debug("No faces are detected!");
2616         } else if (user_data != NULL) {
2617                 media_info_h media = (media_info_h)user_data;
2618                 char *media_id = NULL;
2619                 ret = media_info_get_media_id(media, &media_id);
2620                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2621                         media_content_error("media_info_get_media_id failed: %d", ret);
2622                 if (media_id != NULL) {
2623                         ret = media_info_foreach_face_from_db(media_id, NULL, face_cb, NULL);
2624                         if (ret != MEDIA_CONTENT_ERROR_NONE)
2625                                 media_content_error("media_info_foreach_face_from_db failed: %d", ret);
2626                 }
2627                 ret = media_info_destroy(media);
2628                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2629                         media_content_error("media_info_destroy failed: %d", ret);
2630         }
2631
2632         if (g_cnt == g_media_cnt)
2633                 g_main_loop_quit(g_loop);
2634
2635         return;
2636 }
2637
2638 bool start_face_detection_cb(media_info_h media, void *user_data)
2639 {
2640         char *media_id = NULL;
2641         media_info_h dst = NULL;
2642         int ret = MEDIA_CONTENT_ERROR_NONE;
2643
2644         if (media == NULL) {
2645                 media_content_debug("NO Item");
2646                 return true;
2647         }
2648
2649         ret = media_info_get_media_id(media, &media_id);
2650         if (ret != MEDIA_CONTENT_ERROR_NONE)
2651                 media_content_error("media_info_get_media_id failed: %d", ret);
2652         else
2653                 media_content_debug("media_id : [%s]", media_id);
2654
2655         ret = media_info_clone(&dst, media);
2656         if (ret != MEDIA_CONTENT_ERROR_NONE)
2657                 media_content_error("media_info_clone failed: %d", ret);
2658         else {
2659                 ret = media_info_start_face_detection(dst, face_detection_complete_cb, dst);
2660                 if (ret != MEDIA_CONTENT_ERROR_NONE)
2661                         media_content_error("media_info_start_face_detection failed: %d", ret);
2662         }
2663
2664         /* fix prevent: Resource leak */
2665         SAFE_FREE(media_id);
2666
2667         return true;
2668 }
2669
2670 bool cancel_face_detection_cb(media_info_h media, void *user_data)
2671 {
2672         int ret = MEDIA_CONTENT_ERROR_NONE;
2673
2674         char *media_id = NULL;
2675         media_info_h dst = NULL;
2676
2677         g_cnt++;
2678
2679         if (media == NULL) {
2680                 media_content_debug("NO Item");
2681                 return true;
2682         }
2683
2684         ret = media_info_get_media_id(media, &media_id);
2685         if (ret != MEDIA_CONTENT_ERROR_NONE)
2686                 media_content_error("media_info_get_media_id failed: %d", ret);
2687         else
2688                 media_content_debug("media_id : [%s]", media_id);
2689
2690         ret = media_info_clone(&dst, media);
2691         if (ret != MEDIA_CONTENT_ERROR_NONE)
2692                 media_content_error("media_info_clone failed: %d", ret);
2693
2694         ret = media_info_cancel_face_detection(dst);
2695         if (ret != MEDIA_CONTENT_ERROR_NONE)
2696                 media_content_error("media_info_cancel_face_detection failed: %d", ret);
2697
2698         ret = media_info_destroy(dst);
2699         if (ret != MEDIA_CONTENT_ERROR_NONE)
2700                         media_content_error("media_info_destroy failed: %d", ret);
2701
2702         if (g_cnt == g_media_cnt)
2703                 g_main_loop_quit(g_loop);
2704
2705         /* fix prevent: Resource leak */
2706         SAFE_FREE(media_id);
2707
2708         return true;
2709 }
2710
2711 gboolean face_detection_start(gpointer data)
2712 {
2713         int ret = MEDIA_CONTENT_ERROR_NONE;
2714
2715         ret = media_info_foreach_media_from_db(g_filter, start_face_detection_cb, NULL);
2716
2717         if (ret == MEDIA_CONTENT_ERROR_NONE)
2718                 media_content_debug("media_info_foreach_media_from_db is success");
2719         else
2720                 media_content_error("media_info_foreach_media_from_db is failed");
2721
2722         return false;
2723 }
2724
2725 gboolean face_detection_cancel(gpointer data)
2726 {
2727         int ret = MEDIA_CONTENT_ERROR_NONE;
2728
2729         ret = media_info_foreach_media_from_db(g_filter, cancel_face_detection_cb, NULL);
2730
2731         if (ret == MEDIA_CONTENT_ERROR_NONE)
2732                 media_content_debug("media_info_foreach_media_from_db is success");
2733         else
2734                 media_content_error("media_info_foreach_media_from_db is failed");
2735
2736         return false;
2737 }
2738
2739 int test_start_face_detection(int cancel)
2740 {
2741         int ret = MEDIA_CONTENT_ERROR_NONE;
2742         GSource *source = NULL;
2743         GMainContext *context = NULL;
2744
2745         test_filter_create();
2746
2747         ret = media_info_get_media_count_from_db(g_filter, &g_media_cnt);
2748         if (ret != MEDIA_CONTENT_ERROR_NONE)
2749                 media_content_error("media_info_get_media_count_from_db failed: %d", ret);
2750         else
2751                 media_content_debug("media_count : [%d]", g_media_cnt);
2752
2753         if (g_media_cnt == 0)
2754                 goto END;
2755
2756         g_loop = g_main_loop_new(NULL, FALSE);
2757         context = g_main_loop_get_context(g_loop);
2758         source = g_idle_source_new();
2759         g_source_set_callback(source, face_detection_start, NULL, NULL);
2760         g_source_attach(source, context);
2761
2762         /* Logic to cancel */
2763         if (cancel) {
2764                 GSource *cancel_src = NULL;
2765                 cancel_src = g_idle_source_new();
2766                 g_source_set_callback(cancel_src, face_detection_cancel, NULL, NULL);
2767                 g_source_attach(cancel_src, context);
2768         }
2769
2770         g_main_loop_run(g_loop);
2771         g_main_loop_unref(g_loop);
2772
2773 END:
2774         test_filter_destroy();
2775
2776         return ret;
2777 }
2778
2779 int test_disconnect_database(void)
2780 {
2781         int ret = MEDIA_CONTENT_ERROR_NONE;
2782         media_content_debug("\n============DB Disconnection Test============\n\n");
2783
2784         ret = media_content_disconnect();
2785
2786         if (ret == MEDIA_CONTENT_ERROR_NONE)
2787                 media_content_debug("disconnection is success");
2788         else
2789                 media_content_error("disconnection is failed");
2790
2791         return ret;
2792 }
2793
2794 int test_request_update_db(void)
2795 {
2796         int ret = MEDIA_CONTENT_ERROR_NONE;
2797         media_info_h media = NULL;
2798         char *content_name = NULL;
2799         bool favorite = FALSE;
2800
2801         ret = media_info_get_media_from_db("71b19196-5b38-4ab1-ab34-bfe05c369614", &media);
2802         if (ret != MEDIA_CONTENT_ERROR_NONE)
2803                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2804
2805         ret = media_info_set_content_name(media, "TEST_content_name");
2806         if (ret != MEDIA_CONTENT_ERROR_NONE)
2807                 media_content_error("media_info_set_content_name failed: %d", ret);
2808
2809         ret = media_info_set_favorite(media, TRUE);
2810         if (ret != MEDIA_CONTENT_ERROR_NONE)
2811                 media_content_error("media_info_set_favorite failed: %d", ret);
2812
2813         ret = media_info_update_to_db(media);
2814         if (ret == MEDIA_CONTENT_ERROR_NONE)
2815                 media_content_debug("media_info_update_to_db is success");
2816         else
2817                 media_content_error("media_info_update_to_db is failed");
2818
2819         if (media != NULL)
2820                 media_info_destroy(media);
2821
2822         /*get the updated value*/
2823         ret = media_info_get_media_from_db("71b19196-5b38-4ab1-ab34-bfe05c369614", &media);
2824         if (ret != MEDIA_CONTENT_ERROR_NONE)
2825                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2826
2827         ret = media_info_get_content_name(media, &content_name);
2828         if (ret != MEDIA_CONTENT_ERROR_NONE)
2829                 media_content_error("media_info_get_content_name failed: %d", ret);
2830         else
2831                 media_content_debug("content name [%s]", content_name);
2832
2833         SAFE_FREE(content_name);
2834
2835         ret = media_info_get_favorite(media, &favorite);
2836         if (ret != MEDIA_CONTENT_ERROR_NONE)
2837                 media_content_error("media_info_get_favorite failed: %d", ret);
2838         else
2839                 media_content_debug("favorite [%d]", favorite);
2840
2841         ret = media_info_destroy(media);
2842
2843         return ret;
2844 }
2845
2846 int g_total_photo_size = 0;
2847 int g_total_video_size = 0;
2848 int g_total_mp3_size = 0;
2849 int g_total_voice_memo_size = 0;
2850
2851 bool dft_cb(media_info_h media, void *user_data)
2852 {
2853         unsigned long long file_size = 0;
2854         media_content_type_e media_type = -1;
2855         char *mime_type = NULL;
2856         int ret = MEDIA_CONTENT_ERROR_NONE;
2857
2858         if (media == NULL)
2859                 return true;
2860
2861         ret = media_info_get_media_type(media, &media_type);
2862         if (ret != MEDIA_CONTENT_ERROR_NONE)
2863                 media_content_error("media_info_get_media_type failed: %d", ret);
2864         ret = media_info_get_size(media, &file_size);
2865         if (ret != MEDIA_CONTENT_ERROR_NONE)
2866                 media_content_error("media_info_get_size failed: %d", ret);
2867         ret = media_info_get_mime_type(media, &mime_type);
2868         if (ret != MEDIA_CONTENT_ERROR_NONE)
2869                 media_content_error("media_info_get_mime_type failed: %d", ret);
2870
2871         if (media_type == MEDIA_CONTENT_TYPE_IMAGE)
2872                 g_total_photo_size += file_size;
2873         else if (media_type == MEDIA_CONTENT_TYPE_VIDEO)
2874                 g_total_video_size += file_size;
2875         else if (media_type == MEDIA_CONTENT_TYPE_SOUND)
2876                 g_total_voice_memo_size += file_size;
2877         else if (media_type == MEDIA_CONTENT_TYPE_MUSIC) {
2878                 if ((mime_type != NULL) && (!strcmp("audio/mpeg", mime_type)))
2879                         g_total_mp3_size += file_size;
2880                 else
2881                         g_total_voice_memo_size += file_size;
2882         } else
2883                 media_content_debug("invalid media_type");
2884
2885         if (mime_type != NULL)
2886                 free(mime_type);
2887
2888         return true;
2889
2890 }
2891
2892 int DFT_test(void)
2893 {
2894         int ret = MEDIA_CONTENT_ERROR_NONE;
2895         media_content_debug("\n============DFT_test============\n\n");
2896
2897         filter_h filter = NULL;
2898         int media_cnt = 0;
2899
2900         /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
2901
2902         ret = media_filter_create(&filter);
2903
2904 /*Internal Memory*/
2905         media_content_debug("[Internal Memory]\n");
2906         /*1. Photo ============================================================*/
2907         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
2908
2909         /*Get Photo Count*/
2910         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2911         media_content_debug("Photo count = [%d]\n", media_cnt);
2912
2913         /*Get Photo Size*/
2914         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2915         media_content_debug("Photo size = [%d]\n", g_total_photo_size);
2916
2917         /*2. Video ============================================================*/
2918         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
2919
2920         /*Get Video Count*/
2921         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2922         media_content_debug("Video count = [%d]\n", media_cnt);
2923
2924         /*Get Video Size*/
2925         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2926         media_content_debug("Video size = [%d]\n", g_total_video_size);
2927
2928         /*3. MP3 ============================================================*/
2929         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
2930
2931         /*Get MP3 Count*/
2932         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2933         media_content_debug("MP3 count = [%d]\n", media_cnt);
2934
2935         /*Get MP3 Size*/
2936         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2937         media_content_debug("MP3 size = [%d]\n", g_total_mp3_size);
2938
2939         /*4. Voice Memo ============================================================*/
2940         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);
2941
2942         /*Get Voice Memo Count*/
2943         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2944         media_content_debug("Voice Memo count = [%d]\n", media_cnt);
2945
2946         /*Get Voice Memo Size*/
2947         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2948         media_content_debug("Voice Memo size = [%d]\n", g_total_voice_memo_size);
2949
2950         g_total_photo_size = 0;
2951         g_total_video_size = 0;
2952         g_total_mp3_size = 0;
2953         g_total_voice_memo_size = 0;
2954
2955 /*External Memory*/
2956         media_content_debug("\n[External Memory]\n");
2957         /*1. Photo ============================================================*/
2958         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
2959
2960         /*Get Photo Count*/
2961         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2962         media_content_debug("Photo count = [%d]\n", media_cnt);
2963
2964         /*Get Photo Size*/
2965         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2966         media_content_debug("Photo size = [%d]\n", g_total_photo_size);
2967
2968         /*2. Video ============================================================*/
2969         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
2970
2971         /*Get Video Count*/
2972         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2973         media_content_debug("Video count = [%d]\n", media_cnt);
2974
2975         /*Get Video Size*/
2976         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2977         media_content_debug("Video size = [%d]\n", g_total_video_size);
2978
2979         /*3. MP3 ============================================================*/
2980         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
2981
2982         /*Get MP3 Count*/
2983         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2984         media_content_debug("MP3 count = [%d]\n", media_cnt);
2985
2986         /*Get MP3 Size*/
2987         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2988         media_content_debug("MP3 size = [%d]\n", g_total_mp3_size);
2989
2990         /*4. Voice Memo ============================================================*/
2991         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);
2992
2993         /*Get Voice Memo Count*/
2994         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2995         media_content_debug("Voice Memo count = [%d]\n", media_cnt);
2996
2997         /*Get Voice Memo Size*/
2998         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2999         media_content_debug("Voice Memo size = [%d]\n", g_total_voice_memo_size);
3000         ret = media_filter_destroy(filter);
3001
3002         return ret;
3003 }
3004
3005 void insert_batch_cb(media_content_error_e error, void * user_data)
3006 {
3007         media_content_debug("media_info_insert_batch_to_db completed!\n");
3008 }
3009
3010 int test_batch_operations()
3011 {
3012         int ret = -1;
3013         int i;
3014         char *file_list[10];
3015
3016         for (i = 0; i < 10; i++) {
3017                 char filepath[255] = {0,};
3018                 snprintf(filepath, sizeof(filepath), "%s%d.jpg", tzplatform_mkpath(TZ_USER_CONTENT, "test/image"), i+1);
3019                 media_content_debug("File : %s\n", filepath);
3020                 file_list[i] = strdup(filepath);
3021         }
3022
3023         ret = media_info_insert_batch_to_db((const char **)file_list, 10, insert_batch_cb, NULL);
3024         if (ret != MEDIA_CONTENT_ERROR_NONE)
3025                 media_content_error("media_info_insert_batch_to_db failed : %d\n", ret);
3026
3027         filter_h filter;
3028         char *condition = "MEDIA_PATH LIKE \'";
3029         strncat(condition, tzplatform_mkpath(TZ_USER_CONTENT, "test/image%%jpg\'"), 17);
3030         ret = media_filter_create(&filter);
3031         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3032                 media_content_error("Fail to create filter");
3033                 return ret;
3034         }
3035
3036         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
3037         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3038                 media_filter_destroy(filter);
3039                 media_content_error("Fail to set condition");
3040                 return ret;
3041         }
3042
3043         ret = media_info_delete_batch_from_db(filter);
3044         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3045                 media_filter_destroy(filter);
3046                 media_content_error("media_info_delete_batch_from_db failed : %d\n", ret);
3047                 return ret;
3048         }
3049
3050         ret = media_filter_destroy(filter);
3051
3052         return ret;
3053 }
3054
3055 void insert_burst_shot_cb(media_content_error_e error, void * user_data)
3056 {
3057         media_content_debug("media_info_insert_burst_shot_to_db completed![%d]\n", error);
3058         g_main_loop_quit(g_loop);
3059 }
3060
3061 gboolean test_insert_burst_shot_to_db_start(gpointer data)
3062 {
3063         int ret = MEDIA_CONTENT_ERROR_NONE;
3064         int i = 0;
3065         char *file_list[10];
3066
3067         for (i = 0; i < 10; i++) {
3068                 char filepath[255] = {0,};
3069                 snprintf(filepath, sizeof(filepath), "%s%d.jpg", tzplatform_mkpath(TZ_USER_CONTENT, "test/image"), i+1);
3070                 media_content_debug("File : %s\n", filepath);
3071                 file_list[i] = strdup(filepath);
3072         }
3073
3074         ret = media_info_insert_burst_shot_to_db((const char **)file_list, 10, insert_burst_shot_cb, NULL);
3075         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3076                 media_content_error("media_info_insert_burst_shot_to_db failed : %d\n", ret);
3077                 g_main_loop_quit(g_loop);
3078         }
3079
3080         return ret;
3081 }
3082
3083 int test_insert_burst_shot_to_db(void)
3084 {
3085         GSource *source = NULL;
3086         GMainContext *context = NULL;
3087
3088         g_loop = g_main_loop_new(NULL, FALSE);
3089         context = g_main_loop_get_context(g_loop);
3090         source = g_idle_source_new();
3091         g_source_set_callback(source, test_insert_burst_shot_to_db_start, NULL, NULL);
3092         g_source_attach(source, context);
3093
3094         g_main_loop_run(g_loop);
3095         g_main_loop_unref(g_loop);
3096
3097         return 0;
3098 }
3099
3100 void _scan_cb(media_content_error_e err, void *user_data)
3101 {
3102         media_content_debug("scan callback is called : %d\n", err);
3103         g_main_loop_quit(g_loop);
3104
3105         return;
3106 }
3107
3108 int test_scan_file()
3109 {
3110         int ret = -1;
3111
3112         const char *file_path = tzplatform_mkpath(TZ_USER_CONTENT, "test/image1.jpg");
3113         ret = media_content_scan_file(file_path);
3114         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3115                 media_content_error("Fail to media_content_scan_file : %d", ret);
3116                 return ret;
3117         }
3118
3119         return 0;
3120 }
3121
3122 gboolean test_scan_dir_start(gpointer data)
3123 {
3124         int ret = -1;
3125
3126         const char *dir_path = tzplatform_getenv(TZ_USER_CONTENT);
3127
3128         ret = media_content_scan_folder(dir_path, TRUE, _scan_cb, NULL);
3129
3130         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3131                 media_content_error("Fail to test_scan_dir_start : %d", ret);
3132                 return ret;
3133         }
3134
3135         return 0;
3136 }
3137
3138 gboolean cancel_scan_dir_start(gpointer data)
3139 {
3140         int ret = MEDIA_CONTENT_ERROR_NONE;
3141
3142         const char *dir_path = "/opt/usr/media/Images";
3143
3144         ret = media_content_cancel_scan_folder(dir_path);
3145
3146         if (ret == MEDIA_CONTENT_ERROR_NONE)
3147                 media_content_debug("media_content_cancel_scan_folder is success");
3148         else
3149                 media_content_error("media_content_cancel_scan_folder is failed");
3150
3151         return false;
3152 }
3153
3154 int test_scan_dir(int cancel)
3155 {
3156         GSource *source = NULL;
3157         GMainContext *context = NULL;
3158
3159         g_loop = g_main_loop_new(NULL, FALSE);
3160         context = g_main_loop_get_context(g_loop);
3161         source = g_idle_source_new();
3162         g_source_set_callback(source, test_scan_dir_start, NULL, NULL);
3163         g_source_attach(source, context);
3164
3165         if (cancel) {
3166                 GSource *cancel_src = NULL;
3167                 cancel_src = g_idle_source_new();
3168                 g_source_set_callback(cancel_src, cancel_scan_dir_start, NULL, NULL);
3169                 g_source_attach(cancel_src, context);
3170         }
3171
3172         g_main_loop_run(g_loop);
3173         g_main_loop_unref(g_loop);
3174
3175         return 0;
3176 }
3177
3178 void _noti_cb(media_content_error_e error,
3179                                 int pid,
3180                                 media_content_db_update_item_type_e update_item,
3181                                 media_content_db_update_type_e update_type,
3182                                 media_content_type_e media_type,
3183                                 char *uuid,
3184                                 char *path,
3185                                 char *mime_type,
3186                                 void *user_data)
3187 {
3188         if (error == 0)
3189                 media_content_debug("noti success! : %d\n", error);
3190         else
3191                 media_content_debug("error occured! : %d\n", error);
3192
3193         media_content_debug("Noti from PID(%d)\n", pid);
3194
3195         if (update_item == MEDIA_ITEM_FILE)
3196                 media_content_debug("Noti item : MEDIA_ITEM_FILE\n");
3197         else if (update_item == MEDIA_ITEM_DIRECTORY)
3198                 media_content_debug("Noti item : MEDIA_ITEM_DIRECTORY\n");
3199
3200         if (update_type == MEDIA_CONTENT_INSERT)
3201                 media_content_debug("Noti type : MEDIA_CONTENT_INSERT\n");
3202         else if (update_type == MEDIA_CONTENT_DELETE)
3203                 media_content_debug("Noti type : MEDIA_CONTENT_DELETE\n");
3204         else if (update_type == MEDIA_CONTENT_UPDATE)
3205                 media_content_debug("Noti type : MEDIA_CONTENT_UPDATE\n");
3206
3207         media_content_debug("content type : %d\n", media_type);
3208
3209         if (path)
3210                 media_content_debug("path : %s\n", path);
3211         else
3212                 media_content_debug("path not\n");
3213
3214         if (uuid)
3215                 media_content_debug("uuid : %s\n", uuid);
3216         else
3217                 media_content_debug("uuid not\n");
3218
3219         if (mime_type)
3220                 media_content_debug("mime_type : %s\n", mime_type);
3221         else
3222                 media_content_debug("mime not\n");
3223
3224         if (user_data) media_content_debug("String : %s\n", (char *)user_data);
3225
3226         return;
3227 }
3228
3229 void _noti_cb_2(media_content_error_e error,
3230                                 int pid,
3231                                 media_content_db_update_item_type_e update_item,
3232                                 media_content_db_update_type_e update_type,
3233                                 media_content_type_e media_type,
3234                                 char *uuid,
3235                                 char *path,
3236                                 char *mime_type,
3237                                 void *user_data)
3238 {
3239         if (error == 0)
3240                 media_content_debug("noti_2 success! : %d\n", error);
3241         else
3242                 media_content_debug("error occured! : %d\n", error);
3243
3244         media_content_debug("Noti_2 from PID(%d)\n", pid);
3245
3246         g_main_loop_quit(g_loop);
3247         return;
3248 }
3249
3250 static media_content_noti_h noti_h;
3251 static media_content_noti_h noti_h_2;
3252
3253 gboolean _send_noti_operations(gpointer data)
3254 {
3255         int ret = MEDIA_CONTENT_ERROR_NONE;
3256
3257         /* First of all, noti subscription */
3258         char *user_str = strdup("hi");
3259         media_content_add_db_updated_cb(_noti_cb, (void*)user_str, &noti_h);
3260         media_content_add_db_updated_cb(_noti_cb_2, (void*)user_str, &noti_h_2);
3261
3262         /* media_info_insert_to_db */
3263         media_info_h media_item = NULL;
3264         const char *path = tzplatform_mkpath(TZ_USER_CONTENT, "test/image1.jpg");
3265
3266         ret = media_info_insert_to_db(path, &media_item);
3267         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3268                 media_content_error("media_info_insert_to_db failed : %d", ret);
3269                 media_info_destroy(media_item);
3270                 return FALSE;
3271         }
3272
3273         media_content_debug("media_info_insert_to_db success");
3274
3275         /* media_info_delete_batch_from_db */
3276         filter_h filter;
3277         char condition[2048] = {0,};
3278         const char *temp = NULL;
3279         temp = tzplatform_mkpath(TZ_USER_CONTENT, "test/image%%\'");
3280         snprintf(condition, sizeof(condition), "MEDIA_PATH LIKE \'%s", temp);
3281
3282         ret = media_filter_create(&filter);
3283         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3284                 media_content_error("Fail to create filter");
3285                 media_info_destroy(media_item);
3286                 return ret;
3287         }
3288
3289         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
3290         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3291                 media_filter_destroy(filter);
3292                 media_info_destroy(media_item);
3293                 media_content_error("Fail to set condition");
3294                 return ret;
3295         }
3296         ret = media_info_delete_batch_from_db(filter);
3297         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3298                 media_filter_destroy(filter);
3299                 media_info_destroy(media_item);
3300                 media_content_error("media_info_delete_batch_from_db failed : %d\n", ret);
3301                 return ret;
3302         }
3303
3304         media_filter_destroy(filter);
3305
3306         media_content_remove_db_updated_cb(noti_h);
3307
3308         /* media_info_update_to_db */
3309         ret = media_info_update_to_db(media_item);
3310         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3311                 media_content_error("media_info_update_to_db failed : %d\n", ret);
3312                 media_info_destroy(media_item);
3313                 return ret;
3314         }
3315
3316         media_info_destroy(media_item);
3317
3318         return FALSE;
3319 }
3320
3321 int test_noti()
3322 {
3323         int ret = MEDIA_CONTENT_ERROR_NONE;
3324         GSource *source = NULL;
3325         GMainContext *context = NULL;
3326
3327         g_loop = g_main_loop_new(NULL, FALSE);
3328         context = g_main_loop_get_context(g_loop);
3329         source = g_idle_source_new();
3330         g_source_set_callback(source, _send_noti_operations, NULL, NULL);
3331         g_source_attach(source, context);
3332
3333         g_main_loop_run(g_loop);
3334         g_main_loop_unref(g_loop);
3335
3336         test_filter_destroy();
3337         media_content_remove_db_updated_cb(noti_h_2);
3338
3339         return ret;
3340 }
3341
3342 int test_create_handle(void)
3343 {
3344         int ret = MEDIA_CONTENT_ERROR_NONE;
3345         media_info_h media = NULL;
3346         const char *path = "/home/owner/content/test/test.txt";
3347         char *str_value = NULL;
3348         int int_value = -1;
3349         bool bool_value = FALSE;
3350         unsigned long long content_size = 0;
3351         time_t modified_time = 0;
3352         double double_value = 0.0;
3353
3354         ret = media_info_create(path, &media);
3355
3356         ret = media_info_set_title(media, "test_title");
3357         ret = media_info_set_album(media, "test_album");
3358         ret = media_info_set_artist(media, "test_artist");
3359         ret = media_info_set_genre(media, "test_genre");
3360         ret = media_info_set_recorded_date(media, "test_recorded_date");
3361         ret = media_info_set_age_rating(media, "test_age_rating");
3362         ret = media_info_set_author(media, "test_author");
3363         ret = media_info_set_category(media, "test_category");
3364         ret = media_info_set_content_name(media, "test_content_name");
3365         ret = media_info_set_description(media, "test_description");
3366         ret = media_info_set_display_name(media, "test_display_name");
3367         ret = media_info_set_keyword(media, "test_keyword");
3368         ret = media_info_set_location_tag(media, "test_location_tag");
3369         ret = media_info_set_weather(media, "test_weather");
3370         ret = media_info_set_provider(media, "test_provider");
3371
3372         ret = media_info_set_altitude(media, 100.10);
3373         ret = media_info_set_latitude(media, 200.20);
3374         ret = media_info_set_longitude(media, 300.30);
3375         ret = media_info_set_rating(media, 10);
3376         ret = media_info_set_played_time(media);
3377         ret = media_info_set_favorite(media, TRUE);
3378         ret = media_info_increase_played_count(media);
3379         ret = media_info_set_added_time(media, 12345);
3380
3381         ret = media_info_insert_to_db_with_data(media);
3382         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3383                 media_content_error("media_info_insert_to_db_with_data failed : %d\n", ret);
3384                 media_info_destroy(media);
3385                 return ret;
3386         }
3387
3388         ret = media_info_get_media_id(media, &str_value);
3389         media_content_debug("media_id = [%s]", str_value);
3390         SAFE_FREE(str_value);
3391
3392         ret = media_info_get_file_path(media, &str_value);
3393         media_content_debug("file_path = [%s]", str_value);
3394         SAFE_FREE(str_value);
3395
3396         ret = media_info_get_title(media, &str_value);
3397         media_content_debug("title = [%s]", str_value);
3398         SAFE_FREE(str_value);
3399
3400         ret = media_info_get_age_rating(media, &str_value);
3401         media_content_debug("age_rating = [%s]", str_value);
3402         SAFE_FREE(str_value);
3403
3404         ret = media_info_get_author(media, &str_value);
3405         media_content_debug("author = [%s]", str_value);
3406         SAFE_FREE(str_value);
3407
3408         ret = media_info_get_category(media, &str_value);
3409         media_content_debug("category = [%s]", str_value);
3410         SAFE_FREE(str_value);
3411
3412         ret = media_info_get_content_name(media, &str_value);
3413         media_content_debug("content_name = [%s]", str_value);
3414         SAFE_FREE(str_value);
3415
3416         ret = media_info_get_description(media, &str_value);
3417         media_content_debug("description = [%s]", str_value);
3418         SAFE_FREE(str_value);
3419
3420         ret = media_info_get_display_name(media, &str_value);
3421         media_content_debug("display_name = [%s]", str_value);
3422         SAFE_FREE(str_value);
3423
3424         ret = media_info_get_keyword(media, &str_value);
3425         media_content_debug("keyword = [%s]", str_value);
3426         SAFE_FREE(str_value);
3427
3428         ret = media_info_get_location_tag(media, &str_value);
3429         media_content_debug("location_tag = [%s]", str_value);
3430         SAFE_FREE(str_value);
3431
3432         ret = media_info_get_weather(media, &str_value);
3433         media_content_debug("weather = [%s]", str_value);
3434         SAFE_FREE(str_value);
3435
3436         ret = media_info_get_provider(media, &str_value);
3437         media_content_debug("provider = [%s]", str_value);
3438         SAFE_FREE(str_value);
3439
3440         ret = media_info_get_longitude(media, &double_value);
3441         media_content_debug("longitude = [%lf]", double_value);
3442
3443         ret = media_info_get_latitude(media, &double_value);
3444         media_content_debug("latitude = [%lf]", double_value);
3445
3446         ret = media_info_get_altitude(media, &double_value);
3447         media_content_debug("altitud = [%lf]", double_value);
3448
3449         ret = media_info_get_rating(media, &int_value);
3450         media_content_debug("rating = [%d]", int_value);
3451
3452         ret = media_info_get_favorite(media, &bool_value);
3453         media_content_debug("favorite = [%d]", bool_value);
3454
3455         ret = media_info_get_played_time(media, &modified_time);
3456         media_content_debug("played_time = [%d]", modified_time);
3457
3458         ret = media_info_get_played_count(media, &int_value);
3459         media_content_debug("played_count = [%d]", int_value);
3460
3461         ret = media_info_get_added_time(media, &modified_time);
3462         media_content_debug("added_time = [%d]", modified_time);
3463
3464         ret = media_info_get_size(media, &content_size);
3465         media_content_debug("size = [%d]", content_size);
3466
3467         ret = media_info_get_modified_time(media, &modified_time);
3468         media_content_debug("modified_time = [%d]", modified_time);
3469
3470         ret = media_info_get_media_type(media, (media_content_type_e *)&int_value);
3471         media_content_debug("media_type = [%d]", int_value);
3472
3473         ret = media_info_get_storage_type(media, (media_content_storage_e *)&int_value);
3474         media_content_debug("storage_type = [%d]", int_value);
3475
3476         media_info_destroy(media);
3477
3478         return ret;
3479
3480 }
3481
3482 bool media_face_test_cb(media_face_h face, void *user_data)
3483 {
3484         char *face_id = NULL;
3485         char *media_id = NULL;
3486         unsigned int rect_x = 0;
3487         unsigned int rect_y = 0;
3488         unsigned int rect_w = 0;
3489         unsigned int rect_h = 0;
3490         media_content_orientation_e orientation = 0;
3491         char *face_tag = NULL;
3492
3493         media_face_get_face_id(face, &face_id);
3494         media_face_get_media_id(face, &media_id);
3495         media_face_get_face_rect(face, &rect_x, &rect_y, &rect_w, &rect_h);
3496         media_face_get_orientation(face, &orientation);
3497         media_face_get_tag(face, &face_tag);
3498
3499         media_content_debug("face_id [%s] media_id [%s]", face_id, media_id);
3500         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);
3501         media_content_debug("tag [%s]", face_tag);
3502
3503         if (user_data != NULL) {
3504                 media_face_h new_face = NULL;
3505                 media_face_clone(&new_face, face);
3506
3507                 GList **list = (GList**)user_data;
3508                 *list = g_list_append(*list, new_face);
3509         }
3510
3511         SAFE_FREE(face_id);
3512         SAFE_FREE(media_id);
3513         SAFE_FREE(face_tag);
3514
3515         return true;
3516 }
3517
3518 int test_face(void)
3519 {
3520         int ret = MEDIA_CONTENT_ERROR_NONE;
3521         filter_h filter = NULL;
3522         GList *all_item_list = NULL;
3523         int i = 0;
3524
3525         ret = media_filter_create(&filter);
3526         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_filter_create");
3527
3528         ret = media_filter_set_condition(filter, "MEDIA_TYPE = 0", MEDIA_CONTENT_COLLATE_DEFAULT);
3529         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3530                 media_filter_destroy(filter);
3531                 media_content_error("Fail to set condition");
3532                 return ret;
3533         }
3534
3535         ret = media_info_foreach_media_from_db(filter, gallery_media_item_cb, &all_item_list);
3536         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3537                 media_content_error("media_info_foreach_media_from_db failed: %d", ret);
3538                 media_filter_destroy(filter);
3539                 return ret;
3540         }
3541
3542         for (i = 0; i < g_list_length(all_item_list); i++) {
3543                 media_info_h media_handle = NULL;
3544                 char *media_id = NULL;
3545                 int face_count = 0;
3546
3547                 media_handle = (media_info_h)g_list_nth_data(all_item_list, i);
3548
3549                 ret = media_info_get_media_id(media_handle, &media_id);
3550                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3551                         media_content_error("media_info_get_media_id failed: %d", ret);
3552
3553                 ret = media_info_get_face_count_from_db(media_id, filter, &face_count);
3554                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3555                         media_content_error("media_info_get_face_count_from_db failed: %d", ret);
3556
3557                 media_content_error("media_id [%s] face_count [%d]", media_id, face_count);
3558
3559                 ret = media_info_foreach_face_from_db(media_id, filter, media_face_test_cb, NULL);
3560                 if (ret != MEDIA_CONTENT_ERROR_NONE)
3561                         media_content_error("media_info_foreach_face_from_db failed: %d", ret);
3562
3563                 media_info_destroy(media_handle);
3564         }
3565
3566         media_filter_destroy(filter);
3567
3568         return ret;
3569 }
3570
3571 int test_face_add_del(void)
3572 {
3573         int ret = MEDIA_CONTENT_ERROR_NONE;
3574         char *media_id = "ecca7366-e085-41d8-a12b-cbdfc2b9c5fc";
3575
3576         /* Insert Test */
3577         media_face_h face = NULL;
3578
3579         char *face_tag = "test_face_tag";
3580
3581         ret = media_face_create(media_id, &face);
3582         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_face_create");
3583
3584         ret = media_face_set_face_rect(face, 10, 12, 50, 100);
3585         ret = media_face_set_orientation(face, 5);
3586         ret = media_face_set_tag(face, face_tag);
3587
3588         ret = media_face_insert_to_db(face);
3589         ret = media_face_destroy(face);
3590
3591         /* Update Test */
3592         GList *all_item_list = NULL;
3593         filter_h filter = NULL;
3594         ret = media_filter_create(&filter);
3595         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "fail media_filter_create");
3596
3597         ret = media_filter_set_condition(filter, "MEDIA_FACE_TAG IS NOT NULL", MEDIA_CONTENT_COLLATE_DEFAULT);
3598         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3599                 media_filter_destroy(filter);
3600                 media_content_error("Fail to set condition");
3601                 return ret;
3602         }
3603
3604         ret = media_info_foreach_face_from_db(media_id, filter, media_face_test_cb, &all_item_list);
3605
3606         if (g_list_length(all_item_list) > 0) {
3607                 media_face_h face_handle = NULL;
3608                 face_handle = (media_face_h)g_list_nth_data(all_item_list, 0);
3609
3610                 ret = media_face_set_face_rect(face_handle, 20, 22, 70, 70);
3611                 ret = media_face_set_orientation(face_handle, 3);
3612                 ret = media_face_set_tag(face_handle, NULL);
3613                 ret = media_face_update_to_db(face_handle);
3614
3615                 media_face_destroy(face_handle);
3616         }
3617
3618         media_filter_destroy(filter);
3619
3620         /* Delete Test */
3621         char *face_id = "5e58a3a8-f0b2-4c29-b799-b49a70dc2313";
3622
3623         /* Delete Test*/
3624         ret = media_face_delete_from_db(face_id);
3625
3626         return ret;
3627 }
3628
3629 #ifdef _USE_TV_PROFILE
3630 filter_h g_tv_filter = NULL;
3631
3632 int test_tv_filter_create(void)
3633 {
3634         media_content_debug("\n============Filter Create============\n\n");
3635
3636         int ret = MEDIA_CONTENT_ERROR_NONE;
3637
3638         ret = media_filter_create(&g_tv_filter);
3639
3640         ret = media_filter_set_storage(g_tv_filter, "0a22a163-e634-4a2e-ba14-0469a969eea0");
3641
3642         ret = media_filter_set_order(g_tv_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_STORAGE_ID, MEDIA_CONTENT_COLLATE_DEFAULT);
3643
3644         return ret;
3645 }
3646
3647 int test_tv_filter_destroy(void)
3648 {
3649         media_content_debug("\n============Filter Destroy============\n\n");
3650
3651         int ret = MEDIA_CONTENT_ERROR_NONE;
3652
3653         ret = media_filter_destroy(g_tv_filter);
3654
3655         return ret;
3656 }
3657
3658 bool pvr_item_cb(media_pvr_h pvr, void *user_data)
3659 {
3660         int ret = MEDIA_CONTENT_ERROR_NONE;
3661         char *c_value = NULL;
3662         int i_value = 0;
3663         bool b_value = false;
3664         unsigned long long l_value = 0;
3665
3666         if (pvr == NULL) {
3667                 media_content_debug("NO Item");
3668                 return true;
3669         }
3670
3671         ret = media_pvr_get_media_id(pvr, &c_value);
3672         if (ret != MEDIA_CONTENT_ERROR_NONE)
3673                 media_content_error("Fail to media_pvr_get_media_id");
3674         media_content_debug("media_id [%s]", c_value);
3675         SAFE_FREE(c_value);
3676
3677         ret = media_pvr_get_channel_name(pvr, &c_value);
3678         if (ret != MEDIA_CONTENT_ERROR_NONE)
3679                 media_content_error("Fail to media_pvr_get_channel_name");
3680         media_content_debug("channel_name [%s]", c_value);
3681         SAFE_FREE(c_value);
3682
3683         ret = media_pvr_get_program_title(pvr, &c_value);
3684         if (ret != MEDIA_CONTENT_ERROR_NONE)
3685                 media_content_error("Fail to media_pvr_get_program_title");
3686         media_content_debug("program_title [%s]", c_value);
3687         SAFE_FREE(c_value);
3688
3689         ret = media_pvr_get_program_crid(pvr, &c_value);
3690         if (ret != MEDIA_CONTENT_ERROR_NONE)
3691                 media_content_error("Fail to media_pvr_get_program_crid");
3692         media_content_debug("program_crid [%s]", c_value);
3693         SAFE_FREE(c_value);
3694
3695         ret = media_pvr_get_guidance(pvr, &c_value);
3696         if (ret != MEDIA_CONTENT_ERROR_NONE)
3697                 media_content_error("Fail to media_pvr_get_guidance");
3698         media_content_debug("guidance [%s]", c_value);
3699         SAFE_FREE(c_value);
3700
3701         ret = media_pvr_get_synopsis(pvr, &c_value);
3702         if (ret != MEDIA_CONTENT_ERROR_NONE)
3703                 media_content_error("Fail to media_pvr_get_synopsis");
3704         media_content_debug("synopsis [%s]", c_value);
3705         SAFE_FREE(c_value);
3706
3707         ret = media_pvr_get_genre(pvr, &c_value);
3708         if (ret != MEDIA_CONTENT_ERROR_NONE)
3709                 media_content_error("Fail to media_pvr_get_synopsis");
3710         media_content_debug("genre [%s]", c_value);
3711         SAFE_FREE(c_value);
3712
3713         ret = media_pvr_get_language(pvr, &c_value);
3714         if (ret != MEDIA_CONTENT_ERROR_NONE)
3715                 media_content_error("Fail to media_pvr_get_language");
3716         media_content_debug("language [%s]", c_value);
3717         SAFE_FREE(c_value);
3718
3719         ret = media_pvr_get_path(pvr, &c_value);
3720         if (ret != MEDIA_CONTENT_ERROR_NONE)
3721                 media_content_error("Fail to media_pvr_get_path");
3722         media_content_debug("path [%s]", c_value);
3723         SAFE_FREE(c_value);
3724
3725         ret = media_pvr_get_storage_id(pvr, &c_value);
3726         if (ret != MEDIA_CONTENT_ERROR_NONE)
3727                 media_content_error("Fail to media_pvr_get_storage_id");
3728         media_content_debug("storage_id [%s]", c_value);
3729         SAFE_FREE(c_value);
3730
3731         ret = media_pvr_get_size(pvr, &l_value);
3732         if (ret != MEDIA_CONTENT_ERROR_NONE)
3733                 media_content_error("Fail to media_pvr_get_size");
3734         media_content_debug("size [%ld]", l_value);
3735
3736         ret = media_pvr_get_timezone(pvr, &i_value);
3737         if (ret != MEDIA_CONTENT_ERROR_NONE)
3738                 media_content_error("Fail to media_pvr_get_timezone");
3739         media_content_debug("timezone [%d]", i_value);
3740
3741         ret = media_pvr_get_ptc(pvr, &i_value);
3742         if (ret != MEDIA_CONTENT_ERROR_NONE)
3743                 media_content_error("Fail to media_pvr_get_ptc");
3744         media_content_debug("ptc [%d]", i_value);
3745
3746         ret = media_pvr_get_major(pvr, &i_value);
3747         if (ret != MEDIA_CONTENT_ERROR_NONE)
3748                 media_content_error("Fail to media_pvr_get_major");
3749         media_content_debug("[%d]", i_value);
3750
3751         ret = media_pvr_get_minor(pvr, &i_value);
3752         if (ret != MEDIA_CONTENT_ERROR_NONE)
3753                 media_content_error("Fail to media_pvr_get_minor");
3754         media_content_debug("minor [%d]", i_value);
3755
3756         ret = media_pvr_get_channel_type(pvr, &i_value);
3757         if (ret != MEDIA_CONTENT_ERROR_NONE)
3758                 media_content_error("Fail to media_pvr_get_channel_type");
3759         media_content_debug("channel_type [%d]", i_value);
3760
3761         ret = media_pvr_get_program_num(pvr, &i_value);
3762         if (ret != MEDIA_CONTENT_ERROR_NONE)
3763                 media_content_error("Fail to media_pvr_get_program_num");
3764         media_content_debug("program_num [%d]", i_value);
3765
3766         ret = media_pvr_get_duration(pvr, &i_value);
3767         if (ret != MEDIA_CONTENT_ERROR_NONE)
3768                 media_content_error("Fail to media_pvr_get_duration");
3769         media_content_debug("duration [%d]", i_value);
3770
3771         ret = media_pvr_get_embargo_time(pvr, &i_value);
3772         if (ret != MEDIA_CONTENT_ERROR_NONE)
3773                 media_content_error("Fail to media_pvr_get_embargo_time");
3774         media_content_debug("embargo_time [%d]", i_value);
3775
3776         ret = media_pvr_get_expiry_time(pvr, &i_value);
3777         if (ret != MEDIA_CONTENT_ERROR_NONE)
3778                 media_content_error("Fail to media_pvr_get_expiry_time");
3779         media_content_debug("expiry_time [%d]", i_value);
3780
3781         ret = media_pvr_get_parental_rating(pvr, &i_value);
3782         if (ret != MEDIA_CONTENT_ERROR_NONE)
3783                 media_content_error("Fail to media_pvr_get_parental_rating");
3784         media_content_debug("parental_rating [%d]", i_value);
3785
3786         ret = media_pvr_get_start_time(pvr, &i_value);
3787         if (ret != MEDIA_CONTENT_ERROR_NONE)
3788                 media_content_error("Fail to media_pvr_get_start_time");
3789         media_content_debug("start_time [%d]", i_value);
3790
3791         ret = media_pvr_get_program_start_time(pvr, &i_value);
3792         if (ret != MEDIA_CONTENT_ERROR_NONE)
3793                 media_content_error("Fail to media_pvr_get_program_start_time");
3794         media_content_debug("program_start_time [%d]", i_value);
3795
3796         ret = media_pvr_get_program_end_time(pvr, &i_value);
3797         if (ret != MEDIA_CONTENT_ERROR_NONE)
3798                 media_content_error("Fail to media_pvr_get_program_end_time");
3799         media_content_debug("program_end_time [%d]", i_value);
3800
3801         ret = media_pvr_get_program_date(pvr, &i_value);
3802         if (ret != MEDIA_CONTENT_ERROR_NONE)
3803                 media_content_error("Fail to media_pvr_get_program_date");
3804         media_content_debug("program_date [%d]", i_value);
3805
3806         ret = media_pvr_get_timer_record(pvr, &b_value);
3807         if (ret != MEDIA_CONTENT_ERROR_NONE)
3808                 media_content_error("Fail to media_pvr_get_timer_record");
3809         media_content_debug("timer_record [%d]", b_value);
3810
3811         ret = media_pvr_get_series_record(pvr, &b_value);
3812         if (ret != MEDIA_CONTENT_ERROR_NONE)
3813                 media_content_error("Fail to media_pvr_get_series_record");
3814         media_content_debug("series_record [%d]", b_value);
3815
3816         ret = media_pvr_get_hd(pvr, &i_value);
3817         if (ret != MEDIA_CONTENT_ERROR_NONE)
3818                 media_content_error("Fail to media_pvr_get_hd");
3819         media_content_debug("hd [%d]", i_value);
3820
3821         ret = media_pvr_get_subtitle(pvr, &b_value);
3822         if (ret != MEDIA_CONTENT_ERROR_NONE)
3823                 media_content_error("Fail to media_pvr_get_subtitle");
3824         media_content_debug("subtitle [%d]", b_value);
3825
3826         ret = media_pvr_get_ttx(pvr, &b_value);
3827         if (ret != MEDIA_CONTENT_ERROR_NONE)
3828                 media_content_error("Fail to media_pvr_get_ttx");
3829         media_content_debug("ttx [%d]", b_value);
3830
3831         ret = media_pvr_get_ad(pvr, &b_value);
3832         if (ret != MEDIA_CONTENT_ERROR_NONE)
3833                 media_content_error("Fail to media_pvr_get_ad");
3834         media_content_debug("ad [%d]", b_value);
3835
3836         ret = media_pvr_get_hard_of_hearing_radio(pvr, &b_value);
3837         if (ret != MEDIA_CONTENT_ERROR_NONE)
3838                 media_content_error("Fail to media_pvr_get_hard_of_hearing_radio");
3839         media_content_debug("hard_of_hearing_radio [%d]", b_value);
3840
3841         ret = media_pvr_get_data_service(pvr, &b_value);
3842         if (ret != MEDIA_CONTENT_ERROR_NONE)
3843                 media_content_error("Fail to media_pvr_get_data_service");
3844         media_content_debug("data_service [%d]", b_value);
3845
3846         ret = media_pvr_get_content_lock(pvr, &b_value);
3847         if (ret != MEDIA_CONTENT_ERROR_NONE)
3848                 media_content_error("Fail to media_pvr_get_content_lock");
3849         media_content_debug("content_lock [%d]", b_value);
3850
3851         ret = media_pvr_get_content_watch(pvr, &b_value);
3852         if (ret != MEDIA_CONTENT_ERROR_NONE)
3853                 media_content_error("Fail to media_pvr_get_content_watch");
3854         media_content_debug("content_watch [%d]", b_value);
3855
3856         ret = media_pvr_get_has_audio_only(pvr, &b_value);
3857         if (ret != MEDIA_CONTENT_ERROR_NONE)
3858                 media_content_error("Fail to media_pvr_get_has_audio_only");
3859         media_content_debug("has_audio_only [%d]", b_value);
3860
3861         ret = media_pvr_get_is_local_record(pvr, &b_value);
3862         if (ret != MEDIA_CONTENT_ERROR_NONE)
3863                 media_content_error("Fail to media_pvr_get_is_local_record");
3864         media_content_debug("is_local_record [%d]", b_value);
3865
3866         ret = media_pvr_get_resolution(pvr, (media_pvr_resolution_e*)&i_value);
3867         if (ret != MEDIA_CONTENT_ERROR_NONE)
3868                 media_content_error("Fail to media_pvr_get_resolution");
3869         media_content_debug("resolution [%d]", i_value);
3870
3871         ret = media_pvr_get_aspectratio(pvr, (media_pvr_aspectratio_e*)&i_value);
3872         if (ret != MEDIA_CONTENT_ERROR_NONE)
3873                 media_content_error("Fail to media_pvr_get_aspectratio");
3874         media_content_debug("aspectratio [%d]", i_value);
3875
3876         ret = media_pvr_get_highlight(pvr, &b_value);
3877         if (ret != MEDIA_CONTENT_ERROR_NONE)
3878                 media_content_error("Fail to media_pvr_get_highlight");
3879         media_content_debug("highlight [%d]", b_value);
3880
3881
3882         return TRUE;
3883 }
3884
3885 int test_pvr()
3886 {
3887         int ret = MEDIA_CONTENT_ERROR_NONE;
3888         int media_count = 0;
3889
3890         media_content_debug("\n============PVR Test============\n\n");
3891
3892         test_tv_filter_create();
3893
3894         ret = media_pvr_get_media_count_from_db(g_tv_filter, &media_count);
3895         if (ret != MEDIA_CONTENT_ERROR_NONE)
3896                 media_content_error("media_pvr_get_media_count_from_db failed: %d", ret);
3897         else
3898                 media_content_debug("media_count : [%d]", media_count);
3899
3900         ret = media_pvr_foreach_media_from_db(g_tv_filter, pvr_item_cb, NULL);
3901         if (ret != MEDIA_CONTENT_ERROR_NONE)
3902                 media_content_error("media_pvr_foreach_media_from_db is failed");
3903
3904         test_tv_filter_destroy();
3905
3906         return ret;
3907 }
3908
3909 int test_pvr_update_db(void)
3910 {
3911         int ret = MEDIA_CONTENT_ERROR_NONE;
3912         media_pvr_h pvr = NULL;
3913
3914         ret = media_pvr_get_pvr_from_db("ff9b5a9a-a7b4-47f4-8255-84e007e25f13", &pvr);
3915         if (ret != MEDIA_CONTENT_ERROR_NONE)
3916                 media_content_error("media_pvr_get_pvr_from_db failed: %d", ret);
3917
3918         ret = media_pvr_set_content_lock(pvr, TRUE);
3919         if (ret != MEDIA_CONTENT_ERROR_NONE)
3920                 media_content_error("Fail to media_pvr_set_content_lock");
3921
3922         ret = media_pvr_set_content_watch(pvr, TRUE);
3923         if (ret != MEDIA_CONTENT_ERROR_NONE)
3924                 media_content_error("Fail to media_pvr_set_content_watch");
3925
3926         ret = media_pvr_set_program_title(pvr, "TEST TITLE");
3927         if (ret != MEDIA_CONTENT_ERROR_NONE)
3928                 media_content_error("Fail to media_pvr_set_program_title");
3929
3930         ret = media_pvr_set_highlight(pvr, TRUE);
3931         if (ret != MEDIA_CONTENT_ERROR_NONE)
3932                 media_content_error("Fail to media_pvr_set_highlight");
3933
3934         ret = media_pvr_update_to_db(pvr);
3935         if (ret != MEDIA_CONTENT_ERROR_NONE)
3936                 media_content_error("Fail to media_pvr_update_to_db");
3937
3938         if (pvr != NULL)
3939                 media_pvr_destroy(pvr);
3940
3941         return ret;
3942 }
3943 #endif
3944
3945 int main(int argc, char *argv[])
3946 {
3947         int ret = MEDIA_CONTENT_ERROR_NONE;
3948
3949         media_content_debug("--- content manager test start ---\n\n");
3950
3951         ret = test_connect_database();
3952         if (ret != MEDIA_CONTENT_ERROR_NONE)
3953                 return MEDIA_CONTENT_ERROR_NONE;
3954 #ifdef _USE_TV_PROFILE
3955         test_pvr();
3956
3957         test_pvr_update_db();
3958
3959         test_pvr();
3960 #endif
3961
3962 #if 0
3963         ret = test_start_face_detection(FALSE);
3964         if (ret != MEDIA_CONTENT_ERROR_NONE)
3965                 return ret;
3966
3967         ret = test_move();
3968         if (ret != MEDIA_CONTENT_ERROR_NONE)
3969                 return ret;
3970
3971         ret = test_gallery_scenario();
3972         if (ret != MEDIA_CONTENT_ERROR_NONE)
3973                 return ret;
3974
3975         ret = test_get_all_music_files();
3976         if (ret != MEDIA_CONTENT_ERROR_NONE)
3977                 return ret;
3978
3979         ret = test_media_info_operation();
3980         if (ret != MEDIA_CONTENT_ERROR_NONE)
3981                 return ret;
3982
3983         ret = test_folder_operation();
3984         if (ret != MEDIA_CONTENT_ERROR_NONE)
3985                 return ret;
3986
3987         ret = test_folder_update();
3988         if (ret != MEDIA_CONTENT_ERROR_NONE)
3989                 return ret;
3990
3991         ret = test_playlist_operation();
3992         if (ret != MEDIA_CONTENT_ERROR_NONE)
3993                 return ret;
3994
3995         ret = test_tag_operation();
3996         if (ret != MEDIA_CONTENT_ERROR_NONE)
3997                 return ret;
3998
3999         ret = test_bookmark_operation();
4000         if (ret != MEDIA_CONTENT_ERROR_NONE)
4001                 return ret;
4002
4003         ret = test_album_list();
4004         if (ret != MEDIA_CONTENT_ERROR_NONE)
4005                 return ret;
4006
4007         ret = test_group_operation();
4008         if (ret != MEDIA_CONTENT_ERROR_NONE)
4009                 return ret;
4010
4011         ret = test_update_operation();
4012         if (ret != MEDIA_CONTENT_ERROR_NONE)
4013                 return ret;
4014
4015         ret = test_insert();
4016         if (ret != MEDIA_CONTENT_ERROR_NONE)
4017                 return ret;
4018
4019         ret = test_move();
4020         if (ret != MEDIA_CONTENT_ERROR_NONE)
4021                 return ret;
4022
4023         ret = test_create_thumbnail(TRUE);
4024         if (ret != MEDIA_CONTENT_ERROR_NONE)
4025                 return ret;
4026
4027         ret = test_extrace_face(TRUE);
4028         if (ret != MEDIA_CONTENT_ERROR_NONE)
4029                 return ret;
4030
4031         ret = test_request_update_db();
4032         if (ret != MEDIA_CONTENT_ERROR_NONE)
4033                 return ret;
4034
4035         ret = DFT_test();
4036         if (ret != MEDIA_CONTENT_ERROR_NONE)
4037                 return ret;
4038
4039         ret = test_batch_operations();
4040         if (ret != MEDIA_CONTENT_ERROR_NONE)
4041                 return MEDIA_CONTENT_ERROR_NONE;
4042
4043         ret = test_insert_burst_shot_to_db();
4044         if (ret != MEDIA_CONTENT_ERROR_NONE)
4045                 return MEDIA_CONTENT_ERROR_NONE;
4046
4047         ret = test_scan_file();
4048         if (ret != MEDIA_CONTENT_ERROR_NONE)
4049                 return MEDIA_CONTENT_ERROR_NONE;
4050
4051         ret = test_scan_dir(true);
4052         if (ret != MEDIA_CONTENT_ERROR_NONE)
4053                 return MEDIA_CONTENT_ERROR_NONE;
4054
4055         ret = test_noti();
4056         if (ret != MEDIA_CONTENT_ERROR_NONE)
4057                 return MEDIA_CONTENT_ERROR_NONE;
4058
4059         ret = test_create_handle();
4060         if (ret != MEDIA_CONTENT_ERROR_NONE)
4061                 return MEDIA_CONTENT_ERROR_NONE;
4062
4063         ret = test_face();
4064         if (ret != MEDIA_CONTENT_ERROR_NONE)
4065                 return MEDIA_CONTENT_ERROR_NONE;
4066
4067         ret = test_face_add_del();
4068         if (ret != MEDIA_CONTENT_ERROR_NONE)
4069                 return MEDIA_CONTENT_ERROR_NONE;
4070
4071         ret = test_playlist_operation_v2();
4072         if (ret != MEDIA_CONTENT_ERROR_NONE)
4073                 return MEDIA_CONTENT_ERROR_NONE;
4074
4075         ret = test_bookmark_operation_v2();
4076         if (ret != MEDIA_CONTENT_ERROR_NONE)
4077                 return MEDIA_CONTENT_ERROR_NONE;
4078 #endif
4079
4080         ret = test_disconnect_database();
4081         if (ret != MEDIA_CONTENT_ERROR_NONE)
4082                 return ret;
4083
4084         media_content_debug("--- content manager test end ---\n");
4085
4086         return ret;
4087 }