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