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