2 * Copyright 2012 Samsung Electronics Co., Ltd
\r
4 * Licensed under the Flora License, Version 1.1 (the "License");
\r
5 * you may not use this file except in compliance with the License.
\r
6 * You may obtain a copy of the License at
\r
8 * http://floralicense.org/license/
\r
10 * Unless required by applicable law or agreed to in writing, software
\r
11 * distributed under the License is distributed on an "AS IS" BASIS,
\r
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
13 * See the License for the specific language governing permissions and
\r
14 * limitations under the License.
\r
20 #include <sys/statvfs.h>
\r
22 #include "mf-ug-util.h"
\r
23 #include "mf-ug-cb.h"
\r
24 #include "mf-ug-main.h"
\r
25 #include "mf-ug-fm-svc-wrapper.h"
\r
26 #include "mf-ug-fs-util.h"
\r
27 #include "mf-ug-resource.h"
\r
29 #define UG_FILTER_CATEGORY_ALL \
\r
30 UG_FILTER_CATEGORY_NONE | UG_FILTER_CATEGORY_IMAGE | UG_FILTER_CATEGORY_VIDEO \
\r
31 | UG_FILTER_CATEGORY_SOUND | UG_FILTER_CATEGORY_VOICE | UG_FILTER_CATEGORY_MUSIC \
\r
32 | UG_FILTER_CATEGORY_HTML | UG_FILTER_CATEGORY_FLASH | UG_FILTER_CATEGORY_GAME \
\r
33 | UG_FILTER_CATEGORY_APP | UG_FILTER_CATEGORY_THEME | UG_FILTER_CATEGORY_DOC \
\r
34 | UG_FILTER_CATEGORY_EXCEL | UG_FILTER_CATEGORY_PPT | UG_FILTER_CATEGORY_PDF \
\r
35 | UG_FILTER_CATEGORY_TXT | UG_FILTER_CATEGORY_VCONTACT | UG_FILTER_CATEGORY_VCALENDAR \
\r
36 | UG_FILTER_CATEGORY_VNOTE | UG_FILTER_CATEGORY_VBOOKMARK | UG_FILTER_CATEGORY_VIDEO_PROJECT\
\r
37 | UG_FILTER_CATEGORY_SVG | UG_FILTER_CATEGORY_ETC
\r
40 #define MF_UG_PATH_INFO_RETRENCH 128
\r
41 #define MF_UG_PATH_INFO_HEAD_LEN(x) strlen(x)
\r
42 #define MF_UG_PATH_INFO_TRANS_OMIT elm_entry_utf8_to_markup("..")
\r
43 #define MF_UG_PATH_INFO_LEVEL_BOUNDARY 3
\r
44 #define MF_UG_PATH_INFO_LEN_THRESHOLD 4
\r
45 #define MF_UG_PATH_INFO_SEP elm_entry_utf8_to_markup("/")
\r
54 /*********************
\r
55 **Function name: __mf_ug_fm_svc_wapper_COMESFROM
\r
57 ** GString* fullpath: fullpath to check the location
\r
60 ** location of the path
\r
63 ** get storage type by fullpath
\r
64 *********************/
\r
65 static int __mf_ug_fm_svc_wapper_COMESFROM(char *fullpath)
\r
67 int len_phone = strlen(PHONE_FOLDER);
\r
68 int len_memory = strlen(MEMORY_FOLDER);
\r
70 if (strncmp(fullpath, PHONE_FOLDER, len_phone) == 0) {
\r
72 } else if (strncmp(fullpath, MEMORY_FOLDER, len_memory) == 0) {
\r
75 return MYFILE_ERR_STORAGE_TYPE_ERROR;
\r
79 /******************************
\r
80 ** Prototype : _ug_mf_get_file_list
\r
82 ** Input : struct ugmyfiledata *data
\r
83 ** GString* folder_name
\r
84 ** Eina_List** dir_list
\r
85 ** Eina_List** file_list
\r
92 ** 1.Date : 2010/12/10
\r
94 ** Modification : Created function
\r
96 ******************************/
\r
97 static int __mf_ug_fm_svc_wapper_get_file_list(GString *fullpath, Eina_List **dir_list, Eina_List **file_list)
\r
100 ug_mf_retvm_if(fullpath == NULL, MYFILE_ERR_INVALID_ARG, "fullpath is NULL");
\r
101 ug_mf_retvm_if(fullpath->str == NULL, MYFILE_ERR_INVALID_ARG, "fullpath->str is NULL");
\r
102 ug_mf_retvm_if(fullpath->len == 0, MYFILE_ERR_INVALID_ARG, "fullpath->len is 0");
\r
104 int error_code = 0;
\r
106 error_code = mf_ug_fs_oper_read_dir(fullpath->str, dir_list, file_list);
\r
107 if (error_code != 0) {
\r
108 ug_debug("error_code is [%d]\n", error_code);
\r
110 ug_debug("success get the file list\n");
\r
117 /******************************
\r
118 ** Prototype : mfUgGetFileListWithFormat
\r
120 ** Input : struct ugmyfiledata *data
\r
121 ** GString* folder_name
\r
122 ** Eina_List** dir_list
\r
123 ** Eina_List** file_list
\r
130 ** 1.Date : 2010/12/10
\r
131 ** Author : Samsung
\r
132 ** Modification : Created function
\r
134 ******************************/
\r
135 unsigned long mf_ug_fm_svc_wapper_get_file_filter(int file_filter_mode)
\r
137 unsigned long filter = 0;
\r
138 switch (file_filter_mode) {
\r
139 case SHOW_ALL_LIST:
\r
140 filter |= UG_FILTER_CATEGORY_ALL;
\r
141 ug_debug("show_all_list:::::::::::::::::::::::::::::::::: filter is [%d]", filter);
\r
143 case SHOW_IMAGE_LIST:
\r
144 filter |= UG_FILTER_CATEGORY_IMAGE;
\r
146 case SHOW_SOUND_LIST:
\r
147 filter |= UG_FILTER_CATEGORY_MUSIC | UG_FILTER_CATEGORY_SOUND | UG_FILTER_CATEGORY_VOICE;
\r
149 case SHOW_VIDEO_LIST:
\r
150 filter |= UG_FILTER_CATEGORY_VIDEO;
\r
152 case SHOW_FLASH_LIST:
\r
153 filter |= UG_FILTER_CATEGORY_FLASH;
\r
155 case SHOW_FOLDER_LIST:
\r
157 case SHOW_IMAGE_VIDEO_LIST:
\r
158 filter |= UG_FILTER_CATEGORY_IMAGE | UG_FILTER_CATEGORY_VIDEO;
\r
160 case SHOW_IMAGE_SOUND_LIST:
\r
161 filter |= UG_FILTER_CATEGORY_IMAGE | UG_FILTER_CATEGORY_SOUND | UG_FILTER_CATEGORY_MUSIC | UG_FILTER_CATEGORY_VOICE;
\r
163 case SHOW_VIDEO_SOUND_LIST:
\r
164 filter |= UG_FILTER_CATEGORY_SOUND | UG_FILTER_CATEGORY_VIDEO | UG_FILTER_CATEGORY_MUSIC | UG_FILTER_CATEGORY_VOICE;
\r
172 int mf_ug_fm_svc_wapper_get_drm_filter(int drm_filter_mode, unsigned long file_filter)
\r
174 int drm_filter = 0;
\r
175 unsigned long filter = file_filter;
\r
176 unsigned long all = (unsigned long)(UG_FILTER_CATEGORY_ALL);
\r
178 switch (drm_filter_mode) {
\r
179 case DRM_FILTER_ALL:
\r
180 if (filter == all) {
\r
181 ug_debug("drm_filter is ALL");
\r
182 drm_filter |= MF_UG_FILTER_DRM_ALL;
\r
184 if (filter & UG_FILTER_CATEGORY_IMAGE) {
\r
185 ug_debug("drm_filter is IMAGE");
\r
186 drm_filter |= MF_UG_FILTER_DRM_IMAGE;
\r
188 if (filter & UG_FILTER_CATEGORY_SOUND) {
\r
189 ug_debug("drm_filter is SOUND");
\r
190 drm_filter |= MF_UG_FILTER_DRM_RINGTONE;
\r
192 if (filter & UG_FILTER_CATEGORY_MUSIC) {
\r
193 ug_debug("drm_filter is MUSIC");
\r
194 drm_filter |= MF_UG_FILTER_DRM_RINGTONE;
\r
198 case DRM_FILTER_WITHOUT_FL:
\r
199 drm_filter |= MF_UG_FILTER_DRM_WITHOUT_FL;
\r
200 if (filter == all) {
\r
201 drm_filter |= MF_UG_FILTER_DRM_ALL;
\r
203 if (filter & UG_FILTER_CATEGORY_IMAGE) {
\r
204 drm_filter |= MF_UG_FILTER_DRM_IMAGE;
\r
206 if (filter & UG_FILTER_CATEGORY_SOUND) {
\r
207 drm_filter |= MF_UG_FILTER_DRM_RINGTONE;
\r
209 if (filter & UG_FILTER_CATEGORY_MUSIC) {
\r
210 drm_filter |= MF_UG_FILTER_DRM_RINGTONE;
\r
220 int mf_ug_fm_svc_wapper_get_file_list_by_filter(ugData *data, GString *fullpath, Eina_List **dir_list, Eina_List **filter_list)
\r
222 ugData *ugd = data;
\r
223 ug_mf_retvm_if(ugd == NULL, MYFILE_ERR_INVALID_ARG, "ugd is NULL");
\r
224 ug_mf_retvm_if(fullpath == NULL, MYFILE_ERR_INVALID_ARG, "fullpath is NULL");
\r
225 ug_mf_retvm_if(fullpath->str == NULL, MYFILE_ERR_INVALID_ARG, "fullpath->str is NULL");
\r
226 ug_mf_retvm_if(fullpath->len == 0, MYFILE_ERR_INVALID_ARG, "fullpath->len is 0");
\r
228 int error_code = 0;
\r
229 int filter_mode = 0;
\r
230 int file_filter = 0;
\r
231 int drm_filter = 0;
\r
232 int file_list_len = 0;
\r
233 Eina_List *file_list = NULL;
\r
234 char *extension = NULL;
\r
236 filter_mode = ugd->ug_UiGadget.ug_iFilterMode;
\r
237 file_filter = ugd->ug_UiGadget.ug_iFileFilter;
\r
238 drm_filter = ugd->ug_UiGadget.ug_iDrmFilter;
\r
240 ug_debug("fullpath is [%s]", fullpath->str);
\r
241 error_code = __mf_ug_fm_svc_wapper_get_file_list(fullpath, dir_list, &file_list);
\r
243 if (error_code == 0) {
\r
245 file_list_len = eina_list_count(file_list);
\r
247 if (file_list_len > 0) {
\r
248 ug_debug("file_filter is [%d]\n", filter_mode);
\r
250 if (filter_mode != SHOW_BY_EXTENSION) {
\r
251 ug_debug("file_filter is [%d] drm_filter is [%d]", file_filter, drm_filter);
\r
252 error_code = mf_ug_fs_oper_list_filter(file_list, filter_list, file_filter, drm_filter);
\r
253 } else if (ugd->ug_UiGadget.ug_pExtension != NULL) {
\r
254 extension = strdup(ugd->ug_UiGadget.ug_pExtension);
\r
255 error_code = mf_ug_fs_oper_list_filter_by_extension(file_list, filter_list, extension);
\r
258 ug_debug("error is [%d]%s %d\n", error_code, __func__, __LINE__);
\r
262 ug_debug("error is [%d]%s %d\n", error_code, __func__, __LINE__);
\r
268 /******************************
\r
269 ** Prototype : mfUgIsRootPath
\r
278 ** 1.Date : 2010/12/10
\r
279 ** Author : Samsung
\r
280 ** Modification : Created function
\r
282 ******************************/
\r
283 bool mf_ug_fm_svc_wapper_is_root_path(void *data)
\r
285 GString *g_path = (GString *)data;
\r
286 ug_mf_retvm_if(g_path == NULL, false, "g_path is NULL");
\r
288 if (!strcmp(g_path->str, PHONE_FOLDER)) {
\r
290 } else if (!strcmp(g_path->str, MEMORY_FOLDER)) {
\r
298 /******************************
\r
299 ** Prototype : mfUgGetFileName
\r
301 ** Input : GString* path
\r
308 ** 1.Date : 2010/12/10
\r
309 ** Author : Samsung
\r
310 ** Modification : Created function
\r
312 ******************************/
\r
313 GString *mf_ug_fm_svc_wapper_get_file_name(GString *path)
\r
315 GString *ret = NULL;
\r
316 if (ecore_file_exists(path->str)) {
\r
317 ret = g_string_new(ecore_file_file_get(path->str));
\r
324 char *mf_ug_fm_svc_wapper_get_root_path_by_tab_label(const char *label)
\r
326 if (g_strcmp0(label, MF_UG_LABEL_PHONE) == 0) {
\r
327 return g_strdup(PHONE_FOLDER);
\r
328 } else if (g_strcmp0(label, MF_UG_LABEL_MMC) == 0) {
\r
329 return g_strdup(MEMORY_FOLDER);
\r
334 /******************************
\r
335 ** Prototype : mf_ug_fm_svc_wapper_get_location
\r
336 ** Description : Samsung
\r
337 ** Input : char* fullpath
\r
344 ** 1.Date : 2010/12/10
\r
345 ** Author : Samsung
\r
346 ** Modification : Created function
\r
348 ******************************/
\r
349 int mf_ug_fm_svc_wapper_get_location(char *fullpath)
\r
351 return __mf_ug_fm_svc_wapper_COMESFROM(fullpath);
\r
354 gint mf_ug_fm_svc_wapper_get_folder_foldersystem(GString *path, bool * result)
\r
357 int error_code = 0;
\r
358 error_code = mf_ug_file_attr_is_system_dir(path->str, result);
\r
363 GString *mf_ug_fm_svc_wrapper_get_file_parent_path(GString *fullpath)
\r
365 GString *ret = NULL;
\r
367 int error_code = 0;
\r
369 if (fullpath == NULL || fullpath->str == NULL) {
\r
372 error_code = mf_ug_file_attr_get_parent_path(fullpath->str, &path);
\r
373 if (error_code != 0) {
\r
377 ret = g_string_new(path);
\r
383 char *mf_ug_fm_svc_path_info_retrench(const char *string)
\r
385 ug_mf_retvm_if(string == NULL, g_strdup(MF_UG_PATH_INFO_TRANS_OMIT), "input path is NULL");
\r
386 char *retrench = NULL;
\r
387 char *utf8_string = elm_entry_utf8_to_markup(string);
\r
388 if (utf8_string && strlen (string) > MF_UG_PATH_INFO_LEN_THRESHOLD) {
\r
389 if (g_utf8_strlen(utf8_string, -1) > 2) {
\r
390 retrench = calloc(1, MF_UG_PATH_INFO_RETRENCH);
\r
392 char *omit = MF_UG_PATH_INFO_TRANS_OMIT;
\r
393 char *temp = g_utf8_strncpy(retrench, utf8_string, 2);
\r
394 retrench = g_strconcat(temp, omit, NULL);
\r
395 UG_SAFE_FREE_CHAR(omit);
\r
396 UG_SAFE_FREE_CHAR(temp);
\r
398 UG_SAFE_FREE_CHAR(utf8_string);
\r
401 retrench = utf8_string;
\r
405 return utf8_string;
\r
409 static void __mf_ug_fm_svc_wrapper_path_info_node_free(Eina_List *list)
\r
411 ug_mf_retm_if(list == NULL, "list is NULL");
\r
412 const Eina_List *l = NULL;
\r
414 EINA_LIST_FOREACH(list, l, data) {
\r
415 ug_pNode *node = (ug_pNode *)data;
\r
416 if (node != NULL) {
\r
417 UG_SAFE_FREE_CHAR(node->original);
\r
418 UG_SAFE_FREE_CHAR(node->transfer);
\r
419 UG_SAFE_FREE_CHAR(node);
\r
422 eina_list_free(list);
\r
426 char *mf_ug_fm_svc_path_info_translate(char *path_info, int path_info_max_len)
\r
429 ug_mf_retvm_if(path_info == NULL, g_strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN")), "input path is NULL");
\r
433 Eina_List *temp_list = NULL;
\r
434 const Eina_List *l = NULL;
\r
435 gchar **result = NULL;
\r
436 gchar **params = NULL;
\r
441 char *output = NULL;
\r
442 void *pnode = NULL;
\r
443 char *omit = MF_UG_PATH_INFO_TRANS_OMIT;
\r
445 if (strlen(path_info) < path_info_max_len) {
\r
446 UG_SAFE_FREE_CHAR(omit);
\r
450 result = g_strsplit(path_info, "/", 0);
\r
451 if (result == NULL) {
\r
454 UG_SAFE_FREE_CHAR(omit);
\r
455 return g_strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
\r
459 count = g_strv_length(result);
\r
461 if (count > MF_UG_PATH_INFO_LEVEL_BOUNDARY)
\r
463 top = MF_UG_PATH_INFO_LEVEL_BOUNDARY;
\r
465 max_len = path_info_max_len - MF_UG_PATH_INFO_LEVEL_BOUNDARY - MF_UG_PATH_INFO_HEAD_LEN(omit);//(2 is length of ..) ../aa../bb../***
\r
471 max_len = path_info_max_len - (count-1);
\r
474 for(i = top; i > 1; i--)
\r
476 ug_pNode *nodeB = calloc(sizeof(ug_pNode), 1);
\r
477 nodeB->original = elm_entry_utf8_to_markup(params[count -i]);
\r
478 nodeB->len_orig = strlen(params[count - i]);
\r
479 nodeB->transfer = mf_ug_fm_svc_path_info_retrench(params[count-i]);
\r
480 nodeB->len_trans = strlen(nodeB->transfer);
\r
481 nodeB->flag_trans = FALSE;
\r
482 total_len += nodeB->len_orig;
\r
484 temp_list = eina_list_append(temp_list, nodeB);
\r
487 total_len += strlen(params[count - 1]);
\r
489 for (i = 0 ; i < eina_list_count(temp_list); i++)
\r
491 if (total_len > max_len)
\r
493 ug_pNode *data = NULL;
\r
494 data = eina_list_nth(temp_list, i);
\r
495 total_len -= (data->len_orig - data->len_trans);
\r
496 data->flag_trans = TRUE;
\r
499 if (total_len <= max_len)
\r
506 output = elm_entry_utf8_to_markup("..");
\r
509 char *sep = MF_UG_PATH_INFO_SEP;
\r
510 EINA_LIST_FOREACH(temp_list, l, pnode)
\r
512 ug_pNode *node = (ug_pNode *)pnode;
\r
514 if(node->flag_trans == TRUE)
\r
516 if (output != NULL)
\r
517 output = g_strconcat(output, sep, node->transfer, NULL);
\r
519 output = g_strdup(node->transfer);
\r
523 if (output != NULL)
\r
524 output = g_strconcat(output, sep ,node->original, NULL);
\r
526 output = g_strdup(node->original);
\r
528 UG_SAFE_FREE_CHAR(temp);
\r
531 char *last_string = params[count - 1];
\r
532 char *utf8_last = elm_entry_utf8_to_markup(last_string);
\r
534 if (output != NULL) {
\r
535 int last_len = strlen(last_string);
\r
536 int output_len = strlen(output);
\r
537 int d_value = path_info_max_len - output_len;
\r
538 if ((last_len + output_len) > path_info_max_len) {
\r
539 const char *end = NULL;
\r
540 gboolean ret = FALSE;
\r
541 ret = g_utf8_validate(utf8_last, d_value, &end);
\r
543 d_value = last_len - strlen(end);
\r
544 utf8_last[d_value] = '\0';
\r
545 output = g_strconcat(output, sep, utf8_last, omit, NULL);
\r
546 UG_SAFE_FREE_CHAR(temp);
\r
549 output = g_strconcat(output, sep, utf8_last, NULL);
\r
550 UG_SAFE_FREE_CHAR(temp);
\r
554 output = g_strdup(utf8_last);
\r
555 UG_SAFE_FREE_CHAR(temp);
\r
557 UG_SAFE_FREE_CHAR(utf8_last);
\r
558 UG_SAFE_FREE_CHAR(sep);
\r
559 UG_SAFE_FREE_CHAR(omit);
\r
560 UG_SAFE_FREE_CHAR(path_info);
\r
561 __mf_ug_fm_svc_wrapper_path_info_node_free(temp_list);
\r
563 g_strfreev(result);
\r
569 char *mf_ug_fm_svc_wrapper_translate_path(char *original_path)
\r
571 ug_mf_retvm_if(original_path == NULL, g_strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN")), "input path is NULL");
\r
573 char *new_path = NULL;
\r
576 if (mf_ug_fm_svc_wapper_get_location(original_path) == MF_UG_PHONE) {
\r
577 root_len = strlen(PHONE_FOLDER);
\r
578 new_path = g_strconcat(MF_UG_LABEL_PHONE, original_path + root_len, "/", NULL);
\r
579 } else if (mf_ug_fm_svc_wapper_get_location(original_path) == MF_UG_MMC) {
\r
580 root_len = strlen(MEMORY_FOLDER);
\r
581 new_path = g_strconcat(MF_UG_LABEL_MMC, original_path + root_len, "/", NULL);
\r
583 new_path = g_strdup(original_path);
\r
586 ug_debug("new path is %s", new_path);
\r
590 char *mf_ug_fm_svc_wapper_path_info_get(char *original_path)
\r
592 ug_mf_retvm_if(original_path == NULL, g_strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN")), "input path is NULL");
\r
593 char *path_info = NULL;
\r
596 path_info = mf_ug_fm_svc_wrapper_translate_path(original_path);
\r
598 len = strlen(path_info);
\r
599 if (len > 0 && path_info[len - 1] == '/') {
\r
600 path_info[len - 1] = '\0';
\r
607 unsigned long mf_ug_fm_svc_wrapper_get_free_space(int state)
\r
609 struct statvfs info;
\r
612 if (state == MF_UG_PHONE) {
\r
613 path = PHONE_FOLDER;
\r
614 } else if (state == MF_UG_MMC) {
\r
615 path = MEMORY_FOLDER;
\r
620 if (-1 == statvfs(path, &info)) {
\r
623 return (info.f_bsize) * info.f_bfree;
\r
626 bool mf_ug_fm_svc_wrapper_detect_duplication(GString *to)
\r
628 int existing = MYFILE_ERR_NONE;
\r
632 GString *parent_path = mf_ug_fm_svc_wrapper_get_file_parent_path(to);
\r
633 GString *file_name = mf_ug_fm_svc_wapper_get_file_name(to);
\r
635 ug_debug("full path and file name %s", to->str);
\r
636 if (file_name == NULL || parent_path == NULL || file_name->len == 0) {
\r
640 if (parent_path->str != NULL) {
\r
641 ug_debug("parent_path->str is %s", parent_path->str);
\r
643 if (file_name->str != NULL) {
\r
644 ug_debug("file_name->str is %s", file_name->str);
\r
647 existing = mf_ug_file_attr_is_duplicated_name(parent_path->str, file_name->str);
\r
649 ug_debug("EXIST result is %d", existing);
\r
651 if (parent_path != NULL) {
\r
652 g_string_free(parent_path, TRUE);
\r
654 parent_path = NULL;
\r
656 if (file_name != NULL) {
\r
657 g_string_free(file_name, TRUE);
\r
661 if (existing == MYFILE_ERR_NONE) {
\r
668 static int __mf_ug_fm_svc_wrapper_get_next_number(char *file_name_without_ext, int file_name_type)
\r
672 int nUnderline = 0;
\r
673 bool bAllDigits = true;
\r
676 /* check _02d format */
\r
677 nLength = strlen(file_name_without_ext);
\r
679 if (file_name_type == FILE_NAME_WITH_UNDERLINE) {
\r
680 if (nLength < 3) { /*4 means the # of minimum characters (*_n) */
\r
681 return 1; /*doesn't match */
\r
682 } else { /* input is more than 3 bytes */
\r
684 for (nUnderline = nLength - 1; nUnderline >= 0; nUnderline--) {
\r
685 if (file_name_without_ext[nUnderline] == '_') {
\r
690 if (nUnderline == 0 && file_name_without_ext[0] != '_') {
\r
691 return 1; /* doesn't match */
\r
693 /* check the right characters are all digits */
\r
694 for (i = nUnderline + 1; i < nLength; i++) {
\r
695 if (file_name_without_ext[i] < '0' || file_name_without_ext[i] > '9') {
\r
696 bAllDigits = false;
\r
702 for (i = nUnderline + 1; i < nLength; i++) {
\r
704 nCount += file_name_without_ext[i] - '0';
\r
707 file_name_without_ext[nUnderline] = '\0'; /* truncate the last '_dd' */
\r
712 if (nLength < 5) { /* 5 means the # of minimum characters (*_(n)) */
\r
713 return 1; /*doesn't match */
\r
714 } else { /* input is more than 3 bytes */
\r
716 for (nUnderline = nLength - 1; nUnderline >= 0; nUnderline--) {
\r
717 if (file_name_without_ext[nUnderline] == '(') {
\r
722 if (nUnderline == 0 && file_name_without_ext[0] != '(') {
\r
723 return 1; /* doesn't match */
\r
725 /* check the right characters are all digits */
\r
726 for (i = nUnderline + 1; i < nLength - 1; i++) {
\r
727 if (file_name_without_ext[i] < '0' || file_name_without_ext[i] > '9') {
\r
728 bAllDigits = false;
\r
733 /* and more than 2 columns. */
\r
735 for (i = nUnderline + 1; i < nLength - 1; i++) {
\r
737 nCount += file_name_without_ext[i] - '0';
\r
740 file_name_without_ext[nUnderline] = '\0'; /* truncate the last '_dd' */
\r
745 /* increase nCount by 1 */
\r
751 static int __mf_ug_fm_svc_wrapper_get_unique_name(const char *default_dir_full_path, char *original_file_name, char **unique_file_name,
\r
752 int file_name_type, void *data)
\r
754 //mf_debug("%s %d\n", __func__, __LINE__);
\r
755 ug_mf_retvm_if(unique_file_name == NULL, MYFILE_ERR_SRC_ARG_INVALID, "unique_file_name is NULL");
\r
756 ug_mf_retvm_if(data == NULL, MYFILE_ERR_SRC_ARG_INVALID, "data is NULL");
\r
758 char *file_name_without_ext = NULL;
\r
759 char *file_ext = NULL;
\r
760 char *new_file_name = NULL;
\r
761 bool result = false;
\r
762 char *dir_rel_path = NULL;
\r
766 int error_code = 0;
\r
768 if (default_dir_full_path == NULL || original_file_name == NULL) {
\r
769 ug_debug("default_dir_full_path == NULL || \
\r
770 original_file_name == NULL || \
\r
771 unique_file_name == NULL || \
\r
772 error_code == NULL ");
\r
773 error_code = MYFILE_ERR_SRC_ARG_INVALID;
\r
776 result = mf_ug_file_attr_get_logical_path_by_full(default_dir_full_path, &dir_rel_path);
\r
779 error_code = MYFILE_ERR_GET_LOGIC_PATH_FAIL;
\r
783 if (strncmp(dir_rel_path, "/", strlen(dir_rel_path)) == 0) {
\r
786 error_code = mf_ug_file_attr_is_duplicated_name(default_dir_full_path, original_file_name);
\r
787 if (error_code == 0) {
\r
788 ug_debug("unique_file_name [%s]", *unique_file_name);
\r
789 ug_debug("original_file_name [%s]", new_file_name);
\r
790 *unique_file_name = g_strdup(original_file_name);
\r
791 ug_debug("unique_file_name [%s]", *unique_file_name);
\r
794 while (error_code < 0) {
\r
796 bExt = mf_ug_file_attr_get_file_ext(original_file_name, &file_ext);
\r
797 file_name_without_ext = g_strdup(original_file_name);
\r
799 if (file_name_without_ext == NULL) {
\r
800 error_code = MYFILE_ERR_ALLOCATE_MEMORY_FAIL;
\r
804 /* add a condition, whether extention is or not. */
\r
806 file_name_without_ext[strlen(file_name_without_ext) - strlen(file_ext) - 1] = '\0';
\r
809 nCount = __mf_ug_fm_svc_wrapper_get_next_number(file_name_without_ext, file_name_type);
\r
810 if (nCount == 1 && file_name_type == FILE_NAME_WITH_BRACKETS) {
\r
811 char *file_name_with_space = g_strconcat(file_name_without_ext, " ", NULL);
\r
812 if (file_name_with_space) {
\r
813 UG_SAFE_FREE_CHAR(file_name_without_ext);
\r
814 file_name_without_ext = file_name_with_space;
\r
815 file_name_with_space = NULL;
\r
820 if (file_name_type == FILE_NAME_WITH_BRACKETS)
\r
821 new_file_name = g_strdup_printf("%s(%d).%s", file_name_without_ext, nCount, file_ext);
\r
823 new_file_name = g_strdup_printf("%s_%d.%s", file_name_without_ext, nCount, file_ext);
\r
826 if (file_name_type == FILE_NAME_WITH_BRACKETS)
\r
827 new_file_name = g_strdup_printf("%s(%d)", file_name_without_ext, nCount);
\r
829 new_file_name = g_strdup_printf("%s_%d", file_name_without_ext, nCount);
\r
831 //mf_debug("new_file_name [%s]", new_file_name);
\r
832 //mf_debug("original_file_name [%s]", new_file_name);
\r
833 UG_SAFE_FREE_CHAR(file_name_without_ext);
\r
835 ug_debug("new name is %s\n", new_file_name);
\r
837 error_code = mf_ug_file_attr_is_duplicated_name(default_dir_full_path, new_file_name);
\r
838 if (error_code == 0) {
\r
839 *unique_file_name = g_strdup(new_file_name);
\r
840 //mf_debug("rename finished\n");
\r
841 error_code = MYFILE_ERR_NONE;
\r
844 //mf_debug("rename continue\n");
\r
845 original_file_name = g_strdup(new_file_name);
\r
846 UG_SAFE_FREE_CHAR(new_file_name);
\r
848 UG_SAFE_FREE_CHAR(file_ext);
\r
851 return MYFILE_ERR_NONE;
\r
854 UG_SAFE_FREE_CHAR(dir_rel_path);
\r
855 UG_SAFE_FREE_CHAR(file_ext);
\r
856 UG_SAFE_FREE_CHAR(new_file_name);
\r
860 int mf_ug_fm_svc_wrapper_file_auto_rename(void *data, GString *fullpath, int file_name_type, GString **filename)
\r
862 ug_mf_retvm_if(data == NULL, MYFILE_ERR_SRC_ARG_INVALID, "data is NULL");
\r
863 ugData *ugd = (ugData *)data;
\r
865 GString *parent_path = mf_ug_fm_svc_wrapper_get_file_parent_path(fullpath);
\r
866 GString *file_name = mf_ug_fm_svc_wapper_get_file_name(fullpath);
\r
868 if (parent_path == NULL || file_name == NULL) {
\r
869 return MYFILE_ERR_GENERATE_NAME_FAIL;
\r
871 if (parent_path->str == NULL || file_name->str == NULL) {
\r
872 g_string_free(parent_path, TRUE);
\r
873 parent_path = NULL;
\r
874 g_string_free(file_name, TRUE);
\r
876 return MYFILE_ERR_GENERATE_NAME_FAIL;
\r
880 int error_code = 0;
\r
882 if (parent_path->str != NULL) {
\r
883 //mf_debug("parent_full_path is [%s]", parent_path->str);
\r
886 if (file_name->str != NULL) {
\r
887 //mf_debug("original_file_name is [%s]", file_name->str);
\r
889 error_code = __mf_ug_fm_svc_wrapper_get_unique_name(parent_path->str, file_name->str, &name, file_name_type, ugd);
\r
891 UG_SAFE_FREE_CHAR(name);
\r
892 return MYFILE_ERR_GENERATE_NAME_FAIL;
\r
894 g_string_append_printf(parent_path, "/%s", name);
\r
895 ug_debug("After gstring append, PATH ::: [%s]", parent_path->str);
\r
897 if (file_name != NULL) {
\r
898 g_string_free(file_name, TRUE);
\r
902 if (name != NULL) {
\r
907 *filename = parent_path;
\r
908 return MYFILE_ERR_NONE;
\r
911 int mf_ug_fm_svc_wrapper_create_service(void *data, GString *fullpath)
\r
915 mf_ug_util_remove_dir_watch();
\r
916 error_code = mf_ug_fs_oper_create_dir(fullpath->str);
\r
918 if (error_code != 0) {
\r
919 ug_debug("Make DIR error\n");
\r
925 int mf_ug_fm_svc_wrapper_create_p(const char *fullpath)
\r
929 ug_debug("path is [%s]", fullpath);
\r
930 int error_code = MYFILE_ERR_NONE;
\r
932 char *parent = NULL;
\r
933 error_code = mf_ug_file_attr_get_parent_path(fullpath, &parent);
\r
935 goto_if(error_code != MYFILE_ERR_NONE, EXIT);
\r
937 if (ecore_file_exists(parent) == false) {
\r
938 error_code = mf_ug_fm_svc_wrapper_create_p(parent);
\r
939 goto_if(error_code != MYFILE_ERR_NONE, EXIT);
\r
943 ug_debug("create [%s]", fullpath);
\r
944 error_code = mf_ug_fs_oper_create_dir(fullpath);
\r
945 goto_if(error_code != MYFILE_ERR_NONE, EXIT);
\r