2 * Copyright 2012 Samsung Electronics Co., Ltd
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
8 * http://floralicense.org/license/
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.
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"
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)"
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*/
42 bool with_meta; /*whether get image or video info*/
45 typedef struct __ug_transfer_data_s ug_transfer_data_s;
47 struct __ug_transfer_data_s {
48 const char *file_path;
53 struct _ug_ftype_by_mime {
55 mf_ug_fs_file_type ftype;
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},
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},
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},
117 {"application/pdf", UG_FILE_TYPE_PDF},
119 {"application/msword", UG_FILE_TYPE_DOC},
120 {"application/vnd.openxmlformats-officedocument.wordprocessingml.document", UG_FILE_TYPE_DOC},
122 {"application/vnd.ms-powerpoint", UG_FILE_TYPE_PPT},
123 {"application/vnd.openxmlformats-officedocument.presentationml.presentation", UG_FILE_TYPE_PPT},
125 {"application/vnd.ms-excel", UG_FILE_TYPE_EXCEL},
126 {"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", UG_FILE_TYPE_EXCEL},
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},
134 {"text/html", UG_FILE_TYPE_HTML},
136 {"application/x-shockwave-flash", UG_FILE_TYPE_FLASH},
137 {"video/x-flv", UG_FILE_TYPE_FLASH},
139 {"text/plain", UG_FILE_TYPE_TXT},
141 {"text/x-opml+xml", UG_FILE_TYPE_RSS},
143 {"text/vnd.sun.j2me.app-descriptor", UG_FILE_TYPE_JAVA},
144 {"application/x-java-archive", UG_FILE_TYPE_JAVA},
146 {NULL, UG_FILE_TYPE_ETC},
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,
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
176 ** Get file category by extention
178 *********************/
179 static mf_ug_fs_file_type __mf_ug_file_attr_get_category_by_file_ext(const char *file_ext, const char *fullpath)
183 if (file_ext == NULL) {
184 return UG_FILE_TYPE_ETC;
187 if (file_ext[0] == '.') {
191 switch (file_ext[i]) {
194 if (strcasecmp("ASF", &file_ext[i]) == 0) {
195 return UG_FILE_TYPE_VIDEO;
197 if (strcasecmp("AMR", &file_ext[i]) == 0) {
198 return UG_FILE_TYPE_VOICE;
200 if (strcasecmp("AWB", &file_ext[i]) == 0) {
201 return UG_FILE_TYPE_VOICE;
203 if (strcasecmp("AAC", &file_ext[i]) == 0) {
204 return UG_FILE_TYPE_MUSIC;
206 if (strcasecmp("AVI", &file_ext[i]) == 0) {
207 return UG_FILE_TYPE_VIDEO;
209 if (strcasecmp("AAC", &file_ext[i]) == 0) {
210 return UG_FILE_TYPE_MUSIC;
216 if (strcasecmp("BMP", &file_ext[i]) == 0) {
217 return UG_FILE_TYPE_IMAGE;
222 if (strcasecmp("DOC", &file_ext[i]) == 0) {
223 return UG_FILE_TYPE_DOC;
225 if (strcasecmp("DOCX", &file_ext[i]) == 0) {
226 return UG_FILE_TYPE_DOC;
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;
232 return UG_FILE_TYPE_VIDEO;
235 if (strcasecmp("DCF", &file_ext[i]) == 0) {
236 return UG_FILE_TYPE_DRM;
241 if (strcasecmp("GIF", &file_ext[i]) == 0) {
242 return UG_FILE_TYPE_IMAGE;
244 if (strcasecmp("G72", &file_ext[i]) == 0) {
245 return UG_FILE_TYPE_MUSIC;
250 if (strcasecmp("H263", &file_ext[i]) == 0) {
251 return UG_FILE_TYPE_MUSIC;
253 if (strcasecmp("HTML", &file_ext[i]) == 0) {
254 return UG_FILE_TYPE_HTML;
256 if (strcasecmp("HTM", &file_ext[i]) == 0) {
257 return UG_FILE_TYPE_HTML;
262 if (strcasecmp("IMY", &file_ext[i]) == 0) {
263 return UG_FILE_TYPE_SOUND;
265 if (strcasecmp("IPK", &file_ext[i]) == 0) {
266 return UG_FILE_TYPE_APP;
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;
272 return UG_FILE_TYPE_SOUND;
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;
279 return UG_FILE_TYPE_SOUND;
285 if (strcasecmp("JAD", &file_ext[i]) == 0) {
286 return UG_FILE_TYPE_JAVA;
288 if (strcasecmp("JAR", &file_ext[i]) == 0) {
289 return UG_FILE_TYPE_JAVA;
292 if (strcasecmp("JPG", &file_ext[i]) == 0) {
293 return UG_FILE_TYPE_IMAGE;
295 if (strcasecmp("JPEG", &file_ext[i]) == 0) {
296 return UG_FILE_TYPE_IMAGE;
298 if (strcasecmp("JPE", &file_ext[i]) == 0) {
299 return UG_FILE_TYPE_IMAGE;
304 if (strcasecmp("MMF", &file_ext[i]) == 0) {
305 return UG_FILE_TYPE_SOUND;
307 if (strcasecmp("MP3", &file_ext[i]) == 0) {
308 return UG_FILE_TYPE_MUSIC;
310 if (strcasecmp("MID", &file_ext[i]) == 0) {
311 return UG_FILE_TYPE_SOUND;
313 if (strcasecmp("MIDI", &file_ext[i]) == 0) {
314 return UG_FILE_TYPE_SOUND;
316 if (strcasecmp("MP4", &file_ext[i]) == 0) {
317 return UG_FILE_TYPE_VIDEO;
319 if (strcasecmp("MPG", &file_ext[i]) == 0) {
320 return UG_FILE_TYPE_VIDEO;
322 if (strcasecmp("MPEG", &file_ext[i]) == 0) {
323 return UG_FILE_TYPE_VIDEO;
325 if (strcasecmp("M4A", &file_ext[i]) == 0) {
326 return UG_FILE_TYPE_MUSIC;
328 if (strcasecmp("M3G", &file_ext[i]) == 0) {
329 return UG_FILE_TYPE_FLASH;
331 if (strcasecmp("MXMF", &file_ext[i]) == 0) {
332 return UG_FILE_TYPE_SOUND;
334 if (strcasecmp("MKV", &file_ext[i]) == 0) {
335 return UG_FILE_TYPE_VIDEO;
337 if (strcasecmp("MKA", &file_ext[i]) == 0) {
338 return UG_FILE_TYPE_MUSIC;
343 if (strcasecmp("opml", &file_ext[i]) == 0) {
344 return UG_FILE_TYPE_RSS;
349 if (strcasecmp("PNG", &file_ext[i]) == 0) {
350 return UG_FILE_TYPE_IMAGE;
352 if (strcasecmp("PJPEG", &file_ext[i]) == 0) {
353 return UG_FILE_TYPE_IMAGE;
355 if (strcasecmp("PDF", &file_ext[i]) == 0) {
356 return UG_FILE_TYPE_PDF;
358 if (strcasecmp("PPT", &file_ext[i]) == 0) {
359 return UG_FILE_TYPE_PPT;
361 if (strcasecmp("PPTX", &file_ext[i]) == 0) {
362 return UG_FILE_TYPE_PPT;
364 if (strcasecmp("PEM", &file_ext[i]) == 0) {
365 return UG_FILE_TYPE_CERTIFICATION;
373 if (strcasecmp("SDP", &file_ext[i]) == 0) {
374 return UG_FILE_TYPE_VIDEO;
376 if (strcasecmp("SPM", &file_ext[i]) == 0) {
377 return UG_FILE_TYPE_SOUND;
379 if (strcasecmp("SMP", &file_ext[i]) == 0) {
380 return UG_FILE_TYPE_SOUND;
382 if (strcasecmp("SPF", &file_ext[i]) == 0) {
383 return UG_FILE_TYPE_SOUND;
385 if (strcasecmp("SWF", &file_ext[i]) == 0) {
386 return UG_FILE_TYPE_FLASH;
388 if (strcasecmp("SCN", &file_ext[i]) == 0) {
389 return UG_FILE_TYPE_MOVIE_MAKER;
391 if (strcasecmp("SVG", &file_ext[i]) == 0) {
392 return UG_FILE_TYPE_SVG;
394 if (strcasecmp("SVGZ", &file_ext[i]) == 0) {
395 return UG_FILE_TYPE_SVG;
400 if (strcasecmp("TXT", &file_ext[i]) == 0) {
401 return UG_FILE_TYPE_TXT;
403 if (strcasecmp("THM", &file_ext[i]) == 0) {
404 return UG_FILE_TYPE_THEME;
409 if (strcasecmp("VCF", &file_ext[i]) == 0) {
410 return UG_FILE_TYPE_VCONTACT;
412 if (strcasecmp("VCS", &file_ext[i]) == 0) {
413 return UG_FILE_TYPE_VCALENDAR;
415 if (strcasecmp("VNT", &file_ext[i]) == 0) {
416 return UG_FILE_TYPE_VNOTE;
418 if (strcasecmp("VBM", &file_ext[i]) == 0) {
419 return UG_FILE_TYPE_VBOOKMARK;
424 if (strcasecmp("WAV", &file_ext[i]) == 0) {
425 return UG_FILE_TYPE_SOUND;
427 if (strcasecmp("WBMP", &file_ext[i]) == 0) {
428 return UG_FILE_TYPE_IMAGE;
430 if (strcasecmp("WGT", &file_ext[i]) == 0) {
431 return UG_FILE_TYPE_WGT;
433 if (strcasecmp("WMA", &file_ext[i]) == 0) {
434 return UG_FILE_TYPE_MUSIC;
436 if (strcasecmp("WMV", &file_ext[i]) == 0) {
437 return UG_FILE_TYPE_VIDEO;
442 if (strcasecmp("XLS", &file_ext[i]) == 0) {
443 return UG_FILE_TYPE_EXCEL;
445 if (strcasecmp("XLSX", &file_ext[i]) == 0) {
446 return UG_FILE_TYPE_EXCEL;
448 if (strcasecmp("XMF", &file_ext[i]) == 0) {
449 return UG_FILE_TYPE_SOUND;
451 if (strcasecmp("XHTML", &file_ext[i]) == 0) {
452 return UG_FILE_TYPE_HTML;
456 if (strcasecmp("3GP", &file_ext[i]) == 0) {
457 return UG_FILE_TYPE_VIDEO;
459 if (strcasecmp("3GPP", &file_ext[i]) == 0) {
460 return UG_FILE_TYPE_VIDEO;
462 if (strcasecmp("3G2", &file_ext[i]) == 0) {
463 return UG_FILE_TYPE_VIDEO;
468 return UG_FILE_TYPE_ETC;
471 /*********************
472 **Function name: mf_ug_file_attr_is_valid_name
474 ** const char *filename: the file/dir name we need to check
477 ** -0x14 if the name is invalid
478 ** 0 if the name is valid
481 ** check if the name is valid by file name
483 *********************/
484 int mf_ug_file_attr_is_valid_name(const char *filename)
487 int ret, z, cflags = 0;
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;
497 pattern = MYFILE_NAME_PATTERN;
498 z = regcomp(®, pattern, cflags);
501 regerror(z, ®, ebuf, sizeof(ebuf));
502 fprintf(stderr, "%s: pattern '%s' \n", ebuf, pattern);
503 return MYFILE_ERR_INVALID_FILE_NAME;
506 z = regexec(®, filename, nmatch, pm, 0);
507 if (z == REG_NOMATCH) {
508 ret = MYFILE_ERR_NONE;
510 ret = MYFILE_ERR_INVALID_FILE_NAME;
517 /******************************
518 ** Prototype : __mf_ug_file_attr_default_icon_get_by_type
519 ** Description : Samsung
520 ** Input : mf_ug_fs_file_type ftype
527 ** 1.Date : 2010/12/10
529 ** Modification : Created function
531 ******************************/
532 static char *__mf_ug_file_attr_default_icon_get_by_type(mf_ug_fs_file_type ftype)
534 char *icon_path = NULL;
536 if (icon_array[ftype]) {
537 icon_path = strdup(icon_array[ftype]);
539 icon_path = strdup(UG_DEFAULT_ICON);
546 /******************************
547 ** Prototype : mf_ug_file_attr_get_parent_path
548 ** Description : Samsung
549 ** Input : const char* path
557 ** 1.Date : 2010/12/10
559 ** Modification : Created function
561 ******************************/
562 int mf_ug_file_attr_get_parent_path(const char *path, char **parent_path)
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);
568 *parent_path = g_strdup(path);
569 if (*parent_path == NULL)
570 return MYFILE_ERR_ALLOCATE_FAIL;
572 const char *name = NULL;
573 name = ecore_file_file_get(path);
575 ** input path and parent_path are check in the caller.
576 ** parent_path is full path must be like /opt/media/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
581 if (strlen(*parent_path) > strlen(name))
582 (*parent_path)[strlen(*parent_path) - strlen(name) - 1] = '\0';
584 if (strlen(*parent_path) == 0) {
585 *parent_path = g_strdup("/");
588 return MYFILE_ERR_NONE;
592 /*********************
593 **Function name: mf_get_category
595 ** const char* filepath: file fullpath
596 ** mf_ug_fs_file_type *category: output parameter of category
601 ** Get file category by file full path
603 *********************/
604 int mf_ug_file_attr_get_file_category(const char *filepath, mf_ug_fs_file_type * category)
609 if (mf_ug_file_attr_is_dir(filepath)) {
610 *category = UG_FILE_TYPE_DIR;
611 return MYFILE_ERR_NONE;
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;
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);
630 if (filename[i] == '/') {
637 *category = __mf_ug_file_attr_get_category_by_file_ext(file_ext, filepath);
638 return MYFILE_ERR_NONE;
640 *category = UG_FILE_TYPE_NONE;
641 return MYFILE_ERR_GET_CATEGORY_FAIL;
645 /*********************
646 **Function name: mf_ug_file_attr_get_file_stat
648 ** const char* filename: file name
649 ** ugFsNodeInfo **node: output parameter of what we need to refine
654 ** Get file size and last modified date by file path
656 *********************/
657 int mf_ug_file_attr_get_file_stat(const char *filename, ugFsNodeInfo ** node)
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");
664 if (stat(filename, &statbuf) == -1) {
665 return MYFILE_ERR_GET_STAT_FAIL;
668 (*node)->size = statbuf.st_size;
669 (*node)->date = statbuf.st_mtime;
671 return MYFILE_ERR_NONE;
674 /*********************
675 **Function name: mf_ug_file_attr_is_dir
677 ** const char* filename: file fullpath
679 ** if path is a directory, return 1
683 ** check if the file path is Directory
685 *********************/
686 int mf_ug_file_attr_is_dir(const char *filepath)
688 return ecore_file_is_dir(filepath);
691 /*********************
692 **Function name: mf_ug_file_attr_get_store_type_by_full
694 ** const char* filepath: file full path
695 ** mf_ug_storage_type *store_type: output parameter of storage type
700 ** Get file storage type by file path
702 *********************/
703 int mf_ug_file_attr_get_store_type_by_full(const char *filepath, mf_ug_storage_type * store_type)
705 if (filepath == NULL || store_type == NULL) {
706 return MYFILE_ERR_SRC_ARG_INVALID;
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;
716 *store_type = MF_UG_NONE;
717 return MYFILE_ERR_STORAGE_TYPE_ERROR;
721 /*********************
722 **Function name: mf_ug_file_attr_is_drm_file
724 ** const char* filepath: file full path
727 ** true if it is a DRM file
728 ** false if it is not a DRM file
731 ** check if file is drm file
733 *********************/
734 int mf_ug_file_attr_is_drm_file(const char *file_fullpath)
736 if (file_fullpath == NULL)
737 return MYFILE_ERR_DRM_PERMISSION_DENY;
738 drm_bool_type_e drmFlag = DRM_FALSE;
740 res = drm_is_drm_file(file_fullpath, &drmFlag);
742 if (res == DRM_RETURN_SUCCESS && drmFlag == DRM_TRUE)
745 return MYFILE_ERR_DRM_PERMISSION_DENY;
748 /*********************
749 **Function name: mf_ug_file_attr_get_file_ext
751 ** const char* filepath: file full path
752 ** char *file_ext: output parameter of file extension
758 ** get file extension by file full path
760 *********************/
761 int mf_ug_file_attr_get_file_ext(const char *filepath, char **file_ext)
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");
766 const char *filename = NULL;
767 filename = ecore_file_file_get(filepath);
769 if (filename == NULL) {
770 return MYFILE_ERR_INVALID_FILE_NAME;
773 char *pdot = strrchr(filename, '.');
776 return MYFILE_ERR_EXT_GET_ERROR;
777 } else if (pdot != filepath) {
778 *file_ext = g_strdup(pdot + 1);
779 return MYFILE_ERR_NONE;
781 return MYFILE_ERR_EXT_GET_ERROR;
787 /*********************
788 **Function name: mf_ug_file_attr_is_right_dir_path
790 ** const char *filename: the file/dir name we need to check
796 ** check if the dir path is correct
798 *********************/
799 int mf_ug_file_attr_is_right_dir_path(const char *dir_path)
801 int result = MYFILE_ERR_NONE;
804 length = strlen(dir_path);
806 return MYFILE_ERR_INVALID_DIR_PATH;
809 if (dir_path[length - 1] == '/' && length > 1) {
810 return MYFILE_ERR_INVALID_DIR_PATH;
813 if (dir_path[0] != '/') {
814 return MYFILE_ERR_INVALID_DIR_PATH;
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);
821 if (result != MYFILE_ERR_NONE) {
822 ug_mf_error("Is NOT Valid dir path name");
828 /*********************
829 **Function name: mf_ug_file_attr_is_right_file_path
831 ** const char *filename: the file/dir name we need to check
837 ** check if the file path is correct
839 *********************/
840 int mf_ug_file_attr_is_right_file_path(const char *file_path)
842 int result = MYFILE_ERR_NONE;
844 if (strlen(file_path) == 0) {
845 return MYFILE_ERR_INVALID_FILE_PATH;
848 if (file_path[0] != '/') {
849 return MYFILE_ERR_INVALID_DIR_PATH;
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");
863 static int __mf_ug_create_filter(filter_h *filter, ug_filter_s *condition)
865 ug_mf_retvm_if(filter == NULL, -1, "filter is NULL");
866 ug_mf_retvm_if(condition == NULL, -1, "condition is NULL");
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");
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");
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");
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,
899 if(ret != MEDIA_CONTENT_ERROR_NONE) {
900 ug_debug("Fail to set offset");
904 *filter = tmp_filter;
908 media_filter_destroy(tmp_filter);
914 static int __mf_ug_destroy_filter(filter_h filter)
916 ug_mf_retvm_if(filter == NULL, -1, "filter is NULL");
917 int ret = MEDIA_CONTENT_ERROR_NONE;
918 ret = media_filter_destroy(filter);
923 static bool __mf_ug_local_data_get_media_thumbnail_cb(media_info_h media, void *data)
925 ug_mf_retvm_if(data == NULL, -1, "filter is NULL");
926 ug_transfer_data_s *tmp_data = (ug_transfer_data_s *)data;
928 media_info_get_thumbnail_path(media, &(tmp_data->thumbnail_path));
935 int static __mf_ug_local_thumbnail_get(void *data, ug_filter_s *condition)
939 filter_h filter = NULL;
940 ret = __mf_ug_create_filter(&filter, condition);
942 ug_debug("Create filter failed");
947 ret = media_info_foreach_media_from_db(filter,
948 __mf_ug_local_data_get_media_thumbnail_cb,
951 ug_debug("media_info_foreach_media_from_db failed: %d", ret);
953 ug_debug("media_info_foreach_media_from_db success!", ret);
955 __mf_ug_destroy_filter(filter);
961 int mf_ug_file_attr_get_thumbnail(void *data)
963 ug_mf_retvm_if(data == NULL, -1, "data is NULL");
965 ug_transfer_data_s *mp_data = (ug_transfer_data_s *)data;
969 memset(&filter, 0, sizeof(ug_filter_s));
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;
980 ret = __mf_ug_local_thumbnail_get(data, &filter);
981 UG_SAFE_FREE_CHAR(condition);
987 int mf_ug_file_attr_get_file_icon(const char *file_path, int *error_code, char **thumbnail)
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;
995 ug_mf_retvm_if(file_path == NULL, MF_UG_THUMBNAIL_TYPE_DEFAULT, "file_path is NULL");
998 mime = efreet_mime_type_get(file_path);
1001 ug_mf_warnig("Fail to aul_get_mime_from_file(), set etc icon");
1002 efreet_mime_shutdown();
1003 return thumbnail_type;
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;
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);
1017 case UG_FILE_TYPE_IMAGE:
1018 case UG_FILE_TYPE_VIDEO:
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);
1026 icon_path = g_strdup(tmp_data.thumbnail_path);
1027 thumbnail_type = MF_UG_THUMBNAIL_TYPE_THUMBNAIL;
1036 icon_path = __mf_ug_file_attr_default_icon_get_by_type(ftype);
1037 thumbnail_type = MF_UG_THUMBNAIL_TYPE_DEFAULT;
1041 ug_debug("mime [%s], file type [%d], icon_path [%s]", mime, ftype, icon_path);
1042 *thumbnail = icon_path;
1043 efreet_mime_shutdown();
1045 return thumbnail_type;
1048 static int mf_ug_file_attr_get_path_level(const char *fullpath, int *level)
1050 if (fullpath == NULL) {
1051 return MYFILE_ERR_SRC_ARG_INVALID;
1054 if (mf_ug_file_attr_is_right_dir_path(fullpath) != 0) {
1055 return MYFILE_ERR_INVALID_PATH;
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) {
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;
1071 char *temp = strdup(fullpath);
1073 return MYFILE_ERR_UNKNOW_ERROR;
1078 gchar **result = NULL;
1079 gchar **params = NULL;
1080 result = g_strsplit(temp, "/", 0);
1082 if (result == NULL) {
1085 return MYFILE_ERR_UNKNOW_ERROR;
1088 for (params = result; *params; params++) {
1093 *level = count - start_level - 1;
1095 return MYFILE_ERR_NONE;
1100 int mf_ug_file_attr_is_in_system_folder(char *fullpath, int level, bool * result)
1102 if (fullpath == NULL) {
1103 return MYFILE_ERR_SRC_ARG_INVALID;
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) {
1112 const char *name = NULL;
1113 name = ecore_file_file_get(fullpath);
1114 char *parent_path = malloc(MYFILE_DIR_PATH_LEN_MAX + 1);
1116 if (parent_path == NULL) {
1117 return MYFILE_ERR_ALLOCATE_FAIL;
1119 memset(parent_path, 0, MYFILE_DIR_PATH_LEN_MAX + 1);
1120 error_code = mf_ug_file_attr_get_parent_path(fullpath, &parent_path);
1122 if (error_code != 0) {
1129 if (storage_t == MF_UG_PHONE || storage_t == MF_UG_MMC) {
1131 if ((strlen(name) == strlen(IMAGE_AND_VIDEO)) && strcmp(name, IMAGE_AND_VIDEO) == 0) {
1133 } else if ((strlen(name) == strlen(SOUND_AND_MUSIC)) && strcmp(name, SOUND_AND_MUSIC) == 0) {
1135 } else if ((strlen(name) == strlen(DOWNLOADS)) && strcmp(name, DOWNLOADS) == 0) {
1137 } else if ((strlen(name) == strlen(CAMERA_SHOTS)) && strcmp(name, CAMERA_SHOTS) == 0) {
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)) {
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)) {
1154 } else if ((strlen(name) == strlen(MUSIC)) && !strcmp(MUSIC, name)) {
1156 } else if ((strlen(name) == strlen(RINGTONES)) && !strcmp(RINGTONES, name)) {
1158 } else if ((strlen(name) == strlen(ALERTS)) && !strcmp(ALERTS, name)) {
1160 } else if ((strlen(name) == strlen(VOICE_RECORDER)) && !strcmp(VOICE_RECORDER, name)) {
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)) {
1168 } else if ((strlen(name) == strlen(MY_PHOTO_CLIPS)) && !strcmp(MY_PHOTO_CLIPS, name)) {
1170 } else if ((strlen(name) == strlen(MY_ALBUM)) && !strcmp(MY_ALBUM, name)) {
1172 } else if ((strlen(name) == strlen(MY_VIDEO_CLIPS)) && !strcmp(MY_VIDEO_CLIPS, name)) {
1185 return MYFILE_ERR_STORAGE_TYPE_ERROR;
1195 return MYFILE_ERR_STORAGE_TYPE_ERROR;
1202 return MYFILE_ERR_NONE;
1206 int mf_ug_file_attr_is_system_dir(char *fullpath, bool * result)
1208 if (fullpath == NULL) {
1209 ug_debug("source argument invalid");
1210 return MYFILE_ERR_SRC_ARG_INVALID;
1213 if (mf_ug_file_attr_is_dir(fullpath) == 0) {
1214 ug_debug("source is not exist");
1215 return MYFILE_ERR_SRC_NOT_EXIST;
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");
1227 if (level >= 3 || level <= 0) {
1229 ug_debug("Path Level is wrong");
1230 return MYFILE_ERR_NONE;
1232 error_code = mf_ug_file_attr_is_in_system_folder(fullpath, level, result);
1234 if (error_code != 0) {
1235 ug_debug("Fail .. is in system folder err :: %d", error_code);
1239 return MYFILE_ERR_NONE;
1243 mf_ug_fs_file_type mf_ug_file_attr_get_file_type_by_mime(const char *file_path)
1246 mf_ug_fs_file_type ftype = UG_FILE_TYPE_NONE;
1247 const char *mime = NULL;
1249 mime = efreet_mime_type_get(file_path);
1252 ug_debug("Fail to aul_get_mime_from_file(), set etc icon");
1253 efreet_mime_shutdown();
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;
1263 efreet_mime_shutdown();
1268 int mf_ug_file_attr_is_duplicated_name(const char *dir, const char *name)
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;
1276 UG_SAFE_FREE_CHAR(file_path);
1277 return MYFILE_ERR_NONE;
1281 int mf_ug_file_attr_get_logical_path_by_full(const char *full_path, char **path)
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");
1286 mf_ug_storage_type store_type = 0;
1290 error_code = mf_ug_file_attr_get_store_type_by_full(full_path, &store_type);
1292 *path = g_strdup(full_path);
1293 if (*path == NULL) {
1294 return MYFILE_ERR_ALLOCATE_MEMORY_FAIL;
1297 memset(*path, 0, strlen(*path));
1298 switch (store_type) {
1300 root_len = strlen(PHONE_FOLDER);
1303 root_len = strlen(MEMORY_FOLDER);
1306 return MYFILE_ERR_STORAGE_TYPE_ERROR;
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
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("/");
1320 return MYFILE_ERR_NONE;