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                 if (strcasecmp("isma", &file_ext[i]) == 0) {
 269                         if (mf_ug_file_attr_is_drm_file(fullpath) == 0) {
 270                                 return UG_FILE_TYPE_DRM;
 271                         } else {
 272                                 return UG_FILE_TYPE_SOUND;
 273                         }
 274                 }
 275                 if (strcasecmp("ismv", &file_ext[i]) == 0) {
 276                         if (mf_ug_file_attr_is_drm_file(fullpath) == 0) {
 277                                 return UG_FILE_TYPE_DRM;
 278                         } else {
 279                                 return UG_FILE_TYPE_SOUND;
 280                         }
 281                 }
 282                 break;
 283         case 'j':
 284         case 'J':
 285                 if (strcasecmp("JAD", &file_ext[i]) == 0) {
 286                         return UG_FILE_TYPE_JAVA;
 287                 }
 288                 if (strcasecmp("JAR", &file_ext[i]) == 0) {
 289                         return UG_FILE_TYPE_JAVA;
 290                 }
 291
 292                 if (strcasecmp("JPG", &file_ext[i]) == 0) {
 293                         return UG_FILE_TYPE_IMAGE;
 294                 }
 295                 if (strcasecmp("JPEG", &file_ext[i]) == 0) {
 296                         return UG_FILE_TYPE_IMAGE;
 297                 }
 298                 if (strcasecmp("JPE", &file_ext[i]) == 0) {
 299                         return UG_FILE_TYPE_IMAGE;
 300                 }
 301                 break;
 302         case 'm':
 303         case 'M':
 304                 if (strcasecmp("MMF", &file_ext[i]) == 0) {
 305                         return UG_FILE_TYPE_SOUND;
 306                 }
 307                 if (strcasecmp("MP3", &file_ext[i]) == 0) {
 308                         return UG_FILE_TYPE_MUSIC;
 309                 }
 310                 if (strcasecmp("MID", &file_ext[i]) == 0) {
 311                         return UG_FILE_TYPE_SOUND;
 312                 }
 313                 if (strcasecmp("MIDI", &file_ext[i]) == 0) {
 314                         return UG_FILE_TYPE_SOUND;
 315                 }
 316                 if (strcasecmp("MP4", &file_ext[i]) == 0) {
 317                         return UG_FILE_TYPE_VIDEO;
 318                 }
 319                 if (strcasecmp("MPG", &file_ext[i]) == 0) {
 320                         return UG_FILE_TYPE_VIDEO;
 321                 }
 322                 if (strcasecmp("MPEG", &file_ext[i]) == 0) {
 323                         return UG_FILE_TYPE_VIDEO;
 324                 }
 325                 if (strcasecmp("M4A", &file_ext[i]) == 0) {
 326                         return UG_FILE_TYPE_MUSIC;
 327                 }
 328                 if (strcasecmp("M3G", &file_ext[i]) == 0) {
 329                         return UG_FILE_TYPE_FLASH;
 330                 }
 331                 if (strcasecmp("MXMF", &file_ext[i]) == 0) {
 332                         return UG_FILE_TYPE_SOUND;
 333                 }
 334                 if (strcasecmp("MKV", &file_ext[i]) == 0) {
 335                         return UG_FILE_TYPE_VIDEO;
 336                 }
 337                 if (strcasecmp("MKA", &file_ext[i]) == 0) {
 338                         return UG_FILE_TYPE_MUSIC;
 339                 }
 340                 break;
 341         case 'o':
 342         case 'O':
 343                 if (strcasecmp("opml", &file_ext[i]) == 0) {
 344                         return UG_FILE_TYPE_RSS;
 345                 }
 346                 break;
 347         case 'p':
 348         case 'P':
 349                 if (strcasecmp("PNG", &file_ext[i]) == 0) {
 350                         return UG_FILE_TYPE_IMAGE;
 351                 }
 352                 if (strcasecmp("PJPEG", &file_ext[i]) == 0) {
 353                         return UG_FILE_TYPE_IMAGE;
 354                 }
 355                 if (strcasecmp("PDF", &file_ext[i]) == 0) {
 356                         return UG_FILE_TYPE_PDF;
 357                 }
 358                 if (strcasecmp("PPT", &file_ext[i]) == 0) {
 359                         return UG_FILE_TYPE_PPT;
 360                 }
 361                 if (strcasecmp("PPTX", &file_ext[i]) == 0) {
 362                         return UG_FILE_TYPE_PPT;
 363                 }
 364                 if (strcasecmp("PEM", &file_ext[i]) == 0) {
 365                         return UG_FILE_TYPE_CERTIFICATION;
 366                 }
 367                 break;
 368         case 'r':
 369         case 'R':
 370                 break;
 371         case 's':
 372         case 'S':
 373                 if (strcasecmp("SDP", &file_ext[i]) == 0) {
 374                         return UG_FILE_TYPE_VIDEO;
 375                 }
 376                 if (strcasecmp("SPM", &file_ext[i]) == 0) {
 377                         return UG_FILE_TYPE_SOUND;
 378                 }
 379                 if (strcasecmp("SMP", &file_ext[i]) == 0) {
 380                         return UG_FILE_TYPE_SOUND;
 381                 }
 382                 if (strcasecmp("SPF", &file_ext[i]) == 0) {
 383                         return UG_FILE_TYPE_SOUND;
 384                 }
 385                 if (strcasecmp("SWF", &file_ext[i]) == 0) {
 386                         return UG_FILE_TYPE_FLASH;
 387                 }
 388                 if (strcasecmp("SCN", &file_ext[i]) == 0) {
 389                         return UG_FILE_TYPE_MOVIE_MAKER;
 390                 }
 391                 if (strcasecmp("SVG", &file_ext[i]) == 0) {
 392                         return UG_FILE_TYPE_SVG;
 393                 }
 394                 if (strcasecmp("SVGZ", &file_ext[i]) == 0) {
 395                         return UG_FILE_TYPE_SVG;
 396                 }
 397                 break;
 398         case 't':
 399         case 'T':
 400                 if (strcasecmp("TXT", &file_ext[i]) == 0) {
 401                         return UG_FILE_TYPE_TXT;
 402                 }
 403                 if (strcasecmp("THM", &file_ext[i]) == 0) {
 404                         return UG_FILE_TYPE_THEME;
 405                 }
 406                 break;
 407         case 'v':
 408         case 'V':
 409                 if (strcasecmp("VCF", &file_ext[i]) == 0) {
 410                         return UG_FILE_TYPE_VCONTACT;
 411                 }
 412                 if (strcasecmp("VCS", &file_ext[i]) == 0) {
 413                         return UG_FILE_TYPE_VCALENDAR;
 414                 }
 415                 if (strcasecmp("VNT", &file_ext[i]) == 0) {
 416                         return UG_FILE_TYPE_VNOTE;
 417                 }
 418                 if (strcasecmp("VBM", &file_ext[i]) == 0) {
 419                         return UG_FILE_TYPE_VBOOKMARK;
 420                 }
 421                 break;
 422         case 'w':
 423         case 'W':
 424                 if (strcasecmp("WAV", &file_ext[i]) == 0) {
 425                         return UG_FILE_TYPE_SOUND;
 426                 }
 427                 if (strcasecmp("WBMP", &file_ext[i]) == 0) {
 428                         return UG_FILE_TYPE_IMAGE;
 429                 }
 430                 if (strcasecmp("WGT", &file_ext[i]) == 0) {
 431                         return UG_FILE_TYPE_WGT;
 432                 }
 433                 if (strcasecmp("WMA", &file_ext[i]) == 0) {
 434                         return UG_FILE_TYPE_MUSIC;
 435                 }
 436                 if (strcasecmp("WMV", &file_ext[i]) == 0) {
 437                         return UG_FILE_TYPE_VIDEO;
 438                 }
 439                 break;
 440         case 'x':
 441         case 'X':
 442                 if (strcasecmp("XLS", &file_ext[i]) == 0) {
 443                         return UG_FILE_TYPE_EXCEL;
 444                 }
 445                 if (strcasecmp("XLSX", &file_ext[i]) == 0) {
 446                         return UG_FILE_TYPE_EXCEL;
 447                 }
 448                 if (strcasecmp("XMF", &file_ext[i]) == 0) {
 449                         return UG_FILE_TYPE_SOUND;
 450                 }
 451                 if (strcasecmp("XHTML", &file_ext[i]) == 0) {
 452                         return UG_FILE_TYPE_HTML;
 453                 }
 454                 break;
 455         case '3':
 456                 if (strcasecmp("3GP", &file_ext[i]) == 0) {
 457                         return UG_FILE_TYPE_VIDEO;
 458                 }
 459                 if (strcasecmp("3GPP", &file_ext[i]) == 0) {
 460                         return UG_FILE_TYPE_VIDEO;
 461                 }
 462                 if (strcasecmp("3G2", &file_ext[i]) == 0) {
 463                         return UG_FILE_TYPE_VIDEO;
 464                 }
 465                 break;
 466         }
 467
 468         return UG_FILE_TYPE_ETC;
 469 }
 470
 471 /*********************
 472 **Function name:        mf_ug_file_attr_is_valid_name
 473 **Parameter:
 474 **      const char *filename:   the file/dir name we need to check
 475 **
 476 **Return value:
 477 **      -0x14   if the name is invalid
 478 **      0               if the name is valid
 479 **
 480 **Action:
 481 **      check if the name is valid by file name
 482 **
 483 *********************/
 484 int mf_ug_file_attr_is_valid_name(const char *filename)
 485 {
 486         char *pattern;
 487         int ret, z, cflags = 0;
 488         char ebuf[128];
 489         regex_t reg;
 490         regmatch_t pm[1];
 491         const size_t nmatch = 1;
 492         /*/ToDo: ignore the file star with . */
 493         if (strncmp(filename, ".", 1) == 0) {
 494                 return MYFILE_ERR_INVALID_FILE_NAME;
 495         }
 496
 497         pattern = MYFILE_NAME_PATTERN;
 498         z = regcomp(&reg, pattern, cflags);
 499
 500         if (z != 0) {
 501                 regerror(z, &reg, ebuf, sizeof(ebuf));
 502                 fprintf(stderr, "%s: pattern '%s' \n", ebuf, pattern);
 503                 return MYFILE_ERR_INVALID_FILE_NAME;
 504         }
 505
 506         z = regexec(&reg, filename, nmatch, pm, 0);
 507         if (z == REG_NOMATCH) {
 508                 ret = MYFILE_ERR_NONE;
 509         } else {
 510                 ret = MYFILE_ERR_INVALID_FILE_NAME;
 511         }
 512         regfree(&reg);
 513         return ret;
 514 }
 515
 516
 517 /******************************
 518 ** Prototype    : __mf_ug_file_attr_default_icon_get_by_type
 519 ** Description  : Samsung
 520 ** Input        : mf_ug_fs_file_type ftype
 521 ** Output       : None
 522 ** Return Value :
 523 ** Calls        :
 524 ** Called By    :
 525 **
 526 **  History        :
 527 **  1.Date         : 2010/12/10
 528 **    Author       : Samsung
 529 **    Modification : Created function
 530 **
 531 ******************************/
 532 static char *__mf_ug_file_attr_default_icon_get_by_type(mf_ug_fs_file_type ftype)
 533 {
 534         char *icon_path = NULL;
 535
 536         if (icon_array[ftype]) {
 537                 icon_path = strdup(icon_array[ftype]);
 538         } else {
 539                 icon_path = strdup(UG_DEFAULT_ICON);
 540         }
 541
 542         return icon_path;
 543 }
 544
 545
 546 /******************************
 547 ** Prototype    : mf_ug_file_attr_get_parent_path
 548 ** Description  : Samsung
 549 ** Input        : const char* path
 550 **                char* parent_path
 551 ** Output       : None
 552 ** Return Value :
 553 ** Calls        :
 554 ** Called By    :
 555 **
 556 **  History        :
 557 **  1.Date         : 2010/12/10
 558 **    Author       : Samsung
 559 **    Modification : Created function
 560 **
 561 ******************************/
 562 int mf_ug_file_attr_get_parent_path(const char *path, char **parent_path)
 563 {
 564         ug_mf_retvm_if(path == NULL, MYFILE_ERR_INVALID_ARG, "path is NULL");
 565         ug_mf_retvm_if(parent_path == NULL, MYFILE_ERR_INVALID_ARG, "parent_path is NULL");
 566         ug_debug("Path :::: [%s]", path);
 567
 568         *parent_path = g_strdup(path);
 569         if (*parent_path == NULL)
 570                 return MYFILE_ERR_ALLOCATE_FAIL;
 571
 572         const char *name = NULL;
 573         name = ecore_file_file_get(path);
 574         /*
 575         **      input path and parent_path are check in the caller.
 576         **      parent_path is full path must be like /opt/media/file.ext
 577         **      name is file.ext
 578         **      strlen(parent_path) should large than strlen(name) normally.
 579         **      to take exception like input path is "", we add a if condition
 580         */
 581         if (strlen(*parent_path) > strlen(name))
 582                 (*parent_path)[strlen(*parent_path) - strlen(name) - 1] = '\0';
 583
 584         if (strlen(*parent_path) == 0) {
 585                 *parent_path = g_strdup("/");
 586         }
 587
 588         return MYFILE_ERR_NONE;
 589 }
 590
 591
 592 /*********************
 593 **Function name:        mf_get_category
 594 **Parameter:
 595 **      const char* filepath:   file fullpath
 596 **      mf_ug_fs_file_type *category:   output parameter of category
 597 **Return value:
 598 **      error code
 599 **
 600 **Action:
 601 **      Get file category by file full path
 602 **
 603 *********************/
 604 int mf_ug_file_attr_get_file_category(const char *filepath, mf_ug_fs_file_type * category)
 605 {
 606         int i = 0;
 607         int flag = 0;
 608
 609         if (mf_ug_file_attr_is_dir(filepath)) {
 610                 *category = UG_FILE_TYPE_DIR;
 611                 return MYFILE_ERR_NONE;
 612         }
 613
 614         const char *filename = NULL;
 615         filename = ecore_file_file_get(filepath);
 616         /*/return value ceck */
 617         if (filename == NULL) {
 618                 *category = UG_FILE_TYPE_NONE;
 619                 return MYFILE_ERR_SRC_ARG_INVALID;
 620         }
 621         char file_ext[FILE_EXT_LEN_MAX + 1] = { 0 };
 622         /*/ToDo: error file name like the last letter is "." */
 623         for (i = strlen(filename); i >= 0; i--) {
 624                 if (filename[i] == '.') {
 625                         strncpy(file_ext, &filename[i + 1], FILE_EXT_LEN_MAX + 1);
 626                         flag = 1;
 627                         break;
 628                 }
 629
 630                 if (filename[i] == '/') {
 631                         flag = 0;
 632                         break;
 633                 }
 634         }
 635
 636         if (flag == 1) {
 637                 *category = __mf_ug_file_attr_get_category_by_file_ext(file_ext, filepath);
 638                 return MYFILE_ERR_NONE;
 639         } else {
 640                 *category = UG_FILE_TYPE_NONE;
 641                 return MYFILE_ERR_GET_CATEGORY_FAIL;
 642         }
 643 }
 644
 645 /*********************
 646 **Function name:        mf_ug_file_attr_get_file_stat
 647 **Parameter:
 648 **      const char* filename:   file name
 649 **      ugFsNodeInfo **node:            output parameter of what we need to refine
 650 **Return value:
 651 **      error code
 652 **
 653 **Action:
 654 **      Get file size and last modified date by file path
 655 **
 656 *********************/
 657 int mf_ug_file_attr_get_file_stat(const char *filename, ugFsNodeInfo ** node)
 658 {
 659         struct stat statbuf;
 660
 661         ug_mf_retvm_if(filename == NULL, MYFILE_ERR_INVALID_ARG, "filename is null");
 662         ug_mf_retvm_if(node == NULL, MYFILE_ERR_INVALID_ARG, "node is null");
 663
 664         if (stat(filename, &statbuf) == -1) {
 665                 return MYFILE_ERR_GET_STAT_FAIL;
 666         }
 667
 668         (*node)->size = statbuf.st_size;
 669         (*node)->date = statbuf.st_mtime;
 670
 671         return MYFILE_ERR_NONE;
 672 }
 673
 674 /*********************
 675 **Function name:        mf_ug_file_attr_is_dir
 676 **Parameter:
 677 **      const char* filename:   file fullpath
 678 **Return value:
 679 **      if path is a directory, return 1
 680 **      else, return 0
 681 **
 682 **Action:
 683 **      check if the file path is Directory
 684 **
 685 *********************/
 686 int mf_ug_file_attr_is_dir(const char *filepath)
 687 {
 688         return ecore_file_is_dir(filepath);
 689 }
 690
 691 /*********************
 692 **Function name:        mf_ug_file_attr_get_store_type_by_full
 693 **Parameter:
 694 **      const char* filepath:   file full path
 695 **      mf_ug_storage_type *store_type:         output parameter of storage type
 696 **Return value:
 697 **      error code
 698 **
 699 **Action:
 700 **      Get file storage type by file path
 701 **
 702 *********************/
 703 int mf_ug_file_attr_get_store_type_by_full(const char *filepath, mf_ug_storage_type * store_type)
 704 {
 705         if (filepath == NULL || store_type == NULL) {
 706                 return MYFILE_ERR_SRC_ARG_INVALID;
 707         }
 708
 709         if (strncmp(filepath, PHONE_FOLDER, strlen(PHONE_FOLDER)) == 0) {
 710                 *store_type = MF_UG_PHONE;
 711                 return MYFILE_ERR_NONE;
 712         } else if (strncmp(filepath, MEMORY_FOLDER, strlen(MEMORY_FOLDER)) == 0) {
 713                 *store_type = MF_UG_MMC;
 714                 return MYFILE_ERR_NONE;
 715         } else {
 716                 *store_type = MF_UG_NONE;
 717                 return MYFILE_ERR_STORAGE_TYPE_ERROR;
 718         }
 719 }
 720
 721 /*********************
 722 **Function name:        mf_ug_file_attr_is_drm_file
 723 **Parameter:
 724 **      const char* filepath:   file full path
 725 **
 726 **Return value:
 727 **      true if it is a DRM file
 728 **      false if it is not a DRM file
 729 **
 730 **Action:
 731 **      check if file is drm file
 732 **
 733 *********************/
 734 int mf_ug_file_attr_is_drm_file(const char *file_fullpath)
 735 {
 736         if (file_fullpath == NULL)
 737                 return MYFILE_ERR_DRM_PERMISSION_DENY;
 738         drm_bool_type_e drmFlag = DRM_FALSE;
 739         int res = 0;
 740         res = drm_is_drm_file(file_fullpath, &drmFlag);
 741
 742         if (res == DRM_RETURN_SUCCESS && drmFlag == DRM_TRUE)
 743                 return 0;
 744         else
 745                 return MYFILE_ERR_DRM_PERMISSION_DENY;
 746 }
 747
 748 /*********************
 749 **Function name:        mf_ug_file_attr_get_file_ext
 750 **Parameter:
 751 **      const char* filepath:   file full path
 752 **      char *file_ext:                 output parameter of file extension
 753 **
 754 **Return value:
 755 **      error code
 756 **
 757 **Action:
 758 **      get file extension by file full path
 759 **
 760 *********************/
 761 int mf_ug_file_attr_get_file_ext(const char *filepath, char **file_ext)
 762 {
 763         ug_mf_retvm_if(filepath == NULL, MYFILE_ERR_INVALID_FILE_NAME, "filepath is NULL");
 764         ug_mf_retvm_if(file_ext == NULL, MYFILE_ERR_INVALID_FILE_NAME, "file_ext is NULL");
 765
 766         const char *filename = NULL;
 767         filename = ecore_file_file_get(filepath);
 768
 769         if (filename == NULL) {
 770                 return MYFILE_ERR_INVALID_FILE_NAME;
 771         }
 772
 773         char *pdot = strrchr(filename, '.');
 774
 775         if (!pdot) {
 776                 return MYFILE_ERR_EXT_GET_ERROR;
 777         } else if (pdot != filepath) {
 778                 *file_ext = g_strdup(pdot + 1);
 779                 return MYFILE_ERR_NONE;
 780         } else {
 781                 return MYFILE_ERR_EXT_GET_ERROR;
 782         }
 783 }
 784
 785
 786
 787 /*********************
 788 **Function name:        mf_ug_file_attr_is_right_dir_path
 789 **Parameter:
 790 **      const char *filename:   the file/dir name we need to check
 791 **
 792 **Return value:
 793 **      error code
 794 **
 795 **Action:
 796 **      check if the dir path is correct
 797 **
 798 *********************/
 799 int mf_ug_file_attr_is_right_dir_path(const char *dir_path)
 800 {
 801         int result = MYFILE_ERR_NONE;
 802         int length = 0;
 803
 804         length = strlen(dir_path);
 805         if (length == 0) {
 806                 return MYFILE_ERR_INVALID_DIR_PATH;
 807         }
 808
 809         if (dir_path[length - 1] == '/' && length > 1) {
 810                 return MYFILE_ERR_INVALID_DIR_PATH;
 811         }
 812
 813         if (dir_path[0] != '/') {
 814                 return MYFILE_ERR_INVALID_DIR_PATH;
 815         }
 816
 817         const char *file_name = NULL;
 818         file_name = ecore_file_file_get(dir_path);
 819         result = mf_ug_file_attr_is_valid_name(file_name);
 820
 821         if (result != MYFILE_ERR_NONE) {
 822                 ug_mf_error("Is NOT Valid dir path name");
 823         }
 824
 825         return result;
 826 }
 827
 828 /*********************
 829 **Function name:        mf_ug_file_attr_is_right_file_path
 830 **Parameter:
 831 **      const char *filename:   the file/dir name we need to check
 832 **
 833 **Return value:
 834 **      error code
 835 **
 836 **Action:
 837 **      check if the file path is correct
 838 **
 839 *********************/
 840 int mf_ug_file_attr_is_right_file_path(const char *file_path)
 841 {
 842         int result = MYFILE_ERR_NONE;
 843
 844         if (strlen(file_path) == 0) {
 845                 return MYFILE_ERR_INVALID_FILE_PATH;
 846         }
 847
 848         if (file_path[0] != '/') {
 849                 return MYFILE_ERR_INVALID_DIR_PATH;
 850         }
 851
 852         const char *file_name = NULL;
 853         file_name = ecore_file_file_get(file_path);
 854         result = mf_ug_file_attr_is_valid_name(file_name);
 855         if (result != MYFILE_ERR_NONE) {
 856                 ug_mf_error("Is NOT Valid dir path name");
 857         }
 858
 859         return result;
 860 }
 861
 862
 863 static int __mf_ug_create_filter(filter_h *filter, ug_filter_s *condition)
 864 {
 865         ug_mf_retvm_if(filter == NULL, -1, "filter is NULL");
 866         ug_mf_retvm_if(condition == NULL, -1, "condition is NULL");
 867
 868         int ret = MEDIA_CONTENT_ERROR_NONE;
 869         filter_h tmp_filter = NULL;
 870         ret = media_filter_create(&tmp_filter);
 871         if(ret != MEDIA_CONTENT_ERROR_NONE) {
 872                 ug_debug("Fail to create filter");
 873                 return ret;
 874         }
 875         if (condition->cond) {
 876                 ret = media_filter_set_condition(tmp_filter, condition->cond,
 877                                                  condition->collate_type);
 878                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
 879                         ug_debug("Fail to set condition");
 880                         goto ERROR;
 881                 }
 882         }
 883
 884         if (condition->sort_keyword) {
 885                 ret = media_filter_set_order(tmp_filter, condition->sort_type,
 886                                              condition->sort_keyword,
 887                                              condition->collate_type);
 888                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
 889                         ug_debug("Fail to set order");
 890                         goto ERROR;
 891                 }
 892         }
 893
 894         ug_debug("offset is %d, count is %d", condition->offset, condition->count);
 895         if (condition->offset != -1 && condition->count != -1 &&
 896             condition->count > condition->offset) {
 897                 ret = media_filter_set_offset(tmp_filter, condition->offset,
 898                                               condition->count);
 899                 if(ret != MEDIA_CONTENT_ERROR_NONE) {
 900                         ug_debug("Fail to set offset");
 901                         goto ERROR;
 902                 }
 903         }
 904         *filter = tmp_filter;
 905         return ret;
 906  ERROR:
 907         if (tmp_filter) {
 908                 media_filter_destroy(tmp_filter);
 909                 tmp_filter = NULL;
 910         }
 911         return ret;
 912 }
 913
 914 static int __mf_ug_destroy_filter(filter_h filter)
 915 {
 916         ug_mf_retvm_if(filter == NULL, -1, "filter is NULL");
 917         int ret = MEDIA_CONTENT_ERROR_NONE;
 918         ret = media_filter_destroy(filter);
 919
 920         return ret;
 921 }
 922
 923 static bool __mf_ug_local_data_get_media_thumbnail_cb(media_info_h media, void *data)
 924 {
 925         ug_mf_retvm_if(data == NULL, -1, "filter is NULL");
 926         ug_transfer_data_s *tmp_data = (ug_transfer_data_s *)data;
 927
 928         media_info_get_thumbnail_path(media, &(tmp_data->thumbnail_path));
 929
 930         return false;
 931 }
 932
 933
 934
 935 int static __mf_ug_local_thumbnail_get(void *data, ug_filter_s *condition)
 936 {
 937
 938         int ret = -1;
 939         filter_h filter = NULL;
 940         ret = __mf_ug_create_filter(&filter, condition);
 941         if (ret != 0) {
 942                 ug_debug("Create filter failed");
 943                 return ret;
 944         }
 945
 946
 947         ret = media_info_foreach_media_from_db(filter,
 948                                                __mf_ug_local_data_get_media_thumbnail_cb,
 949                                                data);
 950         if (ret != 0) {
 951                 ug_debug("media_info_foreach_media_from_db failed: %d", ret);
 952         } else {
 953                 ug_debug("media_info_foreach_media_from_db success!", ret);
 954         }
 955         __mf_ug_destroy_filter(filter);
 956
 957         return ret;
 958
 959 }
 960
 961 int mf_ug_file_attr_get_thumbnail(void *data)
 962 {
 963         ug_mf_retvm_if(data == NULL, -1, "data is NULL");
 964
 965         ug_transfer_data_s *mp_data = (ug_transfer_data_s *)data;
 966         ug_filter_s filter;
 967         int ret = -1;
 968
 969         memset(&filter, 0, sizeof(ug_filter_s));
 970
 971         char *condition = NULL;
 972         condition = g_strdup_printf("%s and MEDIA_PATH=\"%s\"", UG_CONDITION_IMAGE_VIDEO, mp_data->file_path);
 973         ug_debug("condition [%s]", condition);
 974         filter.cond = condition;
 975         filter.collate_type = MEDIA_CONTENT_COLLATE_DEFAULT;
 976         filter.sort_type = MEDIA_CONTENT_ORDER_DESC;
 977         filter.sort_keyword = MEDIA_MODIFIED_TIME;
 978         filter.with_meta = true;
 979
 980         ret = __mf_ug_local_thumbnail_get(data, &filter);
 981         UG_SAFE_FREE_CHAR(condition);
 982
 983
 984         return ret;
 985 }
 986
 987 int mf_ug_file_attr_get_file_icon(const char *file_path, int *error_code, char **thumbnail)
 988 {
 989         int index = 0;
 990         char *icon_path = NULL;
 991         mf_ug_fs_file_type ftype = UG_FILE_TYPE_NONE;
 992         int thumbnail_type = MF_UG_THUMBNAIL_TYPE_DEFAULT;
 993         const char *mime = NULL;
 994
 995         ug_mf_retvm_if(file_path == NULL, MF_UG_THUMBNAIL_TYPE_DEFAULT, "file_path is NULL");
 996
 997         efreet_mime_init();
 998         mime = efreet_mime_type_get(file_path);
 999
1000         if (mime == NULL) {
1001                 ug_mf_warnig("Fail to aul_get_mime_from_file(), set etc icon");
1002                 efreet_mime_shutdown();
1003                 return thumbnail_type;
1004         }
1005
1006         for (index = 0; mime_type[index].mime; index++) {
1007                 if (strncmp(mime, mime_type[index].mime, strlen(mime)) == 0) {
1008                         ftype = mime_type[index].ftype;
1009                         break;
1010                 }
1011         }
1012
1013         icon_path = __mf_ug_file_attr_default_icon_get_by_type(ftype);
1014         ug_debug("ftype is [%d] icon_path is [%s]", ftype, icon_path);
1015
1016         switch (ftype) {
1017         case UG_FILE_TYPE_IMAGE:
1018         case UG_FILE_TYPE_VIDEO:
1019                 {
1020                         int err = 0;
1021                         ug_transfer_data_s tmp_data;
1022                         memset(&tmp_data,0x00,sizeof(ug_transfer_data_s));
1023                         tmp_data.file_path = file_path;
1024                         err = mf_ug_file_attr_get_thumbnail(&tmp_data);
1025                         if (err == 0) {
1026                                 icon_path = g_strdup(tmp_data.thumbnail_path);
1027                                 thumbnail_type = MF_UG_THUMBNAIL_TYPE_THUMBNAIL;
1028                         } else {
1029                                 icon_path = NULL;
1030                                 if (error_code)
1031                                         *error_code = err;
1032                         }
1033                 }
1034                 break;
1035         default:
1036                 icon_path = __mf_ug_file_attr_default_icon_get_by_type(ftype);
1037                 thumbnail_type = MF_UG_THUMBNAIL_TYPE_DEFAULT;
1038                 break;
1039         }
1040
1041         ug_debug("mime [%s], file type [%d], icon_path [%s]", mime, ftype, icon_path);
1042         *thumbnail = icon_path;
1043         efreet_mime_shutdown();
1044
1045         return thumbnail_type;
1046 }
1047
1048 static int mf_ug_file_attr_get_path_level(const char *fullpath, int *level)
1049 {
1050         if (fullpath == NULL) {
1051                 return MYFILE_ERR_SRC_ARG_INVALID;
1052         }
1053
1054         if (mf_ug_file_attr_is_right_dir_path(fullpath) != 0) {
1055                 return MYFILE_ERR_INVALID_PATH;
1056         }
1057
1058         mf_ug_storage_type storage_t = 0;
1059         int start_level = 0;
1060         int error_code = mf_ug_file_attr_get_store_type_by_full(fullpath, &storage_t);
1061         if (error_code != 0) {
1062                 return error_code;
1063         }
1064
1065         if (storage_t == MF_UG_PHONE) {
1066                 start_level = MF_UG_PHONE_DEFAULT_LEVEL;
1067         } else if (storage_t == MF_UG_MMC) {
1068                 start_level = MF_UG_MMC_DEFAULT_LEVEL;
1069         }
1070
1071         char *temp = strdup(fullpath);
1072         if (temp == NULL) {
1073                 return MYFILE_ERR_UNKNOW_ERROR;
1074         }
1075
1076         int count = 0;
1077
1078         gchar **result = NULL;
1079         gchar **params = NULL;
1080         result = g_strsplit(temp, "/", 0);
1081
1082         if (result == NULL) {
1083                 free(temp);
1084                 temp = NULL;
1085                 return MYFILE_ERR_UNKNOW_ERROR;
1086         }
1087
1088         for (params = result; *params; params++) {
1089                 count++;
1090         }
1091
1092         g_strfreev(result);
1093         *level = count - start_level - 1;
1094         free(temp);
1095         return MYFILE_ERR_NONE;
1096
1097 }
1098
1099
1100 int mf_ug_file_attr_is_in_system_folder(char *fullpath, int level, bool * result)
1101 {
1102         if (fullpath == NULL) {
1103                 return MYFILE_ERR_SRC_ARG_INVALID;
1104         }
1105
1106         mf_ug_storage_type storage_t = 0;
1107         int error_code = mf_ug_file_attr_get_store_type_by_full(fullpath, &storage_t);
1108         if (error_code != 0) {
1109                 return error_code;
1110         }
1111
1112         const char *name = NULL;
1113         name = ecore_file_file_get(fullpath);
1114         char *parent_path = malloc(MYFILE_DIR_PATH_LEN_MAX + 1);
1115
1116         if (parent_path == NULL) {
1117                 return MYFILE_ERR_ALLOCATE_FAIL;
1118         }
1119         memset(parent_path, 0, MYFILE_DIR_PATH_LEN_MAX + 1);
1120         error_code = mf_ug_file_attr_get_parent_path(fullpath, &parent_path);
1121
1122         if (error_code != 0) {
1123
1124                 free(parent_path);
1125                 parent_path = NULL;
1126                 return error_code;
1127         }
1128
1129         if (storage_t == MF_UG_PHONE || storage_t == MF_UG_MMC) {
1130                 if (level == 1) {
1131                         if ((strlen(name) == strlen(IMAGE_AND_VIDEO)) && strcmp(name, IMAGE_AND_VIDEO) == 0) {
1132                                 *result = true;
1133                         } else if ((strlen(name) == strlen(SOUND_AND_MUSIC)) && strcmp(name, SOUND_AND_MUSIC) == 0) {
1134                                 *result = true;
1135                         } else if ((strlen(name) == strlen(DOWNLOADS)) && strcmp(name, DOWNLOADS) == 0) {
1136                                 *result = true;
1137                         } else if ((strlen(name) == strlen(CAMERA_SHOTS)) && strcmp(name, CAMERA_SHOTS) == 0) {
1138                                 *result = true;
1139                         } else {
1140                                 *result = false;
1141                         }
1142                 } else if (level == 2) {
1143                         const char *parent_name = NULL;
1144                         parent_name = ecore_file_file_get(parent_path);
1145                         if (storage_t == MF_UG_PHONE && (strlen(parent_name) == strlen(DOWNLOADS)) && strcmp(parent_name, DOWNLOADS) == 0) {
1146                                 if ((strlen(name) == strlen(OTHERS)) && !strcmp(OTHERS, name)) {
1147                                         *result = true;
1148                                 } else {
1149                                         *result = false;
1150                                 }
1151                         } else if ((strlen(parent_name) == strlen(SOUND_AND_MUSIC)) && strcmp(parent_name, SOUND_AND_MUSIC) == 0) {
1152                                 if ((strlen(name) == strlen(FM_RADIO)) && !strcmp(FM_RADIO, name)) {
1153                                         *result = true;
1154                                 } else if ((strlen(name) == strlen(MUSIC)) && !strcmp(MUSIC, name)) {
1155                                         *result = true;
1156                                 } else if ((strlen(name) == strlen(RINGTONES)) && !strcmp(RINGTONES, name)) {
1157                                         *result = true;
1158                                 } else if ((strlen(name) == strlen(ALERTS)) && !strcmp(ALERTS, name)) {
1159                                         *result = true;
1160                                 } else if ((strlen(name) == strlen(VOICE_RECORDER)) && !strcmp(VOICE_RECORDER, name)) {
1161                                         *result = true;
1162                                 } else {
1163                                         *result = false;
1164                                 }
1165                         } else if ((strlen(parent_name) == strlen(IMAGE_AND_VIDEO)) && strcmp(parent_name, IMAGE_AND_VIDEO) == 0) {
1166                                 if ((strlen(name) == strlen(WALLPAPER)) && !strcmp(WALLPAPER, name)) {
1167                                         *result = true;
1168                                 } else if ((strlen(name) == strlen(MY_PHOTO_CLIPS)) && !strcmp(MY_PHOTO_CLIPS, name)) {
1169                                         *result = true;
1170                                 } else if ((strlen(name) == strlen(MY_ALBUM)) && !strcmp(MY_ALBUM, name)) {
1171                                         *result = true;
1172                                 } else if ((strlen(name) == strlen(MY_VIDEO_CLIPS)) && !strcmp(MY_VIDEO_CLIPS, name)) {
1173                                         *result = true;
1174                                 } else {
1175                                         *result = false;
1176                                 }
1177                         } else {
1178                                 *result = false;
1179                         }
1180                 } else {
1181                         if (parent_path) {
1182                                 free(parent_path);
1183                                 parent_path = NULL;
1184                         }
1185                         return MYFILE_ERR_STORAGE_TYPE_ERROR;
1186                 }
1187         }
1188
1189         else {
1190                 if (parent_path) {
1191                         free(parent_path);
1192                         parent_path = NULL;
1193                 }
1194                 *result = false;
1195                 return MYFILE_ERR_STORAGE_TYPE_ERROR;
1196         }
1197
1198         if (parent_path) {
1199                 free(parent_path);
1200                 parent_path = NULL;
1201         }
1202         return MYFILE_ERR_NONE;
1203 }
1204
1205
1206 int mf_ug_file_attr_is_system_dir(char *fullpath, bool * result)
1207 {
1208         if (fullpath == NULL) {
1209                 ug_debug("source argument invalid");
1210                 return MYFILE_ERR_SRC_ARG_INVALID;
1211         }
1212
1213         if (mf_ug_file_attr_is_dir(fullpath) == 0) {
1214                 ug_debug("source is not exist");
1215                 return MYFILE_ERR_SRC_NOT_EXIST;
1216         }
1217
1218         int level = 0;
1219         int error_code = 0;
1220
1221         error_code = mf_ug_file_attr_get_path_level(fullpath, &level);
1222         if (error_code != 0) {
1223                 ug_debug("Fail to get path level");
1224                 return error_code;
1225         }
1226
1227         if (level >= 3 || level <= 0) {
1228                 *result = false;
1229                 ug_debug("Path Level is wrong");
1230                 return MYFILE_ERR_NONE;
1231         }
1232         error_code = mf_ug_file_attr_is_in_system_folder(fullpath, level, result);
1233
1234         if (error_code != 0) {
1235                 ug_debug("Fail .. is in system folder err :: %d", error_code);
1236                 return error_code;
1237         }
1238
1239         return MYFILE_ERR_NONE;
1240
1241 }
1242
1243 mf_ug_fs_file_type mf_ug_file_attr_get_file_type_by_mime(const char *file_path)
1244 {
1245         int index;
1246         mf_ug_fs_file_type ftype = UG_FILE_TYPE_NONE;
1247         const char *mime = NULL;
1248         efreet_mime_init();
1249         mime = efreet_mime_type_get(file_path);
1250
1251         if (mime == NULL) {
1252                 ug_debug("Fail to aul_get_mime_from_file(), set etc icon");
1253                 efreet_mime_shutdown();
1254                 return ftype;
1255         }
1256
1257         for (index = 0; mime_type[index].mime; index++) {
1258                 if (strncmp(mime, mime_type[index].mime, strlen(mime)) == 0) {
1259                         ftype = mime_type[index].ftype;
1260                         return ftype;
1261                 }
1262         }
1263         efreet_mime_shutdown();
1264
1265         return ftype;
1266 }
1267
1268 int mf_ug_file_attr_is_duplicated_name(const char *dir, const char *name)
1269 {
1270
1271         char *file_path = g_strconcat(dir, "/", name, NULL);
1272         if (ecore_file_exists(file_path)) {
1273                 UG_SAFE_FREE_CHAR(file_path);
1274                 return MYFILE_ERR_DUPLICATED_NAME;
1275         } else {
1276                 UG_SAFE_FREE_CHAR(file_path);
1277                 return MYFILE_ERR_NONE;
1278         }
1279 }
1280
1281 int mf_ug_file_attr_get_logical_path_by_full(const char *full_path, char **path)
1282 {
1283         ug_mf_retvm_if(full_path == NULL, MYFILE_ERR_INVALID_FILE_PATH, "fullpath is NULL");
1284         ug_mf_retvm_if(path == NULL, MYFILE_ERR_INVALID_FILE_PATH, "path is NULL");
1285
1286         mf_ug_storage_type store_type = 0;
1287         int root_len = 0;
1288         int error_code = 0;
1289
1290         error_code = mf_ug_file_attr_get_store_type_by_full(full_path, &store_type);
1291
1292         *path = g_strdup(full_path);
1293         if (*path == NULL) {
1294                 return MYFILE_ERR_ALLOCATE_MEMORY_FAIL;
1295         }
1296
1297         memset(*path, 0, strlen(*path));
1298         switch (store_type) {
1299         case MF_UG_PHONE:
1300                 root_len = strlen(PHONE_FOLDER);
1301                 break;
1302         case MF_UG_MMC:
1303                 root_len = strlen(MEMORY_FOLDER);
1304                 break;
1305         default:
1306                 return MYFILE_ERR_STORAGE_TYPE_ERROR;
1307         }
1308
1309         /*
1310         **      *path has the same length with full_path
1311         **      strlen(*path) is 0 since the memset called
1312         **      we use length of full_path to reprecent the *path's
1313         */
1314         g_strlcpy(*path, full_path + root_len, strlen(full_path));
1315         if (strlen(*path) == 0) {
1316                 UG_SAFE_FREE_CHAR(*path);
1317                 *path = g_strdup("/");
1318         }
1319
1320         return MYFILE_ERR_NONE;
1321 }
1322