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