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                 if(_dst == NULL)
 141                 {
 142                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 143                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 144                 }
 145
 146                 if(STRING_VALID(_src->folder_id))
 147                 {
 148                         _dst->folder_id = strdup(_src->folder_id);
 149                         if(_dst->folder_id == NULL)
 150                         {
 151                                 SAFE_FREE(_dst);
 152                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 153                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 154                         }
 155                 }
 156
 157                 _dst->storage_type = _src->storage_type;
 158
 159                 if(STRING_VALID(_src->name))
 160                 {
 161                         _dst->name = strdup(_src->name);
 162                         if(_dst->name == NULL)
 163                         {
 164                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 165                                 media_folder_destroy((media_folder_h)_dst);
 166                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 167                         }
 168                 }
 169
 170                 if(STRING_VALID(_src->path))
 171                 {
 172                         _dst->path = strdup(_src->path);
 173                         if(_dst->path == NULL)
 174                         {
 175                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 176                                 media_folder_destroy((media_folder_h)_dst);
 177                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 178                         }
 179                 }
 180
 181                 if(STRING_VALID(_src->storage_uuid))
 182                 {
 183                         _dst->storage_uuid = strdup(_src->storage_uuid);
 184                         if(_dst->storage_uuid == NULL)
 185                         {
 186                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 187                                 media_folder_destroy((media_folder_h)_dst);
 188                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 189                         }
 190                 }
 191
 192                 *dst = (media_folder_h)_dst;
 193
 194                 ret = MEDIA_CONTENT_ERROR_NONE;
 195         }
 196         else
 197         {
 198                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 199                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 200         }
 201
 202         return ret;
 203 }
 204
 205 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 206 {
 207         int ret = MEDIA_CONTENT_ERROR_NONE;
 208         media_folder_s *_folder = (media_folder_s*)folder;
 209
 210         if(_folder)
 211         {
 212                 if(STRING_VALID(_folder->folder_id))
 213                 {
 214                         *folder_id = strdup(_folder->folder_id);
 215                         if(*folder_id == NULL)
 216                         {
 217                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 218                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 219                         }
 220                 }
 221                 else
 222                 {
 223                         *folder_id = NULL;
 224                 }
 225                 ret = MEDIA_CONTENT_ERROR_NONE;
 226         }
 227         else
 228         {
 229                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 230                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 231         }
 232
 233         return ret;
 234 }
 235
 236 int media_folder_get_path(media_folder_h folder, char **path)
 237 {
 238         int ret = MEDIA_CONTENT_ERROR_NONE;
 239         media_folder_s *_folder = (media_folder_s*)folder;
 240         if(_folder)
 241         {
 242                 if(STRING_VALID(_folder->path))
 243                 {
 244                         *path = strdup(_folder->path);
 245                         if(*path == NULL)
 246                         {
 247                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 248                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 249                         }
 250                 }
 251                 else
 252                 {
 253                         *path = NULL;
 254                 }
 255                 ret = MEDIA_CONTENT_ERROR_NONE;
 256
 257         }
 258         else
 259         {
 260                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 261                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 262         }
 263
 264         return ret;
 265
 266 }
 267
 268 int media_folder_get_name(media_folder_h folder, char **name)
 269 {
 270         int ret = MEDIA_CONTENT_ERROR_NONE;
 271         media_folder_s *_folder = (media_folder_s*)folder;
 272         if(_folder)
 273         {
 274                 if(STRING_VALID(_folder->name))
 275                 {
 276                         *name = strdup(_folder->name);
 277                         if(*name == 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                 else
 284                 {
 285                         *name = NULL;
 286                 }
 287                 ret = MEDIA_CONTENT_ERROR_NONE;
 288
 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_folder_get_modified_time(media_folder_h folder, time_t* time)
 300 {
 301         int ret = MEDIA_CONTENT_ERROR_NONE;
 302         media_folder_s *_folder = (media_folder_s*)folder;
 303         if(_folder)
 304         {
 305                 *time = _folder->modified_time;
 306                 ret = MEDIA_CONTENT_ERROR_NONE;
 307         }
 308         else
 309         {
 310                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 311                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 312         }
 313
 314         return ret;
 315 }
 316
 317 int media_folder_get_storage_type(media_folder_h folder, media_content_storage_e* storage_type)
 318 {
 319         int ret = MEDIA_CONTENT_ERROR_NONE;
 320         media_folder_s *_folder = (media_folder_s*)folder;
 321         if(_folder)
 322         {
 323                 *storage_type = _folder->storage_type;
 324                 ret = MEDIA_CONTENT_ERROR_NONE;
 325         }
 326         else
 327         {
 328                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 329                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 330         }
 331
 332         return ret;
 333 }
 334
 335 int media_folder_get_storage_id(media_folder_h folder, char **storage_id)
 336 {
 337         int ret = MEDIA_CONTENT_ERROR_NONE;
 338         media_folder_s *_folder = (media_folder_s*)folder;
 339         if(_folder)
 340         {
 341                 if(STRING_VALID(_folder->storage_uuid))
 342                 {
 343                         *storage_id = strdup(_folder->storage_uuid);
 344                         if(*storage_id == NULL)
 345                         {
 346                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 347                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 348                         }
 349                 }
 350                 else
 351                 {
 352                         *storage_id = NULL;
 353                 }
 354                 ret = MEDIA_CONTENT_ERROR_NONE;
 355
 356         }
 357         else
 358         {
 359                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 360                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 361         }
 362
 363         return ret;
 364 }
 365
 366 int media_folder_get_order(media_folder_h folder, int *order)
 367 {
 368         int ret = MEDIA_CONTENT_ERROR_NONE;
 369         media_folder_s *_folder = (media_folder_s*)folder;
 370         if(_folder)
 371         {
 372                 *order = _folder->folder_order;
 373                 ret = MEDIA_CONTENT_ERROR_NONE;
 374         }
 375         else
 376         {
 377                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 378                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 379         }
 380
 381         return ret;
 382 }
 383
 384
 385 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 386 {
 387         int ret = MEDIA_CONTENT_ERROR_NONE;
 388         sqlite3_stmt *stmt = NULL;
 389         char select_query[DEFAULT_QUERY_SIZE];
 390
 391         if(!STRING_VALID(folder_id))
 392         {
 393                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 394                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 395         }
 396
 397         memset(select_query, 0x00, sizeof(select_query));
 398
 399         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 400
 401         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 402         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 403
 404         while(sqlite3_step(stmt) == SQLITE_ROW)
 405         {
 406                 media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 407
 408                 if(_folder == NULL)
 409                 {
 410                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 411                         SQLITE3_FINALIZE(stmt);
 412                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 413                 }
 414
 415                 media_content_error("folder handle %x", _folder);
 416
 417                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
 418                         _folder->folder_id = strdup((const char *)sqlite3_column_text(stmt, 0));
 419
 420                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 421                         _folder->path = strdup((const char *)sqlite3_column_text(stmt, 1));
 422
 423                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
 424                         _folder->name = strdup((const char *)sqlite3_column_text(stmt, 2));
 425
 426                 *folder = (media_folder_h)_folder;
 427         }
 428
 429         SQLITE3_FINALIZE(stmt);
 430
 431         return ret;
 432 }
 433
 434 int media_folder_update_to_db(media_folder_h folder)
 435 {
 436         int ret = MEDIA_CONTENT_ERROR_NONE;
 437         media_folder_s *_folder = (media_folder_s*)folder;
 438         char *set_sql = NULL;
 439         char *sql = NULL;
 440
 441         if((_folder == NULL) || (_folder->folder_id == NULL))
 442         {
 443                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 444                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 445         }
 446
 447         /* Update folder order */
 448         sql = sqlite3_mprintf(UPDATE_FOLDER_ORDER, _folder->folder_order, _folder->folder_id);
 449
 450         ret = _content_query_sql(sql);
 451         sqlite3_free(sql);
 452
 453         if(STRING_VALID(_folder->folder_id) && g_src_path)
 454         {
 455                 /* Set modified time */
 456                 time_t date;
 457                 time(&date);
 458                 _folder->modified_time = date;
 459
 460                 set_sql = __media_folder_get_update_folder_sql((media_folder_h)_folder);
 461                 if(set_sql == NULL)
 462                 {
 463                         SAFE_FREE(g_src_path);
 464                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 465                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 466                 }
 467
 468                 sql = sqlite3_mprintf("UPDATE %Q SET %s WHERE folder_uuid=%Q", DB_TABLE_FOLDER, set_sql, _folder->folder_id);
 469
 470                 ret = _content_query_sql(sql);
 471
 472                 sqlite3_free(set_sql);
 473                 sqlite3_free(sql);
 474                 if (ret != MEDIA_CONTENT_ERROR_NONE)
 475                 {
 476                         SAFE_FREE(g_src_path);
 477                         return ret;
 478                 }
 479
 480                 ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, _folder->path, tzplatform_getuid(TZ_USER_NAME));
 481                 SAFE_FREE(g_src_path);
 482
 483                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 484         }
 485
 486         return ret;
 487 }
 488
 489 int media_folder_set_name(media_folder_h folder, const char *name)
 490 {
 491         int ret = MEDIA_CONTENT_ERROR_NONE;
 492         media_folder_s *_folder = (media_folder_s*)folder;
 493
 494         if(_folder != NULL && STRING_VALID(name))
 495         {
 496                 if (STRING_VALID(_folder->path) && STRING_VALID(_folder->name)) {
 497                         char *folder_path = NULL;
 498                         char new_folder_path[MAX_QUERY_SIZE] = {0,};
 499
 500                         folder_path = g_path_get_dirname(_folder->path);
 501                         media_content_sec_debug("Existed Folder Path : %s", _folder->path);
 502                         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 503                         media_content_sec_debug("New Path : %s", new_folder_path);
 504
 505                         SAFE_FREE(g_src_path);
 506                         g_src_path = strdup(_folder->path);
 507
 508                         SAFE_FREE(_folder->path);
 509                         SAFE_FREE(_folder->name);
 510                         SAFE_FREE(folder_path);
 511                         _folder->path = strdup(new_folder_path);
 512
 513                         if(_folder->path == NULL)
 514                         {
 515                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 516                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 517                         }
 518                 }
 519
 520                 _folder->name = strdup(name);
 521                 if(_folder->name == NULL)
 522                 {
 523                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 524                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 525                 }
 526         }
 527         else
 528         {
 529                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 530                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 531         }
 532
 533         return ret;
 534 }
 535
 536 int media_folder_set_order(media_folder_h folder, int order)
 537 {
 538         int ret = MEDIA_CONTENT_ERROR_NONE;
 539         media_folder_s *_folder = (media_folder_s*)folder;
 540
 541         if(_folder != NULL && order >= 0)
 542         {
 543                 _folder->folder_order = order;
 544         }
 545         else
 546         {
 547                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 548                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 549         }
 550
 551         return ret;
 552 }