src/media_folder.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 #include <media_util_private.h>
  20
  21 static char *g_src_path = NULL;
  22
  23 static char *__media_folder_get_update_folder_sql(media_folder_h folder);
  24
  25 static char *__media_folder_get_update_folder_sql(media_folder_h folder)
  26 {
  27         media_folder_s *_folder = (media_folder_s*)folder;
  28         char *return_sql = NULL;
  29         char *name_pinyin = NULL;
  30         bool pinyin_support = FALSE;
  31
  32         /*Update Pinyin If Support Pinyin*/
  33         media_svc_check_pinyin_support(&pinyin_support);
  34         if(pinyin_support)
  35                 media_svc_get_pinyin(_content_get_db_handle(), _folder->name, &name_pinyin);
  36
  37         return_sql = sqlite3_mprintf("%q='%q', %q='%q', %q=%d, %q='%q'",
  38                                                                                         DB_FIELD_FOLDER_PATH, _folder->path,
  39                                                                                         DB_FIELD_FOLDER_NAME, _folder->name,
  40                                                                                         DB_FIELD_FOLDER_MODIFIED_TIME, _folder->modified_time,
  41                                                                                         DB_FIELD_FOLDER_NAME_PINYIN, name_pinyin);
  42
  43         SAFE_FREE(name_pinyin);
  44         return return_sql;
  45 }
  46
  47 int media_folder_get_folder_count_from_db(filter_h filter, int *folder_count)
  48 {
  49         int ret = MEDIA_CONTENT_ERROR_NONE;
  50
  51         if(!folder_count)
  52         {
  53                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  54                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  55         }
  56
  57         ret = _media_db_get_group_count(filter, MEDIA_GROUP_FOLDER, folder_count);
  58
  59         return ret;
  60 }
  61
  62 int media_folder_foreach_folder_from_db(filter_h filter, media_folder_cb callback, void *user_data)
  63 {
  64         int ret = MEDIA_CONTENT_ERROR_NONE;
  65
  66         if(callback == NULL)
  67         {
  68                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  69                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  70         }
  71
  72         ret = _media_db_get_folder(filter, callback, user_data);
  73
  74         return ret;
  75 }
  76
  77 int media_folder_get_media_count_from_db(const char *folder_id, filter_h filter, int *media_count)
  78 {
  79         int ret = MEDIA_CONTENT_ERROR_NONE;
  80
  81         if(STRING_VALID(folder_id) && media_count)
  82         {
  83                 ret = _media_db_get_group_item_count(folder_id, filter, MEDIA_GROUP_FOLDER, media_count);
  84         }
  85         else
  86         {
  87                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  88                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  89         }
  90
  91         return ret;
  92 }
  93
  94 int media_folder_foreach_media_from_db(const char *folder_id, filter_h filter, media_info_cb callback, void *user_data)
  95 {
  96         int ret = MEDIA_CONTENT_ERROR_NONE;
  97
  98         if((callback != NULL) && STRING_VALID(folder_id))
  99         {
 100                 ret = _media_db_get_group_item(folder_id, filter, callback, user_data, MEDIA_GROUP_FOLDER);
 101         }
 102         else
 103         {
 104                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 105                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 106         }
 107
 108         return ret;
 109 }
 110
 111 int media_folder_destroy(media_folder_h folder)
 112 {
 113         int ret = MEDIA_CONTENT_ERROR_NONE;
 114         media_folder_s *_folder = (media_folder_s*)folder;
 115         if(_folder)
 116         {
 117                 SAFE_FREE(_folder->path);
 118                 SAFE_FREE(_folder->name);
 119                 SAFE_FREE(_folder->folder_id);
 120                 SAFE_FREE(_folder->storage_uuid);
 121                 SAFE_FREE(_folder);
 122                 ret = MEDIA_CONTENT_ERROR_NONE;
 123         }
 124         else
 125         {
 126                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 127                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 128         }
 129
 130         return ret;
 131 }
 132 int media_folder_clone(media_folder_h *dst, media_folder_h src)
 133 {
 134         int ret = MEDIA_CONTENT_ERROR_NONE;
 135         media_folder_s *_src = (media_folder_s*)src;
 136
 137         if(_src != NULL)
 138         {
 139                 media_folder_s *_dst = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 140                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 141
 142                 if(STRING_VALID(_src->folder_id))
 143                 {
 144                         _dst->folder_id = strdup(_src->folder_id);
 145                         if(_dst->folder_id == NULL)
 146                         {
 147                                 SAFE_FREE(_dst);
 148                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 149                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 150                         }
 151                 }
 152
 153                 _dst->storage_type = _src->storage_type;
 154
 155                 if(STRING_VALID(_src->name))
 156                 {
 157                         _dst->name = strdup(_src->name);
 158                         if(_dst->name == NULL)
 159                         {
 160                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 161                                 media_folder_destroy((media_folder_h)_dst);
 162                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 163                         }
 164                 }
 165
 166                 if(STRING_VALID(_src->path))
 167                 {
 168                         _dst->path = strdup(_src->path);
 169                         if(_dst->path == NULL)
 170                         {
 171                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 172                                 media_folder_destroy((media_folder_h)_dst);
 173                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 174                         }
 175                 }
 176
 177                 if(STRING_VALID(_src->storage_uuid))
 178                 {
 179                         _dst->storage_uuid = strdup(_src->storage_uuid);
 180                         if(_dst->storage_uuid == NULL)
 181                         {
 182                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 183                                 media_folder_destroy((media_folder_h)_dst);
 184                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 185                         }
 186                 }
 187
 188                 *dst = (media_folder_h)_dst;
 189
 190                 ret = MEDIA_CONTENT_ERROR_NONE;
 191         }
 192         else
 193         {
 194                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 195                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 196         }
 197
 198         return ret;
 199 }
 200
 201 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 202 {
 203         int ret = MEDIA_CONTENT_ERROR_NONE;
 204         media_folder_s *_folder = (media_folder_s*)folder;
 205
 206         if(_folder)
 207         {
 208                 if(STRING_VALID(_folder->folder_id))
 209                 {
 210                         *folder_id = strdup(_folder->folder_id);
 211                         media_content_retvm_if(*folder_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 212                 }
 213                 else
 214                 {
 215                         *folder_id = NULL;
 216                 }
 217                 ret = MEDIA_CONTENT_ERROR_NONE;
 218         }
 219         else
 220         {
 221                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 222                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 223         }
 224
 225         return ret;
 226 }
 227
 228 int media_folder_get_path(media_folder_h folder, char **path)
 229 {
 230         int ret = MEDIA_CONTENT_ERROR_NONE;
 231         media_folder_s *_folder = (media_folder_s*)folder;
 232
 233         if(_folder)
 234         {
 235                 if(STRING_VALID(_folder->path))
 236                 {
 237                         *path = strdup(_folder->path);
 238                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 239                 }
 240                 else
 241                 {
 242                         *path = NULL;
 243                 }
 244                 ret = MEDIA_CONTENT_ERROR_NONE;
 245
 246         }
 247         else
 248         {
 249                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 250                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 251         }
 252
 253         return ret;
 254
 255 }
 256
 257 int media_folder_get_name(media_folder_h folder, char **name)
 258 {
 259         int ret = MEDIA_CONTENT_ERROR_NONE;
 260         media_folder_s *_folder = (media_folder_s*)folder;
 261
 262         if(_folder)
 263         {
 264                 if(STRING_VALID(_folder->name))
 265                 {
 266                         *name = strdup(_folder->name);
 267                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 268                 }
 269                 else
 270                 {
 271                         *name = NULL;
 272                 }
 273                 ret = MEDIA_CONTENT_ERROR_NONE;
 274
 275         }
 276         else
 277         {
 278                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 279                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 280         }
 281
 282         return ret;
 283 }
 284
 285 int media_folder_get_modified_time(media_folder_h folder, time_t* time)
 286 {
 287         int ret = MEDIA_CONTENT_ERROR_NONE;
 288         media_folder_s *_folder = (media_folder_s*)folder;
 289
 290         if(_folder)
 291         {
 292                 *time = _folder->modified_time;
 293                 ret = MEDIA_CONTENT_ERROR_NONE;
 294         }
 295         else
 296         {
 297                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 298                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 299         }
 300
 301         return ret;
 302 }
 303
 304 int media_folder_get_storage_type(media_folder_h folder, media_content_storage_e* storage_type)
 305 {
 306         int ret = MEDIA_CONTENT_ERROR_NONE;
 307         media_folder_s *_folder = (media_folder_s*)folder;
 308
 309         if(_folder)
 310         {
 311                 *storage_type = _folder->storage_type;
 312                 ret = MEDIA_CONTENT_ERROR_NONE;
 313         }
 314         else
 315         {
 316                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 317                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 318         }
 319
 320         return ret;
 321 }
 322
 323 int media_folder_get_storage_id(media_folder_h folder, char **storage_id)
 324 {
 325         int ret = MEDIA_CONTENT_ERROR_NONE;
 326         media_folder_s *_folder = (media_folder_s*)folder;
 327
 328         if(_folder)
 329         {
 330                 if(STRING_VALID(_folder->storage_uuid))
 331                 {
 332                         *storage_id = strdup(_folder->storage_uuid);
 333                         media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 334                 }
 335                 else
 336                 {
 337                         *storage_id = NULL;
 338                 }
 339                 ret = MEDIA_CONTENT_ERROR_NONE;
 340
 341         }
 342         else
 343         {
 344                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 345                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 346         }
 347
 348         return ret;
 349 }
 350
 351 int media_folder_get_order(media_folder_h folder, int *order)
 352 {
 353         int ret = MEDIA_CONTENT_ERROR_NONE;
 354         media_folder_s *_folder = (media_folder_s*)folder;
 355
 356         if(_folder)
 357         {
 358                 *order = _folder->folder_order;
 359                 ret = MEDIA_CONTENT_ERROR_NONE;
 360         }
 361         else
 362         {
 363                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 364                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 365         }
 366
 367         return ret;
 368 }
 369
 370
 371 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 372 {
 373         int ret = MEDIA_CONTENT_ERROR_NONE;
 374         sqlite3_stmt *stmt = NULL;
 375         char select_query[DEFAULT_QUERY_SIZE];
 376
 377         if(!STRING_VALID(folder_id))
 378         {
 379                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 380                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 381         }
 382
 383         memset(select_query, 0x00, sizeof(select_query));
 384
 385         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 386
 387         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 388         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 389
 390         media_folder_s *_folder = NULL;
 391
 392         while(sqlite3_step(stmt) == SQLITE_ROW)
 393         {
 394                 if(_folder)
 395                         media_folder_destroy((media_folder_h)_folder);
 396
 397                 _folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 398                 if(_folder == NULL)
 399                 {
 400                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 401                         SQLITE3_FINALIZE(stmt);
 402                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 403                 }
 404
 405                 media_content_error("folder handle %x", _folder);
 406
 407                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
 408                         _folder->folder_id = strdup((const char *)sqlite3_column_text(stmt, 0));
 409
 410                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 411                         _folder->path = strdup((const char *)sqlite3_column_text(stmt, 1));
 412
 413                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
 414                         _folder->name = strdup((const char *)sqlite3_column_text(stmt, 2));
 415
 416                 *folder = (media_folder_h)_folder;
 417         }
 418
 419         SQLITE3_FINALIZE(stmt);
 420
 421         return ret;
 422 }
 423
 424 int media_folder_update_to_db(media_folder_h folder)
 425 {
 426         int ret = MEDIA_CONTENT_ERROR_NONE;
 427         media_folder_s *_folder = (media_folder_s*)folder;
 428         char *set_sql = NULL;
 429         char *sql = NULL;
 430
 431         if((_folder == NULL) || (_folder->folder_id == NULL))
 432         {
 433                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 434                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 435         }
 436
 437         /* Update folder order */
 438         sql = sqlite3_mprintf(UPDATE_FOLDER_ORDER, _folder->folder_order, _folder->folder_id);
 439
 440         ret = _content_query_sql(sql);
 441         sqlite3_free(sql);
 442
 443         if(STRING_VALID(_folder->folder_id) && g_src_path)
 444         {
 445                 /* Set modified time */
 446                 time_t date;
 447                 time(&date);
 448                 _folder->modified_time = date;
 449
 450                 set_sql = __media_folder_get_update_folder_sql((media_folder_h)_folder);
 451                 if(set_sql == NULL)
 452                 {
 453                         SAFE_FREE(g_src_path);
 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                 sql = sqlite3_mprintf("UPDATE %Q SET %s WHERE folder_uuid=%Q", DB_TABLE_FOLDER, set_sql, _folder->folder_id);
 459
 460                 ret = _content_query_sql(sql);
 461
 462                 sqlite3_free(set_sql);
 463                 sqlite3_free(sql);
 464                 if (ret != MEDIA_CONTENT_ERROR_NONE)
 465                 {
 466                         SAFE_FREE(g_src_path);
 467                         return ret;
 468                 }
 469
 470                 ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, _folder->path, tzplatform_getuid(TZ_USER_NAME));
 471                 SAFE_FREE(g_src_path);
 472
 473                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 474         }
 475
 476         return ret;
 477 }
 478
 479 int media_folder_set_name(media_folder_h folder, const char *name)
 480 {
 481         int ret = MEDIA_CONTENT_ERROR_NONE;
 482         media_folder_s *_folder = (media_folder_s*)folder;
 483
 484         if(_folder != NULL && STRING_VALID(name))
 485         {
 486                 if (STRING_VALID(_folder->path) && STRING_VALID(_folder->name)) {
 487                         char *folder_path = NULL;
 488                         char new_folder_path[MAX_QUERY_SIZE] = {0,};
 489
 490                         folder_path = g_path_get_dirname(_folder->path);
 491                         media_content_sec_debug("Existed Folder Path : %s", _folder->path);
 492                         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 493                         media_content_sec_debug("New Path : %s", new_folder_path);
 494
 495                         SAFE_FREE(g_src_path);
 496                         g_src_path = strdup(_folder->path);
 497
 498                         SAFE_FREE(_folder->path);
 499                         SAFE_FREE(_folder->name);
 500                         SAFE_FREE(folder_path);
 501                         _folder->path = strdup(new_folder_path);
 502                         media_content_retvm_if(_folder->path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 503                 }
 504
 505                 _folder->name = strdup(name);
 506                 media_content_retvm_if(_folder->name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 507         }
 508         else
 509         {
 510                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 511                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         return ret;
 515 }
 516
 517 int media_folder_set_order(media_folder_h folder, int order)
 518 {
 519         int ret = MEDIA_CONTENT_ERROR_NONE;
 520         media_folder_s *_folder = (media_folder_s*)folder;
 521
 522         if(_folder != NULL && order >= 0)
 523         {
 524                 _folder->folder_order = order;
 525         }
 526         else
 527         {
 528                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 529                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 530         }
 531
 532         return ret;
 533 }