src/common/mf-ug-fm-svc-wapper.c

   1 /*\r
   2  * Copyright 2012          Samsung Electronics Co., Ltd\r
   3  *\r
   4  * Licensed under the Flora License, Version 1.0 (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
   7  *\r
   8  *  http://floralicense.org/license/\r
   9  *\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
  15  */\r
  16 \r
  17 \r
  18 \r
  19 \r
  20 #include <sys/statvfs.h>\r
  21 \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
  28 \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
  38 \r
  39 \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
  46 typedef struct {\r
  47          int len_orig;\r
  48          int len_trans;\r
  49          char *original;\r
  50          char *transfer;\r
  51          bool flag_trans;\r
  52 }ug_pNode;\r
  53 \r
  54 /*********************\r
  55 **Function name:        __mf_ug_fm_svc_wapper_COMESFROM\r
  56 **Parameter:\r
  57 **      GString* fullpath:      fullpath to check the location\r
  58 **\r
  59 **Return value:\r
  60 **      location of the path\r
  61 **\r
  62 **Action:\r
  63 **      get storage type by fullpath\r
  64 *********************/\r
  65 static int __mf_ug_fm_svc_wapper_COMESFROM(char *fullpath)\r
  66 {\r
  67         int len_phone = strlen(PHONE_FOLDER);\r
  68         int len_memory = strlen(MEMORY_FOLDER);\r
  69 \r
  70         if (strncmp(fullpath, PHONE_FOLDER, len_phone) == 0) {\r
  71                 return MF_UG_PHONE;\r
  72         } else if (strncmp(fullpath, MEMORY_FOLDER, len_memory) == 0) {\r
  73                 return MF_UG_MMC;\r
  74         } else {\r
  75                 return MYFILE_ERR_STORAGE_TYPE_ERROR;\r
  76         }\r
  77 }\r
  78 \r
  79 /******************************\r
  80 ** Prototype    : _ug_mf_get_file_list\r
  81 ** Description  :\r
  82 ** Input        : struct ugmyfiledata *data\r
  83 **                GString* folder_name\r
  84 **                Eina_List** dir_list\r
  85 **                Eina_List** file_list\r
  86 ** Output       : None\r
  87 ** Return Value :\r
  88 ** Calls        :\r
  89 ** Called By    :\r
  90 **\r
  91 **  History        :\r
  92 **  1.Date         : 2010/12/10\r
  93 **    Author       : Samsung\r
  94 **    Modification : Created function\r
  95 **\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
  98 {\r
  99         UG_TRACE_BEGIN;\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
 103 \r
 104         int error_code = 0;\r
 105 \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
 109         } else {\r
 110                 ug_debug("success get the file list\n");\r
 111         }\r
 112         UG_TRACE_END;\r
 113         return error_code;\r
 114 }\r
 115 \r
 116 \r
 117 /******************************\r
 118 ** Prototype    : mfUgGetFileListWithFormat\r
 119 ** Description  :\r
 120 ** Input        : struct ugmyfiledata *data\r
 121 **                GString* folder_name\r
 122 **                Eina_List** dir_list\r
 123 **                Eina_List** file_list\r
 124 ** Output       : None\r
 125 ** Return Value :\r
 126 ** Calls        :\r
 127 ** Called By    :\r
 128 **\r
 129 **  History        :\r
 130 **  1.Date         : 2010/12/10\r
 131 **    Author       : Samsung\r
 132 **    Modification : Created function\r
 133 **\r
 134 ******************************/\r
 135 unsigned long mf_ug_fm_svc_wapper_get_file_filter(int file_filter_mode)\r
 136 {\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
 142                 break;\r
 143         case SHOW_IMAGE_LIST:\r
 144                 filter |= UG_FILTER_CATEGORY_IMAGE;\r
 145                 break;\r
 146         case SHOW_SOUND_LIST:\r
 147                 filter |= UG_FILTER_CATEGORY_MUSIC | UG_FILTER_CATEGORY_SOUND | UG_FILTER_CATEGORY_VOICE;\r
 148                 break;\r
 149         case SHOW_VIDEO_LIST:\r
 150                 filter |= UG_FILTER_CATEGORY_VIDEO;\r
 151                 break;\r
 152         case SHOW_FLASH_LIST:\r
 153                 filter |= UG_FILTER_CATEGORY_FLASH;\r
 154                 break;\r
 155         case SHOW_FOLDER_LIST:\r
 156                 break;\r
 157         case SHOW_IMAGE_VIDEO_LIST:\r
 158                 filter |= UG_FILTER_CATEGORY_IMAGE | UG_FILTER_CATEGORY_VIDEO;\r
 159                 break;\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
 162                 break;\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
 165                 break;\r
 166         default:\r
 167                 break;\r
 168         }\r
 169         return filter;\r
 170 }\r
 171 \r
 172 int mf_ug_fm_svc_wapper_get_drm_filter(int drm_filter_mode, unsigned long file_filter)\r
 173 {\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
 177 \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
 183                 } else {\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
 187                         }\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
 191                         }\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
 195                         }\r
 196                 }\r
 197                 break;\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
 202                 } else {\r
 203                         if (filter & UG_FILTER_CATEGORY_IMAGE) {\r
 204                                 drm_filter |= MF_UG_FILTER_DRM_IMAGE;\r
 205                         }\r
 206                         if (filter & UG_FILTER_CATEGORY_SOUND) {\r
 207                                 drm_filter |= MF_UG_FILTER_DRM_RINGTONE;\r
 208                         }\r
 209                         if (filter & UG_FILTER_CATEGORY_MUSIC) {\r
 210                                 drm_filter |= MF_UG_FILTER_DRM_RINGTONE;\r
 211                         }\r
 212                 }\r
 213                 break;\r
 214         default:\r
 215                 break;\r
 216         }\r
 217         return drm_filter;\r
 218 }\r
 219 \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
 221 {\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
 227 \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
 235 \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
 239 \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
 242 \r
 243         if (error_code == 0) {\r
 244                 ug_debug();\r
 245                 file_list_len = eina_list_count(file_list);\r
 246 \r
 247                 if (file_list_len > 0) {\r
 248                         ug_debug("file_filter is [%d]\n", filter_mode);\r
 249 \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
 256                                 free(extension);\r
 257                         }\r
 258                         ug_debug("error is [%d]%s %d\n", error_code, __func__, __LINE__);\r
 259                         return error_code;\r
 260                 }\r
 261         }\r
 262         ug_debug("error is [%d]%s %d\n", error_code, __func__, __LINE__);\r
 263         return error_code;\r
 264 }\r
 265 \r
 266 \r
 267 \r
 268 /******************************\r
 269 ** Prototype    : mfUgIsRootPath\r
 270 ** Description  :\r
 271 ** Input        : None\r
 272 ** Output       : None\r
 273 ** Return Value :\r
 274 ** Calls        :\r
 275 ** Called By    :\r
 276 **\r
 277 **  History        :\r
 278 **  1.Date         : 2010/12/10\r
 279 **    Author       : Samsung\r
 280 **    Modification : Created function\r
 281 **\r
 282 ******************************/\r
 283 bool mf_ug_fm_svc_wapper_is_root_path(void *data)\r
 284 {\r
 285         GString *g_path = (GString *)data;\r
 286         ug_mf_retvm_if(g_path == NULL, false, "g_path is NULL");\r
 287 \r
 288         if (!strcmp(g_path->str, PHONE_FOLDER)) {\r
 289                 return true;\r
 290         } else if (!strcmp(g_path->str, MEMORY_FOLDER)) {\r
 291                 return true;\r
 292         } else {\r
 293                 return false;\r
 294         }\r
 295 }\r
 296 \r
 297 \r
 298 /******************************\r
 299 ** Prototype    : mfUgGetFileName\r
 300 ** Description  :\r
 301 ** Input        : GString* path\r
 302 ** Output       : None\r
 303 ** Return Value :\r
 304 ** Calls        :\r
 305 ** Called By    :\r
 306 **\r
 307 **  History        :\r
 308 **  1.Date         : 2010/12/10\r
 309 **    Author       : Samsung\r
 310 **    Modification : Created function\r
 311 **\r
 312 ******************************/\r
 313 GString *mf_ug_fm_svc_wapper_get_file_name(GString *path)\r
 314 {\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
 318         } else {\r
 319                 ret = NULL;\r
 320         }\r
 321         return ret;\r
 322 }\r
 323 \r
 324 char *mf_ug_fm_svc_wapper_get_root_path_by_tab_label(const char *label)\r
 325 {\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
 330         } else\r
 331                 return NULL;\r
 332 }\r
 333 \r
 334 /******************************\r
 335 ** Prototype    : mf_ug_fm_svc_wapper_get_location\r
 336 ** Description  : Samsung\r
 337 ** Input        : char* fullpath\r
 338 ** Output       : None\r
 339 ** Return Value :\r
 340 ** Calls        :\r
 341 ** Called By    :\r
 342 **\r
 343 **  History        :\r
 344 **  1.Date         : 2010/12/10\r
 345 **    Author       : Samsung\r
 346 **    Modification : Created function\r
 347 **\r
 348 ******************************/\r
 349 int mf_ug_fm_svc_wapper_get_location(char *fullpath)\r
 350 {\r
 351         return __mf_ug_fm_svc_wapper_COMESFROM(fullpath);\r
 352 }\r
 353 \r
 354 gint mf_ug_fm_svc_wapper_get_folder_foldersystem(GString *path, bool * result)\r
 355 {\r
 356 \r
 357         int error_code = 0;\r
 358         error_code = mf_ug_file_attr_is_system_dir(path->str, result);\r
 359         return error_code;\r
 360 \r
 361 }\r
 362 \r
 363 GString *mf_ug_fm_svc_wrapper_get_file_parent_path(GString *fullpath)\r
 364 {\r
 365         GString *ret = NULL;\r
 366         char *path = NULL;\r
 367         int error_code = 0;\r
 368 \r
 369         if (fullpath == NULL || fullpath->str == NULL) {\r
 370                 return NULL;\r
 371         }\r
 372         error_code = mf_ug_file_attr_get_parent_path(fullpath->str, &path);\r
 373         if (error_code != 0) {\r
 374                 return NULL;\r
 375         }\r
 376 \r
 377         ret = g_string_new(path);\r
 378         free(path);\r
 379         path = NULL;\r
 380         return ret;\r
 381 }\r
 382 \r
 383 char *mf_ug_fm_svc_path_info_retrench(const char *string)\r
 384 {\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
 391                         if (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
 397                         }\r
 398                         UG_SAFE_FREE_CHAR(utf8_string);\r
 399 \r
 400                 } else {\r
 401                         retrench = utf8_string;\r
 402                 }\r
 403                 return retrench;\r
 404         } else {\r
 405                 return utf8_string;\r
 406         }\r
 407 }\r
 408 \r
 409 static void __mf_ug_fm_svc_wrapper_path_info_node_free(Eina_List *list)\r
 410 {\r
 411         ug_mf_retm_if(list == NULL, "list is NULL");\r
 412         const Eina_List *l = NULL;\r
 413         void *data = 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
 420                 }\r
 421         }\r
 422         eina_list_free(list);\r
 423 }\r
 424 \r
 425 \r
 426 char *mf_ug_fm_svc_path_info_translate(char *path_info, int path_info_max_len)\r
 427 {\r
 428 \r
 429         ug_mf_retvm_if(path_info == NULL, g_strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN")), "input path is NULL");\r
 430 \r
 431         int top = 0;\r
 432         bool flag = TRUE;\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
 437         int count = 0;\r
 438         int max_len = 0;\r
 439         int total_len = 0;\r
 440         int i = 0;\r
 441         char *output = NULL;\r
 442         void *pnode = NULL;\r
 443         char *omit = MF_UG_PATH_INFO_TRANS_OMIT;\r
 444 \r
 445         if (strlen(path_info) < path_info_max_len) {\r
 446                 UG_SAFE_FREE_CHAR(omit);\r
 447                 return path_info;\r
 448         }\r
 449 \r
 450         result = g_strsplit(path_info, "/", 0);\r
 451         if (result == NULL) {\r
 452                 free(path_info);\r
 453                 path_info = NULL;\r
 454                 UG_SAFE_FREE_CHAR(omit);\r
 455                 return g_strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));\r
 456         }\r
 457 \r
 458         params = result;\r
 459         count = g_strv_length(result);\r
 460 \r
 461         if (count > MF_UG_PATH_INFO_LEVEL_BOUNDARY)\r
 462         {\r
 463                 top = MF_UG_PATH_INFO_LEVEL_BOUNDARY;\r
 464                 flag = FALSE;\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
 466         }\r
 467         else\r
 468         {\r
 469                 top = count;\r
 470                 flag = TRUE;\r
 471                 max_len = path_info_max_len - (count-1);\r
 472         }\r
 473 \r
 474         for(i = top; i > 1; i--)\r
 475         {\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
 483 \r
 484                 temp_list = eina_list_append(temp_list, nodeB);\r
 485         }\r
 486 \r
 487         total_len += strlen(params[count - 1]);\r
 488 \r
 489         for (i = 0 ; i < eina_list_count(temp_list); i++)\r
 490         {\r
 491                 if (total_len > max_len)\r
 492                 {\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
 497                 }\r
 498 \r
 499                 if (total_len <= max_len)\r
 500                 break;\r
 501         }\r
 502 \r
 503 \r
 504         if (flag == FALSE)\r
 505         {\r
 506                 output = elm_entry_utf8_to_markup("..");\r
 507         }\r
 508         char *temp = NULL;\r
 509         char *sep = MF_UG_PATH_INFO_SEP;\r
 510         EINA_LIST_FOREACH(temp_list, l, pnode)\r
 511         {\r
 512                 ug_pNode *node = (ug_pNode *)pnode;\r
 513                 temp = output;\r
 514                 if(node->flag_trans == TRUE)\r
 515                 {\r
 516                         if (output != NULL)\r
 517                                 output = g_strconcat(output, sep, node->transfer, NULL);\r
 518                         else\r
 519                                 output = g_strdup(node->transfer);\r
 520                 }\r
 521                 else\r
 522                 {\r
 523                         if (output != NULL)\r
 524                                 output = g_strconcat(output, sep ,node->original, NULL);\r
 525                         else\r
 526                                 output = g_strdup(node->original);\r
 527                 }\r
 528                 UG_SAFE_FREE_CHAR(temp);\r
 529         }\r
 530         temp = output;\r
 531         char *last_string = params[count - 1];\r
 532         char *utf8_last = elm_entry_utf8_to_markup(last_string);\r
 533 \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
 542                         if (ret == TRUE) {\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
 547                         }\r
 548                 } else {\r
 549                         output = g_strconcat(output, sep, utf8_last, NULL);\r
 550                         UG_SAFE_FREE_CHAR(temp);\r
 551                 }\r
 552         }\r
 553         else {\r
 554                 output = g_strdup(utf8_last);\r
 555                 UG_SAFE_FREE_CHAR(temp);\r
 556         }\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
 562         temp_list = NULL;\r
 563         g_strfreev(result);\r
 564         result = NULL;\r
 565         return output;\r
 566 }\r
 567 \r
 568 \r
 569 char *mf_ug_fm_svc_wrapper_translate_path(char *original_path)\r
 570 {\r
 571         ug_mf_retvm_if(original_path == NULL, g_strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN")), "input path is NULL");\r
 572 \r
 573         char *new_path = NULL;\r
 574         int root_len = 0;\r
 575 \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
 582         } else {\r
 583                 new_path = g_strdup(original_path);\r
 584         }\r
 585 \r
 586         ug_debug("new path is %s", new_path);\r
 587         return new_path;\r
 588 }\r
 589 \r
 590 char *mf_ug_fm_svc_wapper_path_info_get(char *original_path)\r
 591 {\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
 594         int len = 0;\r
 595 \r
 596         path_info = mf_ug_fm_svc_wrapper_translate_path(original_path);\r
 597         if (path_info) {\r
 598                 len = strlen(path_info);\r
 599                 if (len > 0 && path_info[len - 1] == '/') {\r
 600                         path_info[len - 1] = '\0';\r
 601                 }\r
 602         }\r
 603         return path_info;\r
 604 \r
 605 }\r
 606 \r
 607 unsigned long mf_ug_fm_svc_wrapper_get_free_space(int state)\r
 608 {\r
 609         struct statvfs info;\r
 610         char *path = NULL;\r
 611 \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
 616         } else {\r
 617                 return -1;\r
 618         }\r
 619 \r
 620         if (-1 == statvfs(path, &info)) {\r
 621                 return -2;\r
 622         }\r
 623         return (info.f_bsize) * info.f_bfree;\r
 624 }\r
 625 \r
 626 bool mf_ug_fm_svc_wrapper_detect_duplication(GString *to)\r
 627 {\r
 628         int existing = MYFILE_ERR_NONE;\r
 629         if (to == NULL) {\r
 630                 return false;\r
 631         }\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
 634 \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
 637                 return false;\r
 638         }\r
 639 \r
 640         if (parent_path->str != NULL) {\r
 641                 ug_debug("parent_path->str is %s", parent_path->str);\r
 642         }\r
 643         if (file_name->str != NULL) {\r
 644                 ug_debug("file_name->str is %s", file_name->str);\r
 645         }\r
 646 \r
 647         existing = mf_ug_file_attr_is_duplicated_name(parent_path->str, file_name->str);\r
 648 \r
 649         ug_debug("EXIST result is %d", existing);\r
 650 \r
 651         if (parent_path != NULL) {\r
 652                 g_string_free(parent_path, TRUE);\r
 653         }\r
 654         parent_path = NULL;\r
 655 \r
 656         if (file_name != NULL) {\r
 657                 g_string_free(file_name, TRUE);\r
 658         }\r
 659         file_name = NULL;\r
 660 \r
 661         if (existing == MYFILE_ERR_NONE) {\r
 662                 return false;\r
 663         } else {\r
 664                 return true;\r
 665         }\r
 666 }\r
 667 \r
 668 static int __mf_ug_fm_svc_wrapper_get_next_number(char *file_name_without_ext, int file_name_type)\r
 669 {\r
 670         int nCount = 0;\r
 671         int nLength = 0;\r
 672         int nUnderline = 0;\r
 673         bool bAllDigits = true;\r
 674         int i;\r
 675 \r
 676         /* check _02d format */\r
 677         nLength = strlen(file_name_without_ext);\r
 678 \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
 683                         /* find '_' */\r
 684                         for (nUnderline = nLength - 1; nUnderline >= 0; nUnderline--) {\r
 685                                 if (file_name_without_ext[nUnderline] == '_') {\r
 686                                         break;\r
 687                                 }\r
 688                         }\r
 689 \r
 690                         if (nUnderline == 0 && file_name_without_ext[0] != '_') {\r
 691                                 return 1;       /* doesn't match */\r
 692                         }\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
 697                                         break;\r
 698                                 }\r
 699                         }\r
 700 \r
 701                         if (bAllDigits) {\r
 702                                 for (i = nUnderline + 1; i < nLength; i++) {\r
 703                                         nCount *= 10;\r
 704                                         nCount += file_name_without_ext[i] - '0';\r
 705                                 }\r
 706 \r
 707                                 file_name_without_ext[nUnderline] = '\0';       /* truncate the last  '_dd' */\r
 708                         }\r
 709                 }\r
 710         } else {\r
 711 \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
 715                         /* find '_' */\r
 716                         for (nUnderline = nLength - 1; nUnderline >= 0; nUnderline--) {\r
 717                                 if (file_name_without_ext[nUnderline] == '(') {\r
 718                                         break;\r
 719                                 }\r
 720                         }\r
 721 \r
 722                         if (nUnderline == 0 && file_name_without_ext[0] != '(') {\r
 723                                 return 1;       /* doesn't match */\r
 724                         }\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
 729                                         break;\r
 730                                 }\r
 731                         }\r
 732 \r
 733                         /* and more than 2 columns. */\r
 734                         if (bAllDigits) {\r
 735                                 for (i = nUnderline + 1; i < nLength - 1; i++) {\r
 736                                         nCount *= 10;\r
 737                                         nCount += file_name_without_ext[i] - '0';\r
 738                                 }\r
 739 \r
 740                                 file_name_without_ext[nUnderline] = '\0';       /* truncate the last  '_dd' */\r
 741                         }\r
 742                 }\r
 743         }\r
 744 \r
 745         /* increase nCount by 1 */\r
 746         nCount++;\r
 747 \r
 748         return nCount;\r
 749 }\r
 750 \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
 753 {\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
 757 \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
 763         int slash = 1;\r
 764         int nCount = 0;\r
 765         bool bExt = false;\r
 766         int error_code = 0;\r
 767 \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
 774                 goto Exception;\r
 775         }\r
 776         result = mf_ug_file_attr_get_logical_path_by_full(default_dir_full_path, &dir_rel_path);\r
 777 \r
 778         if (result) {\r
 779                 error_code = MYFILE_ERR_GET_LOGIC_PATH_FAIL;\r
 780                 goto Exception;\r
 781         }\r
 782 \r
 783         if (strncmp(dir_rel_path, "/", strlen(dir_rel_path)) == 0) {\r
 784                 slash = 0;\r
 785         }\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
 792         }\r
 793 \r
 794         while (error_code < 0) {\r
 795                 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
 798 \r
 799                 if (file_name_without_ext == NULL) {\r
 800                         error_code = MYFILE_ERR_ALLOCATE_MEMORY_FAIL;\r
 801                         goto Exception;\r
 802                 }\r
 803 \r
 804                 /* add a condition, whether extention is or not. */\r
 805                 if (bExt == 0) {\r
 806                         file_name_without_ext[strlen(file_name_without_ext) - strlen(file_ext) - 1] = '\0';\r
 807                 }\r
 808 \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
 816                         }\r
 817                 }\r
 818 \r
 819                 if (bExt == 0) {\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
 822                         else\r
 823                                 new_file_name = g_strdup_printf("%s_%d.%s", file_name_without_ext, nCount, file_ext);\r
 824                         } else {\r
 825 \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
 828                         else\r
 829                                 new_file_name = g_strdup_printf("%s_%d", file_name_without_ext, nCount);\r
 830                 }\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
 834 \r
 835                 ug_debug("new name is %s\n", new_file_name);\r
 836 \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
 842                         goto Exception;\r
 843                 } else {\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
 847                 }\r
 848                 UG_SAFE_FREE_CHAR(file_ext);\r
 849         }\r
 850 \r
 851         return MYFILE_ERR_NONE;\r
 852 \r
 853 Exception:\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
 857         return error_code;\r
 858 }\r
 859 \r
 860 int mf_ug_fm_svc_wrapper_file_auto_rename(void *data, GString *fullpath, int file_name_type, GString **filename)\r
 861 {\r
 862         ug_mf_retvm_if(data == NULL, MYFILE_ERR_SRC_ARG_INVALID, "data is NULL");\r
 863         ugData *ugd = (ugData *)data;\r
 864 \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
 867 \r
 868         if (parent_path == NULL || file_name == NULL) {\r
 869                 return MYFILE_ERR_GENERATE_NAME_FAIL;\r
 870         }\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
 875                 file_name = NULL;\r
 876                 return MYFILE_ERR_GENERATE_NAME_FAIL;\r
 877         }\r
 878 \r
 879         char *name = NULL;\r
 880         int error_code = 0;\r
 881 \r
 882         if (parent_path->str != NULL) {\r
 883                 //mf_debug("parent_full_path is [%s]", parent_path->str);\r
 884         }\r
 885 \r
 886         if (file_name->str != NULL) {\r
 887                 //mf_debug("original_file_name is [%s]", file_name->str);\r
 888         }\r
 889         error_code = __mf_ug_fm_svc_wrapper_get_unique_name(parent_path->str, file_name->str, &name, file_name_type, ugd);\r
 890         if (error_code) {\r
 891                 UG_SAFE_FREE_CHAR(name);\r
 892                 return MYFILE_ERR_GENERATE_NAME_FAIL;\r
 893         }\r
 894         g_string_append_printf(parent_path, "/%s", name);\r
 895         ug_debug("After gstring append, PATH ::: [%s]", parent_path->str);\r
 896 \r
 897         if (file_name != NULL) {\r
 898                 g_string_free(file_name, TRUE);\r
 899         }\r
 900 \r
 901         file_name = NULL;\r
 902         if (name != NULL) {\r
 903                 free(name);\r
 904                 name = NULL;\r
 905         }\r
 906 \r
 907         *filename = parent_path;\r
 908         return MYFILE_ERR_NONE;\r
 909 }\r
 910 \r
 911 int mf_ug_fm_svc_wrapper_create_service(void *data, GString *fullpath)\r
 912 {\r
 913         int error_code;\r
 914 \r
 915         mf_ug_util_remove_dir_watch();\r
 916         error_code = mf_ug_fs_oper_create_dir(fullpath->str);\r
 917 \r
 918         if (error_code != 0) {\r
 919                 ug_debug("Make DIR error\n");\r
 920         }\r
 921 \r
 922         return error_code;\r
 923 }\r
 924 \r
 925 int mf_ug_fm_svc_wrapper_create_p(const char *fullpath)\r
 926 {\r
 927         UG_TRACE_BEGIN;\r
 928 \r
 929         ug_debug("path is [%s]", fullpath);\r
 930         int error_code = MYFILE_ERR_NONE;\r
 931 \r
 932         char *parent = NULL;\r
 933         error_code = mf_ug_file_attr_get_parent_path(fullpath, &parent);\r
 934 \r
 935         goto_if(error_code != MYFILE_ERR_NONE, EXIT);\r
 936 \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
 940 \r
 941         }\r
 942 \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
 946 \r
 947 EXIT:\r
 948         return error_code;\r
 949 }\r