test/media-content_test.c

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