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