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                 SAFE_FREE(tag_name);
 117
 118                 id = (int)sqlite3_column_int(stmt,0);
 119                 tag_name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 120         }
 121
 122         _tag->tag_id = id;
 123         _tag->name = tag_name;
 124
 125         SQLITE3_FINALIZE(stmt);
 126
 127         return ret;
 128 }
 129
 130 int media_tag_insert_to_db(const char *tag_name, media_tag_h *tag)
 131 {
 132         int ret = MEDIA_CONTENT_ERROR_NONE;
 133         char *query_str = NULL;
 134
 135         if(!STRING_VALID(tag_name))
 136         {
 137                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 138                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 139         }
 140
 141         query_str = sqlite3_mprintf(INSERT_TAG_TO_TAG, tag_name);
 142         ret = _content_query_sql(query_str);
 143         SQLITE3_SAFE_FREE(query_str);
 144
 145         if(ret == MEDIA_CONTENT_ERROR_NONE)
 146         {
 147                 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 148                 media_content_retvm_if(_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 149
 150                 ret = __media_tag_get_tag_info_from_db(tag_name, (media_tag_h)_tag);
 151                 *tag = (media_tag_h)_tag;
 152         }
 153
 154         return ret;
 155 }
 156
 157 int media_tag_delete_from_db(int tag_id)
 158 {
 159         int ret = MEDIA_CONTENT_ERROR_NONE;
 160         char *query_str = NULL;
 161
 162         if(tag_id < 0)
 163         {
 164                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 165                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 166         }
 167
 168         query_str = sqlite3_mprintf(DELETE_TAG_FROM_TAG, tag_id);
 169
 170         ret = _content_query_sql(query_str);
 171
 172         SQLITE3_SAFE_FREE(query_str);
 173
 174         return ret;
 175 }
 176
 177 int media_tag_get_tag_count_from_db(filter_h filter, int *tag_count)
 178 {
 179         int ret = MEDIA_CONTENT_ERROR_NONE;
 180
 181         if(tag_count != NULL)
 182         {
 183                 ret = _media_db_get_group_count(filter, MEDIA_GROUP_TAG, tag_count);
 184         }
 185         else
 186         {
 187                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 188                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 189         }
 190
 191         return ret;
 192 }
 193
 194 int media_tag_foreach_tag_from_db (filter_h filter, media_tag_cb callback, void *user_data)
 195 {
 196         int ret = MEDIA_CONTENT_ERROR_NONE;
 197
 198         if(callback == NULL)
 199         {
 200                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 201                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 202         }
 203
 204         ret = _media_db_get_tag(NULL, filter, callback, user_data);
 205
 206         return ret;
 207 }
 208
 209 int media_tag_get_media_count_from_db(int tag_id, filter_h filter, int *media_count)
 210 {
 211         int ret = MEDIA_CONTENT_ERROR_NONE;
 212
 213         if((tag_id > 0) && (media_count != NULL))
 214         {
 215                 ret = _media_db_get_group_item_count_by_id(tag_id, filter, MEDIA_GROUP_TAG, media_count);
 216         }
 217         else
 218         {
 219                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 220                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 221         }
 222
 223         return ret;
 224 }
 225
 226 int media_tag_foreach_media_from_db(int tag_id, filter_h filter, media_info_cb callback, void *user_data)
 227 {
 228         int ret = MEDIA_CONTENT_ERROR_NONE;
 229
 230         if(callback == NULL)
 231         {
 232                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 233                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 234         }
 235
 236         ret = _media_db_get_group_item_by_id(tag_id, filter, callback, user_data, MEDIA_GROUP_TAG);
 237
 238         return ret;
 239 }
 240
 241 int media_tag_destroy(media_tag_h tag)
 242 {
 243         int ret = MEDIA_CONTENT_ERROR_NONE;
 244         media_tag_s *_tag = (media_tag_s*)tag;
 245         if(_tag)
 246         {
 247                 SAFE_FREE(_tag->name);
 248                 SAFE_FREE(_tag);
 249                 ret = MEDIA_CONTENT_ERROR_NONE;
 250         }
 251         else
 252         {
 253                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 254                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 255         }
 256
 257         return ret;
 258 }
 259 int media_tag_clone(media_tag_h *dst, media_tag_h src)
 260 {
 261         int ret = MEDIA_CONTENT_ERROR_NONE;
 262         media_tag_s *_src = (media_tag_s*)src;
 263         media_tag_s *_dst = NULL;
 264
 265         if((_src != NULL))
 266         {
 267                 _dst = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 268                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 269
 270                 _dst->tag_id = _src->tag_id;
 271
 272                 if(STRING_VALID(_src->name))
 273                 {
 274                         _dst->name = strdup(_src->name);
 275                         if(_dst->name == NULL)
 276                         {
 277                                 SAFE_FREE(_dst);
 278                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 279                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 280                         }
 281                 }
 282                 *dst = (media_tag_h)_dst;
 283                 ret = MEDIA_CONTENT_ERROR_NONE;
 284         }
 285         else
 286         {
 287                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 288                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 289         }
 290
 291         return ret;
 292 }
 293
 294 int media_tag_get_tag_id(media_tag_h tag, int *tag_id)
 295 {
 296         int ret = MEDIA_CONTENT_ERROR_NONE;
 297         media_tag_s *_tag = (media_tag_s*)tag;
 298
 299         if((_tag != NULL) && (tag_id != NULL))
 300         {
 301                 *tag_id = _tag->tag_id;
 302                 ret = MEDIA_CONTENT_ERROR_NONE;
 303         }
 304         else
 305         {
 306                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 307                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 308         }
 309
 310         return ret;
 311 }
 312
 313 int media_tag_get_name(media_tag_h tag, char **name)
 314 {
 315         int ret = MEDIA_CONTENT_ERROR_NONE;
 316         media_tag_s *_tag = (media_tag_s*)tag;
 317         if(_tag)
 318         {
 319                 if(STRING_VALID(_tag->name))
 320                 {
 321                         *name = strdup(_tag->name);
 322                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 323                 }
 324                 else
 325                 {
 326                         *name = NULL;
 327                 }
 328                 ret = MEDIA_CONTENT_ERROR_NONE;
 329
 330         }
 331         else
 332         {
 333                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 334                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 335         }
 336
 337         return ret;
 338 }
 339
 340 int media_tag_get_tag_from_db(int tag_id, media_tag_h *tag)
 341 {
 342         int ret = MEDIA_CONTENT_ERROR_NONE;
 343         sqlite3_stmt *stmt = NULL;
 344         char select_query[DEFAULT_QUERY_SIZE];
 345
 346         if(tag_id <= 0)
 347         {
 348                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 349                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 350         }
 351
 352         memset(select_query, 0x00, sizeof(select_query));
 353
 354         snprintf(select_query, sizeof(select_query), SELECT_TAG_FROM_TAG, tag_id);
 355
 356         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 357         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 358
 359         media_tag_s *_tag = NULL;
 360
 361         while(sqlite3_step(stmt) == SQLITE_ROW)
 362         {
 363                 if(_tag)
 364                         media_tag_destroy((media_tag_h)_tag);
 365
 366                 _tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 367                 if(_tag == NULL)
 368                 {
 369                         SQLITE3_FINALIZE(stmt);
 370                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 371                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 372                 }
 373
 374                 _tag->tag_id = (int)sqlite3_column_int(stmt, 0);
 375                 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 376
 377                 *tag = (media_tag_h)_tag;
 378         }
 379
 380         SQLITE3_FINALIZE(stmt);
 381
 382         return ret;
 383 }
 384
 385 int media_tag_add_media(media_tag_h tag, const char *media_id)
 386 {
 387         int ret = MEDIA_CONTENT_ERROR_NONE;
 388         media_tag_s *_tag = (media_tag_s*)tag;
 389
 390         if((_tag != NULL) && STRING_VALID(media_id))
 391         {
 392                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 393                 media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 394
 395                 _item->media_id = strdup(media_id);
 396                 _item->function = MEDIA_TAG_ADD;
 397
 398                 if(_item->media_id == NULL)
 399                 {
 400                         SAFE_FREE(_item);
 401                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 402                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 403                 }
 404
 405                 __media_tag_item_add(_tag, _item);
 406         }
 407         else
 408         {
 409                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 410                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 411         }
 412
 413         return ret;
 414 }
 415
 416 int media_tag_remove_media(media_tag_h tag, const char *media_id)
 417 {
 418         int ret = MEDIA_CONTENT_ERROR_NONE;
 419         media_tag_s *_tag = (media_tag_s*)tag;
 420
 421         if(_tag != NULL && STRING_VALID(media_id))
 422         {
 423                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 424                 media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 425
 426                 _item->media_id = strdup(media_id);
 427                 _item->function = MEDIA_TAG_REMOVE;
 428
 429                 if(_item->media_id == NULL)
 430                 {
 431                         SAFE_FREE(_item);
 432                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 433                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 434                 }
 435
 436                 __media_tag_item_add(_tag, _item);
 437         }
 438         else
 439         {
 440                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 441                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 442         }
 443
 444         return ret;
 445 }
 446
 447 int media_tag_set_name(media_tag_h tag, char *tag_name)
 448 {
 449         int ret = MEDIA_CONTENT_ERROR_NONE;
 450         media_tag_s *_tag = (media_tag_s*)tag;
 451
 452         if(_tag != NULL && STRING_VALID(tag_name))
 453         {
 454                 SAFE_FREE(_tag->name);
 455
 456                 media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
 457                 media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 458
 459                 _item->tag_name = strdup(tag_name);
 460                 _item->function = MEDIA_TAG_UPDATE_TAG_NAME;
 461
 462                 if(_item->tag_name == NULL)
 463                 {
 464                         SAFE_FREE(_item);
 465                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 466                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 467                 }
 468
 469                 _tag->name = strdup(tag_name);
 470                 if(_tag->name == NULL)
 471                 {
 472                         SAFE_FREE(_item->tag_name);
 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                 __media_tag_item_add(_tag, _item);
 479         }
 480         else
 481         {
 482                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 483                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 484         }
 485
 486         return ret;
 487 }
 488
 489 int media_tag_update_to_db(media_tag_h tag)
 490 {
 491         int ret = MEDIA_CONTENT_ERROR_NONE;
 492         media_tag_s *_tag = (media_tag_s*)tag;
 493         int idx = 0;
 494         int length = 0;
 495         media_tag_item_s *_tag_item = NULL;
 496
 497         if(_tag == NULL)
 498         {
 499                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 500                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 501         }
 502
 503         if(_tag->item_list != NULL) {
 504                 length = g_list_length(_tag->item_list);
 505         } else {
 506                 media_content_debug("operation list length is 0");
 507                 return MEDIA_CONTENT_ERROR_NONE;
 508         }
 509
 510         for (idx = 0; idx < length; idx++) {
 511                 _tag_item = (media_tag_item_s*)g_list_nth_data(_tag->item_list, idx);
 512                 if(_tag_item != NULL) {
 513                         switch(_tag_item->function) {
 514                                 case MEDIA_TAG_ADD:
 515                                 {
 516                                         ret = __media_tag_insert_item_to_tag(_tag->tag_id, _tag_item->media_id);
 517                                 }
 518                                 break;
 519
 520                                 case MEDIA_TAG_REMOVE:
 521                                 {
 522                                         ret = __media_tag_remove_item_from_tag(_tag->tag_id, _tag_item->media_id);
 523                                 }
 524                                 break;
 525
 526                                 case MEDIA_TAG_UPDATE_TAG_NAME:
 527                                 {
 528                                         ret = __media_tag_update_tag_name(_tag->tag_id, _tag_item->tag_name);
 529                                 }
 530                                 break;
 531
 532                                 default:
 533                                 break;
 534                         }
 535                 }
 536         }
 537
 538         __media_tag_item_release(_tag);
 539
 540         return ret;
 541 }