src/common/mf-media-content.c

   1 /*
   2  * Copyright 2013         Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 <media_content.h>
  19
  20 #include "mf-dlog.h"
  21 #include "mf-util.h"
  22 #include "mf-media-content.h"
  23
  24 mf_condition_s *mf_media_content_condition_create(const char *condition)
  25 {
  26         mf_condition_s *filter = NULL;
  27
  28         filter = (mf_condition_s *)calloc(1, sizeof(mf_condition_s));
  29
  30         if (filter == NULL) {
  31                 return NULL;
  32         }
  33
  34         memset(filter, 0, sizeof(mf_condition_s));
  35
  36         mf_debug("condition [%s]", condition);
  37         filter->cond = condition;
  38         filter->collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
  39         filter->sort_type = MEDIA_CONTENT_ORDER_DESC;
  40         filter->sort_keyword = MEDIA_MODIFIED_TIME;
  41         filter->with_meta = true;
  42
  43         return filter;
  44 }
  45
  46 void mf_media_conte_free_condition(mf_condition_s **condition)
  47 {
  48         mf_retm_if(condition == NULL, "condition is NULL");
  49         if (*condition) {
  50                 SAFE_FREE_CHAR((*condition)->cond);
  51                 SAFE_FREE_CHAR(*condition);
  52         }
  53 }
  54
  55 int mf_media_content_create_filter(filter_h *filter, mf_condition_s *condition)
  56 {
  57         mf_retvm_if(filter == NULL, -1, "filter is NULL");
  58         mf_retvm_if(condition == NULL, -1, "condition is NULL");
  59
  60         int ret = MEDIA_CONTENT_ERROR_NONE;
  61         filter_h tmp_filter = NULL;
  62         ret = media_filter_create(&tmp_filter);
  63         if(ret != MEDIA_CONTENT_ERROR_NONE) {
  64                 mf_debug("Fail to create filter");
  65                 return ret;
  66         }
  67         if (condition->cond) {
  68                 ret = media_filter_set_condition(tmp_filter, condition->cond,
  69                                                  condition->collate_type);
  70                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
  71                         mf_debug("Fail to set condition");
  72                         goto ERROR;
  73                 }
  74         }
  75
  76         if (condition->sort_keyword) {
  77                 ret = media_filter_set_order(tmp_filter, condition->sort_type,
  78                                              condition->sort_keyword,
  79                                              condition->collate_type);
  80                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
  81                         mf_debug("Fail to set order");
  82                         goto ERROR;
  83                 }
  84         }
  85
  86         mf_debug("offset is %d, count is %d", condition->offset, condition->count);
  87         if (condition->offset != -1 && condition->count != -1 &&
  88             condition->count > condition->offset) {
  89                 ret = media_filter_set_offset(tmp_filter, condition->offset,
  90                                               condition->count);
  91                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
  92                         mf_debug("Fail to set offset");
  93                         goto ERROR;
  94                 }
  95         }
  96         *filter = tmp_filter;
  97         return ret;
  98  ERROR:
  99         if (tmp_filter) {
 100                 media_filter_destroy(tmp_filter);
 101                 tmp_filter = NULL;
 102         }
 103         return ret;
 104 }
 105
 106 int mf_media_content_destroy_filter(filter_h filter)
 107 {
 108         mf_retvm_if(filter == NULL, -1, "filter is NULL");
 109         int ret = MEDIA_CONTENT_ERROR_NONE;
 110         ret = media_filter_destroy(filter);
 111
 112         return ret;
 113 }
 114
 115 int mf_media_content_data_get(void *data, char *condition, bool (*func) (media_info_h media, void *data))
 116 {
 117
 118         mf_condition_s *temp_condition = NULL;
 119         filter_h filter = NULL;
 120         temp_condition = mf_media_content_condition_create(condition);
 121
 122         int ret = -1;
 123         ret = mf_media_content_create_filter(&filter, temp_condition);
 124
 125         if (ret != 0) {
 126                 mf_debug("Create filter failed");
 127                 mf_media_conte_free_condition(&temp_condition);
 128                 return ret;
 129         }
 130
 131
 132         ret = media_info_foreach_media_from_db(filter,
 133                                                (media_info_cb)func,
 134                                                data);
 135         if (ret != 0) {
 136                 mf_debug("media_info_foreach_media_from_db failed: %d", ret);
 137         } else {
 138                 mf_debug("media_info_foreach_media_from_db success!", ret);
 139         }
 140
 141         mf_media_content_destroy_filter(filter);
 142         mf_media_conte_free_condition(&temp_condition);
 143
 144         return ret;
 145
 146 }
 147
 148 void mf_media_content_scan_file(const char *path)
 149 {
 150         mf_retm_if(path == NULL, "path is NULL");
 151
 152         media_content_scan_file(path);
 153 }
 154
 155 void mf_media_content_scan_folder(const char *path)
 156 {
 157         mf_retm_if(path == NULL, "path is NULL");
 158
 159         media_content_scan_folder(path, NULL, NULL);
 160 }
 161