src/common/file-system/mf-ug-file-attr.c

   1 /*
   2  * Copyright 2012          Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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
  19
  20
  21 #include <regex.h>
  22 #include <sys/types.h>
  23 #include <media_content.h>
  24 #include <drm_client.h>
  25 #include <drm_client_types.h>
  26 #include "mf-ug-fs-util.h"
  27 #include "mf-ug-util.h"
  28
  29 #define MF_UG_PHONE_DEFAULT_LEVEL               2   /*the phone path is /opt/media, it consists of opt and media two parts*/
  30 #define MF_UG_MMC_DEFAULT_LEVEL                 3   /*the mmc path is /opt/storage/sdcard, it consists of opt and storage and sdcard three parts*/
  31 #define CONDITION_LENGTH 200
  32 #define UG_CONDITION_IMAGE_VIDEO "(MEDIA_TYPE=0 OR MEDIA_TYPE=1)"
  33
  34 typedef struct __ug_filter_s ug_filter_s;
  35 struct __ug_filter_s {
  36         char *cond;                              /*set media type or favorite type, or other query statement*/
  37         media_content_collation_e collate_type;  /*collate type*/
  38         media_content_order_e sort_type;         /*sort type*/
  39         char *sort_keyword;                      /*sort keyword*/
  40         int offset;                              /*offset*/
  41         int count;                               /*count*/
  42         bool with_meta;                          /*whether get image or video info*/
  43 };
  44
  45 typedef struct __ug_transfer_data_s ug_transfer_data_s;
  46
  47 struct __ug_transfer_data_s {
  48         const char *file_path;
  49         char *thumbnail_path;
  50 };
  51
  52
  53 struct _ug_ftype_by_mime {
  54         const char *mime;
  55         mf_ug_fs_file_type ftype;
  56 };
  57
  58 static struct _ug_ftype_by_mime mime_type[] = {
  59         {"image/png", UG_FILE_TYPE_IMAGE},
  60         {"image/jpeg", UG_FILE_TYPE_IMAGE},
  61         {"image/gif", UG_FILE_TYPE_IMAGE},
  62         {"image/bmp", UG_FILE_TYPE_IMAGE},
  63         {"image/vnd.wap.wbmp", UG_FILE_TYPE_IMAGE},
  64
  65         {"video/x-msvideo", UG_FILE_TYPE_VIDEO},
  66         {"video/mp4", UG_FILE_TYPE_VIDEO},
  67         {"video/3gpp", UG_FILE_TYPE_VIDEO},
  68         {"video/x-ms-asf", UG_FILE_TYPE_VIDEO},
  69         {"video/x-ms-wmv", UG_FILE_TYPE_VIDEO},
  70         {"video/x-matroska", UG_FILE_TYPE_VIDEO},
  71
  72         {"audio/mpeg", UG_FILE_TYPE_MUSIC},
  73         {"audio/x-wav", UG_FILE_TYPE_MUSIC},
  74         {"application/x-smaf", UG_FILE_TYPE_MUSIC},
  75         {"audio/mxmf", UG_FILE_TYPE_MUSIC},
  76         {"audio/midi", UG_FILE_TYPE_MUSIC},
  77         {"audio/x-xmf", UG_FILE_TYPE_MUSIC},
  78         {"audio/x-ms-wma", UG_FILE_TYPE_MUSIC},
  79         {"audio/aac", UG_FILE_TYPE_MUSIC},
  80         {"audio/ac3", UG_FILE_TYPE_MUSIC},
  81         {"audio/ogg", UG_FILE_TYPE_MUSIC},
  82         {"audio/vorbis", UG_FILE_TYPE_MUSIC},
  83         {"audio/imelody", UG_FILE_TYPE_MUSIC},
  84         {"audio/iMelody", UG_FILE_TYPE_MUSIC},
  85         {"audio/x-rmf", UG_FILE_TYPE_MUSIC},
  86         {"application/vnd.smaf", UG_FILE_TYPE_MUSIC},
  87         {"audio/mobile-xmf", UG_FILE_TYPE_MUSIC},
  88         {"audio/mid", UG_FILE_TYPE_MUSIC},
  89         {"audio/vnd.ms-playready.media.pya", UG_FILE_TYPE_MUSIC},
  90         {"audio/imy", UG_FILE_TYPE_MUSIC},
  91         {"audio/m4a", UG_FILE_TYPE_MUSIC},
  92         {"audio/melody", UG_FILE_TYPE_MUSIC},
  93         {"audio/mmf", UG_FILE_TYPE_MUSIC},
  94         {"audio/mp3", UG_FILE_TYPE_MUSIC},
  95         {"audio/mp4", UG_FILE_TYPE_MUSIC},
  96         {"audio/MP4A-LATM", UG_FILE_TYPE_MUSIC},
  97         {"audio/mpeg3", UG_FILE_TYPE_MUSIC},
  98         {"audio/mpeg4", UG_FILE_TYPE_MUSIC},
  99         {"audio/mpg", UG_FILE_TYPE_MUSIC},
 100         {"audio/mpg3", UG_FILE_TYPE_MUSIC},
 101         {"audio/smaf", UG_FILE_TYPE_MUSIC},
 102         {"audio/sp-midi", UG_FILE_TYPE_MUSIC},
 103         {"audio/wav", UG_FILE_TYPE_MUSIC},
 104         {"audio/wave", UG_FILE_TYPE_MUSIC},
 105         {"audio/wma", UG_FILE_TYPE_MUSIC},
 106         {"audio/xmf", UG_FILE_TYPE_MUSIC},
 107         {"audio/x-mid", UG_FILE_TYPE_MUSIC},
 108         {"audio/x-midi", UG_FILE_TYPE_MUSIC},
 109         {"audio/x-mp3", UG_FILE_TYPE_MUSIC},
 110         {"audio/-mpeg", UG_FILE_TYPE_MUSIC},
 111         {"audio/x-mpeg", UG_FILE_TYPE_MUSIC},
 112         {"audio/x-mpegaudio", UG_FILE_TYPE_MUSIC},
 113         {"audio/x-mpg", UG_FILE_TYPE_MUSIC},
 114         {"audio/x-ms-asf", UG_FILE_TYPE_MUSIC},
 115         {"audio/x-wave", UG_FILE_TYPE_MUSIC},
 116
 117         {"application/pdf", UG_FILE_TYPE_PDF},
 118
 119         {"application/msword", UG_FILE_TYPE_DOC},
 120         {"application/vnd.openxmlformats-officedocument.wordprocessingml.document", UG_FILE_TYPE_DOC},
 121
 122         {"application/vnd.ms-powerpoint", UG_FILE_TYPE_PPT},
 123         {"application/vnd.openxmlformats-officedocument.presentationml.presentation", UG_FILE_TYPE_PPT},
 124
 125         {"application/vnd.ms-excel", UG_FILE_TYPE_EXCEL},
 126         {"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", UG_FILE_TYPE_EXCEL},
 127
 128         {"audio/AMR", UG_FILE_TYPE_VOICE},
 129         {"audio/AMR-WB", UG_FILE_TYPE_VOICE},
 130         {"audio/amr", UG_FILE_TYPE_VOICE},
 131         {"audio/amr-wb", UG_FILE_TYPE_VOICE},
 132         {"audio/x-amr", UG_FILE_TYPE_VOICE},
 133
 134         {"text/html", UG_FILE_TYPE_HTML},
 135
 136         {"application/x-shockwave-flash", UG_FILE_TYPE_FLASH},
 137         {"video/x-flv", UG_FILE_TYPE_FLASH},
 138
 139         {"text/plain", UG_FILE_TYPE_TXT},
 140
 141         {"text/x-opml+xml", UG_FILE_TYPE_RSS},
 142
 143         {"text/vnd.sun.j2me.app-descriptor", UG_FILE_TYPE_JAVA},
 144         {"application/x-java-archive", UG_FILE_TYPE_JAVA},
 145
 146         {NULL, UG_FILE_TYPE_ETC},
 147 };
 148
 149 static char *icon_array[UG_FILE_TYPE_MAX] = {
 150         [UG_FILE_TYPE_DIR] = UG_ICON_FOLDER,
 151         [UG_FILE_TYPE_IMAGE] = UG_ICON_IMAGE,
 152         [UG_FILE_TYPE_VIDEO] = UG_ICON_VIDEO,
 153         [UG_FILE_TYPE_MUSIC] = UG_ICON_MUSIC,
 154         [UG_FILE_TYPE_SOUND] = UG_ICON_SOUND,
 155         [UG_FILE_TYPE_PDF] = UG_ICON_PDF,
 156         [UG_FILE_TYPE_DOC] = UG_ICON_DOC,
 157         [UG_FILE_TYPE_PPT] = UG_ICON_PPT,
 158         [UG_FILE_TYPE_EXCEL] = UG_ICON_EXCEL,
 159         [UG_FILE_TYPE_VOICE] = UG_ICON_VOICE,
 160         [UG_FILE_TYPE_HTML] = UG_ICON_HTML,
 161         [UG_FILE_TYPE_FLASH] = UG_ICON_FLASH,
 162         [UG_FILE_TYPE_TXT] = UG_ICON_TXT,
 163         [UG_FILE_TYPE_VCONTACT] = UG_ICON_VCONTACT,
 164         [UG_FILE_TYPE_VCALENDAR] = UG_ICON_VCALENDAR,
 165         [UG_FILE_TYPE_VNOTE] = UG_ICON_VNOTE,
 166         [UG_FILE_TYPE_RSS] = UG_ICON_RSS,
 167         [UG_FILE_TYPE_JAVA] = UG_ICON_JAVA,
 168 };
 169
 170 /*********************
 171 **Function name:        __mf_ug_file_attr_get_category_by_file_ext
 172 **Parameter:            const char* file_ext
 173 **Return value:         mf_ug_fs_file_type
 174 **
 175 **Action:
 176 **      Get file category by extention
 177 **
 178 *********************/
 179 static mf_ug_fs_file_type __mf_ug_file_attr_get_category_by_file_ext(const char *file_ext, const char *fullpath)
 180 {
 181         int i = 0;
 182
 183         if (file_ext == NULL) {
 184                 return UG_FILE_TYPE_ETC;
 185         }
 186
 187         if (file_ext[0] == '.') {
 188                 i = 1;
 189         }
 190
 191         switch (file_ext[i]) {
 192         case 'a':
 193         case 'A':
 194                 if (strcasecmp("ASF", &file_ext[i]) == 0) {
 195                         return UG_FILE_TYPE_VIDEO;
 196                 }
 197                 if (strcasecmp("AMR", &file_ext[i]) == 0) {
 198                         return UG_FILE_TYPE_VOICE;
 199                 }
 200                 if (strcasecmp("AWB", &file_ext[i]) == 0) {
 201                         return UG_FILE_TYPE_VOICE;
 202                 }
 203                 if (strcasecmp("AAC", &file_ext[i]) == 0) {
 204                         return UG_FILE_TYPE_MUSIC;
 205                 }
 206                 if (strcasecmp("AVI", &file_ext[i]) == 0) {
 207                         return UG_FILE_TYPE_VIDEO;
 208                 }
 209                 if (strcasecmp("AAC", &file_ext[i]) == 0) {
 210                         return UG_FILE_TYPE_MUSIC;
 211                 }
 212
 213                 break;
 214         case 'b':
 215         case 'B':
 216                 if (strcasecmp("BMP", &file_ext[i]) == 0) {
 217                         return UG_FILE_TYPE_IMAGE;
 218                 }
 219                 break;
 220         case 'd':
 221         case 'D':
 222                 if (strcasecmp("DOC", &file_ext[i]) == 0) {
 223                         return UG_FILE_TYPE_DOC;
 224                 }
 225                 if (strcasecmp("DOCX", &file_ext[i]) == 0) {
 226                         return UG_FILE_TYPE_DOC;
 227                 }
 228                 if (strcasecmp("DIVX", &file_ext[i]) == 0) {
 229                         if (mf_ug_file_attr_is_drm_file(fullpath) == 0) {
 230                                 return UG_FILE_TYPE_DRM;
 231                         } else {
 232                                 return UG_FILE_TYPE_VIDEO;
 233                         }
 234                 }
 235                 if (strcasecmp("DCF", &file_ext[i]) == 0) {
 236                         return UG_FILE_TYPE_DRM;
 237                 }
 238                 break;
 239         case 'g':
 240         case 'G':
 241                 if (strcasecmp("GIF", &file_ext[i]) == 0) {
 242                         return UG_FILE_TYPE_IMAGE;
 243                 }
 244                 if (strcasecmp("G72", &file_ext[i]) == 0) {
 245                         return UG_FILE_TYPE_MUSIC;
 246                 }
 247                 break;
 248         case 'h':
 249         case 'H':
 250                 if (strcasecmp("H263", &file_ext[i]) == 0) {
 251                         return UG_FILE_TYPE_MUSIC;
 252                 }
 253                 if (strcasecmp("HTML", &file_ext[i]) == 0) {
 254                         return UG_FILE_TYPE_HTML;
 255                 }
 256                 if (strcasecmp("HTM", &file_ext[i]) == 0) {
 257                         return UG_FILE_TYPE_HTML;
 258                 }
 259                 break;
 260         case 'i':
 261         case 'I':
 262                 if (strcasecmp("IMY", &file_ext[i]) == 0) {
 263                         return UG_FILE_TYPE_SOUND;
 264                 }
 265                 if (strcasecmp("IPK", &file_ext[i]) == 0) {
 266                         return UG_FILE_TYPE_APP;
 267                 }
 268                 break;
 269         case 'j':
 270         case 'J':
 271                 if (strcasecmp("JAD", &file_ext[i]) == 0) {
 272                         return UG_FILE_TYPE_JAVA;
 273                 }
 274                 if (strcasecmp("JAR", &file_ext[i]) == 0) {
 275                         return UG_FILE_TYPE_JAVA;
 276                 }
 277
 278                 if (strcasecmp("JPG", &file_ext[i]) == 0) {
 279                         return UG_FILE_TYPE_IMAGE;
 280                 }
 281                 if (strcasecmp("JPEG", &file_ext[i]) == 0) {
 282                         return UG_FILE_TYPE_IMAGE;
 283                 }
 284                 if (strcasecmp("JPE", &file_ext[i]) == 0) {
 285                         return UG_FILE_TYPE_IMAGE;
 286                 }
 287                 break;
 288         case 'm':
 289         case 'M':
 290                 if (strcasecmp("MMF", &file_ext[i]) == 0) {
 291                         return UG_FILE_TYPE_SOUND;
 292                 }
 293                 if (strcasecmp("MP3", &file_ext[i]) == 0) {
 294                         return UG_FILE_TYPE_MUSIC;
 295                 }
 296                 if (strcasecmp("MID", &file_ext[i]) == 0) {
 297                         return UG_FILE_TYPE_SOUND;
 298                 }
 299                 if (strcasecmp("MIDI", &file_ext[i]) == 0) {
 300                         return UG_FILE_TYPE_SOUND;
 301                 }
 302                 if (strcasecmp("MP4", &file_ext[i]) == 0) {
 303                         return UG_FILE_TYPE_VIDEO;
 304                 }
 305                 if (strcasecmp("MPG", &file_ext[i]) == 0) {
 306                         return UG_FILE_TYPE_VIDEO;
 307                 }
 308                 if (strcasecmp("MPEG", &file_ext[i]) == 0) {
 309                         return UG_FILE_TYPE_VIDEO;
 310                 }
 311                 if (strcasecmp("M4A", &file_ext[i]) == 0) {
 312                         return UG_FILE_TYPE_MUSIC;
 313                 }
 314                 if (strcasecmp("M3G", &file_ext[i]) == 0) {
 315                         return UG_FILE_TYPE_FLASH;
 316                 }
 317                 if (strcasecmp("MXMF", &file_ext[i]) == 0) {
 318                         return UG_FILE_TYPE_SOUND;
 319                 }
 320                 if (strcasecmp("MKV", &file_ext[i]) == 0) {
 321                         return UG_FILE_TYPE_VIDEO;
 322                 }
 323                 if (strcasecmp("MKA", &file_ext[i]) == 0) {
 324                         return UG_FILE_TYPE_MUSIC;
 325                 }
 326                 break;
 327         case 'o':
 328         case 'O':
 329                 if (strcasecmp("opml", &file_ext[i]) == 0) {
 330                         return UG_FILE_TYPE_RSS;
 331                 }
 332                 break;
 333         case 'p':
 334         case 'P':
 335                 if (strcasecmp("PNG", &file_ext[i]) == 0) {
 336                         return UG_FILE_TYPE_IMAGE;
 337                 }
 338                 if (strcasecmp("PJPEG", &file_ext[i]) == 0) {
 339                         return UG_FILE_TYPE_IMAGE;
 340                 }
 341                 if (strcasecmp("PDF", &file_ext[i]) == 0) {
 342                         return UG_FILE_TYPE_PDF;
 343                 }
 344                 if (strcasecmp("PPT", &file_ext[i]) == 0) {
 345                         return UG_FILE_TYPE_PPT;
 346                 }
 347                 if (strcasecmp("PPTX", &file_ext[i]) == 0) {
 348                         return UG_FILE_TYPE_PPT;
 349                 }
 350                 if (strcasecmp("PEM", &file_ext[i]) == 0) {
 351                         return UG_FILE_TYPE_CERTIFICATION;
 352                 }
 353                 break;
 354         case 'r':
 355         case 'R':
 356                 break;
 357         case 's':
 358         case 'S':
 359                 if (strcasecmp("SDP", &file_ext[i]) == 0) {
 360                         return UG_FILE_TYPE_VIDEO;
 361                 }
 362                 if (strcasecmp("SPM", &file_ext[i]) == 0) {
 363                         return UG_FILE_TYPE_SOUND;
 364                 }
 365                 if (strcasecmp("SMP", &file_ext[i]) == 0) {
 366                         return UG_FILE_TYPE_SOUND;
 367                 }
 368                 if (strcasecmp("SPF", &file_ext[i]) == 0) {
 369                         return UG_FILE_TYPE_SOUND;
 370                 }
 371                 if (strcasecmp("SWF", &file_ext[i]) == 0) {
 372                         return UG_FILE_TYPE_FLASH;
 373                 }
 374                 if (strcasecmp("SCN", &file_ext[i]) == 0) {
 375                         return UG_FILE_TYPE_MOVIE_MAKER;
 376                 }
 377                 if (strcasecmp("SVG", &file_ext[i]) == 0) {
 378                         return UG_FILE_TYPE_SVG;
 379                 }
 380                 if (strcasecmp("SVGZ", &file_ext[i]) == 0) {
 381                         return UG_FILE_TYPE_SVG;
 382                 }
 383                 break;
 384         case 't':
 385         case 'T':
 386                 if (strcasecmp("TXT", &file_ext[i]) == 0) {
 387                         return UG_FILE_TYPE_TXT;
 388                 }
 389                 if (strcasecmp("THM", &file_ext[i]) == 0) {
 390                         return UG_FILE_TYPE_THEME;
 391                 }
 392                 break;
 393         case 'v':
 394         case 'V':
 395                 if (strcasecmp("VCF", &file_ext[i]) == 0) {
 396                         return UG_FILE_TYPE_VCONTACT;
 397                 }
 398                 if (strcasecmp("VCS", &file_ext[i]) == 0) {
 399                         return UG_FILE_TYPE_VCALENDAR;
 400                 }
 401                 if (strcasecmp("VNT", &file_ext[i]) == 0) {
 402                         return UG_FILE_TYPE_VNOTE;
 403                 }
 404                 if (strcasecmp("VBM", &file_ext[i]) == 0) {
 405                         return UG_FILE_TYPE_VBOOKMARK;
 406                 }
 407                 break;
 408         case 'w':
 409         case 'W':
 410                 if (strcasecmp("WAV", &file_ext[i]) == 0) {
 411                         return UG_FILE_TYPE_SOUND;
 412                 }
 413                 if (strcasecmp("WBMP", &file_ext[i]) == 0) {
 414                         return UG_FILE_TYPE_IMAGE;
 415                 }
 416                 if (strcasecmp("WGT", &file_ext[i]) == 0) {
 417                         return UG_FILE_TYPE_WGT;
 418                 }
 419                 if (strcasecmp("WMA", &file_ext[i]) == 0) {
 420                         return UG_FILE_TYPE_MUSIC;
 421                 }
 422                 if (strcasecmp("WMV", &file_ext[i]) == 0) {
 423                         return UG_FILE_TYPE_VIDEO;
 424                 }
 425                 break;
 426         case 'x':
 427         case 'X':
 428                 if (strcasecmp("XLS", &file_ext[i]) == 0) {
 429                         return UG_FILE_TYPE_EXCEL;
 430                 }
 431                 if (strcasecmp("XLSX", &file_ext[i]) == 0) {
 432                         return UG_FILE_TYPE_EXCEL;
 433                 }
 434                 if (strcasecmp("XMF", &file_ext[i]) == 0) {
 435                         return UG_FILE_TYPE_SOUND;
 436                 }
 437                 if (strcasecmp("XHTML", &file_ext[i]) == 0) {
 438                         return UG_FILE_TYPE_HTML;
 439                 }
 440                 break;
 441         case '3':
 442                 if (strcasecmp("3GP", &file_ext[i]) == 0) {
 443                         return UG_FILE_TYPE_VIDEO;
 444                 }
 445                 if (strcasecmp("3GPP", &file_ext[i]) == 0) {
 446                         return UG_FILE_TYPE_VIDEO;
 447                 }
 448                 if (strcasecmp("3G2", &file_ext[i]) == 0) {
 449                         return UG_FILE_TYPE_VIDEO;
 450                 }
 451                 break;
 452         }
 453
 454         return UG_FILE_TYPE_ETC;
 455 }
 456
 457 /*********************
 458 **Function name:        mf_ug_file_attr_is_valid_name
 459 **Parameter:
 460 **      const char *filename:   the file/dir name we need to check
 461 **
 462 **Return value:
 463 **      -0x14   if the name is invalid
 464 **      0               if the name is valid
 465 **
 466 **Action:
 467 **      check if the name is valid by file name
 468 **
 469 *********************/
 470 int mf_ug_file_attr_is_valid_name(const char *filename)
 471 {
 472         char *pattern;
 473         int ret, z, cflags = 0;
 474         char ebuf[128];
 475         regex_t reg;
 476         regmatch_t pm[1];
 477         const size_t nmatch = 1;
 478         /*/ToDo: ignore the file star with . */
 479         if (strncmp(filename, ".", 1) == 0) {
 480                 return MYFILE_ERR_INVALID_FILE_NAME;
 481         }
 482
 483         pattern = MYFILE_NAME_PATTERN;
 484         z = regcomp(&reg, pattern, cflags);
 485
 486         if (z != 0) {
 487                 regerror(z, &reg, ebuf, sizeof(ebuf));
 488                 fprintf(stderr, "%s: pattern '%s' \n", ebuf, pattern);
 489                 return MYFILE_ERR_INVALID_FILE_NAME;
 490         }
 491
 492         z = regexec(&reg, filename, nmatch, pm, 0);
 493         if (z == REG_NOMATCH) {
 494                 ret = MYFILE_ERR_NONE;
 495         } else {
 496                 ret = MYFILE_ERR_INVALID_FILE_NAME;
 497         }
 498         regfree(&reg);
 499         return ret;
 500 }
 501
 502
 503 /******************************
 504 ** Prototype    : __mf_ug_file_attr_default_icon_get_by_type
 505 ** Description  : Samsung
 506 ** Input        : mf_ug_fs_file_type ftype
 507 ** Output       : None
 508 ** Return Value :
 509 ** Calls        :
 510 ** Called By    :
 511 **
 512 **  History        :
 513 **  1.Date         : 2010/12/10
 514 **    Author       : Samsung
 515 **    Modification : Created function
 516 **
 517 ******************************/
 518 static char *__mf_ug_file_attr_default_icon_get_by_type(mf_ug_fs_file_type ftype)
 519 {
 520         char *icon_path = NULL;
 521
 522         if (icon_array[ftype]) {
 523                 icon_path = strdup(icon_array[ftype]);
 524         } else {
 525                 icon_path = strdup(UG_DEFAULT_ICON);
 526         }
 527
 528         return icon_path;
 529 }
 530
 531
 532 /******************************
 533 ** Prototype    : mf_ug_file_attr_get_parent_path
 534 ** Description  : Samsung
 535 ** Input        : const char* path
 536 **                char* parent_path
 537 ** Output       : None
 538 ** Return Value :
 539 ** Calls        :
 540 ** Called By    :
 541 **
 542 **  History        :
 543 **  1.Date         : 2010/12/10
 544 **    Author       : Samsung
 545 **    Modification : Created function
 546 **
 547 ******************************/
 548 int mf_ug_file_attr_get_parent_path(const char *path, char **parent_path)
 549 {
 550         ug_mf_retvm_if(path == NULL, MYFILE_ERR_INVALID_ARG, "path is NULL");
 551         ug_mf_retvm_if(parent_path == NULL, MYFILE_ERR_INVALID_ARG, "parent_path is NULL");
 552         ug_debug("Path :::: [%s]", path);
 553
 554         *parent_path = g_strdup(path);
 555         if (*parent_path == NULL)
 556                 return MYFILE_ERR_ALLOCATE_FAIL;
 557
 558         const char *name = NULL;
 559         name = ecore_file_file_get(path);
 560         /*
 561         **      input path and parent_path are check in the caller.
 562         **      parent_path is full path must be like /opt/media/file.ext
 563         **      name is file.ext
 564         **      strlen(parent_path) should large than strlen(name) normally.
 565         **      to take exception like input path is "", we add a if condition
 566         */
 567         if (strlen(*parent_path) > strlen(name))
 568                 (*parent_path)[strlen(*parent_path) - strlen(name) - 1] = '\0';
 569
 570         if (strlen(*parent_path) == 0) {
 571                 *parent_path = g_strdup("/");
 572         }
 573
 574         return MYFILE_ERR_NONE;
 575 }
 576
 577
 578 /*********************
 579 **Function name:        mf_get_category
 580 **Parameter:
 581 **      const char* filepath:   file fullpath
 582 **      mf_ug_fs_file_type *category:   output parameter of category
 583 **Return value:
 584 **      error code
 585 **
 586 **Action:
 587 **      Get file category by file full path
 588 **
 589 *********************/
 590 int mf_ug_file_attr_get_file_category(const char *filepath, mf_ug_fs_file_type * category)
 591 {
 592         int i = 0;
 593         int flag = 0;
 594
 595         if (mf_ug_file_attr_is_dir(filepath)) {
 596                 *category = UG_FILE_TYPE_DIR;
 597                 return MYFILE_ERR_NONE;
 598         }
 599
 600         const char *filename = NULL;
 601         filename = ecore_file_file_get(filepath);
 602         /*/return value ceck */
 603         if (filename == NULL) {
 604                 *category = UG_FILE_TYPE_NONE;
 605                 return MYFILE_ERR_SRC_ARG_INVALID;
 606         }
 607         char file_ext[FILE_EXT_LEN_MAX + 1] = { 0 };
 608         /*/ToDo: error file name like the last letter is "." */
 609         for (i = strlen(filename); i >= 0; i--) {
 610                 if (filename[i] == '.') {
 611                         strncpy(file_ext, &filename[i + 1], FILE_EXT_LEN_MAX + 1);
 612                         flag = 1;
 613                         break;
 614                 }
 615
 616                 if (filename[i] == '/') {
 617                         flag = 0;
 618                         break;
 619                 }
 620         }
 621
 622         if (flag == 1) {
 623                 *category = __mf_ug_file_attr_get_category_by_file_ext(file_ext, filepath);
 624                 return MYFILE_ERR_NONE;
 625         } else {
 626                 *category = UG_FILE_TYPE_NONE;
 627                 return MYFILE_ERR_GET_CATEGORY_FAIL;
 628         }
 629 }
 630
 631 /*********************
 632 **Function name:        mf_ug_file_attr_get_file_stat
 633 **Parameter:
 634 **      const char* filename:   file name
 635 **      ugFsNodeInfo **node:            output parameter of what we need to refine
 636 **Return value:
 637 **      error code
 638 **
 639 **Action:
 640 **      Get file size and last modified date by file path
 641 **
 642 *********************/
 643 int mf_ug_file_attr_get_file_stat(const char *filename, ugFsNodeInfo ** node)
 644 {
 645         struct stat statbuf;
 646
 647         ug_mf_retvm_if(filename == NULL, MYFILE_ERR_INVALID_ARG, "filename is null");
 648         ug_mf_retvm_if(node == NULL, MYFILE_ERR_INVALID_ARG, "node is null");
 649
 650         if (stat(filename, &statbuf) == -1) {
 651                 return MYFILE_ERR_GET_STAT_FAIL;
 652         }
 653
 654         (*node)->size = statbuf.st_size;
 655         (*node)->date = statbuf.st_mtime;
 656
 657         return MYFILE_ERR_NONE;
 658 }
 659
 660 /*********************
 661 **Function name:        mf_ug_file_attr_is_dir
 662 **Parameter:
 663 **      const char* filename:   file fullpath
 664 **Return value:
 665 **      if path is a directory, return 1
 666 **      else, return 0
 667 **
 668 **Action:
 669 **      check if the file path is Directory
 670 **
 671 *********************/
 672 int mf_ug_file_attr_is_dir(const char *filepath)
 673 {
 674         return ecore_file_is_dir(filepath);
 675 }
 676
 677 /*********************
 678 **Function name:        mf_ug_file_attr_get_store_type_by_full
 679 **Parameter:
 680 **      const char* filepath:   file full path
 681 **      mf_ug_storage_type *store_type:         output parameter of storage type
 682 **Return value:
 683 **      error code
 684 **
 685 **Action:
 686 **      Get file storage type by file path
 687 **
 688 *********************/
 689 int mf_ug_file_attr_get_store_type_by_full(const char *filepath, mf_ug_storage_type * store_type)
 690 {
 691         if (filepath == NULL || store_type == NULL) {
 692                 return MYFILE_ERR_SRC_ARG_INVALID;
 693         }
 694
 695         if (strncmp(filepath, PHONE_FOLDER, strlen(PHONE_FOLDER)) == 0) {
 696                 *store_type = MF_UG_PHONE;
 697                 return MYFILE_ERR_NONE;
 698         } else if (strncmp(filepath, MEMORY_FOLDER, strlen(MEMORY_FOLDER)) == 0) {
 699                 *store_type = MF_UG_MMC;
 700                 return MYFILE_ERR_NONE;
 701         } else {
 702                 *store_type = MF_UG_NONE;
 703                 return MYFILE_ERR_STORAGE_TYPE_ERROR;
 704         }
 705 }
 706
 707 /*********************
 708 **Function name:        mf_ug_file_attr_is_drm_file
 709 **Parameter:
 710 **      const char* filepath:   file full path
 711 **
 712 **Return value:
 713 **      true if it is a DRM file
 714 **      false if it is not a DRM file
 715 **
 716 **Action:
 717 **      check if file is drm file
 718 **
 719 *********************/
 720 int mf_ug_file_attr_is_drm_file(const char *file_fullpath)
 721 {
 722         if (file_fullpath == NULL)
 723                 return MYFILE_ERR_DRM_PERMISSION_DENY;
 724         drm_bool_type_e drmFlag = DRM_FALSE;
 725         int res = 0;
 726         res = drm_is_drm_file(file_fullpath, &drmFlag);
 727
 728         if (res == DRM_RETURN_SUCCESS && drmFlag == DRM_TRUE)
 729                 return 0;
 730         else
 731                 return MYFILE_ERR_DRM_PERMISSION_DENY;
 732 }
 733
 734 /*********************
 735 **Function name:        mf_ug_file_attr_get_file_ext
 736 **Parameter:
 737 **      const char* filepath:   file full path
 738 **      char *file_ext:                 output parameter of file extension
 739 **
 740 **Return value:
 741 **      error code
 742 **
 743 **Action:
 744 **      get file extension by file full path
 745 **
 746 *********************/
 747 int mf_ug_file_attr_get_file_ext(const char *filepath, char **file_ext)
 748 {
 749         ug_mf_retvm_if(filepath == NULL, MYFILE_ERR_INVALID_FILE_NAME, "filepath is NULL");
 750         ug_mf_retvm_if(file_ext == NULL, MYFILE_ERR_INVALID_FILE_NAME, "file_ext is NULL");
 751
 752         const char *filename = NULL;
 753         filename = ecore_file_file_get(filepath);
 754
 755         if (filename == NULL) {
 756                 return MYFILE_ERR_INVALID_FILE_NAME;
 757         }
 758
 759         char *pdot = strrchr(filename, '.');
 760
 761         if (!pdot) {
 762                 return MYFILE_ERR_EXT_GET_ERROR;
 763         } else if (pdot != filepath) {
 764                 *file_ext = g_strdup(pdot + 1);
 765                 return MYFILE_ERR_NONE;
 766         } else {
 767                 return MYFILE_ERR_EXT_GET_ERROR;
 768         }
 769 }
 770
 771
 772
 773 /*********************
 774 **Function name:        mf_ug_file_attr_is_right_dir_path
 775 **Parameter:
 776 **      const char *filename:   the file/dir name we need to check
 777 **
 778 **Return value:
 779 **      error code
 780 **
 781 **Action:
 782 **      check if the dir path is correct
 783 **
 784 *********************/
 785 int mf_ug_file_attr_is_right_dir_path(const char *dir_path)
 786 {
 787         int result = MYFILE_ERR_NONE;
 788         int length = 0;
 789
 790         length = strlen(dir_path);
 791         if (length == 0) {
 792                 return MYFILE_ERR_INVALID_DIR_PATH;
 793         }
 794
 795         if (dir_path[length - 1] == '/' && length > 1) {
 796                 return MYFILE_ERR_INVALID_DIR_PATH;
 797         }
 798
 799         if (dir_path[0] != '/') {
 800                 return MYFILE_ERR_INVALID_DIR_PATH;
 801         }
 802
 803         const char *file_name = NULL;
 804         file_name = ecore_file_file_get(dir_path);
 805         result = mf_ug_file_attr_is_valid_name(file_name);
 806
 807         if (result != MYFILE_ERR_NONE) {
 808                 ug_mf_error("Is NOT Valid dir path name");
 809         }
 810
 811         return result;
 812 }
 813
 814 /*********************
 815 **Function name:        mf_ug_file_attr_is_right_file_path
 816 **Parameter:
 817 **      const char *filename:   the file/dir name we need to check
 818 **
 819 **Return value:
 820 **      error code
 821 **
 822 **Action:
 823 **      check if the file path is correct
 824 **
 825 *********************/
 826 int mf_ug_file_attr_is_right_file_path(const char *file_path)
 827 {
 828         int result = MYFILE_ERR_NONE;
 829
 830         if (strlen(file_path) == 0) {
 831                 return MYFILE_ERR_INVALID_FILE_PATH;
 832         }
 833
 834         if (file_path[0] != '/') {
 835                 return MYFILE_ERR_INVALID_DIR_PATH;
 836         }
 837
 838         const char *file_name = NULL;
 839         file_name = ecore_file_file_get(file_path);
 840         result = mf_ug_file_attr_is_valid_name(file_name);
 841         if (result != MYFILE_ERR_NONE) {
 842                 ug_mf_error("Is NOT Valid dir path name");
 843         }
 844
 845         return result;
 846 }
 847
 848
 849 static int __mf_ug_create_filter(filter_h *filter, ug_filter_s *condition)
 850 {
 851         ug_mf_retvm_if(filter == NULL, -1, "filter is NULL");
 852         ug_mf_retvm_if(condition == NULL, -1, "condition is NULL");
 853
 854         int ret = MEDIA_CONTENT_ERROR_NONE;
 855         filter_h tmp_filter = NULL;
 856         ret = media_filter_create(&tmp_filter);
 857         if(ret != MEDIA_CONTENT_ERROR_NONE) {
 858                 ug_debug("Fail to create filter");
 859                 return ret;
 860         }
 861         if (condition->cond) {
 862                 ret = media_filter_set_condition(tmp_filter, condition->cond,
 863                                                  condition->collate_type);
 864                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
 865                         ug_debug("Fail to set condition");
 866                         goto ERROR;
 867                 }
 868         }
 869
 870         if (condition->sort_keyword) {
 871                 ret = media_filter_set_order(tmp_filter, condition->sort_type,
 872                                              condition->sort_keyword,
 873                                              condition->collate_type);
 874                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
 875                         ug_debug("Fail to set order");
 876                         goto ERROR;
 877                 }
 878         }
 879
 880         ug_debug("offset is %d, count is %d", condition->offset, condition->count);
 881         if (condition->offset != -1 && condition->count != -1 &&
 882             condition->count > condition->offset) {
 883                 ret = media_filter_set_offset(tmp_filter, condition->offset,
 884                                               condition->count);
 885                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
 886                         ug_debug("Fail to set offset");
 887                         goto ERROR;
 888                 }
 889         }
 890         *filter = tmp_filter;
 891         return ret;
 892  ERROR:
 893         if (tmp_filter) {
 894                 media_filter_destroy(tmp_filter);
 895                 tmp_filter = NULL;
 896         }
 897         return ret;
 898 }
 899
 900 static int __mf_ug_destroy_filter(filter_h filter)
 901 {
 902         ug_mf_retvm_if(filter == NULL, -1, "filter is NULL");
 903         int ret = MEDIA_CONTENT_ERROR_NONE;
 904         ret = media_filter_destroy(filter);
 905
 906         return ret;
 907 }
 908
 909 static bool __mf_ug_local_data_get_media_thumbnail_cb(media_info_h media, void *data)
 910 {
 911         ug_mf_retvm_if(data == NULL, -1, "filter is NULL");
 912         ug_transfer_data_s *tmp_data = (ug_transfer_data_s *)data;
 913
 914         media_info_get_thumbnail_path(media, &(tmp_data->thumbnail_path));
 915
 916         return false;
 917 }
 918
 919
 920
 921 int static __mf_ug_local_thumbnail_get(void *data, ug_filter_s *condition)
 922 {
 923
 924         int ret = -1;
 925         filter_h filter = NULL;
 926         ret = __mf_ug_create_filter(&filter, condition);
 927         if (ret != 0) {
 928                 ug_debug("Create filter failed");
 929                 return ret;
 930         }
 931
 932
 933         ret = media_info_foreach_media_from_db(filter,
 934                                                __mf_ug_local_data_get_media_thumbnail_cb,
 935                                                data);
 936         if (ret != 0) {
 937                 ug_debug("media_info_foreach_media_from_db failed: %d", ret);
 938         } else {
 939                 ug_debug("media_info_foreach_media_from_db success!", ret);
 940         }
 941         __mf_ug_destroy_filter(filter);
 942
 943         return ret;
 944
 945 }
 946
 947 int mf_ug_file_attr_get_thumbnail(void *data)
 948 {
 949         ug_mf_retvm_if(data == NULL, -1, "data is NULL");
 950
 951         ug_transfer_data_s *mp_data = (ug_transfer_data_s *)data;
 952         ug_filter_s filter;
 953         int ret = -1;
 954
 955         memset(&filter, 0, sizeof(ug_filter_s));
 956
 957         char *condition = NULL;
 958         condition = g_strdup_printf("%s and MEDIA_PATH=\"%s\"", UG_CONDITION_IMAGE_VIDEO, mp_data->file_path);
 959         ug_debug("condition [%s]", condition);
 960         filter.cond = condition;
 961         filter.collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
 962         filter.sort_type = MEDIA_CONTENT_ORDER_DESC;
 963         filter.sort_keyword = MEDIA_MODIFIED_TIME;
 964         filter.with_meta = true;
 965
 966         ret = __mf_ug_local_thumbnail_get(data, &filter);
 967         UG_SAFE_FREE_CHAR(condition);
 968
 969
 970         return ret;
 971 }
 972
 973 int mf_ug_file_attr_get_file_icon(const char *file_path, int *error_code, char **thumbnail)
 974 {
 975         int index = 0;
 976         char *icon_path = NULL;
 977         mf_ug_fs_file_type ftype = UG_FILE_TYPE_NONE;
 978         int thumbnail_type = MF_UG_THUMBNAIL_TYPE_DEFAULT;
 979         const char *mime = NULL;
 980
 981         ug_mf_retvm_if(file_path == NULL, MF_UG_THUMBNAIL_TYPE_DEFAULT, "file_path is NULL");
 982
 983         efreet_mime_init();
 984         mime = efreet_mime_type_get(file_path);
 985
 986         if (mime == NULL) {
 987                 ug_mf_warnig("Fail to aul_get_mime_from_file(), set etc icon");
 988                 efreet_mime_shutdown();
 989                 return thumbnail_type;
 990         }
 991
 992         for (index = 0; mime_type[index].mime; index++) {
 993                 if (strncmp(mime, mime_type[index].mime, strlen(mime)) == 0) {
 994                         ftype = mime_type[index].ftype;
 995                         break;
 996                 }
 997         }
 998
 999         icon_path = __mf_ug_file_attr_default_icon_get_by_type(ftype);
1000         ug_debug("ftype is [%d] icon_path is [%s]", ftype, icon_path);
1001
1002         switch (ftype) {
1003         case UG_FILE_TYPE_IMAGE:
1004         case UG_FILE_TYPE_VIDEO:
1005                 {
1006                         int err = 0;
1007                         ug_transfer_data_s tmp_data;
1008                         memset(&tmp_data,0x00,sizeof(ug_transfer_data_s));
1009                         tmp_data.file_path = file_path;
1010                         err = mf_ug_file_attr_get_thumbnail(&tmp_data);
1011                         if (err == 0) {
1012                                 icon_path = g_strdup(tmp_data.thumbnail_path);
1013                                 thumbnail_type = MF_UG_THUMBNAIL_TYPE_THUMBNAIL;
1014                         } else {
1015                                 icon_path = NULL;
1016                                 if (error_code)
1017                                         *error_code = err;
1018                         }
1019                 }
1020                 break;
1021         default:
1022                 icon_path = __mf_ug_file_attr_default_icon_get_by_type(ftype);
1023                 thumbnail_type = MF_UG_THUMBNAIL_TYPE_DEFAULT;
1024                 break;
1025         }
1026
1027         ug_debug("mime [%s], file type [%d], icon_path [%s]", mime, ftype, icon_path);
1028         *thumbnail = icon_path;
1029         efreet_mime_shutdown();
1030
1031         return thumbnail_type;
1032 }
1033
1034 static int mf_ug_file_attr_get_path_level(const char *fullpath, int *level)
1035 {
1036         if (fullpath == NULL) {
1037                 return MYFILE_ERR_SRC_ARG_INVALID;
1038         }
1039
1040         if (mf_ug_file_attr_is_right_dir_path(fullpath) != 0) {
1041                 return MYFILE_ERR_INVALID_PATH;
1042         }
1043
1044         mf_ug_storage_type storage_t = 0;
1045         int start_level = 0;
1046         int error_code = mf_ug_file_attr_get_store_type_by_full(fullpath, &storage_t);
1047         if (error_code != 0) {
1048                 return error_code;
1049         }
1050
1051         if (storage_t == MF_UG_PHONE) {
1052                 start_level = MF_UG_PHONE_DEFAULT_LEVEL;
1053         } else if (storage_t == MF_UG_MMC) {
1054                 start_level = MF_UG_MMC_DEFAULT_LEVEL;
1055         }
1056
1057         char *temp = strdup(fullpath);
1058         if (temp == NULL) {
1059                 return MYFILE_ERR_UNKNOW_ERROR;
1060         }
1061
1062         int count = 0;
1063
1064         gchar **result = NULL;
1065         gchar **params = NULL;
1066         result = g_strsplit(temp, "/", 0);
1067
1068         if (result == NULL) {
1069                 free(temp);
1070                 temp = NULL;
1071                 return MYFILE_ERR_UNKNOW_ERROR;
1072         }
1073
1074         for (params = result; *params; params++) {
1075                 count++;
1076         }
1077
1078         g_strfreev(result);
1079         *level = count - start_level - 1;
1080         free(temp);
1081         return MYFILE_ERR_NONE;
1082
1083 }
1084
1085
1086 int mf_ug_file_attr_is_in_system_folder(char *fullpath, int level, bool * result)
1087 {
1088         if (fullpath == NULL) {
1089                 return MYFILE_ERR_SRC_ARG_INVALID;
1090         }
1091
1092         mf_ug_storage_type storage_t = 0;
1093         int error_code = mf_ug_file_attr_get_store_type_by_full(fullpath, &storage_t);
1094         if (error_code != 0) {
1095                 return error_code;
1096         }
1097
1098         const char *name = NULL;
1099         name = ecore_file_file_get(fullpath);
1100         char *parent_path = malloc(MYFILE_DIR_PATH_LEN_MAX + 1);
1101
1102         if (parent_path == NULL) {
1103                 return MYFILE_ERR_ALLOCATE_FAIL;
1104         }
1105         memset(parent_path, 0, MYFILE_DIR_PATH_LEN_MAX + 1);
1106         error_code = mf_ug_file_attr_get_parent_path(fullpath, &parent_path);
1107
1108         if (error_code != 0) {
1109
1110                 free(parent_path);
1111                 parent_path = NULL;
1112                 return error_code;
1113         }
1114
1115         if (storage_t == MF_UG_PHONE || storage_t == MF_UG_MMC) {
1116                 if (level == 1) {
1117                         if ((strlen(name) == strlen(IMAGE_AND_VIDEO)) && strcmp(name, IMAGE_AND_VIDEO) == 0) {
1118                                 *result = true;
1119                         } else if ((strlen(name) == strlen(SOUND_AND_MUSIC)) && strcmp(name, SOUND_AND_MUSIC) == 0) {
1120                                 *result = true;
1121                         } else if ((strlen(name) == strlen(DOWNLOADS)) && strcmp(name, DOWNLOADS) == 0) {
1122                                 *result = true;
1123                         } else if ((strlen(name) == strlen(CAMERA_SHOTS)) && strcmp(name, CAMERA_SHOTS) == 0) {
1124                                 *result = true;
1125                         } else {
1126                                 *result = false;
1127                         }
1128                 } else if (level == 2) {
1129                         const char *parent_name = NULL;
1130                         parent_name = ecore_file_file_get(parent_path);
1131                         if (storage_t == MF_UG_PHONE && (strlen(parent_name) == strlen(DOWNLOADS)) && strcmp(parent_name, DOWNLOADS) == 0) {
1132                                 if ((strlen(name) == strlen(OTHERS)) && !strcmp(OTHERS, name)) {
1133                                         *result = true;
1134                                 } else {
1135                                         *result = false;
1136                                 }
1137                         } else if ((strlen(parent_name) == strlen(SOUND_AND_MUSIC)) && strcmp(parent_name, SOUND_AND_MUSIC) == 0) {
1138                                 if ((strlen(name) == strlen(FM_RADIO)) && !strcmp(FM_RADIO, name)) {
1139                                         *result = true;
1140                                 } else if ((strlen(name) == strlen(MUSIC)) && !strcmp(MUSIC, name)) {
1141                                         *result = true;
1142                                 } else if ((strlen(name) == strlen(RINGTONES)) && !strcmp(RINGTONES, name)) {
1143                                         *result = true;
1144                                 } else if ((strlen(name) == strlen(ALERTS)) && !strcmp(ALERTS, name)) {
1145                                         *result = true;
1146                                 } else if ((strlen(name) == strlen(VOICE_RECORDER)) && !strcmp(VOICE_RECORDER, name)) {
1147                                         *result = true;
1148                                 } else {
1149                                         *result = false;
1150                                 }
1151                         } else if ((strlen(parent_name) == strlen(IMAGE_AND_VIDEO)) && strcmp(parent_name, IMAGE_AND_VIDEO) == 0) {
1152                                 if ((strlen(name) == strlen(WALLPAPER)) && !strcmp(WALLPAPER, name)) {
1153                                         *result = true;
1154                                 } else if ((strlen(name) == strlen(MY_PHOTO_CLIPS)) && !strcmp(MY_PHOTO_CLIPS, name)) {
1155                                         *result = true;
1156                                 } else if ((strlen(name) == strlen(MY_ALBUM)) && !strcmp(MY_ALBUM, name)) {
1157                                         *result = true;
1158                                 } else if ((strlen(name) == strlen(MY_VIDEO_CLIPS)) && !strcmp(MY_VIDEO_CLIPS, name)) {
1159                                         *result = true;
1160                                 } else {
1161                                         *result = false;
1162                                 }
1163                         } else {
1164                                 *result = false;
1165                         }
1166                 } else {
1167                         if (parent_path) {
1168                                 free(parent_path);
1169                                 parent_path = NULL;
1170                         }
1171                         return MYFILE_ERR_STORAGE_TYPE_ERROR;
1172                 }
1173         }
1174
1175         else {
1176                 if (parent_path) {
1177                         free(parent_path);
1178                         parent_path = NULL;
1179                 }
1180                 *result = false;
1181                 return MYFILE_ERR_STORAGE_TYPE_ERROR;
1182         }
1183
1184         if (parent_path) {
1185                 free(parent_path);
1186                 parent_path = NULL;
1187         }
1188         return MYFILE_ERR_NONE;
1189 }
1190
1191
1192 int mf_ug_file_attr_is_system_dir(char *fullpath, bool * result)
1193 {
1194         if (fullpath == NULL) {
1195                 ug_debug("source argument invalid");
1196                 return MYFILE_ERR_SRC_ARG_INVALID;
1197         }
1198
1199         if (mf_ug_file_attr_is_dir(fullpath) == 0) {
1200                 ug_debug("source is not exist");
1201                 return MYFILE_ERR_SRC_NOT_EXIST;
1202         }
1203
1204         int level = 0;
1205         int error_code = 0;
1206
1207         error_code = mf_ug_file_attr_get_path_level(fullpath, &level);
1208         if (error_code != 0) {
1209                 ug_debug("Fail to get path level");
1210                 return error_code;
1211         }
1212
1213         if (level >= 3 || level <= 0) {
1214                 *result = false;
1215                 ug_debug("Path Level is wrong");
1216                 return MYFILE_ERR_NONE;
1217         }
1218         error_code = mf_ug_file_attr_is_in_system_folder(fullpath, level, result);
1219
1220         if (error_code != 0) {
1221                 ug_debug("Fail .. is in system folder err :: %d", error_code);
1222                 return error_code;
1223         }
1224
1225         return MYFILE_ERR_NONE;
1226
1227 }
1228
1229 mf_ug_fs_file_type mf_ug_file_attr_get_file_type_by_mime(const char *file_path)
1230 {
1231         int index;
1232         mf_ug_fs_file_type ftype = UG_FILE_TYPE_NONE;
1233         const char *mime = NULL;
1234         efreet_mime_init();
1235         mime = efreet_mime_type_get(file_path);
1236
1237         if (mime == NULL) {
1238                 ug_debug("Fail to aul_get_mime_from_file(), set etc icon");
1239                 efreet_mime_shutdown();
1240                 return ftype;
1241         }
1242
1243         for (index = 0; mime_type[index].mime; index++) {
1244                 if (strncmp(mime, mime_type[index].mime, strlen(mime)) == 0) {
1245                         ftype = mime_type[index].ftype;
1246                         return ftype;
1247                 }
1248         }
1249         efreet_mime_shutdown();
1250
1251         return ftype;
1252 }
1253
1254 int mf_ug_file_attr_is_duplicated_name(const char *dir, const char *name)
1255 {
1256
1257         char *file_path = g_strconcat(dir, "/", name, NULL);
1258         if (ecore_file_exists(file_path)) {
1259                 UG_SAFE_FREE_CHAR(file_path);
1260                 return MYFILE_ERR_DUPLICATED_NAME;
1261         } else {
1262                 UG_SAFE_FREE_CHAR(file_path);
1263                 return MYFILE_ERR_NONE;
1264         }
1265 }
1266
1267 int mf_ug_file_attr_get_logical_path_by_full(const char *full_path, char **path)
1268 {
1269         ug_mf_retvm_if(full_path == NULL, MYFILE_ERR_INVALID_FILE_PATH, "fullpath is NULL");
1270         ug_mf_retvm_if(path == NULL, MYFILE_ERR_INVALID_FILE_PATH, "path is NULL");
1271
1272         mf_ug_storage_type store_type = 0;
1273         int root_len = 0;
1274         int error_code = 0;
1275
1276         error_code = mf_ug_file_attr_get_store_type_by_full(full_path, &store_type);
1277
1278         *path = g_strdup(full_path);
1279         if (*path == NULL) {
1280                 return MYFILE_ERR_ALLOCATE_MEMORY_FAIL;
1281         }
1282
1283         memset(*path, 0, strlen(*path));
1284         switch (store_type) {
1285         case MF_UG_PHONE:
1286                 root_len = strlen(PHONE_FOLDER);
1287                 break;
1288         case MF_UG_MMC:
1289                 root_len = strlen(MEMORY_FOLDER);
1290                 break;
1291         default:
1292                 return MYFILE_ERR_STORAGE_TYPE_ERROR;
1293         }
1294
1295         /*
1296         **      *path has the same length with full_path
1297         **      strlen(*path) is 0 since the memset called
1298         **      we use length of full_path to reprecent the *path's
1299         */
1300         g_strlcpy(*path, full_path + root_len, strlen(full_path));
1301         if (strlen(*path) == 0) {
1302                 UG_SAFE_FREE_CHAR(*path);
1303                 *path = g_strdup("/");
1304         }
1305
1306         return MYFILE_ERR_NONE;
1307 }
1308