src/data/ge-local-data.c

   1 /*
   2 * Copyright (c) 2000-2015 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
  18 #include <stdio.h>
  19 #include <media_content.h>
  20 #include <media_info.h>
  21 #include <glib.h>
  22 #include <string.h>
  23 #include "ge-data-util.h"
  24 #include "ge-local-data.h"
  25 #include "ge-debug.h"
  26
  27 static bool __ge_local_data_clone_album(media_folder_h folder, bool b_path,
  28                                         ge_album_s **palbum)
  29 {
  30         GE_CHECK_FALSE(folder);
  31         GE_CHECK_FALSE(palbum);
  32         ge_album_s *album = NULL;
  33
  34         album = (ge_album_s *)calloc(1, sizeof(ge_album_s));
  35         if (album == NULL) {
  36                 ge_dbgE("Failed to calloc!");
  37                 return false;
  38         }
  39         album->gtype = GE_TYPE_ALBUM;
  40
  41         if (b_path) {
  42                 if (media_folder_get_path(folder, &(album->path)) != MEDIA_CONTENT_ERROR_NONE) {
  43                         ge_dbgE("Get folder path failed!");
  44                         goto GE_LOCAL_FAILED;
  45                 }
  46         }
  47         if (media_folder_get_folder_id(folder, &(album->uuid)) != MEDIA_CONTENT_ERROR_NONE) {
  48                 ge_dbgE("Get folder id failed!");
  49                 goto GE_LOCAL_FAILED;
  50         }
  51         if (media_folder_get_modified_time(folder, &(album->mtime)) != MEDIA_CONTENT_ERROR_NONE) {
  52                 ge_dbgE("Get modified time failed!");
  53                 goto GE_LOCAL_FAILED;
  54         }
  55
  56         media_content_storage_e storage_type;
  57         if (media_folder_get_storage_type(folder, &storage_type) != MEDIA_CONTENT_ERROR_NONE) {
  58                 ge_dbgE("Get storage type failed!");
  59                 goto GE_LOCAL_FAILED;
  60         }
  61
  62         if (storage_type == MEDIA_CONTENT_STORAGE_INTERNAL) { /* The device's internal storage */
  63                 album->type = GE_PHONE;
  64         } else if (storage_type == MEDIA_CONTENT_STORAGE_EXTERNAL) { /* The device's external storage */
  65                 album->type = GE_MMC;
  66         } else {
  67                 ge_dbgE("Undefined mode[%d]!", storage_type);
  68         }
  69
  70         if (media_folder_get_name(folder, &(album->display_name)) != MEDIA_CONTENT_ERROR_NONE) {
  71                 ge_dbgE("Get folder name failed!");
  72                 goto GE_LOCAL_FAILED;
  73         }
  74
  75         *palbum = album;
  76         return true;
  77
  78  GE_LOCAL_FAILED:
  79
  80         _ge_data_type_free_geitem((void **)(&album));
  81         *palbum = NULL;
  82         return false;
  83 }
  84
  85 static bool __ge_local_data_get_album_list_cb(media_folder_h folder,
  86                                               void *data)
  87 {
  88         GE_CHECK_FALSE(data);
  89         ge_transfer_data_s *tmp_data = (ge_transfer_data_s *)data;
  90         GE_CHECK_FALSE(tmp_data->userdata);
  91         GE_CHECK_FALSE(folder);
  92         Eina_List **elist = (Eina_List **)(tmp_data->userdata);
  93         ge_album_s *album = NULL;
  94
  95         char *path = NULL;
  96         if (media_folder_get_path(folder, &path) != MEDIA_CONTENT_ERROR_NONE) {
  97                 ge_dbgE("Get folder path failed!");
  98                 return false;
  99         }
 100         GE_CHECK_FALSE(path);
 101
 102         if (tmp_data->list_type != GE_ALBUM_LIST_PATH) {
 103                 if (!g_strcmp0(GE_CAMERA_PATH_PHONE, path) ||
 104                     !g_strcmp0(GE_CAMERA_PATH_MMC, path) ||
 105                     !g_strcmp0(GE_DOWNLOADS_PATH, path)) {
 106                         ge_dbgW("Camera or Downloads!");
 107                         GE_FREE(path);
 108                         return true;
 109                 }
 110         }
 111
 112         __ge_local_data_clone_album(folder, false, &album);
 113         if (album == NULL) {
 114                 GE_FREE(path);
 115                 ge_dbgE("Failed clone album!");
 116                 return false;
 117         }
 118         album->path = path;
 119
 120         *elist = eina_list_append(*elist, album);
 121         return true;
 122 }
 123
 124 static bool __ge_local_data_get_media_list_cb(media_info_h media, void *data)
 125 {
 126         GE_CHECK_FALSE(data);
 127         ge_transfer_data_s *td = (ge_transfer_data_s *)data;
 128         GE_CHECK_FALSE(td->userdata);
 129         GE_CHECK_FALSE(media);
 130         ge_media_s *item = NULL;
 131
 132         Eina_List **elist = (Eina_List **)(td->userdata);
 133
 134         if (_ge_data_util_clone_media(media, &item, td->with_meta)) {
 135                 *elist = eina_list_append(*elist, item);
 136                 return true;
 137         } else {
 138                 return false;
 139         }
 140 }
 141
 142 static bool __ge_local_data_get_cover_cb(media_info_h media, void *data)
 143 {
 144         GE_CHECK_FALSE(data);
 145         GE_CHECK_FALSE(media);
 146         Eina_List **elist = (Eina_List **)data;
 147         ge_media_s *item = NULL;
 148
 149         item = (ge_media_s *)calloc(1, sizeof(ge_media_s));
 150         GE_CHECK_FALSE(item);
 151         item->gtype = GE_TYPE_MEDIA;
 152
 153         if (media_info_clone(&(item->media_h), media) != MEDIA_CONTENT_ERROR_NONE) {
 154                 ge_dbgE("Clone media handle error");
 155                 goto GE_LOCAL_FAILED;
 156         }
 157         if (media_info_get_file_path(media, &(item->file_url)) != MEDIA_CONTENT_ERROR_NONE) {
 158                 ge_dbgE("Get media file path error");
 159                 goto GE_LOCAL_FAILED;
 160         }
 161         if (media_info_get_media_type(media, (media_content_type_e *)&(item->type)) != MEDIA_CONTENT_ERROR_NONE) {
 162                 ge_dbgE("Get media type error");
 163                 goto GE_LOCAL_FAILED;
 164         }
 165         if (media_info_get_thumbnail_path(media, &(item->thumb_url)) != MEDIA_CONTENT_ERROR_NONE) {
 166                 ge_dbgE("Get media thumbnail path error");
 167                 goto GE_LOCAL_FAILED;
 168         }
 169         ge_sdbg("thumb_url: %s", item->thumb_url);
 170         *elist = eina_list_append(*elist, item);
 171         return true;
 172
 173  GE_LOCAL_FAILED:
 174
 175         _ge_data_type_free_geitem((void **)(&item));
 176         return false;
 177 }
 178
 179 int _ge_local_data_connect(void)
 180 {
 181         int ret = -1;
 182
 183         ret = media_content_connect();
 184         if (ret == MEDIA_CONTENT_ERROR_NONE) {
 185                 ge_dbg("DB connection is success");
 186                 return 0;
 187         } else {
 188                 ge_dbgE("DB connection is failed!");
 189                 return -1;
 190         }
 191 }
 192
 193 int _ge_local_data_disconnect(void)
 194 {
 195         int ret = -1;
 196
 197         ret = media_content_disconnect();
 198         if (ret == MEDIA_CONTENT_ERROR_NONE) {
 199                 ge_dbg("DB disconnection is success");
 200                 return 0;
 201         } else {
 202                 ge_dbgE("DB disconnection is failed!");
 203                 return -1;
 204         }
 205 }
 206
 207 int _ge_local_data_get_media_by_id(char *media_id, ge_media_s **mitem)
 208 {
 209         GE_CHECK_VAL(mitem, -1);
 210
 211         if (media_id == NULL) {
 212                 //ge_dbg("Create a empty media");
 213                 _ge_data_type_new_media(mitem);
 214                 return 0;
 215         }
 216
 217         int ret = -1;
 218         Eina_List *list = NULL;
 219         ge_media_s *_mitem = NULL;
 220         media_info_h media_h = NULL;
 221         int i = 0;
 222         ge_sdbg("media id: %s", media_id);
 223
 224         ret = media_info_get_media_from_db(media_id, &media_h);
 225         if (ret != MEDIA_CONTENT_ERROR_NONE || media_h == NULL) {
 226                 ge_dbgE("Failed to get media handle[%d]!", ret);
 227                 if (media_h)
 228                         media_info_destroy(media_h);
 229                 return -1;
 230         }
 231
 232         ge_transfer_data_s tran_data;
 233         memset(&tran_data, 0x00, sizeof(ge_transfer_data_s));
 234         tran_data.userdata = (void **)&list;
 235         tran_data.album_id = NULL;
 236         tran_data.with_meta = false;
 237
 238         bool b_ret = __ge_local_data_get_media_list_cb(media_h, &tran_data);
 239
 240         media_info_destroy(media_h);
 241
 242         if (b_ret && list) {
 243                 *mitem = eina_list_nth(list, 0);
 244                 i = 1;
 245                 ret = 0;
 246         } else {
 247                 ge_dbgE("Failed to get media list!");
 248                 ret = -1;
 249         }
 250
 251         /* Free other items */
 252         if (list) {
 253                 int len = eina_list_count(list);
 254                 ge_dbg("len: %d", len);
 255
 256                 for (; i < len; i++) {
 257                         _mitem = eina_list_nth(list, i);
 258                         _ge_data_type_free_geitem((void **)(&_mitem));
 259                 }
 260
 261                 eina_list_free(list);
 262         }
 263
 264         return ret;
 265 }
 266
 267 int _ge_local_data_get_album_by_path(char *path, ge_album_s **album)
 268 {
 269         GE_CHECK_VAL(path, -1);
 270         GE_CHECK_VAL(album, -1);
 271         int ret = -1;
 272         Eina_List *list = NULL;
 273         ge_filter_s condition;
 274         ge_album_s *_item = NULL;
 275         int i = 0;
 276
 277         if (strlen(path) <=0) {
 278                 ge_dbgE("Invalid path!");
 279                 return -1;
 280         }
 281         ge_dbg("path: %s", path);
 282
 283         memset(&condition, 0x00, sizeof(ge_filter_s));
 284         condition.collate_type = MEDIA_CONTENT_COLLATE_NOCASE;
 285         condition.sort_type = MEDIA_CONTENT_ORDER_DESC;
 286         condition.offset = -1;
 287         condition.count = -1;
 288         condition.with_meta = false;
 289         condition.list_type = GE_ALBUM_LIST_PATH;
 290
 291         snprintf(condition.cond, CONDITION_LENGTH, "%s AND %s=\'%s\'",
 292                  GE_CONDITION_IMAGE_VIDEO, FOLDER_PATH, path);
 293
 294         ret = _ge_local_data_get_album_list(&condition, &list);
 295         if (ret != 0 || NULL == list) {
 296                 ge_dbgE("Failed to get album list[%d]!", ret);
 297                 ret = -1;
 298         } else if (NULL != list) {
 299                 *album = eina_list_nth(list, 0);
 300                 i = 1;
 301                 ret = 0;
 302         }
 303
 304         /* Free other items */
 305         if (list) {
 306                 int len = eina_list_count(list);
 307                 ge_dbg("len: %d", len);
 308
 309                 for (; i < len; i++) {
 310                         _item = eina_list_nth(list, i);
 311                         _ge_data_type_free_geitem((void **)(&_item));
 312                 }
 313
 314                 eina_list_free(list);
 315         }
 316
 317         return ret;
 318 }
 319
 320 int _ge_local_data_get_album_list(ge_filter_s *condition, Eina_List **elilst)
 321 {
 322         GE_CHECK_VAL(elilst, -1);
 323         GE_CHECK_VAL(condition, -1);
 324         int ret = -1;
 325         filter_h filter = NULL;
 326
 327         ret = _ge_data_util_create_filter(condition, &filter);
 328         if (ret != 0) {
 329                 ge_dbgE("Create filter failed[%d]!", ret);
 330                 return -1;
 331         }
 332
 333         ge_transfer_data_s tran_data;
 334         memset(&tran_data, 0x00, sizeof(ge_transfer_data_s));
 335         tran_data.userdata = (void **)elilst;
 336         tran_data.album_id = NULL;
 337         tran_data.with_meta = false;
 338         tran_data.list_type = condition->list_type;
 339
 340         ge_dbg("Get folders--start");
 341         ret = media_folder_foreach_folder_from_db(filter,
 342                                                   __ge_local_data_get_album_list_cb,
 343                                                   &tran_data);
 344         ge_dbg("Get folders--over");
 345
 346         _ge_data_util_destroy_filter(filter);
 347
 348         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 349                 ge_dbgE("Get folders failed[%d]!", ret);
 350                 return -1;
 351         }
 352
 353         return 0;
 354 }
 355
 356 int _ge_local_data_get_media_count(const char *cluster_id, ge_filter_s *condition,
 357                                    int *item_cnt)
 358 {
 359         GE_CHECK_VAL(cluster_id, -1);
 360         GE_CHECK_VAL(condition, -1);
 361         GE_CHECK_VAL(item_cnt, -1);
 362         int ret = -1;
 363         filter_h filter = NULL;
 364
 365         ret = _ge_data_util_create_filter(condition, &filter);
 366         if (ret != 0) {
 367                 ge_dbgE("Create filter failed[%d]!", ret);
 368                 return -1;
 369         }
 370
 371         ge_dbg("Get media count--start");
 372         ret = media_folder_get_media_count_from_db(cluster_id, filter,
 373                                                    item_cnt);
 374         ge_dbg("Get media count--over");
 375
 376         _ge_data_util_destroy_filter(filter);
 377
 378         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 379                 ge_dbgE("Get media count failed[d]!", ret);
 380                 return -1;
 381         }
 382
 383         return 0;
 384 }
 385
 386 int _ge_local_data_get_all_media_count(ge_filter_s *condtion, int *item_cnt)
 387 {
 388         GE_CHECK_VAL(condtion, -1);
 389         GE_CHECK_VAL(item_cnt, -1);
 390         int ret = -1;
 391         filter_h filter = NULL;
 392
 393         ret = _ge_data_util_create_filter(condtion, &filter);
 394         if (ret != 0) {
 395                 ge_dbgE("Create filter failed[%d]!", ret);
 396                 return -1;
 397         }
 398
 399         ge_dbg("Get media count--start");
 400         ret = media_info_get_media_count_from_db(filter, item_cnt);
 401         ge_dbg("Get media count--over");
 402
 403         _ge_data_util_destroy_filter(filter);
 404
 405         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 406                 ge_dbgE("Get media count failed[d]!", ret);
 407                 return -1;
 408         }
 409
 410         return 0;
 411 }
 412
 413 int _ge_local_data_get_media(const char *media_id, ge_media_s **mitem)
 414 {
 415         GE_CHECK_VAL(mitem, -1);
 416
 417         if (media_id == NULL) {
 418                 ge_dbg("Create a empty media");
 419                 _ge_data_type_new_media(mitem);
 420                 return 0;
 421         }
 422
 423         int ret = -1;
 424         Eina_List *list = NULL;
 425         ge_media_s *_mitem = NULL;
 426         int i = 0;
 427
 428         ge_sdbg("media id: %s", media_id);
 429         media_info_h media_h = NULL;
 430
 431         ret = media_info_get_media_from_db(media_id, &media_h);
 432         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 433                 ge_dbgE("Get media handle failed[%d]!", ret);
 434                 if (media_h)
 435                         media_info_destroy(media_h);
 436                 return -1;
 437         }
 438
 439         ge_transfer_data_s tran_data;
 440         memset(&tran_data, 0x00, sizeof(ge_transfer_data_s));
 441         tran_data.userdata = (void **)&list;
 442         tran_data.album_id = NULL;
 443         tran_data.with_meta = false;
 444
 445         ge_dbg("Get media list--start");
 446         bool b_ret = __ge_local_data_get_media_list_cb(media_h, &tran_data);
 447         ge_dbg("Get media list--over");
 448
 449         media_info_destroy(media_h);
 450
 451         if (b_ret && list) {
 452                 *mitem = eina_list_nth(list, 0);
 453                 i = 1;
 454                 ret = 0;
 455         } else {
 456                 ge_dbgE("Failed to get media list!");
 457                 ret = -1;
 458         }
 459
 460         /* Free other items */
 461         if (list) {
 462                 int len = eina_list_count(list);
 463                 ge_dbg("len: %d", len);
 464
 465                 for (; i < len; i++) {
 466                         _mitem = eina_list_nth(list, i);
 467                         _ge_data_type_free_geitem((void **)(&_mitem));
 468                 }
 469
 470                 eina_list_free(list);
 471         }
 472
 473         return ret;
 474 }
 475
 476 int _ge_local_data_get_album_cover(char *album_id, ge_filter_s *condition,
 477                                    Eina_List **elist)
 478 {
 479         GE_CHECK_VAL(elist, -1);
 480         GE_CHECK_VAL(album_id, -1);
 481         GE_CHECK_VAL(condition, -1);
 482         int ret = -1;
 483         filter_h filter = NULL;
 484
 485         ret = _ge_data_util_create_filter(condition, &filter);
 486         if (ret != 0) {
 487                 ge_dbgE("Create filter failed!");
 488                 return -1;
 489         }
 490
 491         ge_dbg("Get medias--start");
 492         ret = media_folder_foreach_media_from_db(album_id, filter,
 493                                                  __ge_local_data_get_cover_cb,
 494                                                  elist);
 495         ge_dbg("Get medias--over");
 496
 497         _ge_data_util_destroy_filter(filter);
 498
 499         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 500                 ge_dbgE("Get medias failed[d]!", ret);
 501                 return -1;
 502         }
 503
 504         return 0;
 505 }
 506
 507 int _ge_local_data_get_all_albums_cover(ge_filter_s *condition,
 508                                         Eina_List **elist)
 509 {
 510         GE_CHECK_VAL(elist, -1);
 511         GE_CHECK_VAL(condition, -1);
 512         int ret = -1;
 513         filter_h filter = NULL;
 514
 515         ret = _ge_data_util_create_filter(condition, &filter);
 516         if (ret != 0) {
 517                 ge_dbgE("Create filter failed!");
 518                 return -1;
 519         }
 520
 521         ge_dbg("Get all medias--start");
 522         ret = media_info_foreach_media_from_db(filter,
 523                                                __ge_local_data_get_cover_cb,
 524                                                elist);
 525         ge_dbg("Get all medias--over");
 526
 527         _ge_data_util_destroy_filter(filter);
 528
 529        if (ret != MEDIA_CONTENT_ERROR_NONE) {
 530                ge_dbgE("Get all medias failed[d]!", ret);
 531                return -1;
 532        }
 533
 534        return 0;
 535 }
 536
 537 int _ge_local_data_get_album_media_list(char *album_id, ge_filter_s *condition,
 538                                         Eina_List **elist)
 539 {
 540         GE_CHECK_VAL(elist, -1);
 541         GE_CHECK_VAL(album_id, -1);
 542         GE_CHECK_VAL(condition, -1);
 543         int ret = -1;
 544         filter_h filter = NULL;
 545
 546         ret = _ge_data_util_create_filter(condition, &filter);
 547         if (ret != 0) {
 548                 ge_dbgE("Create filter failed!");
 549                 return -1;
 550         }
 551
 552         ge_transfer_data_s tran_data;
 553         memset(&tran_data, 0x00, sizeof(ge_transfer_data_s));
 554         tran_data.userdata = (void **)elist;
 555         tran_data.album_id = album_id;
 556         tran_data.with_meta = condition->with_meta;
 557
 558         ge_dbg("Get medias--start");
 559         ret = media_folder_foreach_media_from_db(album_id, filter,
 560                                                                  __ge_local_data_get_media_list_cb,
 561                                                                  &tran_data);
 562         ge_dbg("Get medias--over");
 563
 564         _ge_data_util_destroy_filter(filter);
 565
 566         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 567                 ge_dbgE("Get medias failed[d]!", ret);
 568                 return -1;
 569         }
 570
 571         return 0;
 572 }
 573
 574 int _ge_local_data_get_all_albums_media_list(ge_filter_s *condition,
 575                                              Eina_List **elist)
 576 {
 577         GE_CHECK_VAL(elist, -1);
 578         GE_CHECK_VAL(condition, -1);
 579         int ret = -1;
 580         filter_h filter = NULL;
 581
 582         ret = _ge_data_util_create_filter(condition, &filter);
 583         if (ret != 0) {
 584                 ge_dbgE("Create filter failed!");
 585                 return -1;
 586         }
 587
 588         ge_transfer_data_s tran_data;
 589         memset(&tran_data, 0x00, sizeof(ge_transfer_data_s));
 590         tran_data.userdata = (void **)elist;
 591         tran_data.album_id = NULL;
 592         tran_data.with_meta = condition->with_meta;
 593
 594         ge_dbg("Get all medias--start");
 595         ret = media_info_foreach_media_from_db(filter,
 596                                                                __ge_local_data_get_media_list_cb,
 597                                                                &tran_data);
 598         ge_dbg("Get all medias--over");
 599
 600         _ge_data_util_destroy_filter(filter);
 601
 602        if (ret != MEDIA_CONTENT_ERROR_NONE) {
 603                ge_dbgE("Get all medias failed[d]!", ret);
 604                return -1;
 605        }
 606
 607        return 0;
 608 }
 609
 610 int _ge_local_data_get_album_by_id(char *album_id, ge_album_s **cluster)
 611 {
 612         GE_CHECK_VAL(cluster, -1);
 613         GE_CHECK_VAL(album_id, -1);
 614         media_folder_h folder_h = NULL;
 615
 616         if (media_folder_get_folder_from_db(album_id, &folder_h) != MEDIA_CONTENT_ERROR_NONE) {
 617                 ge_sdbgE("Failed to get album[%s]!", album_id);
 618                 if (folder_h)
 619                         media_folder_destroy(folder_h);
 620                 return -1;
 621         }
 622         if (folder_h == NULL)
 623                 return -1;
 624         if (!__ge_local_data_clone_album(folder_h, true, cluster)) {
 625                 ge_sdbgE("Failed to clone album[%s]!", album_id);
 626                 media_folder_destroy(folder_h);
 627                 return -1;
 628         }
 629         media_folder_destroy(folder_h);
 630         return 0;
 631 }
 632
 633 int _ge_local_data_get_duration(media_info_h media, int *duration)
 634 {
 635         GE_CHECK_VAL(duration, -1);
 636         GE_CHECK_VAL(media, -1);
 637         video_meta_h video_handle = NULL;
 638         int ret = -1;
 639
 640         ret = media_info_get_video(media, &video_handle);
 641         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 642                 ge_dbgE("Failed to get video handle[%d]!", ret);
 643                 return -1;
 644         }
 645
 646         ret = video_meta_get_duration(video_handle, duration);
 647         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 648                 ge_dbgE("Get video duration failed[%d]!", ret);
 649                 video_meta_destroy(video_handle);
 650                 return -1;
 651         }
 652
 653         video_meta_destroy(video_handle);
 654         return 0;
 655 }
 656