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