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