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

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