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_retvm_if(!result, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid result");
 105         content_retvm_if(!STRING_VALID(condition), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid condition");
 106         content_retvm_if(!__check_collate_type(collate_type), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid collate_type");
 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_retvm_if(!_filter, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid filter");
 123         content_retvm_if(!result, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid 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         content_retvm_if(!_filter, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid filter");
 177
 178         g_free(_filter->storage_id);
 179         g_free(_filter->condition);
 180         g_free(_filter->order_keyword);
 181         g_free(_filter);
 182
 183         return MEDIA_CONTENT_ERROR_NONE;
 184 }
 185
 186 int media_filter_set_offset(filter_h filter, int offset, int count)
 187 {
 188         filter_s *_filter = (filter_s *)filter;
 189         content_retvm_if(!_filter, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid filter");
 190
 191         _filter->offset = offset;
 192         _filter->count = count;
 193
 194         return MEDIA_CONTENT_ERROR_NONE;
 195 }
 196
 197 int media_filter_set_condition(filter_h filter, const char *condition, media_content_collation_e collate_type)
 198 {
 199         int ret = MEDIA_CONTENT_ERROR_NONE;
 200         filter_s *_filter = (filter_s *)filter;
 201         content_retvm_if(!_filter, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid filter");
 202         content_retvm_if(!STRING_VALID(condition), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid condition");
 203         content_retvm_if(!__check_collate_type(collate_type), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid collate_type");
 204
 205         _filter->is_full_condition = false;
 206         g_free(_filter->condition);
 207
 208         _filter->condition = _media_content_replace_path_in_condition(condition);
 209
 210         /* FIXME
 211                 If an error is occured in _media_content_replace_path_in_condition(),
 212                 A suitable return value is 'MEDIA_CONTENT_ERROR_INVALID_OPERATION'.
 213                 However, it is not stated in the description of media_filter_set_condition().
 214                 Therefore, use 'MEDIA_CONTENT_ERROR_OUT_OF_MEMORY' temporarily.
 215                 It will be modified after removing _media_content_replace_path_in_condition() function.
 216         */
 217         content_retvm_if(_filter->condition == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "Fail to set condition");
 218
 219         content_sec_debug("Condition string : %s", _filter->condition);
 220
 221         _filter->condition_collate_type = collate_type;
 222
 223         return ret;
 224 }
 225
 226 int media_filter_set_order(filter_h filter, media_content_order_e order_type, const char *order_keyword, media_content_collation_e collate_type)
 227 {
 228         filter_s *_filter = (filter_s *)filter;
 229
 230         content_retip_if_fail(filter);
 231         content_retip_if_fail(STRING_VALID(order_keyword));
 232         content_retip_if_fail(__check_order_type(order_type));
 233         content_retip_if_fail(__check_collate_type(collate_type));
 234
 235         _filter->is_full_order = false;
 236
 237         g_free(_filter->order_keyword);
 238
 239         _filter->order_keyword = g_strdup(order_keyword);
 240         _filter->order_type = order_type;
 241         _filter->order_collate_type = collate_type;
 242
 243         return MEDIA_CONTENT_ERROR_NONE;
 244 }
 245
 246 int media_filter_set_storage(filter_h filter, const char *storage_id)
 247 {
 248         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.");
 249         filter_s *_filter = (filter_s *)filter;
 250
 251         content_retip_if_fail(filter);
 252         content_retip_if_fail(STRING_VALID(storage_id));
 253
 254         g_free(_filter->storage_id);
 255         _filter->storage_id = g_strdup(storage_id);
 256
 257         content_sec_debug("storage_id : %s", _filter->storage_id);
 258
 259         return MEDIA_CONTENT_ERROR_NONE;
 260 }
 261
 262 int media_filter_get_offset(filter_h filter, int *offset, int *count)
 263 {
 264         filter_s *_filter = (filter_s *)filter;
 265         content_retvm_if(!_filter || !offset || !count, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid parameter");
 266
 267         *offset = _filter->offset;
 268         *count = _filter->count;
 269
 270         return MEDIA_CONTENT_ERROR_NONE;
 271 }
 272
 273 int media_filter_get_condition(filter_h filter, char **condition, media_content_collation_e *collate_type)
 274 {
 275         filter_s *_filter = (filter_s *)filter;
 276
 277         content_retip_if_fail(filter);
 278         content_retip_if_fail(condition);
 279         content_retip_if_fail(collate_type);
 280
 281         if (!_filter->is_full_condition)
 282                 *condition = g_strdup(_filter->condition);
 283
 284         *collate_type = _filter->condition_collate_type;
 285
 286         return MEDIA_CONTENT_ERROR_NONE;
 287 }
 288
 289 int media_filter_get_order(filter_h filter, media_content_order_e *order_type, char **order_keyword, media_content_collation_e *collate_type)
 290 {
 291         filter_s *_filter = (filter_s *)filter;
 292
 293         content_retip_if_fail(filter);
 294         content_retip_if_fail(order_type);
 295         content_retip_if_fail(order_keyword);
 296         content_retip_if_fail(collate_type);
 297
 298         if (!_filter->is_full_order)
 299                 *order_keyword = g_strdup(_filter->order_keyword);
 300
 301         *order_type = _filter->order_type;
 302         *collate_type = _filter->order_collate_type;
 303
 304         return MEDIA_CONTENT_ERROR_NONE;
 305 }
 306
 307 int media_filter_get_storage(filter_h filter, char **storage_id)
 308 {
 309         content_warn("DEPRECATION WARNING: media_filter_get_storage() is deprecated and will be removed from next release.");
 310         filter_s *_filter = (filter_s *)filter;
 311
 312         content_retip_if_fail(filter);
 313         content_retip_if_fail(storage_id);
 314
 315         *storage_id = g_strdup(_filter->storage_id);
 316
 317         return MEDIA_CONTENT_ERROR_NONE;
 318 }
 319
 320 int media_filter_set_condition_v2(filter_h filter, const char *condition)
 321 {
 322         filter_s *_filter = (filter_s *)filter;
 323         content_retvm_if(!_filter || !STRING_VALID(condition), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid parameter");
 324
 325         _filter->is_full_condition = true;
 326
 327         g_free(_filter->condition);
 328
 329         /* FIXME
 330                 If an error is occured in _media_content_replace_path_in_condition(),
 331                 A suitable return value is 'MEDIA_CONTENT_ERROR_INVALID_OPERATION'.
 332                 However, it is not stated in the description of media_filter_set_condition().
 333                 Therefore, use 'MEDIA_CONTENT_ERROR_OUT_OF_MEMORY' temporarily.
 334                 It will be modified after removing _media_content_replace_path_in_condition() function.
 335         */
 336         _filter->condition = _media_content_replace_path_in_condition(condition);
 337         content_retvm_if(_filter->condition == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "Fail to set condition");
 338
 339         content_sec_debug("Condition string : %s", _filter->condition);
 340
 341         return MEDIA_CONTENT_ERROR_NONE;
 342 }
 343
 344 int media_filter_get_condition_v2(filter_h filter, char **condition)
 345 {
 346         filter_s *_filter = (filter_s *)filter;
 347
 348         content_retip_if_fail(filter);
 349         content_retip_if_fail(condition);
 350
 351         if (_filter->is_full_condition)
 352                 *condition = g_strdup(_filter->condition);
 353
 354         return MEDIA_CONTENT_ERROR_NONE;
 355 }
 356
 357 int media_filter_set_order_v2(filter_h filter, const char *order)
 358 {
 359         filter_s *_filter = (filter_s *)filter;
 360
 361         content_retip_if_fail(filter);
 362         content_retip_if_fail(STRING_VALID(order));
 363
 364         _filter->is_full_order = true;
 365
 366         g_free(_filter->order_keyword);
 367         _filter->order_keyword = g_strdup(order);
 368
 369         return MEDIA_CONTENT_ERROR_NONE;
 370 }
 371
 372 int media_filter_get_order_v2(filter_h filter, char **order)
 373 {
 374         filter_s *_filter = (filter_s *)filter;
 375
 376         content_retip_if_fail(filter);
 377         content_retip_if_fail(order);
 378
 379         if (_filter->is_full_order)
 380                 *order = g_strdup(_filter->order_keyword);
 381
 382         return MEDIA_CONTENT_ERROR_NONE;
 383 }
 384