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         media_tag_s *_tag = (media_tag_s*)tag;
 106
 107         if(_tag == NULL)
 108         {
 109                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 110                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 111         }
 112
 113         select_query = sqlite3_mprintf(SELECT_TAG_BY_NAME, name);
 114
 115         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 116         sqlite3_free(select_query);
 117         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 118
 119         while(sqlite3_step(stmt) == SQLITE_ROW)
 120         {
 121                 _tag->tag_id = (int)sqlite3_column_int(stmt,0);
 122
 123                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 124                 {
 125                         _tag->name = strdup((const char *)sqlite3_column_text(stmt, 1));
 126                 }
 127         }
 128
 129         SQLITE3_FINALIZE(stmt);
 130
 131         return ret;
 132 }
 133
 134 int media_tag_insert_to_db(const char *tag_name, media_tag_h *tag)
 135 {
 136         int ret = MEDIA_CONTENT_ERROR_NONE;
 137         char *query_str = NULL;
 138
 139         if(!STRING_VALID(tag_name))
 140         {
 141                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 142                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 143         }
 144
 145         query_str = sqlite3_mprintf(INSERT_TAG_TO_TAG, tag_name);
 146         ret = _content_query_sql(query_str);
 147         sqlite3_free(query_str);
 148
 149         if(ret == MEDIA_CONTENT_ERROR_NONE)
 150         {
 151                 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 152                 if(_tag == NULL)
 153                 {
 154                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 155                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 156                 }
 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
 277                 if(_dst == NULL)
 278                 {
 279                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 280                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 281                 }
 282
 283                 _dst->tag_id = _src->tag_id;
 284
 285                 if(STRING_VALID(_src->name))
 286                 {
 287                         _dst->name = strdup(_src->name);
 288                         if(_dst->name == NULL)
 289                         {
 290                                 SAFE_FREE(_dst);
 291                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 292                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 293                         }
 294                 }
 295                 *dst = (media_tag_h)_dst;
 296                 ret = MEDIA_CONTENT_ERROR_NONE;
 297         }
 298         else
 299         {
 300                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 301                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 302         }
 303
 304         return ret;
 305 }
 306
 307 int media_tag_get_tag_id(media_tag_h tag, int *tag_id)
 308 {
 309         int ret = MEDIA_CONTENT_ERROR_NONE;
 310         media_tag_s *_tag = (media_tag_s*)tag;
 311
 312         if((_tag != NULL) && (tag_id != NULL))
 313         {
 314                 *tag_id = _tag->tag_id;
 315                 ret = MEDIA_CONTENT_ERROR_NONE;
 316         }
 317         else
 318         {
 319                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 320                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 321         }
 322
 323         return ret;
 324 }
 325
 326 int media_tag_get_name(media_tag_h tag, char **name)
 327 {
 328         int ret = MEDIA_CONTENT_ERROR_NONE;
 329         media_tag_s *_tag = (media_tag_s*)tag;
 330         if(_tag)
 331         {
 332                 if(STRING_VALID(_tag->name))
 333                 {
 334                         *name = strdup(_tag->name);
 335                         if(*name == NULL)
 336                         {
 337                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 338                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 339                         }
 340                 }
 341                 else
 342                 {
 343                         *name = NULL;
 344                 }
 345                 ret = MEDIA_CONTENT_ERROR_NONE;
 346
 347         }
 348         else
 349         {
 350                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 351                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 352         }
 353
 354         return ret;
 355 }
 356
 357 int media_tag_get_tag_from_db(int tag_id, media_tag_h *tag)
 358 {
 359         int ret = MEDIA_CONTENT_ERROR_NONE;
 360         sqlite3_stmt *stmt = NULL;
 361         char select_query[DEFAULT_QUERY_SIZE];
 362
 363         if(tag_id <= 0)
 364         {
 365                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 366                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 367         }
 368
 369         memset(select_query, 0x00, sizeof(select_query));
 370
 371         snprintf(select_query, sizeof(select_query), SELECT_TAG_FROM_TAG, tag_id);
 372
 373         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 374         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 375
 376         while(sqlite3_step(stmt) == SQLITE_ROW)
 377         {
 378                 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 379
 380                 if(_tag == NULL)
 381                 {
 382                         SQLITE3_FINALIZE(stmt);
 383                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 384                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 385                 }
 386
 387                 _tag->tag_id = (int)sqlite3_column_int(stmt, 0);
 388
 389                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 390                 {
 391                         _tag->name = strdup((const char *)sqlite3_column_text(stmt, 1));
 392                 }
 393
 394                 *tag = (media_tag_h)_tag;
 395         }
 396
 397         SQLITE3_FINALIZE(stmt);
 398
 399         return ret;
 400 }
 401
 402 int media_tag_add_media(media_tag_h tag, const char *media_id)
 403 {
 404         int ret = MEDIA_CONTENT_ERROR_NONE;
 405         media_tag_s *_tag = (media_tag_s*)tag;
 406
 407         if((_tag != NULL) && STRING_VALID(media_id))
 408         {
 409                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 410                 if(_item == NULL)
 411                 {
 412                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 413                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 414                 }
 415
 416                 _item->media_id = strdup(media_id);
 417                 _item->function = MEDIA_TAG_ADD;
 418
 419                 if(_item->media_id == NULL)
 420                 {
 421                         SAFE_FREE(_item);
 422                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 423                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 424                 }
 425
 426                 __media_tag_item_add(_item);
 427         }
 428         else
 429         {
 430                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 431                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 432         }
 433
 434         return ret;
 435 }
 436
 437 int media_tag_remove_media(media_tag_h tag, const char *media_id)
 438 {
 439         int ret = MEDIA_CONTENT_ERROR_NONE;
 440         media_tag_s *_tag = (media_tag_s*)tag;
 441
 442         if(_tag != NULL && STRING_VALID(media_id))
 443         {
 444                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 445                 if(_item == NULL)
 446                 {
 447                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 448                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 449                 }
 450
 451                 _item->media_id = strdup(media_id);
 452                 _item->function = MEDIA_TAG_REMOVE;
 453
 454                 if(_item->media_id == NULL)
 455                 {
 456                         SAFE_FREE(_item);
 457                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 458                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 459                 }
 460
 461                 __media_tag_item_add(_item);
 462         }
 463         else
 464         {
 465                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 466                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 467         }
 468
 469         return ret;
 470 }
 471
 472 int media_tag_set_name(media_tag_h tag, char *tag_name)
 473 {
 474         int ret = MEDIA_CONTENT_ERROR_NONE;
 475         media_tag_s *_tag = (media_tag_s*)tag;
 476
 477         if(_tag != NULL && STRING_VALID(tag_name))
 478         {
 479                 SAFE_FREE(_tag->name);
 480
 481                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 482                 if(_item == NULL)
 483                 {
 484                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 485                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 486                 }
 487
 488                 _item->tag_name = strdup(tag_name);
 489                 _item->function = MEDIA_TAG_UPDATE_TAG_NAME;
 490
 491                 if(_item->tag_name == NULL)
 492                 {
 493                         SAFE_FREE(_item);
 494                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 495                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 496                 }
 497
 498                 _tag->name = strdup(tag_name);
 499                 if(_tag->name == NULL)
 500                 {
 501                         SAFE_FREE(_item->tag_name);
 502                         SAFE_FREE(_item);
 503                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 504                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 505                 }
 506
 507                 __media_tag_item_add(_item);
 508         }
 509         else
 510         {
 511                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 512                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 513         }
 514
 515         return ret;
 516 }
 517
 518 int media_tag_update_to_db(media_tag_h tag)
 519 {
 520         int ret = MEDIA_CONTENT_ERROR_NONE;
 521         media_tag_s *_tag = (media_tag_s*)tag;
 522         int idx = 0;
 523         int length = 0;
 524         media_tag_item_s *_tag_item = NULL;
 525
 526         if(_tag == NULL)
 527         {
 528                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 529                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 530         }
 531
 532         length = g_list_length(g_tag_item_list);
 533
 534         for (idx = 0; idx < length; idx++) {
 535                 _tag_item = (media_tag_item_s*)g_list_nth_data(g_tag_item_list, idx);
 536                 if(_tag_item != NULL) {
 537                         switch(_tag_item->function) {
 538                                 case MEDIA_TAG_ADD:
 539                                 {
 540                                         ret = __media_tag_insert_item_to_tag(_tag->tag_id, _tag_item->media_id);
 541                                 }
 542                                 break;
 543
 544                                 case MEDIA_TAG_REMOVE:
 545                                 {
 546                                         ret = __media_tag_remove_item_from_tag(_tag->tag_id, _tag_item->media_id);
 547                                 }
 548                                 break;
 549
 550                                 case MEDIA_TAG_UPDATE_TAG_NAME:
 551                                 {
 552                                         ret = __media_tag_update_tag_name(_tag->tag_id, _tag_item->tag_name);
 553                                 }
 554                                 break;
 555                         }
 556                 }
 557         }
 558
 559         __media_tag_item_release();
 560
 561         return ret;
 562 }