test/media-content_test.c

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