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         media_playlist_get_playlist_count_from_db(filter, &playlist_count);
1667         media_content_debug("playlist_count [%d]", playlist_count);
1668
1669         /* Get Playlist*/
1670         GList *playlist_id_list = NULL;
1671         media_playlist_foreach_playlist_from_db(filter, playlist_list_cb, &playlist_id_list);
1672
1673         /* Get Playlist id*/
1674         playlist_id_1 = (int)g_list_nth_data(playlist_id_list, 0);
1675         playlist_id_2 = (int)g_list_nth_data(playlist_id_list, 1);
1676         playlist_id_3 = (int)g_list_nth_data(playlist_id_list, 2);
1677         media_content_debug("playlist_id_1 [%d]", playlist_id_1);
1678         media_content_debug("playlist_id_2 [%d]", playlist_id_2);
1679         media_content_debug("playlist_id_3 [%d]", playlist_id_3);
1680
1681         /* Filter for media*/
1682         ret = media_filter_create(&m_filter);
1683
1684         ret = media_filter_set_condition(m_filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
1685
1686         ret = media_filter_set_order(m_filter, MEDIA_CONTENT_ORDER_ASC, PLAYLIST_MEMBER_ORDER, MEDIA_CONTENT_COLLATE_DEFAULT);
1687
1688         /* Get media count */
1689         media_playlist_get_media_count_from_db(playlist_id_1, m_filter, &media_count);
1690         media_content_debug("playlist_1_media_count [%d]", media_count);
1691
1692         media_playlist_get_media_count_from_db(playlist_id_2, m_filter, &media_count);
1693         media_content_debug("playlist_2_media_count [%d]", media_count);
1694
1695         media_playlist_get_media_count_from_db(playlist_id_3, m_filter, &media_count);
1696         media_content_debug("playlist_3_media_count [%d]", media_count);
1697
1698         /* Get media of playlist */
1699         GList *playlist_member_id_list = NULL;
1700         GList *playlist_member_id_list_1 = NULL;
1701
1702         media_playlist_foreach_media_from_db(playlist_id_1, m_filter, playlist_item_cb, &playlist_member_id_list);
1703         media_playlist_foreach_media_from_db(playlist_id_2, m_filter, playlist_item_cb, &playlist_member_id_list_1);
1704
1705         int playlist_member_id_1_1 =0;
1706         int playlist_member_id_1_2 =0;
1707         int playlist_member_id_1_3 =0;
1708         int playlist_member_id_2_1 =0;
1709         int playlist_member_id_2_2 =0;
1710
1711         playlist_member_id_1_1 = (int)g_list_nth_data(playlist_member_id_list, 0);
1712         playlist_member_id_1_2 = (int)g_list_nth_data(playlist_member_id_list, 1);
1713         playlist_member_id_1_3 = (int)g_list_nth_data(playlist_member_id_list, 2);
1714         playlist_member_id_2_1 = (int)g_list_nth_data(playlist_member_id_list_1, 0);
1715         playlist_member_id_2_2 = (int)g_list_nth_data(playlist_member_id_list_1, 1);
1716
1717         media_content_debug("playlist_member_id_1_1 [%d]", playlist_member_id_1_1);
1718         media_content_debug("playlist_member_id_1_2 [%d]", playlist_member_id_1_2);
1719         media_content_debug("playlist_member_id_1_3 [%d]", playlist_member_id_1_3);
1720         media_content_debug("playlist_member_id_2_1 [%d]", playlist_member_id_2_1);
1721         media_content_debug("playlist_member_id_2_2 [%d]", playlist_member_id_2_2);
1722
1723         media_playlist_get_play_order(playlist_1, playlist_member_id_1_1, &order_1);
1724         media_playlist_get_play_order(playlist_1, playlist_member_id_1_2, &order_2);
1725         media_playlist_get_play_order(playlist_1, playlist_member_id_1_3, &order_3);
1726         media_playlist_get_play_order(playlist_2, playlist_member_id_2_1, &order_4);
1727         media_playlist_get_play_order(playlist_2, playlist_member_id_2_2, &order_5);
1728         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);
1729
1730         /* Update Playlist */
1731         media_playlist_remove_media(playlist_2, playlist_member_id_2_1);
1732         media_playlist_add_media(playlist_2, test_video_id);
1733         media_playlist_set_name(playlist_2, "test_playlist");
1734         media_playlist_set_play_order(playlist_2, playlist_member_id_2_2, order_5+100);
1735         media_playlist_update_to_db(playlist_2);
1736
1737         /* Get Updated Playlist*/
1738         media_playlist_foreach_playlist_from_db(filter, playlist_list_cb, NULL);
1739
1740         /* deletes the playlist */
1741         //media_playlist_delete_from_db(playlist_id_1);
1742         //media_playlist_delete_from_db(playlist_id_2);
1743
1744         if(playlist_1 != NULL)
1745                 media_playlist_destroy(playlist_1);
1746         if(playlist_2 != NULL)
1747                 media_playlist_destroy(playlist_2);
1748         if(playlist_3 != NULL)
1749                 media_playlist_destroy(playlist_3);
1750
1751         g_list_free(playlist_id_list);
1752         g_list_free(playlist_member_id_list);
1753         g_list_free(playlist_member_id_list_1);
1754
1755         if(filter != NULL)
1756                 ret = media_filter_destroy(filter);
1757         if(m_filter != NULL)
1758                 ret = media_filter_destroy(m_filter);
1759
1760         return ret;
1761 }
1762
1763 int test_tag_operation(void)
1764 {
1765         int ret = MEDIA_CONTENT_ERROR_NONE;
1766         media_tag_h tag_1;
1767         media_tag_h tag_2;
1768         media_tag_h tag_3;
1769         int tag_id_1 = 0;
1770         int tag_id_2 = 0;
1771         int tag_id_3 = 0;
1772         char *tag_name_1 = "myTag_1";
1773         char *tag_name_2 = "myTag_2";
1774         char *tag_name_3 = "myTag_3";
1775         int tag_count = 0;
1776         int media_count = 0;
1777         filter_h filter;
1778
1779         media_content_debug("\n============Tag Test============\n\n");
1780
1781         char *g_condition = "TAG_NAME like \"%%my%%\"";
1782
1783         ret = media_filter_create(&filter);
1784
1785         ret = media_filter_set_condition(filter, g_condition, MEDIA_CONTENT_COLLATE_DEFAULT);
1786
1787         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, TAG_NAME, MEDIA_CONTENT_COLLATE_DEFAULT);
1788
1789         /* Create Tag */
1790         ret = media_tag_insert_to_db(tag_name_1, &tag_1);
1791         if(ret != MEDIA_CONTENT_ERROR_NONE)
1792                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1793         ret = media_tag_insert_to_db(tag_name_2, &tag_2);
1794         if(ret != MEDIA_CONTENT_ERROR_NONE)
1795                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1796         ret = media_tag_insert_to_db(tag_name_3, &tag_3);
1797         if(ret != MEDIA_CONTENT_ERROR_NONE)
1798                 media_content_error("error media_tag_insert_to_db : [%d]", ret);
1799
1800         /* Add media to Tag */
1801         ret = media_tag_add_media(tag_1, test_audio_id);
1802         if(ret != MEDIA_CONTENT_ERROR_NONE)
1803                 media_content_error("error media_tag_add_media : [%d]", ret);
1804         ret = media_tag_add_media(tag_1, test_video_id);
1805         if(ret != MEDIA_CONTENT_ERROR_NONE)
1806                 media_content_error("error media_tag_add_media : [%d]", ret);
1807         ret = media_tag_update_to_db(tag_1);
1808         if(ret != MEDIA_CONTENT_ERROR_NONE)
1809                 media_content_error("error media_tag_update_to_db : [%d]", ret);
1810
1811         ret = media_tag_add_media(tag_2, test_audio_id);
1812         if(ret != MEDIA_CONTENT_ERROR_NONE)
1813                 media_content_error("error media_tag_add_media : [%d]", ret);
1814         ret = media_tag_update_to_db(tag_2);
1815         if(ret != MEDIA_CONTENT_ERROR_NONE)
1816                 media_content_error("error media_tag_update_to_db : [%d]", ret);
1817
1818         /* Get Tag Count*/
1819         ret = media_tag_get_tag_count_from_db(filter, &tag_count);
1820         if(ret != MEDIA_CONTENT_ERROR_NONE)
1821                 media_content_error("error media_tag_get_tag_count_from_db : [%d]", ret);
1822         else
1823                 media_content_debug("tag_count [%d]", tag_count);
1824
1825         /* Get Tag*/
1826         ret = media_tag_foreach_tag_from_db(filter, tag_list_cb, NULL);
1827         if(ret != MEDIA_CONTENT_ERROR_NONE)
1828                 media_content_error("error media_tag_foreach_tag_from_db : [%d]", ret);
1829
1830         /* Get Tag id*/
1831         ret = media_tag_get_tag_id(tag_1, &tag_id_1);
1832         if(ret != MEDIA_CONTENT_ERROR_NONE)
1833                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1834         else
1835                 media_content_debug("tag_id_1 [%d]", tag_id_1);
1836
1837         ret = media_tag_get_tag_id(tag_2, &tag_id_2);
1838         if(ret != MEDIA_CONTENT_ERROR_NONE)
1839                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1840         else
1841                 media_content_debug("tag_id_2 [%d]", tag_id_2);
1842
1843         ret = media_tag_get_tag_id(tag_3, &tag_id_3);
1844         if(ret != MEDIA_CONTENT_ERROR_NONE)
1845                 media_content_error("error media_tag_get_tag_id : [%d]", ret);
1846         else
1847                 media_content_debug("tag_id_3 [%d]", tag_id_3);
1848
1849         /* Get media count */
1850         ret = media_tag_get_media_count_from_db(tag_id_1, NULL, &media_count);
1851         if(ret != MEDIA_CONTENT_ERROR_NONE)
1852                 media_content_error("error media_tag_get_media_count_from_db : [%d]", ret);
1853         else
1854                 media_content_debug("tag_1_media_count [%d]", media_count);
1855
1856         ret = media_tag_get_media_count_from_db(tag_id_2, NULL, &media_count);
1857         if(ret != MEDIA_CONTENT_ERROR_NONE)
1858                 media_content_error("error media_tag_get_media_count_from_db : [%d]", ret);
1859         else
1860                 media_content_debug("tag_2_media_count [%d]", media_count);
1861
1862         /* Get media of Tag */
1863         ret = media_tag_foreach_media_from_db(tag_id_1, NULL, media_item_cb, NULL);
1864         if(ret != MEDIA_CONTENT_ERROR_NONE)
1865                 media_content_error("error media_tag_foreach_media_from_db : [%d]", ret);
1866
1867         ret = media_tag_foreach_media_from_db(tag_id_2, NULL, media_item_cb, NULL);
1868         if(ret != MEDIA_CONTENT_ERROR_NONE)
1869                 media_content_error("error media_tag_foreach_media_from_db : [%d]", ret);
1870
1871         /* Update Tag */
1872         ret = media_tag_add_media(tag_2, test_video_id);
1873         if(ret != MEDIA_CONTENT_ERROR_NONE)
1874                 media_content_error("error media_tag_add_media : [%d]", ret);
1875         ret = media_tag_set_name(tag_2, "test_tag");
1876         if(ret != MEDIA_CONTENT_ERROR_NONE)
1877                 media_content_error("error media_tag_set_name : [%d]", ret);
1878         ret = media_tag_update_to_db(tag_2);
1879         if(ret != MEDIA_CONTENT_ERROR_NONE)
1880                 media_content_error("error media_tag_update_to_db : [%d]", ret);
1881
1882         /* Get Updated Tag*/
1883         ret = media_tag_foreach_tag_from_db(filter, tag_list_cb, NULL);
1884         if(ret != MEDIA_CONTENT_ERROR_NONE)
1885                 media_content_error("error media_tag_foreach_tag_from_db : [%d]", ret);
1886
1887         /* deletes the tag */
1888         ret = media_tag_delete_from_db(tag_id_1);
1889         if(ret != MEDIA_CONTENT_ERROR_NONE)
1890                 media_content_error("error media_tag_delete_from_db : [%d]", ret);
1891         ret = media_tag_delete_from_db(tag_id_2);
1892         if(ret != MEDIA_CONTENT_ERROR_NONE)
1893                 media_content_error("error media_tag_delete_from_db : [%d]", ret);
1894
1895         ret = media_tag_destroy(tag_1);
1896         if(ret != MEDIA_CONTENT_ERROR_NONE)
1897                 media_content_error("error media_tag_destroy : [%d]", ret);
1898         ret = media_tag_destroy(tag_2);
1899         if(ret != MEDIA_CONTENT_ERROR_NONE)
1900                 media_content_error("error media_tag_destroy : [%d]", ret);
1901         ret = media_filter_destroy(filter);
1902         if(ret != MEDIA_CONTENT_ERROR_NONE)
1903                 media_content_error("error media_filter_destroy : [%d]", ret);
1904
1905         return ret;
1906 }
1907
1908
1909 int test_bookmark_operation(void)
1910 {
1911         //bookmark is only supported for video information.
1912         int ret = MEDIA_CONTENT_ERROR_NONE;
1913         int bookmark_count = 0;
1914         filter_h filter;
1915
1916         media_content_debug("\n============Bookmark Test============\n\n");
1917
1918         char *g_condition = "BOOKMARK_MARKED_TIME > 300";
1919
1920         ret = media_filter_create(&filter);
1921         if(ret != MEDIA_CONTENT_ERROR_NONE)
1922                 media_content_error("error media_filter_create : [%d]", ret);
1923
1924         ret = media_filter_set_condition(filter, g_condition, MEDIA_CONTENT_COLLATE_DEFAULT);
1925         if(ret != MEDIA_CONTENT_ERROR_NONE)
1926                 media_content_error("error media_filter_set_condition : [%d]", ret);
1927
1928         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, BOOKMARK_MARKED_TIME, MEDIA_CONTENT_COLLATE_DEFAULT);
1929         if(ret != MEDIA_CONTENT_ERROR_NONE)
1930                 media_content_error("error media_filter_set_order : [%d]", ret);
1931
1932         //insert bookmark to video
1933         char *thumbnail_path1 = "/opt/usr/media/Images and videos/My video clips/teat11.jpg";
1934         ret = media_bookmark_insert_to_db(test_video_id, 400, thumbnail_path1);
1935         if(ret != MEDIA_CONTENT_ERROR_NONE)
1936                 media_content_error("error media_bookmark_insert_to_db : [%d]", ret);
1937
1938         ret = media_bookmark_insert_to_db(test_video_id, 600, thumbnail_path1);
1939         if(ret != MEDIA_CONTENT_ERROR_NONE)
1940                 media_content_error("error media_bookmark_insert_to_db : [%d]", ret);
1941
1942         ret = media_bookmark_get_bookmark_count_from_db(filter, &bookmark_count);
1943         if(ret != MEDIA_CONTENT_ERROR_NONE)
1944                 media_content_error("error media_bookmark_get_bookmark_count_from_db : [%d]", ret);
1945         else
1946                 media_content_debug("bookmark_count = [%d]", bookmark_count);
1947
1948         ret = media_filter_destroy(filter);
1949         if(ret != MEDIA_CONTENT_ERROR_NONE)
1950                 media_content_error("error media_filter_destroy : [%d]", ret);
1951
1952         return ret;
1953 }
1954
1955 int test_album_list(void)
1956 {
1957         media_content_debug("\n============Album Test============\n\n");
1958
1959         int ret = MEDIA_CONTENT_ERROR_NONE;
1960         int album_count = 0;
1961         filter_h filter;
1962
1963         /*Set Filter*/
1964         char *condition = "MEDIA_TYPE=3";       /*0-image, 1-video, 2-sound, 3-music, 4-other*/
1965
1966         ret = media_filter_create(&filter);
1967         if(ret != MEDIA_CONTENT_ERROR_NONE) {
1968                 media_content_error("Fail to create filter");
1969                 return ret;
1970         }
1971         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
1972         if(ret != MEDIA_CONTENT_ERROR_NONE) {
1973                 media_filter_destroy(filter);
1974                 media_content_error("Fail to set condition");
1975                 return ret;
1976         }
1977         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ALBUM, MEDIA_CONTENT_COLLATE_NOCASE);
1978         if(ret != MEDIA_CONTENT_ERROR_NONE) {
1979                 media_filter_destroy(filter);
1980                 media_content_error("Fail to set order");
1981                 return ret;
1982         }
1983
1984         ret = media_album_get_album_count_from_db(filter, &album_count);
1985         if(ret != MEDIA_CONTENT_ERROR_NONE) {
1986                 media_filter_destroy(filter);
1987                 return ret;
1988         } else {
1989                 media_content_debug("album_count [%d]", album_count);
1990         }
1991
1992         ret = media_album_foreach_album_from_db(filter, album_list_cb, NULL);
1993         if(ret != MEDIA_CONTENT_ERROR_NONE)
1994                 media_content_error("error media_album_foreach_album_from_db : [%d]", ret);
1995
1996         ret = media_filter_destroy(filter);
1997         if(ret != MEDIA_CONTENT_ERROR_NONE)
1998                 media_content_error("error media_filter_destroy : [%d]", ret);
1999
2000         return ret;
2001 }
2002
2003 int test_group_operation(void)
2004 {
2005         media_content_debug("\n============Group Test============\n\n");
2006
2007         int ret = MEDIA_CONTENT_ERROR_NONE;
2008         int group_count = 0;
2009         int idx = 0;
2010
2011         ret = test_filter_create();
2012         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2013                 media_content_error("[%d]error(0x%08x)", __LINE__, ret);
2014                 return ret;
2015         }
2016
2017         for(idx = 0; idx <= MEDIA_CONTENT_GROUP_KEYWORD; idx++)
2018         {
2019                 ret = media_group_get_group_count_from_db(g_filter, idx, &group_count);
2020                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
2021                         test_filter_destroy();
2022                         media_content_error("media_group_get_group_count_from_db fail. idx=[%d]", ret, idx);
2023                         return ret;
2024                 } else {
2025                         media_content_debug("[%2d]group_count [%d]", idx, group_count);
2026                 }
2027
2028                 ret = media_group_foreach_group_from_db(g_filter, idx, group_list_cb, &idx);
2029         }
2030         ret = test_filter_destroy();
2031
2032         return ret;
2033 }
2034
2035 int test_update_operation()
2036 {
2037         int ret = MEDIA_CONTENT_ERROR_NONE;
2038         int i;
2039         media_info_h media_handle = NULL;
2040         GList *all_item_list = NULL;
2041
2042         /* Get all item list */
2043         ret = media_info_foreach_media_from_db(NULL, gallery_media_item_cb, &all_item_list);
2044         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2045                 media_content_error("media_info_foreach_media_from_db failed: %d", ret);
2046                 return -1;
2047         } else {
2048                 media_content_debug("media_info_foreach_media_from_db success");
2049                 char *media_id = NULL;
2050                 char *media_path = NULL;
2051                 media_content_type_e media_type = 0;
2052
2053                 for(i = 0; i < g_list_length(all_item_list); i++) {
2054                         media_handle = (media_info_h)g_list_nth_data(all_item_list, i);
2055
2056                         ret = media_info_get_media_id(media_handle, &media_id);
2057                         if(ret != MEDIA_CONTENT_ERROR_NONE)
2058                                 media_content_error("media_info_get_media_id failed: %d", ret);
2059                         ret = media_info_get_file_path(media_handle, &media_path);
2060                         if(ret != MEDIA_CONTENT_ERROR_NONE)
2061                                 media_content_error("media_info_get_file_path failed: %d", ret);
2062                         ret = media_info_get_media_type(media_handle, &media_type);
2063                         if(ret != MEDIA_CONTENT_ERROR_NONE)
2064                                 media_content_error("media_info_get_media_type failed: %d", ret);
2065
2066                         media_content_debug("media_id [%d] : %s", i, media_id);
2067                         media_content_debug("media_type [%d] : %d", i, media_type);
2068                         media_content_debug("media_path [%d] : %s", i, media_path);
2069 #if 0
2070                         if(media_type == MEDIA_CONTENT_TYPE_IMAGE) {
2071                                 image_meta_h image_handle;
2072                                 media_content_orientation_e orientation;
2073
2074                                 ret = media_info_get_image(media_handle, &image_handle);
2075                                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
2076                                         media_content_error("media_info_get_image failed: %d", ret);
2077                                 } else {
2078                                         media_content_debug("media_info_get_image success");
2079
2080                                         //update image meta
2081                                         orientation = MEDIA_CONTENT_ORIENTATION_ROT_180;
2082                                         image_meta_set_orientation(image_handle, orientation);
2083
2084                                         ret = image_meta_update_to_db(image_handle);
2085                                         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2086                                                 media_content_error("image_meta_update_to_db failed: %d", ret);
2087                                         } else {
2088                                                 media_content_debug("image_meta_update_to_db success");
2089                                         }
2090                                 }
2091
2092                         } else if(media_type == MEDIA_CONTENT_TYPE_VIDEO) {
2093                                 video_meta_h video_handle;
2094
2095                                 ret = media_info_get_video(media_handle, &video_handle);
2096                                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
2097                                         media_content_error("media_info_get_video failed: %d", ret);
2098                                 } else {
2099                                         media_content_debug("media_info_get_video success");
2100
2101                                         //update video meta
2102                                         video_meta_set_played_count(video_handle,5);
2103                                         video_meta_set_played_time(video_handle,5);
2104                                         video_meta_set_played_position(video_handle,5);
2105                                         video_meta_update_to_db(video_handle);
2106
2107                                         ret = video_meta_update_to_db(video_handle);
2108                                         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2109                                                 media_content_error("video_meta_update_to_db failed: %d", ret);
2110                                         } else {
2111                                                 media_content_debug("video_meta_update_to_db success");
2112                                         }
2113                                 }
2114                         } else if(media_type == MEDIA_CONTENT_TYPE_MUSIC) {//update audio meta
2115                                 audio_meta_h audio_handle = NULL;
2116                                 ret = media_info_get_audio(media_handle, &audio_handle);
2117                                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
2118                                         media_content_error("media_info_get_audio failed: %d", ret);
2119                                 } else {
2120                                         media_content_debug("media_info_get_audio success");
2121
2122                                         audio_meta_set_played_count(audio_handle,5);
2123                                         audio_meta_set_played_time(audio_handle,1000);
2124                                         audio_meta_set_played_position(audio_handle,180);
2125
2126                                         ret = audio_meta_update_to_db(audio_handle);
2127                                         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2128                                                 media_content_error("audio_meta_update_to_db failed: %d", ret);
2129                                         } else {
2130                                                 media_content_debug("audio_meta_update_to_db success");
2131                                         }
2132                                 }
2133
2134                         }
2135 #endif
2136                 }
2137         }
2138
2139         return MEDIA_CONTENT_ERROR_NONE;
2140 }
2141
2142 int test_insert(void)
2143 {
2144         int ret = MEDIA_CONTENT_ERROR_NONE;
2145         //char *path = "/opt/media/Images/Default.jpg";
2146         char *path = "/opt/usr/media/Others/other.txt";
2147         //char *path = NULL;
2148         media_info_h media_item = NULL;
2149         media_content_debug("\n============DB Insert Test============\n\n");
2150
2151         ret = media_info_insert_to_db(path, &media_item);
2152
2153         if((ret == MEDIA_CONTENT_ERROR_NONE) && (media_item != NULL))
2154         {
2155                 media_content_debug("Insertion is success");
2156         }
2157         else
2158         {
2159                 media_content_error("Insertion is failed");
2160                 ret = media_info_destroy(media_item);
2161                 return ret;
2162         }
2163
2164         char *media_id = NULL;
2165
2166         ret = media_info_get_media_id(media_item, &media_id);
2167         if(ret != MEDIA_CONTENT_ERROR_NONE)
2168                 media_content_error("media_info_get_media_id failed: %d", ret);
2169         else
2170                 media_content_debug("Media ID: %s", media_id);
2171
2172         SAFE_FREE(media_id);
2173
2174         ret = media_info_update_to_db(media_item);
2175         if(ret == MEDIA_CONTENT_ERROR_NONE)
2176                 media_content_debug("media_info_update_to_db is success");
2177         else
2178                 media_content_error("media_info_update_to_db is failed");
2179
2180         ret = media_info_destroy(media_item);
2181         if(ret != MEDIA_CONTENT_ERROR_NONE)
2182                 media_content_error("media_info_destroy failed: %d", ret);
2183
2184         return ret;
2185 }
2186
2187 int test_move(void)
2188 {
2189         int ret = MEDIA_CONTENT_ERROR_NONE;
2190         const char *move_media_id = "60aea677-4742-408e-b5f7-f2628062d06d";
2191         char *dst_path = "/opt/usr/media/Images/XX/Default1.jpg";
2192         media_info_h move_media = NULL;
2193
2194         ret = media_info_get_media_from_db(move_media_id, &move_media);
2195         if(ret == MEDIA_CONTENT_ERROR_NONE)
2196                 media_content_debug("media_info_get_media_from_db success");
2197         else
2198                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2199
2200         media_content_debug("\n============DB Move Test============\n\n");
2201
2202         if(move_media) {
2203                 ret = media_info_move_to_db(move_media, dst_path);
2204
2205                 if(ret == MEDIA_CONTENT_ERROR_NONE)
2206                         media_content_debug("Move is success");
2207                 else
2208                         media_content_error("Move is failed");
2209
2210                 ret = media_info_destroy(move_media);
2211         } else {
2212                 media_content_debug("There is no item : %s", move_media_id);
2213         }
2214
2215         return ret;
2216 }
2217
2218 void thumbnail_completed_cb(media_content_error_e error, const char *path, void *user_data)
2219 {
2220         char *thumbnail_path = NULL;
2221         int ret = MEDIA_CONTENT_ERROR_NONE;
2222         g_cnt++;
2223
2224         media_content_debug("=================[%d][%d]", g_media_cnt, g_cnt);
2225         media_content_debug("error_code [%d]", error);
2226         media_content_debug("thumbnail_path [%s]", path);
2227         if(user_data != NULL)
2228         {
2229                 media_info_h media = (media_info_h)user_data;
2230                 ret = media_info_get_thumbnail_path(media, &thumbnail_path);
2231                 if(ret != MEDIA_CONTENT_ERROR_NONE)
2232                         media_content_error("media_info_get_thumbnail_path failed: %d", ret);
2233                 else
2234                         media_content_debug("thumbnail_path get from media[%s]", thumbnail_path);
2235                 SAFE_FREE(thumbnail_path);
2236                 ret = media_info_destroy(media);
2237                 if(ret != MEDIA_CONTENT_ERROR_NONE)
2238                         media_content_error("media_info_destroy failed: %d", ret);
2239         }
2240
2241         if(g_cnt == g_media_cnt)
2242                 g_main_loop_quit(g_loop);
2243
2244         return;
2245 }
2246
2247 bool thumbnail_create_cb(media_info_h media, void *user_data)
2248 {
2249         char *media_id = NULL;
2250         media_info_h dst = NULL;
2251         int ret = MEDIA_CONTENT_ERROR_NONE;
2252
2253         if(media == NULL)
2254         {
2255                 media_content_debug("NO Item");
2256                 return true;
2257         }
2258
2259         ret = media_info_get_media_id(media, &media_id);
2260         if(ret != MEDIA_CONTENT_ERROR_NONE)
2261                 media_content_error("media_info_get_media_id failed: %d", ret);
2262         else
2263                 media_content_debug("media_id : [%s]", media_id);
2264
2265         ret = media_info_clone(&dst, media);
2266         if(ret != MEDIA_CONTENT_ERROR_NONE)
2267                 media_content_error("media_info_clone failed: %d", ret);
2268         else
2269         {
2270                 ret = media_info_create_thumbnail(dst, thumbnail_completed_cb, dst);
2271                 if(ret != MEDIA_CONTENT_ERROR_NONE)
2272                         media_content_error("media_info_create_thumbnail failed: %d", ret);
2273         }
2274
2275         return true;
2276 }
2277
2278 bool thumbnail_cancel_cb(media_info_h media, void *user_data)
2279 {
2280         int ret = MEDIA_CONTENT_ERROR_NONE;
2281
2282         char *media_id = NULL;
2283         media_info_h dst = NULL;
2284
2285         g_cnt++;
2286
2287         if(media == NULL)
2288         {
2289                 media_content_debug("NO Item");
2290                 return true;
2291         }
2292
2293         ret = media_info_get_media_id(media, &media_id);
2294         if(ret != MEDIA_CONTENT_ERROR_NONE)
2295                 media_content_error("media_info_get_media_id failed: %d", ret);
2296         else
2297                 media_content_debug("media_id : [%s]", media_id);
2298
2299         ret = media_info_clone(&dst, media);
2300         if(ret != MEDIA_CONTENT_ERROR_NONE)
2301                 media_content_error("media_info_clone failed: %d", ret);
2302
2303         ret = media_info_cancel_thumbnail(dst);
2304         if(ret != MEDIA_CONTENT_ERROR_NONE)
2305                 media_content_error("media_info_cancel_thumbnail failed: %d", ret);
2306
2307         ret = media_info_destroy(dst);
2308         if(ret != MEDIA_CONTENT_ERROR_NONE)
2309                         media_content_error("media_info_destroy failed: %d", ret);
2310
2311         if(g_cnt == g_media_cnt)
2312                 g_main_loop_quit(g_loop);
2313
2314         return true;
2315 }
2316
2317 gboolean create_thumbnail_start(gpointer data)
2318 {
2319         int ret = MEDIA_CONTENT_ERROR_NONE;
2320
2321         ret = media_info_foreach_media_from_db(g_filter, thumbnail_create_cb, NULL);
2322
2323         if(ret == MEDIA_CONTENT_ERROR_NONE)
2324                 media_content_debug("media_info_foreach_media_from_db is success");
2325         else
2326                 media_content_error("media_info_foreach_media_from_db is failed");
2327
2328         return false;
2329 }
2330
2331 gboolean cancel_thumbnail_start(gpointer data)
2332 {
2333         int ret = MEDIA_CONTENT_ERROR_NONE;
2334
2335         ret = media_info_foreach_media_from_db(g_filter, thumbnail_cancel_cb, NULL);
2336
2337         if(ret == MEDIA_CONTENT_ERROR_NONE)
2338                 media_content_debug("media_info_foreach_media_from_db is success");
2339         else
2340                 media_content_error("media_info_foreach_media_from_db is failed");
2341
2342         return false;
2343 }
2344
2345 int test_create_thumbnail(int cancel)
2346 {
2347         int ret = MEDIA_CONTENT_ERROR_NONE;
2348         GSource *source = NULL;
2349         GMainContext *context = NULL;
2350
2351         test_filter_create();
2352
2353         ret = media_info_get_media_count_from_db(g_filter, &g_media_cnt);
2354         if(ret != MEDIA_CONTENT_ERROR_NONE)
2355                 media_content_error("media_info_get_media_count_from_db failed: %d", ret);
2356         else
2357                 media_content_debug("media_count : [%d]", g_media_cnt);
2358
2359         g_loop = g_main_loop_new(NULL, FALSE);
2360         context = g_main_loop_get_context(g_loop);
2361         source = g_idle_source_new();
2362         g_source_set_callback (source, create_thumbnail_start, NULL, NULL);
2363         g_source_attach (source, context);
2364
2365         /* Logic to cancel */
2366         if (cancel) {
2367                 GSource *cancel_src = NULL;
2368                 cancel_src = g_idle_source_new();
2369                 g_source_set_callback (cancel_src, cancel_thumbnail_start, NULL, NULL);
2370                 g_source_attach (cancel_src, context);
2371         }
2372
2373         g_main_loop_run(g_loop);
2374         g_main_loop_unref(g_loop);
2375
2376         test_filter_destroy();
2377
2378         return ret;
2379 }
2380
2381 int test_disconnect_database(void)
2382 {
2383         int ret = MEDIA_CONTENT_ERROR_NONE;
2384         media_content_debug("\n============DB Disconnection Test============\n\n");
2385
2386         ret = media_content_disconnect();
2387
2388         if(ret == MEDIA_CONTENT_ERROR_NONE)
2389                 media_content_debug("disconnection is success");
2390         else
2391                 media_content_error("disconnection is failed");
2392
2393         return ret;
2394 }
2395
2396 int test_request_update_db(void)
2397 {
2398         int ret = MEDIA_CONTENT_ERROR_NONE;
2399         media_info_h media = NULL;
2400
2401         //get the content of Over the horizon
2402         ret = media_info_get_media_from_db("0f999626-6218-450c-a4ad-181a3bab6ebf", &media);
2403         if(ret != MEDIA_CONTENT_ERROR_NONE)
2404                 media_content_error("media_info_get_media_from_db failed: %d", ret);
2405
2406         test_disconnect_database();
2407
2408         ret = media_info_set_content_name(media, "TEST_content_name");
2409         if(ret != MEDIA_CONTENT_ERROR_NONE)
2410                 media_content_error("media_info_set_content_name failed: %d", ret);
2411
2412         ret = media_info_update_to_db(media);
2413         if(ret == MEDIA_CONTENT_ERROR_NONE)
2414                 media_content_debug("media_info_update_to_db is success");
2415         else
2416                 media_content_error("media_info_update_to_db is failed");
2417
2418         if(media != NULL)
2419                 media_info_destroy(media);
2420
2421         return ret;
2422 }
2423
2424 int g_total_photo_size = 0;
2425 int g_total_video_size = 0;
2426 int g_total_mp3_size = 0;
2427 int g_total_voice_memo_size = 0;
2428
2429 bool dft_cb(media_info_h media, void *user_data)
2430 {
2431         unsigned long long file_size = 0;
2432         media_content_type_e media_type = -1;
2433         char *mime_type = NULL;
2434         int ret = MEDIA_CONTENT_ERROR_NONE;
2435
2436         if(media == NULL)
2437         {
2438                 return true;
2439         }
2440
2441         ret = media_info_get_media_type(media, &media_type);
2442         if(ret != MEDIA_CONTENT_ERROR_NONE)
2443                 media_content_error("media_info_get_media_type failed: %d", ret);
2444         ret = media_info_get_size(media, &file_size);
2445         if(ret != MEDIA_CONTENT_ERROR_NONE)
2446                 media_content_error("media_info_get_size failed: %d", ret);
2447         ret = media_info_get_mime_type(media, &mime_type);
2448         if(ret != MEDIA_CONTENT_ERROR_NONE)
2449                 media_content_error("media_info_get_mime_type failed: %d", ret);
2450
2451         if(media_type == MEDIA_CONTENT_TYPE_IMAGE)
2452         {
2453                 g_total_photo_size += file_size;
2454         }
2455         else if(media_type == MEDIA_CONTENT_TYPE_VIDEO)
2456         {
2457                 g_total_video_size += file_size;
2458         }
2459         else if(media_type == MEDIA_CONTENT_TYPE_SOUND)
2460         {
2461                 g_total_voice_memo_size += file_size;
2462         }
2463         else if(media_type == MEDIA_CONTENT_TYPE_MUSIC)
2464         {
2465                 if((mime_type != NULL) && (!strcmp("audio/mpeg", mime_type)))
2466                 {
2467                         g_total_mp3_size += file_size;
2468                 }
2469                 else
2470                 {
2471                         g_total_voice_memo_size += file_size;
2472                 }
2473         }
2474         else
2475         {
2476                 printf("invalid media_type");
2477         }
2478
2479         if(mime_type != NULL)
2480                 free(mime_type);
2481
2482         return true;
2483
2484 }
2485
2486 int DFT_test(void)
2487 {
2488         int ret = MEDIA_CONTENT_ERROR_NONE;
2489         printf("\n============DFT_test============\n\n");
2490
2491         filter_h filter = NULL;
2492         int media_cnt = 0;
2493
2494         /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
2495
2496         ret = media_filter_create(&filter);
2497
2498 /*Internal Memory*/
2499         printf("[Internal Memory]\n");
2500         /*1. Photo ============================================================*/
2501         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
2502
2503         /*Get Photo Count*/
2504         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2505         printf("Photo count = [%d]\n", media_cnt);
2506
2507         /*Get Photo Size*/
2508         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2509         printf("Photo size = [%d]\n", g_total_photo_size);
2510
2511         /*2. Video ============================================================*/
2512         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
2513
2514         /*Get Video Count*/
2515         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2516         printf("Video count = [%d]\n", media_cnt);
2517
2518         /*Get Video Size*/
2519         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2520         printf("Video size = [%d]\n", g_total_video_size);
2521
2522         /*3. MP3 ============================================================*/
2523         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
2524
2525         /*Get MP3 Count*/
2526         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2527         printf("MP3 count = [%d]\n", media_cnt);
2528
2529         /*Get MP3 Size*/
2530         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2531         printf("MP3 size = [%d]\n", g_total_mp3_size);
2532
2533         /*4. Voice Memo ============================================================*/
2534         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);
2535
2536         /*Get Voice Memo Count*/
2537         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2538         printf("Voice Memo count = [%d]\n", media_cnt);
2539
2540         /*Get Voice Memo Size*/
2541         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2542         printf("Voice Memo size = [%d]\n", g_total_voice_memo_size);
2543
2544         g_total_photo_size = 0;
2545         g_total_video_size = 0;
2546         g_total_mp3_size = 0;
2547         g_total_voice_memo_size = 0;
2548
2549 /*External Memory*/
2550         printf("\n[External Memory]\n");
2551         /*1. Photo ============================================================*/
2552         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
2553
2554         /*Get Photo Count*/
2555         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2556         printf("Photo count = [%d]\n", media_cnt);
2557
2558         /*Get Photo Size*/
2559         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2560         printf("Photo size = [%d]\n", g_total_photo_size);
2561
2562         /*2. Video ============================================================*/
2563         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
2564
2565         /*Get Video Count*/
2566         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2567         printf("Video count = [%d]\n", media_cnt);
2568
2569         /*Get Video Size*/
2570         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2571         printf("Video size = [%d]\n", g_total_video_size);
2572
2573         /*3. MP3 ============================================================*/
2574         ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
2575
2576         /*Get MP3 Count*/
2577         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2578         printf("MP3 count = [%d]\n", media_cnt);
2579
2580         /*Get MP3 Size*/
2581         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2582         printf("MP3 size = [%d]\n", g_total_mp3_size);
2583
2584         /*4. Voice Memo ============================================================*/
2585         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);
2586
2587         /*Get Voice Memo Count*/
2588         ret = media_info_get_media_count_from_db(filter, &media_cnt);
2589         printf("Voice Memo count = [%d]\n", media_cnt);
2590
2591         /*Get Voice Memo Size*/
2592         ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
2593         printf("Voice Memo size = [%d]\n", g_total_voice_memo_size);
2594         ret = media_filter_destroy(filter);
2595
2596         return ret;
2597 }
2598
2599 void insert_batch_cb(media_content_error_e error, void * user_data)
2600 {
2601         printf("media_info_insert_batch_to_db completed!\n");
2602 }
2603
2604 int test_batch_operations()
2605 {
2606         int ret = -1;
2607         int i;
2608         char *file_list[10];
2609
2610         for (i = 0; i < 10; i++) {
2611                 char filepath[255] = {0,};
2612                 snprintf(filepath, sizeof(filepath), "%s%d.jpg", "/opt/usr/media/test/image", i+1);
2613                 media_content_debug("File : %s\n", filepath);
2614                 file_list[i] = strdup(filepath);
2615         }
2616
2617         ret = media_info_insert_batch_to_db((const char **)file_list, 10, insert_batch_cb, NULL);
2618         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2619                 media_content_error("media_info_insert_batch_to_db failed : %d\n", ret);
2620         }
2621
2622         filter_h filter;
2623         char *condition = "MEDIA_PATH LIKE \'/opt/usr/media/test/image%%jpg\'";
2624
2625         ret = media_filter_create(&filter);
2626         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2627                 media_content_error("Fail to create filter");
2628                 return ret;
2629         }
2630
2631         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
2632         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2633                 media_filter_destroy(filter);
2634                 media_content_error("Fail to set condition");
2635                 return ret;
2636         }
2637
2638         ret = media_info_delete_batch_from_db(filter);
2639         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2640                 media_filter_destroy(filter);
2641                 media_content_error("media_info_delete_batch_from_db failed : %d\n", ret);
2642                 return ret;
2643         }
2644
2645         ret = media_filter_destroy(filter);
2646
2647         return ret;
2648 }
2649
2650 void insert_burst_shot_cb(media_content_error_e error, void * user_data)
2651 {
2652         printf("media_info_insert_burst_shot_to_db completed![%d]\n", error);
2653         g_main_loop_quit(g_loop);
2654 }
2655
2656 gboolean test_insert_burst_shot_to_db_start(gpointer data)
2657 {
2658         int ret = MEDIA_CONTENT_ERROR_NONE;
2659         int i = 0;
2660         char *file_list[10];
2661
2662         for (i = 0; i < 10; i++) {
2663                 char filepath[255] = {0,};
2664                 snprintf(filepath, sizeof(filepath), "%s%d.jpg", "/opt/usr/media/test/image", i+1);
2665                 media_content_debug("File : %s\n", filepath);
2666                 file_list[i] = strdup(filepath);
2667         }
2668
2669         ret = media_info_insert_burst_shot_to_db((const char **)file_list, 10, insert_burst_shot_cb, NULL);
2670         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2671                 media_content_error("media_info_insert_burst_shot_to_db failed : %d\n", ret);
2672         }
2673
2674         return ret;
2675 }
2676
2677 int test_insert_burst_shot_to_db(void)
2678 {
2679         GSource *source = NULL;
2680         GMainContext *context = NULL;
2681
2682         g_loop = g_main_loop_new(NULL, FALSE);
2683         context = g_main_loop_get_context(g_loop);
2684         source = g_idle_source_new();
2685         g_source_set_callback (source, test_insert_burst_shot_to_db_start, NULL, NULL);
2686         g_source_attach (source, context);
2687
2688         g_main_loop_run(g_loop);
2689         g_main_loop_unref(g_loop);
2690
2691         return 0;
2692 }
2693
2694 void _scan_cb(media_content_error_e err, void *user_data)
2695 {
2696         printf("scan callback is called : %d\n", err);
2697         g_main_loop_quit(g_loop);
2698
2699         return;
2700 }
2701
2702 int test_scan_file()
2703 {
2704         int ret = -1;
2705
2706         const char *file_path = "/opt/usr/media/test/image1.jpg";
2707
2708         ret = media_content_scan_file(file_path);
2709         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2710                 media_content_error("Fail to media_content_scan_file : %d", ret);
2711                 return ret;
2712         }
2713
2714         return 0;
2715 }
2716
2717 gboolean test_scan_dir_start(gpointer data)
2718 {
2719         int ret = -1;
2720
2721         const char *dir_path = "/opt/usr/media";
2722
2723         ret = media_content_scan_folder(dir_path, TRUE, _scan_cb, NULL);
2724
2725         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2726                 media_content_error("Fail to media_content_scan_file : %d", ret);
2727                 return ret;
2728         }
2729
2730         return 0;
2731 }
2732
2733 int test_scan_dir()
2734 {
2735         GSource *source = NULL;
2736         GMainContext *context = NULL;
2737
2738         g_loop = g_main_loop_new(NULL, FALSE);
2739         context = g_main_loop_get_context(g_loop);
2740         source = g_idle_source_new();
2741         g_source_set_callback (source, test_scan_dir_start, NULL, NULL);
2742         g_source_attach (source, context);
2743
2744         g_main_loop_run(g_loop);
2745         g_main_loop_unref(g_loop);
2746
2747         return 0;
2748 }
2749
2750 void _noti_cb(media_content_error_e error,
2751                                 int pid,
2752                                 media_content_db_update_item_type_e update_item,
2753                                 media_content_db_update_type_e update_type,
2754                                 media_content_type_e media_type,
2755                                 char *uuid,
2756                                 char *path,
2757                                 char *mime_type,
2758                                 void *user_data)
2759 {
2760         if (error == 0) {
2761                 printf("noti success! : %d\n", error);
2762         } else {
2763                 printf("error occured! : %d\n", error);
2764         }
2765
2766         printf("Noti from PID(%d)\n", pid);
2767
2768         if (update_item == MEDIA_ITEM_FILE) {
2769                 printf("Noti item : MEDIA_ITEM_FILE\n");
2770         } else if (update_item == MEDIA_ITEM_DIRECTORY) {
2771                 printf("Noti item : MEDIA_ITEM_DIRECTORY\n");
2772         }
2773
2774         if (update_type == MEDIA_CONTENT_INSERT) {
2775                 printf("Noti type : MEDIA_CONTENT_INSERT\n");
2776         } else if (update_type == MEDIA_CONTENT_DELETE) {
2777                 printf("Noti type : MEDIA_CONTENT_DELETE\n");
2778         } else if (update_type == MEDIA_CONTENT_UPDATE) {
2779                 printf("Noti type : MEDIA_CONTENT_UPDATE\n");
2780         }
2781
2782         printf("content type : %d\n", media_type);
2783
2784         if (path)
2785                 printf("path : %s\n", path);
2786         else
2787                 printf("path not\n");
2788
2789         if (uuid)
2790                 printf("uuid : %s\n", uuid);
2791         else
2792                 printf("uuid not\n");
2793
2794         if (mime_type)
2795                 printf("mime_type : %s\n", mime_type);
2796         else
2797                 printf("mime not\n");
2798
2799         if (user_data) printf("String : %s\n", (char *)user_data);
2800
2801         //g_main_loop_quit(g_loop);
2802         return;
2803 }
2804
2805 gboolean _send_noti_operations(gpointer data)
2806 {
2807         int ret = MEDIA_CONTENT_ERROR_NONE;
2808
2809         /* First of all, noti subscription */
2810         char *user_str = strdup("hi");
2811         media_content_set_db_updated_cb(_noti_cb, (void*)user_str);
2812
2813         /* media_info_insert_to_db */
2814         media_info_h media_item = NULL;
2815         char *path = "/opt/usr/media/test/image1.jpg";
2816
2817         ret = media_info_insert_to_db(path, &media_item);
2818         if (ret < MEDIA_CONTENT_ERROR_NONE) {
2819                 media_content_error("media_info_insert_to_db failed : %d", ret);
2820                 return FALSE;
2821         }
2822
2823         media_content_debug("media_info_insert_to_db success");
2824
2825         /* media_info_delete_batch_from_db */
2826         filter_h filter;
2827         char *condition = "MEDIA_PATH LIKE \'/opt/usr/media/test/image%%jpg\'";
2828
2829         ret = media_filter_create(&filter);
2830         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2831                 media_content_error("Fail to create filter");
2832                 return ret;
2833         }
2834
2835         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
2836         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2837                 media_filter_destroy(filter);
2838                 media_content_error("Fail to set condition");
2839                 return ret;
2840         }
2841         ret = media_info_delete_batch_from_db(filter);
2842         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2843                 media_filter_destroy(filter);
2844                 media_content_error("media_info_delete_batch_from_db failed : %d\n", ret);
2845                 return ret;
2846         }
2847
2848         media_filter_destroy(filter);
2849
2850         /* media_info_update_to_db */
2851         ret = media_info_update_to_db(media_item);
2852         if(ret != MEDIA_CONTENT_ERROR_NONE) {
2853                 media_content_error("media_info_update_to_db failed : %d\n", ret);
2854                 return ret;
2855         }
2856
2857         return FALSE;
2858 }
2859
2860 int test_noti()
2861 {
2862         int ret = MEDIA_CONTENT_ERROR_NONE;
2863         GSource *source = NULL;
2864         GMainContext *context = NULL;
2865
2866         g_loop = g_main_loop_new(NULL, FALSE);
2867         context = g_main_loop_get_context(g_loop);
2868         source = g_idle_source_new();
2869         g_source_set_callback (source, _send_noti_operations, NULL, NULL);
2870         g_source_attach (source, context);
2871
2872         g_main_loop_run(g_loop);
2873         g_main_loop_unref(g_loop);
2874
2875         test_filter_destroy();
2876         media_content_unset_db_updated_cb();
2877
2878         return ret;
2879 }
2880
2881 int main(int argc, char *argv[])
2882 {
2883         int ret = MEDIA_CONTENT_ERROR_NONE;
2884
2885         media_content_debug("--- content manager test start ---\n\n");
2886
2887         ret = test_connect_database();
2888         if(ret != MEDIA_CONTENT_ERROR_NONE)
2889                 return MEDIA_CONTENT_ERROR_NONE;
2890
2891 #if 0
2892         ret = test_move();
2893         if(ret != MEDIA_CONTENT_ERROR_NONE)
2894                 return ret;
2895
2896         ret = test_gallery_scenario();
2897         if(ret != MEDIA_CONTENT_ERROR_NONE)
2898                 return ret;
2899
2900         ret = test_get_all_music_files();
2901         if(ret != MEDIA_CONTENT_ERROR_NONE)
2902                 return ret;
2903
2904         ret = test_media_info_operation();
2905         if(ret != MEDIA_CONTENT_ERROR_NONE)
2906                 return ret;
2907
2908         ret = test_folder_operation();
2909         if(ret != MEDIA_CONTENT_ERROR_NONE)
2910                 return ret;
2911
2912         ret = test_playlist_operation();
2913         if(ret != MEDIA_CONTENT_ERROR_NONE)
2914                 return ret;
2915
2916         ret = test_tag_operation();
2917         if(ret != MEDIA_CONTENT_ERROR_NONE)
2918                 return ret;
2919
2920         ret = test_bookmark_operation();
2921         if(ret != MEDIA_CONTENT_ERROR_NONE)
2922                 return ret;
2923
2924         ret = test_album_list();
2925         if(ret != MEDIA_CONTENT_ERROR_NONE)
2926                 return ret;
2927
2928         ret = test_group_operation();
2929         if(ret != MEDIA_CONTENT_ERROR_NONE)
2930                 return ret;
2931
2932         ret = test_update_operation();
2933         if(ret != MEDIA_CONTENT_ERROR_NONE)
2934                 return ret;
2935
2936         ret = test_insert();
2937         if(ret != MEDIA_CONTENT_ERROR_NONE)
2938                 return ret;
2939
2940         ret = test_move();
2941         if(ret != MEDIA_CONTENT_ERROR_NONE)
2942                 return ret;
2943
2944         ret = test_create_thumbnail(TRUE);
2945         if(ret != MEDIA_CONTENT_ERROR_NONE)
2946                 return ret;
2947
2948         ret = test_request_update_db();
2949         if(ret != MEDIA_CONTENT_ERROR_NONE)
2950                 return ret;
2951
2952         ret = DFT_test();
2953         if(ret != MEDIA_CONTENT_ERROR_NONE)
2954                 return ret;
2955
2956         ret = test_batch_operations();
2957         if(ret != MEDIA_CONTENT_ERROR_NONE)
2958                 return MEDIA_CONTENT_ERROR_NONE;
2959
2960         ret = test_insert_burst_shot_to_db();
2961         if(ret != MEDIA_CONTENT_ERROR_NONE)
2962                 return MEDIA_CONTENT_ERROR_NONE;
2963
2964         ret = test_scan_file();
2965         if(ret != MEDIA_CONTENT_ERROR_NONE)
2966                 return MEDIA_CONTENT_ERROR_NONE;
2967
2968         ret = test_scan_dir();
2969         if(ret != MEDIA_CONTENT_ERROR_NONE)
2970                 return MEDIA_CONTENT_ERROR_NONE;
2971
2972         ret = test_noti();
2973         if(ret != MEDIA_CONTENT_ERROR_NONE)
2974                 return MEDIA_CONTENT_ERROR_NONE;
2975 #endif
2976
2977         ret = test_disconnect_database();
2978         if(ret != MEDIA_CONTENT_ERROR_NONE)
2979                 return ret;
2980
2981         media_content_debug("--- content manager test end ---\n");
2982
2983         return ret;
2984 }