test/media-content_test.c

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