src/media_tag.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
  20
  21 static __thread GList *g_tag_item_list = NULL;
  22
  23 static void __media_tag_item_add(media_tag_item_s *item_s);
  24 static void __media_tag_item_release(void);
  25 static int __media_tag_insert_item_to_tag(int tag_id, const char *media_id);
  26 static int __media_tag_remove_item_from_tag(int tag_id, const char *media_id);
  27 static int __media_tag_update_tag_name(int tag_id, const char *tag_name);
  28 static int __media_tag_get_tag_info_from_db(const char *name, media_tag_h tag);
  29
  30 static void __media_tag_item_add(media_tag_item_s *item_s)
  31 {
  32         g_tag_item_list = g_list_append(g_tag_item_list, item_s);
  33 }
  34
  35 static void __media_tag_item_release(void)
  36 {
  37         int idx = 0;
  38         int list_cnt = 0;
  39         media_tag_item_s *item = NULL;
  40
  41         list_cnt = g_list_length(g_tag_item_list);
  42
  43         media_content_debug("list_cnt : [%d]", list_cnt);
  44
  45         for(idx = 0; idx < list_cnt; idx++)
  46         {
  47                 item = (media_tag_item_s*)g_list_nth_data(g_tag_item_list, idx);
  48                 if(item != NULL)
  49                 {
  50                         SAFE_FREE(item->media_id);
  51                         SAFE_FREE(item->tag_name);
  52                         SAFE_FREE(item);
  53                 }
  54         }
  55
  56         g_list_free(g_tag_item_list);
  57         g_tag_item_list = NULL;
  58
  59 }
  60
  61 static int __media_tag_insert_item_to_tag(int tag_id, const char *media_id)
  62 {
  63         int ret = MEDIA_CONTENT_ERROR_NONE;
  64         char *query_str = NULL;
  65
  66         query_str = sqlite3_mprintf("INSERT INTO %q (tag_id, media_uuid) values (%d, '%q')",
  67                         DB_TABLE_TAG_MAP, tag_id, media_id);
  68         ret = _content_query_sql(query_str);
  69         sqlite3_free(query_str);
  70
  71         return ret;
  72 }
  73
  74 static int __media_tag_remove_item_from_tag(int tag_id, const char *media_id)
  75 {
  76         int ret = MEDIA_CONTENT_ERROR_NONE;
  77         char *query_str = NULL;
  78
  79         query_str = sqlite3_mprintf(REMOVE_TAG_ITEM_FROM_TAG_MAP, tag_id, media_id);
  80
  81         ret = _content_query_sql(query_str);
  82         sqlite3_free(query_str);
  83
  84         return ret;
  85 }
  86
  87 static int __media_tag_update_tag_name(int tag_id, const char *tag_name)
  88 {
  89         int ret = MEDIA_CONTENT_ERROR_NONE;
  90         char *query_str = NULL;
  91
  92         query_str = sqlite3_mprintf(UPDATE_TAG_NAME_FROM_TAG, tag_name, tag_id);
  93
  94         ret = _content_query_sql(query_str);
  95         sqlite3_free(query_str);
  96
  97         return ret;
  98 }
  99
 100 static int __media_tag_get_tag_info_from_db(const char *name, media_tag_h tag)
 101 {
 102         int ret = MEDIA_CONTENT_ERROR_NONE;
 103         sqlite3_stmt *stmt = NULL;
 104         char *select_query = NULL;
 105         int id = 0;
 106         char *tag_name = NULL;
 107         media_tag_s *_tag = (media_tag_s*)tag;
 108
 109         media_content_retvm_if(_tag == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid tag");
 110
 111         select_query = sqlite3_mprintf(SELECT_TAG_BY_NAME, name);
 112
 113         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 114         sqlite3_free(select_query);
 115         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 116
 117         while(sqlite3_step(stmt) == SQLITE_ROW)
 118         {
 119                 id = (int)sqlite3_column_int(stmt,0);
 120
 121                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 122                 {
 123                         if(tag_name)
 124                                 SAFE_FREE(tag_name);
 125
 126                         tag_name = strdup((const char *)sqlite3_column_text(stmt, 1));
 127                 }
 128         }
 129
 130         _tag->tag_id = id;
 131         _tag->name = tag_name;
 132
 133         SQLITE3_FINALIZE(stmt);
 134
 135         return ret;
 136 }
 137
 138 int media_tag_insert_to_db(const char *tag_name, media_tag_h *tag)
 139 {
 140         int ret = MEDIA_CONTENT_ERROR_NONE;
 141         char *query_str = NULL;
 142
 143         if(!STRING_VALID(tag_name))
 144         {
 145                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 146                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 147         }
 148
 149         query_str = sqlite3_mprintf(INSERT_TAG_TO_TAG, tag_name);
 150         ret = _content_query_sql(query_str);
 151         sqlite3_free(query_str);
 152
 153         if(ret == MEDIA_CONTENT_ERROR_NONE)
 154         {
 155                 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 156                 media_content_retvm_if(_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 157
 158                 ret = __media_tag_get_tag_info_from_db(tag_name, (media_tag_h)_tag);
 159                 *tag = (media_tag_h)_tag;
 160         }
 161
 162         return ret;
 163 }
 164
 165 int media_tag_delete_from_db(int tag_id)
 166 {
 167         int ret = MEDIA_CONTENT_ERROR_NONE;
 168         char *query_str = NULL;
 169
 170         if(tag_id < 0)
 171         {
 172                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 173                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 174         }
 175
 176         query_str = sqlite3_mprintf(DELETE_TAG_FROM_TAG, tag_id);
 177
 178         ret = _content_query_sql(query_str);
 179
 180         sqlite3_free(query_str);
 181
 182         return ret;
 183 }
 184
 185 int media_tag_get_tag_count_from_db(filter_h filter, int *tag_count)
 186 {
 187         int ret = MEDIA_CONTENT_ERROR_NONE;
 188
 189         if(tag_count != NULL)
 190         {
 191                 ret = _media_db_get_group_count(filter, MEDIA_GROUP_TAG, tag_count);
 192         }
 193         else
 194         {
 195                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 196                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 197         }
 198
 199         return ret;
 200 }
 201
 202 int media_tag_foreach_tag_from_db (filter_h filter, media_tag_cb callback, void *user_data)
 203 {
 204         int ret = MEDIA_CONTENT_ERROR_NONE;
 205
 206         if(callback == NULL)
 207         {
 208                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 209                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 210         }
 211
 212         ret = _media_db_get_tag(NULL, filter, callback, user_data);
 213
 214         return ret;
 215 }
 216
 217 int media_tag_get_media_count_from_db(int tag_id, filter_h filter, int *media_count)
 218 {
 219         int ret = MEDIA_CONTENT_ERROR_NONE;
 220
 221         if((tag_id > 0) && (media_count != NULL))
 222         {
 223                 ret = _media_db_get_group_item_count_by_id(tag_id, filter, MEDIA_GROUP_TAG, media_count);
 224         }
 225         else
 226         {
 227                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 228                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 229         }
 230
 231         return ret;
 232 }
 233
 234 int media_tag_foreach_media_from_db(int tag_id, filter_h filter, media_info_cb callback, void *user_data)
 235 {
 236         int ret = MEDIA_CONTENT_ERROR_NONE;
 237
 238         if(callback == NULL)
 239         {
 240                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 241                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 242         }
 243
 244         ret = _media_db_get_group_item_by_id(tag_id, filter, callback, user_data, MEDIA_GROUP_TAG);
 245
 246         return ret;
 247 }
 248
 249 int media_tag_destroy(media_tag_h tag)
 250 {
 251         int ret = MEDIA_CONTENT_ERROR_NONE;
 252         media_tag_s *_tag = (media_tag_s*)tag;
 253         if(_tag)
 254         {
 255                 SAFE_FREE(_tag->name);
 256                 SAFE_FREE(_tag);
 257                 ret = MEDIA_CONTENT_ERROR_NONE;
 258         }
 259         else
 260         {
 261                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 262                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 263         }
 264
 265         return ret;
 266 }
 267 int media_tag_clone(media_tag_h *dst, media_tag_h src)
 268 {
 269         int ret = MEDIA_CONTENT_ERROR_NONE;
 270         media_tag_s *_src = (media_tag_s*)src;
 271         media_tag_s *_dst = NULL;
 272
 273         if((_src != NULL))
 274         {
 275                 _dst = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 276                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 277
 278                 _dst->tag_id = _src->tag_id;
 279
 280                 if(STRING_VALID(_src->name))
 281                 {
 282                         _dst->name = strdup(_src->name);
 283                         if(_dst->name == NULL)
 284                         {
 285                                 SAFE_FREE(_dst);
 286                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 287                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 288                         }
 289                 }
 290                 *dst = (media_tag_h)_dst;
 291                 ret = MEDIA_CONTENT_ERROR_NONE;
 292         }
 293         else
 294         {
 295                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 296                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 297         }
 298
 299         return ret;
 300 }
 301
 302 int media_tag_get_tag_id(media_tag_h tag, int *tag_id)
 303 {
 304         int ret = MEDIA_CONTENT_ERROR_NONE;
 305         media_tag_s *_tag = (media_tag_s*)tag;
 306
 307         if((_tag != NULL) && (tag_id != NULL))
 308         {
 309                 *tag_id = _tag->tag_id;
 310                 ret = MEDIA_CONTENT_ERROR_NONE;
 311         }
 312         else
 313         {
 314                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 315                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 316         }
 317
 318         return ret;
 319 }
 320
 321 int media_tag_get_name(media_tag_h tag, char **name)
 322 {
 323         int ret = MEDIA_CONTENT_ERROR_NONE;
 324         media_tag_s *_tag = (media_tag_s*)tag;
 325         if(_tag)
 326         {
 327                 if(STRING_VALID(_tag->name))
 328                 {
 329                         *name = strdup(_tag->name);
 330                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 331                 }
 332                 else
 333                 {
 334                         *name = NULL;
 335                 }
 336                 ret = MEDIA_CONTENT_ERROR_NONE;
 337
 338         }
 339         else
 340         {
 341                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 342                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 343         }
 344
 345         return ret;
 346 }
 347
 348 int media_tag_get_tag_from_db(int tag_id, media_tag_h *tag)
 349 {
 350         int ret = MEDIA_CONTENT_ERROR_NONE;
 351         sqlite3_stmt *stmt = NULL;
 352         char select_query[DEFAULT_QUERY_SIZE];
 353
 354         if(tag_id <= 0)
 355         {
 356                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 357                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 358         }
 359
 360         memset(select_query, 0x00, sizeof(select_query));
 361
 362         snprintf(select_query, sizeof(select_query), SELECT_TAG_FROM_TAG, tag_id);
 363
 364         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 365         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 366
 367         media_tag_s *_tag = NULL;
 368
 369         while(sqlite3_step(stmt) == SQLITE_ROW)
 370         {
 371                 if(_tag)
 372                         media_tag_destroy((media_tag_h)_tag);
 373
 374                 _tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 375                 if(_tag == NULL)
 376                 {
 377                         SQLITE3_FINALIZE(stmt);
 378                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 379                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 380                 }
 381
 382                 _tag->tag_id = (int)sqlite3_column_int(stmt, 0);
 383
 384                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 385                 {
 386                         _tag->name = strdup((const char *)sqlite3_column_text(stmt, 1));
 387                 }
 388
 389                 *tag = (media_tag_h)_tag;
 390         }
 391
 392         SQLITE3_FINALIZE(stmt);
 393
 394         return ret;
 395 }
 396
 397 int media_tag_add_media(media_tag_h tag, const char *media_id)
 398 {
 399         int ret = MEDIA_CONTENT_ERROR_NONE;
 400         media_tag_s *_tag = (media_tag_s*)tag;
 401
 402         if((_tag != NULL) && STRING_VALID(media_id))
 403         {
 404                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 405                 media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 406
 407                 _item->media_id = strdup(media_id);
 408                 _item->function = MEDIA_TAG_ADD;
 409
 410                 if(_item->media_id == NULL)
 411                 {
 412                         SAFE_FREE(_item);
 413                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 414                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 415                 }
 416
 417                 __media_tag_item_add(_item);
 418         }
 419         else
 420         {
 421                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 422                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 423         }
 424
 425         return ret;
 426 }
 427
 428 int media_tag_remove_media(media_tag_h tag, const char *media_id)
 429 {
 430         int ret = MEDIA_CONTENT_ERROR_NONE;
 431         media_tag_s *_tag = (media_tag_s*)tag;
 432
 433         if(_tag != NULL && STRING_VALID(media_id))
 434         {
 435                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 436                 media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 437
 438                 _item->media_id = strdup(media_id);
 439                 _item->function = MEDIA_TAG_REMOVE;
 440
 441                 if(_item->media_id == NULL)
 442                 {
 443                         SAFE_FREE(_item);
 444                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 445                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 446                 }
 447
 448                 __media_tag_item_add(_item);
 449         }
 450         else
 451         {
 452                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 453                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 454         }
 455
 456         return ret;
 457 }
 458
 459 int media_tag_set_name(media_tag_h tag, char *tag_name)
 460 {
 461         int ret = MEDIA_CONTENT_ERROR_NONE;
 462         media_tag_s *_tag = (media_tag_s*)tag;
 463
 464         if(_tag != NULL && STRING_VALID(tag_name))
 465         {
 466                 SAFE_FREE(_tag->name);
 467
 468                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 469                 media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 470
 471                 _item->tag_name = strdup(tag_name);
 472                 _item->function = MEDIA_TAG_UPDATE_TAG_NAME;
 473
 474                 if(_item->tag_name == NULL)
 475                 {
 476                         SAFE_FREE(_item);
 477                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 478                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 479                 }
 480
 481                 _tag->name = strdup(tag_name);
 482                 if(_tag->name == NULL)
 483                 {
 484                         SAFE_FREE(_item->tag_name);
 485                         SAFE_FREE(_item);
 486                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 487                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 488                 }
 489
 490                 __media_tag_item_add(_item);
 491         }
 492         else
 493         {
 494                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 495                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 496         }
 497
 498         return ret;
 499 }
 500
 501 int media_tag_update_to_db(media_tag_h tag)
 502 {
 503         int ret = MEDIA_CONTENT_ERROR_NONE;
 504         media_tag_s *_tag = (media_tag_s*)tag;
 505         int idx = 0;
 506         int length = 0;
 507         media_tag_item_s *_tag_item = NULL;
 508
 509         if(_tag == NULL)
 510         {
 511                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 512                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 513         }
 514
 515         length = g_list_length(g_tag_item_list);
 516
 517         for (idx = 0; idx < length; idx++) {
 518                 _tag_item = (media_tag_item_s*)g_list_nth_data(g_tag_item_list, idx);
 519                 if(_tag_item != NULL) {
 520                         switch(_tag_item->function) {
 521                                 case MEDIA_TAG_ADD:
 522                                 {
 523                                         ret = __media_tag_insert_item_to_tag(_tag->tag_id, _tag_item->media_id);
 524                                 }
 525                                 break;
 526
 527                                 case MEDIA_TAG_REMOVE:
 528                                 {
 529                                         ret = __media_tag_remove_item_from_tag(_tag->tag_id, _tag_item->media_id);
 530                                 }
 531                                 break;
 532
 533                                 case MEDIA_TAG_UPDATE_TAG_NAME:
 534                                 {
 535                                         ret = __media_tag_update_tag_name(_tag->tag_id, _tag_item->tag_name);
 536                                 }
 537                                 break;
 538
 539                                 default:
 540                                 break;
 541                         }
 542                 }
 543         }
 544
 545         __media_tag_item_release();
 546
 547         return ret;
 548 }