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 #ifdef _USE_TVPD_MODE
 144                 *result = g_strdup_printf("%s LIMIT %d, %d", _filter->order_keyword, _filter->offset, _filter->count);
 145 #else
 146                 *result = g_strdup_printf("ORDER BY %s LIMIT %d, %d", _filter->order_keyword, _filter->offset, _filter->count);
 147 #endif
 148         }
 149
 150         return MEDIA_CONTENT_ERROR_NONE;
 151 }
 152
 153 int media_filter_create(filter_h *filter)
 154 {
 155         int ret = MEDIA_CONTENT_ERROR_NONE;
 156
 157         content_retip_if_fail(filter);
 158
 159         filter_s *_filter = g_new0(filter_s, 1);
 160
 161         _filter->storage_id = NULL;
 162         _filter->condition = NULL;
 163         _filter->order_keyword = NULL;
 164         _filter->order_type = -1;
 165         _filter->condition_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
 166         _filter->order_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
 167         _filter->offset = -1;
 168         _filter->count = -1;
 169         _filter->is_full_condition = false;
 170         _filter->is_full_order = false;
 171
 172         *filter = (filter_h)_filter;
 173
 174         return ret;
 175 }
 176
 177 int media_filter_destroy(filter_h filter)
 178 {
 179         filter_s *_filter = (filter_s *)filter;
 180
 181         content_retip_if_fail(filter);
 182
 183         g_free(_filter->storage_id);
 184         g_free(_filter->condition);
 185         g_free(_filter->order_keyword);
 186         g_free(_filter);
 187
 188         return MEDIA_CONTENT_ERROR_NONE;
 189 }
 190
 191 int media_filter_set_offset(filter_h filter, int offset, int count)
 192 {
 193         filter_s *_filter = (filter_s *)filter;
 194
 195         content_retip_if_fail(filter);
 196
 197         _filter->offset = offset;
 198         _filter->count = count;
 199
 200         return MEDIA_CONTENT_ERROR_NONE;
 201 }
 202
 203 int media_filter_set_condition(filter_h filter, const char *condition, media_content_collation_e collate_type)
 204 {
 205         int ret = MEDIA_CONTENT_ERROR_NONE;
 206         filter_s *_filter = (filter_s *)filter;
 207
 208         content_retip_if_fail(filter);
 209         content_retip_if_fail(STRING_VALID(condition));
 210         content_retip_if_fail(__check_collate_type(collate_type));
 211
 212         _filter->is_full_condition = false;
 213         g_free(_filter->condition);
 214
 215         _filter->condition = g_strdup(condition);
 216
 217         content_sec_debug("Condition string : %s", _filter->condition);
 218
 219         _filter->condition_collate_type = collate_type;
 220
 221         return ret;
 222 }
 223
 224 int media_filter_set_order(filter_h filter, media_content_order_e order_type, const char *order_keyword, media_content_collation_e collate_type)
 225 {
 226         filter_s *_filter = (filter_s *)filter;
 227
 228         content_retip_if_fail(filter);
 229         content_retip_if_fail(STRING_VALID(order_keyword));
 230         content_retip_if_fail(__check_order_type(order_type));
 231         content_retip_if_fail(__check_collate_type(collate_type));
 232
 233         _filter->is_full_order = false;
 234
 235         g_free(_filter->order_keyword);
 236
 237         _filter->order_keyword = g_strdup(order_keyword);
 238         _filter->order_type = order_type;
 239         _filter->order_collate_type = collate_type;
 240
 241         return MEDIA_CONTENT_ERROR_NONE;
 242 }
 243
 244 int media_filter_set_storage(filter_h filter, const char *storage_id)
 245 {
 246         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.");
 247         filter_s *_filter = (filter_s *)filter;
 248
 249         content_retip_if_fail(filter);
 250         content_retip_if_fail(STRING_VALID(storage_id));
 251
 252         g_free(_filter->storage_id);
 253         _filter->storage_id = g_strdup(storage_id);
 254
 255         content_sec_debug("storage_id : %s", _filter->storage_id);
 256
 257         return MEDIA_CONTENT_ERROR_NONE;
 258 }
 259
 260 int media_filter_get_offset(filter_h filter, int *offset, int *count)
 261 {
 262         filter_s *_filter = (filter_s *)filter;
 263
 264         content_retip_if_fail(filter);
 265         content_retip_if_fail(offset);
 266         content_retip_if_fail(count);
 267
 268         *offset = _filter->offset;
 269         *count = _filter->count;
 270
 271         return MEDIA_CONTENT_ERROR_NONE;
 272 }
 273
 274 int media_filter_get_condition(filter_h filter, char **condition, media_content_collation_e *collate_type)
 275 {
 276         filter_s *_filter = (filter_s *)filter;
 277
 278         content_retip_if_fail(filter);
 279         content_retip_if_fail(condition);
 280         content_retip_if_fail(collate_type);
 281
 282         if (!_filter->is_full_condition)
 283                 *condition = g_strdup(_filter->condition);
 284
 285         *collate_type = _filter->condition_collate_type;
 286
 287         return MEDIA_CONTENT_ERROR_NONE;
 288 }
 289
 290 int media_filter_get_order(filter_h filter, media_content_order_e *order_type, char **order_keyword, media_content_collation_e *collate_type)
 291 {
 292         filter_s *_filter = (filter_s *)filter;
 293
 294         content_retip_if_fail(filter);
 295         content_retip_if_fail(order_type);
 296         content_retip_if_fail(order_keyword);
 297         content_retip_if_fail(collate_type);
 298
 299         if (!_filter->is_full_order)
 300                 *order_keyword = g_strdup(_filter->order_keyword);
 301
 302         *order_type = _filter->order_type;
 303         *collate_type = _filter->order_collate_type;
 304
 305         return MEDIA_CONTENT_ERROR_NONE;
 306 }
 307
 308 int media_filter_get_storage(filter_h filter, char **storage_id)
 309 {
 310         content_warn("DEPRECATION WARNING: media_filter_get_storage() is deprecated and will be removed from next release.");
 311         filter_s *_filter = (filter_s *)filter;
 312
 313         content_retip_if_fail(filter);
 314         content_retip_if_fail(storage_id);
 315
 316         *storage_id = g_strdup(_filter->storage_id);
 317
 318         return MEDIA_CONTENT_ERROR_NONE;
 319 }
 320
 321 int media_filter_set_condition_v2(filter_h filter, const char *condition)
 322 {
 323         filter_s *_filter = (filter_s *)filter;
 324
 325         content_retip_if_fail(filter);
 326         content_retip_if_fail(STRING_VALID(condition));
 327
 328         _filter->is_full_condition = true;
 329
 330         g_free(_filter->condition);
 331
 332         _filter->condition = g_strdup(condition);
 333
 334         content_sec_debug("Condition string : %s", _filter->condition);
 335
 336         return MEDIA_CONTENT_ERROR_NONE;
 337 }
 338
 339 int media_filter_get_condition_v2(filter_h filter, char **condition)
 340 {
 341         filter_s *_filter = (filter_s *)filter;
 342
 343         content_retip_if_fail(filter);
 344         content_retip_if_fail(condition);
 345
 346         if (_filter->is_full_condition)
 347                 *condition = g_strdup(_filter->condition);
 348
 349         return MEDIA_CONTENT_ERROR_NONE;
 350 }
 351
 352 int media_filter_set_order_v2(filter_h filter, const char *order)
 353 {
 354         filter_s *_filter = (filter_s *)filter;
 355
 356         content_retip_if_fail(filter);
 357         content_retip_if_fail(STRING_VALID(order));
 358
 359         _filter->is_full_order = true;
 360
 361         g_free(_filter->order_keyword);
 362         _filter->order_keyword = g_strdup(order);
 363
 364         return MEDIA_CONTENT_ERROR_NONE;
 365 }
 366
 367 int media_filter_get_order_v2(filter_h filter, char **order)
 368 {
 369         filter_s *_filter = (filter_s *)filter;
 370
 371         content_retip_if_fail(filter);
 372         content_retip_if_fail(order);
 373
 374         if (_filter->is_full_order)
 375                 *order = g_strdup(_filter->order_keyword);
 376
 377         return MEDIA_CONTENT_ERROR_NONE;
 378 }
 379