test/media-content_test.c

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