src/media_filter.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
  18 #include <media_info_private.h>
  19 #include <media_util_private.h>
  20 #include <vconf.h>
  21
  22 static bool __is_pinyin_needed(void)
  23 {
  24         char *lang = NULL;
  25         const char *china = "zh_CN";
  26         const char *hongkong = "zh_HK";
  27         int ret = FALSE;
  28
  29         /*Check CSC first*/
  30         bool pinyin_support = FALSE;
  31         media_svc_check_pinyin_support(&pinyin_support);
  32         if (pinyin_support) {
  33                 /*Check Language Setting*/
  34                 lang = vconf_get_str(VCONFKEY_LANGSET);
  35                 content_retvm_if(lang == NULL, ret, "Fail to get string of language set");
  36
  37                 if ((strncmp(china, lang, strlen(china)) == 0) ||
  38                         (strncmp(hongkong, lang, strlen(hongkong)) == 0)) {
  39                         ret = TRUE;
  40                 }
  41
  42                 SAFE_FREE(lang);
  43         }
  44
  45         return ret;
  46 }
  47
  48 static const char *__get_order_str(media_content_order_e order_enum)
  49 {
  50         switch (order_enum) {
  51         case MEDIA_CONTENT_ORDER_ASC:
  52                 return "ASC ";
  53         case MEDIA_CONTENT_ORDER_DESC:
  54                 return "DESC ";
  55         default:
  56                 return " ";
  57         }
  58 }
  59
  60 static const char *__get_collate_str(media_content_collation_e collate_type)
  61 {
  62         switch (collate_type) {
  63         case MEDIA_CONTENT_COLLATE_NOCASE:
  64                 return " COLLATE NOCASE ";
  65         case MEDIA_CONTENT_COLLATE_RTRIM:
  66                 return " COLLATE RTRIM ";
  67         case MEDIA_CONTENT_COLLATE_LOCALIZED:
  68                 if (__is_pinyin_needed())
  69                         return " COLLATE NOCASE ";
  70                 else
  71                         return " COLLATE localized ";
  72         default:
  73                 return " ";
  74         }
  75 }
  76
  77 static bool __check_collate_type(media_content_collation_e collate_type)
  78 {
  79         switch (collate_type) {
  80         case MEDIA_CONTENT_COLLATE_DEFAULT:
  81         case MEDIA_CONTENT_COLLATE_NOCASE:
  82         case MEDIA_CONTENT_COLLATE_RTRIM:
  83         case MEDIA_CONTENT_COLLATE_LOCALIZED:
  84                 return true;
  85         default:
  86                 return false;
  87         }
  88 }
  89
  90 static bool __check_order_type(media_content_order_e order)
  91 {
  92         switch (order) {
  93         case MEDIA_CONTENT_ORDER_ASC:
  94         case MEDIA_CONTENT_ORDER_DESC:
  95         case MEDIA_CONTENT_ORDER_OTHER:
  96                 return true;
  97         default:
  98                 return false;
  99         }
 100 }
 101
 102 int _media_filter_build_condition(bool is_full, const char *condition, media_content_collation_e collate_type, char **result)
 103 {
 104         content_retip_if_fail(condition);
 105         content_retip_if_fail(__check_collate_type(collate_type));
 106         content_retip_if_fail(result);
 107
 108         if (is_full)
 109                 *result = g_strdup_printf("(%s)", condition);
 110         else
 111                 *result = g_strdup_printf("(%s%s)", condition, __get_collate_str(collate_type));
 112
 113         content_sec_debug("Condition : %s", *result);
 114
 115         return MEDIA_CONTENT_ERROR_NONE;
 116 }
 117
 118 int _media_filter_build_option(filter_h filter, char **result)
 119 {
 120         filter_s *_filter = (filter_s *)filter;
 121
 122         content_retip_if_fail(filter);
 123         content_retip_if_fail(result);
 124
 125         if (!STRING_VALID(_filter->order_keyword)) {
 126                 *result = g_strdup_printf(" LIMIT %d, %d", _filter->offset, _filter->count);
 127                 return MEDIA_CONTENT_ERROR_NONE;
 128         }
 129
 130         if (_filter->is_full_order) {
 131                 *result = g_strdup_printf("ORDER BY %s LIMIT %d, %d", _filter->order_keyword, _filter->offset, _filter->count);
 132                 return MEDIA_CONTENT_ERROR_NONE;
 133         }
 134
 135         if (_filter->order_type == MEDIA_CONTENT_ORDER_ASC || _filter->order_type == MEDIA_CONTENT_ORDER_DESC) {
 136                 *result = g_strdup_printf("ORDER BY %s%s%s LIMIT %d, %d",
 137                         _filter->order_keyword,
 138                         __get_collate_str(_filter->order_collate_type),
 139                         __get_order_str(_filter->order_type),
 140                         _filter->offset,
 141                         _filter->count);
 142         } else {
 143                 *result = g_strdup_printf("%s LIMIT %d, %d", _filter->order_keyword, _filter->offset, _filter->count);
 144         }
 145
 146         return MEDIA_CONTENT_ERROR_NONE;
 147 }
 148
 149 int media_filter_create(filter_h *filter)
 150 {
 151         int ret = MEDIA_CONTENT_ERROR_NONE;
 152
 153         content_retip_if_fail(filter);
 154
 155         filter_s *_filter = g_new0(filter_s, 1);
 156
 157         _filter->storage_id = NULL;
 158         _filter->condition = NULL;
 159         _filter->order_keyword = NULL;
 160         _filter->order_type = -1;
 161         _filter->condition_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
 162         _filter->order_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
 163         _filter->offset = -1;
 164         _filter->count = -1;
 165         _filter->is_full_condition = false;
 166         _filter->is_full_order = false;
 167
 168         *filter = (filter_h)_filter;
 169
 170         return ret;
 171 }
 172
 173 int media_filter_destroy(filter_h filter)
 174 {
 175         filter_s *_filter = (filter_s *)filter;
 176
 177         content_retip_if_fail(filter);
 178
 179         g_free(_filter->storage_id);
 180         g_free(_filter->condition);
 181         g_free(_filter->order_keyword);
 182         g_free(_filter);
 183
 184         return MEDIA_CONTENT_ERROR_NONE;
 185 }
 186
 187 int media_filter_set_offset(filter_h filter, int offset, int count)
 188 {
 189         filter_s *_filter = (filter_s *)filter;
 190
 191         content_retip_if_fail(filter);
 192
 193         _filter->offset = offset;
 194         _filter->count = count;
 195
 196         return MEDIA_CONTENT_ERROR_NONE;
 197 }
 198
 199 int media_filter_set_condition(filter_h filter, const char *condition, media_content_collation_e collate_type)
 200 {
 201         int ret = MEDIA_CONTENT_ERROR_NONE;
 202         filter_s *_filter = (filter_s *)filter;
 203
 204         content_retip_if_fail(filter);
 205         content_retip_if_fail(STRING_VALID(condition));
 206         content_retip_if_fail(__check_collate_type(collate_type));
 207
 208         _filter->is_full_condition = false;
 209         g_free(_filter->condition);
 210
 211         _filter->condition = _media_content_replace_path_in_condition(condition);
 212
 213         /* FIXME
 214                 If an error is occured in _media_content_replace_path_in_condition(),
 215                 A suitable return value is 'MEDIA_CONTENT_ERROR_INVALID_OPERATION'.
 216                 However, it is not stated in the description of media_filter_set_condition().
 217                 Therefore, use 'MEDIA_CONTENT_ERROR_OUT_OF_MEMORY' temporarily.
 218                 It will be modified after removing _media_content_replace_path_in_condition() function.
 219         */
 220         content_retvm_if(_filter->condition == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "Fail to set condition");
 221
 222         content_sec_debug("Condition string : %s", _filter->condition);
 223
 224         _filter->condition_collate_type = collate_type;
 225
 226         return ret;
 227 }
 228
 229 int media_filter_set_order(filter_h filter, media_content_order_e order_type, const char *order_keyword, media_content_collation_e collate_type)
 230 {
 231         filter_s *_filter = (filter_s *)filter;
 232
 233         content_retip_if_fail(filter);
 234         content_retip_if_fail(STRING_VALID(order_keyword));
 235         content_retip_if_fail(__check_order_type(order_type));
 236         content_retip_if_fail(__check_collate_type(collate_type));
 237
 238         _filter->is_full_order = false;
 239
 240         g_free(_filter->order_keyword);
 241
 242         _filter->order_keyword = g_strdup(order_keyword);
 243         _filter->order_type = order_type;
 244         _filter->order_collate_type = collate_type;
 245
 246         return MEDIA_CONTENT_ERROR_NONE;
 247 }
 248
 249 int media_filter_set_storage(filter_h filter, const char *storage_id)
 250 {
 251         content_warn("DEPRECATION WARNING: media_filter_set_storage() is deprecated and will be removed from next release. Use media_filter_set_condition() with MEDIA_PATH keyword instead.");
 252         filter_s *_filter = (filter_s *)filter;
 253
 254         content_retip_if_fail(filter);
 255         content_retip_if_fail(STRING_VALID(storage_id));
 256
 257         g_free(_filter->storage_id);
 258         _filter->storage_id = g_strdup(storage_id);
 259
 260         content_sec_debug("storage_id : %s", _filter->storage_id);
 261
 262         return MEDIA_CONTENT_ERROR_NONE;
 263 }
 264
 265 int media_filter_get_offset(filter_h filter, int *offset, int *count)
 266 {
 267         filter_s *_filter = (filter_s *)filter;
 268
 269         content_retip_if_fail(filter);
 270         content_retip_if_fail(offset);
 271         content_retip_if_fail(count);
 272
 273         *offset = _filter->offset;
 274         *count = _filter->count;
 275
 276         return MEDIA_CONTENT_ERROR_NONE;
 277 }
 278
 279 int media_filter_get_condition(filter_h filter, char **condition, media_content_collation_e *collate_type)
 280 {
 281         filter_s *_filter = (filter_s *)filter;
 282
 283         content_retip_if_fail(filter);
 284         content_retip_if_fail(condition);
 285         content_retip_if_fail(collate_type);
 286
 287         if (!_filter->is_full_condition)
 288                 *condition = g_strdup(_filter->condition);
 289
 290         *collate_type = _filter->condition_collate_type;
 291
 292         return MEDIA_CONTENT_ERROR_NONE;
 293 }
 294
 295 int media_filter_get_order(filter_h filter, media_content_order_e *order_type, char **order_keyword, media_content_collation_e *collate_type)
 296 {
 297         filter_s *_filter = (filter_s *)filter;
 298
 299         content_retip_if_fail(filter);
 300         content_retip_if_fail(order_type);
 301         content_retip_if_fail(order_keyword);
 302         content_retip_if_fail(collate_type);
 303
 304         if (!_filter->is_full_order)
 305                 *order_keyword = g_strdup(_filter->order_keyword);
 306
 307         *order_type = _filter->order_type;
 308         *collate_type = _filter->order_collate_type;
 309
 310         return MEDIA_CONTENT_ERROR_NONE;
 311 }
 312
 313 int media_filter_get_storage(filter_h filter, char **storage_id)
 314 {
 315         content_warn("DEPRECATION WARNING: media_filter_get_storage() is deprecated and will be removed from next release.");
 316         filter_s *_filter = (filter_s *)filter;
 317
 318         content_retip_if_fail(filter);
 319         content_retip_if_fail(storage_id);
 320
 321         *storage_id = g_strdup(_filter->storage_id);
 322
 323         return MEDIA_CONTENT_ERROR_NONE;
 324 }
 325
 326 int media_filter_set_condition_v2(filter_h filter, const char *condition)
 327 {
 328         filter_s *_filter = (filter_s *)filter;
 329
 330         content_retip_if_fail(filter);
 331         content_retip_if_fail(STRING_VALID(condition));
 332
 333         _filter->is_full_condition = true;
 334
 335         g_free(_filter->condition);
 336
 337         /* FIXME
 338                 If an error is occured in _media_content_replace_path_in_condition(),
 339                 A suitable return value is 'MEDIA_CONTENT_ERROR_INVALID_OPERATION'.
 340                 However, it is not stated in the description of media_filter_set_condition().
 341                 Therefore, use 'MEDIA_CONTENT_ERROR_OUT_OF_MEMORY' temporarily.
 342                 It will be modified after removing _media_content_replace_path_in_condition() function.
 343         */
 344         _filter->condition = _media_content_replace_path_in_condition(condition);
 345         content_retvm_if(_filter->condition == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "Fail to set condition");
 346
 347         content_sec_debug("Condition string : %s", _filter->condition);
 348
 349         return MEDIA_CONTENT_ERROR_NONE;
 350 }
 351
 352 int media_filter_get_condition_v2(filter_h filter, char **condition)
 353 {
 354         filter_s *_filter = (filter_s *)filter;
 355
 356         content_retip_if_fail(filter);
 357         content_retip_if_fail(condition);
 358
 359         if (_filter->is_full_condition)
 360                 *condition = g_strdup(_filter->condition);
 361
 362         return MEDIA_CONTENT_ERROR_NONE;
 363 }
 364
 365 int media_filter_set_order_v2(filter_h filter, const char *order)
 366 {
 367         filter_s *_filter = (filter_s *)filter;
 368
 369         content_retip_if_fail(filter);
 370         content_retip_if_fail(STRING_VALID(order));
 371
 372         _filter->is_full_order = true;
 373
 374         g_free(_filter->order_keyword);
 375         _filter->order_keyword = g_strdup(order);
 376
 377         return MEDIA_CONTENT_ERROR_NONE;
 378 }
 379
 380 int media_filter_get_order_v2(filter_h filter, char **order)
 381 {
 382         filter_s *_filter = (filter_s *)filter;
 383
 384         content_retip_if_fail(filter);
 385         content_retip_if_fail(order);
 386
 387         if (_filter->is_full_order)
 388                 *order = g_strdup(_filter->order_keyword);
 389
 390         return MEDIA_CONTENT_ERROR_NONE;
 391 }
 392