src/mf-ug-main.c

   1 /*
   2  * Copyright 2012          Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *  http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18
  19
  20
  21 #include <stdio.h>
  22 #include <sys/time.h>
  23 #include <Elementary.h>
  24 #include <Ecore_X.h>
  25 #include <vconf.h>
  26 #include <media_content.h>
  27
  28 #include "mf-ug-main.h"
  29 #include "mf-ug-fs-util.h"
  30 #include "mf-ug-util.h"
  31 #include "mf-ug-conf.h"
  32 #include "mf-ug-dlog.h"
  33 #include "mf-ug-winset.h"
  34 #include "mf-ug-fm-svc-wrapper.h"
  35 #include "mf-ug-resource.h"
  36 #include "mf-ug-cb.h"
  37 #include "mf-ug-list-play.h"
  38
  39 /******************************
  40 ** Prototype    : __mf_ug_main_init_data
  41 ** Description  :
  42 ** Input        : void *data
  43 ** Output       : None
  44 ** Return Value :
  45 ** Calls        :
  46 ** Called By    :
  47 **
  48 **  History        :
  49 **  1.Date         : 2010/12/10
  50 **    Author       : Samsung
  51 **    Modification : Created function
  52 **
  53 ******************************/
  54 static void __mf_ug_main_init_data(void *data)
  55 {
  56         UG_TRACE_BEGIN;
  57         ugData *ugd = (ugData *)data;
  58         ug_mf_retm_if(ugd == NULL, "ugData is NULL");
  59
  60         if (ugd->ug_Status.ug_pPath != NULL) {
  61                 g_string_free(ugd->ug_Status.ug_pPath, TRUE);
  62                 ugd->ug_Status.ug_pPath = NULL;
  63         }
  64         ugd->ug_Status.ug_pPath = g_string_new(PHONE_FOLDER);
  65         ugd->ug_Status.ug_iState = STATE_PHONE;
  66         ugd->ug_Status.ug_iRadioOn = 0;
  67         ugd->ug_Status.ug_iMmcFlag = false;
  68         ugd->ug_Status.ug_bAudioPlayFlag = false;
  69         ugd->ug_Status.ug_bInstallFlag = true;
  70         ugd->ug_Status.ug_bInSettingView = false;
  71         ugd->ug_Status.ug_bSettingEntry = false;
  72         ugd->ug_Status.ug_iMore = UG_MORE_DEFAULT;
  73         ugd->ug_Status.ug_iViewType = mf_ug_view_root;
  74
  75         ugd->ug_UiGadget.ug_iSelectMode = SINGLE_FILE_MODE;
  76         ugd->ug_UiGadget.ug_iFilterMode = SHOW_ALL_LIST;
  77         ugd->ug_UiGadget.ug_pExtension = NULL;
  78         ugd->ug_UiGadget.ug_iDrmFilter = DRM_FILTER_NONE;
  79         ugd->ug_UiGadget.ug_iMarkedMode = MARKED_OFF;
  80         ugd->ug_UiGadget.ug_pMultiSelectFileList = NULL;
  81
  82         ugd->ug_ListPlay.ug_pPlayFilePath = NULL;
  83         ugd->ug_ListPlay.ug_iPlayState = PLAY_STATE_INIT;
  84
  85
  86         mf_ug_util_create_dir_monitor(ugd);
  87         mf_ug_util_set_mmc_state_cb(ugd);
  88         UG_TRACE_END;
  89 }
  90
  91 /******************************
  92 ** Prototype    : __mf_ug_main_free_data
  93 ** Description  :
  94 ** Input        : void *data
  95 ** Output       : None
  96 ** Return Value :
  97 ** Calls        :
  98 ** Called By    :
  99 **
 100 **  History        :
 101 **  1.Date         : 2010/12/10
 102 **    Author       : Samsung
 103 **    Modification : Created function
 104 **
 105 ******************************/
 106 static void __mf_ug_main_free_data(void *data)
 107 {
 108         UG_TRACE_BEGIN;
 109         ugData *ugd = (ugData *)data;
 110         ug_mf_retm_if(ugd == NULL, "ugData is NULL");
 111
 112         if (ugd->ug_Status.ug_pPath) {
 113                 g_string_free(ugd->ug_Status.ug_pPath, TRUE);
 114                 ugd->ug_Status.ug_pPath = NULL;
 115         }
 116         if (ugd->ug_UiGadget.ug_pMultiSelectFileList) {
 117                 mf_ug_util_free_eina_list_data(&ugd->ug_UiGadget.ug_pMultiSelectFileList, NODE_TYPE_CHAR);
 118                 ugd->ug_UiGadget.ug_pMultiSelectFileList = NULL;
 119         }
 120         if (ugd->ug_UiGadget.ug_pDirList) {
 121                 mf_ug_util_free_eina_list_data(&ugd->ug_UiGadget.ug_pDirList, NODE_TYPE_PNODE);
 122                 ugd->ug_UiGadget.ug_pDirList = NULL;
 123         }
 124         if (ugd->ug_UiGadget.ug_pFilterList) {
 125                 mf_ug_util_free_eina_list_data(&ugd->ug_UiGadget.ug_pFilterList, NODE_TYPE_PNODE);
 126                 ugd->ug_UiGadget.ug_pFilterList = NULL;
 127         }
 128
 129         if (ugd->ug_Status.ug_pUpper_folder) {
 130                 free(ugd->ug_Status.ug_pUpper_folder);
 131                 ugd->ug_Status.ug_pUpper_folder = NULL;
 132         }
 133         if (ugd->ug_Status.ug_pEntryPath) {
 134                 free(ugd->ug_Status.ug_pEntryPath);
 135                 ugd->ug_Status.ug_pEntryPath = NULL;
 136         }
 137
 138         UG_TRACE_END;
 139
 140 }
 141
 142
 143 /******************************
 144 ** Prototype    : __mf_ug_main_free_evas_object
 145 ** Description  : Samsung
 146 ** Input        : void *data
 147 ** Output       : None
 148 ** Return Value :
 149 ** Calls        :
 150 ** Called By    :
 151 **
 152 **  History        :
 153 **  1.Date         : 2010/12/10
 154 **    Author       : Samsung
 155 **    Modification : Created function
 156 **
 157 ******************************/
 158 static void __mf_ug_main_free_evas_object(void *data)
 159 {
 160
 161         UG_TRACE_BEGIN;
 162         ugData *ugd = (ugData *)data;
 163         ug_mf_retm_if(ugd == NULL, "ugData is NULL");
 164
 165         int iNaviListLen = 0;
 166         int index = 0;
 167
 168         if (ugd->ug_MainWindow.ug_pNormalPopup != NULL) {
 169
 170                 evas_object_del(ugd->ug_MainWindow.ug_pNormalPopup);
 171                 ugd->ug_MainWindow.ug_pNormalPopup = NULL;
 172         }
 173         if (ugd->ug_MainWindow.ug_pRadioGroup != NULL) {
 174
 175                 evas_object_del(ugd->ug_MainWindow.ug_pRadioGroup);
 176                 ugd->ug_MainWindow.ug_pRadioGroup = NULL;
 177         }
 178
 179         iNaviListLen = eina_list_count(ugd->ug_MainWindow.ug_pNaviBarList);
 180         for (index = 0; index < iNaviListLen; index++) {
 181                 ugNaviBar *pNavi_s = NULL;
 182                 pNavi_s = (ugNaviBar *)eina_list_nth(ugd->ug_MainWindow.ug_pNaviBarList, index);
 183                 if (pNavi_s->ug_pNaviLabel != NULL) {
 184                         free(pNavi_s->ug_pNaviLabel);
 185                         pNavi_s->ug_pNaviLabel = NULL;
 186                 }
 187                 if (pNavi_s->ug_pNaviTitle != NULL) {
 188                         free(pNavi_s->ug_pNaviTitle);
 189                         pNavi_s->ug_pNaviTitle = NULL;
 190                 }
 191         }
 192
 193         if (ugd->ug_MainWindow.ug_pTabBar != NULL) {
 194                 evas_object_del(ugd->ug_MainWindow.ug_pTabBar);
 195                 ugd->ug_MainWindow.ug_pTabBar = NULL;
 196         }
 197
 198
 199         if (ugd->ug_MainWindow.ug_pBackGround != NULL) {
 200                 evas_object_del(ugd->ug_MainWindow.ug_pBackGround);
 201                 ugd->ug_MainWindow.ug_pBackGround = NULL;
 202         }
 203
 204         if (ugd->ug_MainWindow.ug_pMainLayout != NULL) {
 205                 evas_object_del(ugd->ug_MainWindow.ug_pMainLayout);
 206                 ugd->ug_MainWindow.ug_pMainLayout = NULL;
 207         }
 208         UG_TRACE_END;
 209 }
 210
 211 Evas_Object *mf_ug_main_create_bg(Evas_Object *win)
 212 {
 213         ug_mf_retv_if(win == NULL, NULL);
 214         Evas_Object *bg = elm_bg_add(win);
 215
 216         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 217         evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 218         evas_object_show(bg);
 219
 220         return bg;
 221 }
 222
 223 /******************************
 224 ** Prototype    : _ug_mf_create_layout_main
 225 ** Description  :
 226 ** Input        : Evas_Object* parent
 227 ** Output       : None
 228 ** Return Value :
 229 ** Calls        :
 230 ** Called By    :
 231 **
 232 **  History        :
 233 **  1.Date         : 2010/12/10
 234 **    Author       : Samsung
 235 **    Modification : Created function
 236 **
 237 ******************************/
 238 static Evas_Object *__mf_ug_main_create_main_layout(Evas_Object *parent)
 239 {
 240         UG_TRACE_BEGIN;
 241         Evas_Object *layout = NULL;
 242         ug_mf_retvm_if(parent == NULL, NULL, "parent is NULL");
 243
 244         layout = elm_layout_add(parent);
 245         ug_mf_retvm_if(layout == NULL, NULL, "Failed elm_layout_add.\n");
 246
 247         elm_layout_theme_set(layout, "layout", "application", "default");
 248         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 249         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 250         evas_object_show(layout);
 251         UG_TRACE_END;
 252
 253         return layout;
 254 }
 255
 256 Evas_Object *mf_ug_main_tab_layout_create(Evas_Object *parent)
 257 {
 258         Evas_Object *layout;
 259
 260         ug_mf_retv_if(parent == NULL, NULL);
 261
 262         layout = elm_layout_add(parent);
 263         ug_mf_retvm_if(layout == NULL, NULL, "Failed elm_layout_add.\n");
 264         elm_object_focus_set(layout, EINA_FALSE);
 265
 266         //elm_layout_theme_set(layout, "layout", "application", "tabbar");
 267         elm_layout_theme_set(layout, "layout", "tabbar", "default");
 268
 269         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 270
 271         evas_object_hide(layout);
 272         return layout;
 273 }
 274
 275 /******************************
 276 ** Prototype    : __mf_ug_main_set_path_option
 277 ** Description  : Samsung
 278 ** Input        : void *data
 279 **                char *path
 280 ** Output       : None
 281 ** Return Value :
 282 ** Calls        :
 283 ** Called By    :
 284 **
 285 **  History        :
 286 **  1.Date         : 2010/12/10
 287 **    Author       : Samsung
 288 **    Modification : Created function
 289 **
 290 ******************************/
 291 static int __mf_ug_main_set_path_option(void *data, const char *path)
 292 {
 293         UG_TRACE_BEGIN;
 294         ugData *ugd = (ugData *)data;
 295         ug_mf_retvm_if(ugd == NULL, MYFILE_ERR_SRC_ARG_INVALID, "ugd is NULL");
 296         ug_mf_retvm_if(path == NULL, MYFILE_ERR_SRC_ARG_INVALID, "path is NULL");
 297
 298         int error_code = MYFILE_ERR_NONE;
 299         char *entry_path = NULL;
 300
 301         if (strncmp(path, PHONE_FOLDER, strlen(PHONE_FOLDER)) == 0 || strncmp(path, MEMORY_FOLDER, strlen(MEMORY_FOLDER)) == 0) {
 302
 303                 /**check whether is /opt/media or /mnt/mmc  */
 304                 entry_path = strdup(path);
 305                 if (entry_path == NULL) {
 306                         return MYFILE_ERR_ALLOCATE_FAIL;
 307                 }
 308         } else if (strncmp(path, UG_SETTING_RINGTONE_PATH, strlen(UG_SETTING_RINGTONE_PATH)) == 0
 309                    || strncmp(path, UG_SETTING_ALERTS_PATH, strlen(UG_SETTING_ALERTS_PATH)) == 0
 310                    || strncmp(path, UG_SETTING_MSG_ALERTS_PATH, strlen(UG_SETTING_MSG_ALERTS_PATH)) == 0) {
 311
 312                 /**check whether is setting ringtone or alerts path  */
 313                 entry_path = strdup(path);
 314                 if (entry_path == NULL) {
 315                         return MYFILE_ERR_ALLOCATE_FAIL;
 316                 }
 317                 ugd->ug_Status.ug_bInSettingView = true;
 318                 ugd->ug_Status.ug_bSettingEntry = true;
 319         } else if (strlen(path) == 1 && strncmp(path, "/", 1)) {
 320                 /**chech the path whether is "/" */
 321                 entry_path = strdup(PHONE_FOLDER);
 322                 if (entry_path == NULL) {
 323                         return MYFILE_ERR_ALLOCATE_FAIL;
 324                 }
 325         } else {
 326                 /**not begin with /mnt/mmc and /opt/media , so append it to /opt/media*/
 327                 char *temp = strdup(PHONE_FOLDER);
 328                 if (temp == NULL) {
 329                         return MYFILE_ERR_ALLOCATE_FAIL;
 330                 }
 331                 entry_path = g_strconcat(temp, path, NULL);
 332                 free(temp);
 333         }
 334
 335         if (entry_path != NULL) {
 336                 /** if there is a '/' at the end of the path, can't be recognized */
 337                 if (entry_path[strlen(entry_path) - 1] == '/') {
 338                         entry_path[strlen(entry_path) - 1] = '\0';
 339                 }
 340
 341                 if (ecore_file_exists(entry_path) == false) {
 342
 343                         if (ugd->ug_UiGadget.ug_iSelectMode == EXPORT_MODE ||
 344                             ugd->ug_UiGadget.ug_iSelectMode == IMPORT_MODE ||
 345                             ugd->ug_UiGadget.ug_iSelectMode == SAVE_MODE ||
 346                             ugd->ug_UiGadget.ug_iSelectMode == IMPORT_SINGLE) {
 347                                 error_code = mf_ug_fm_svc_wrapper_create_p(entry_path);
 348                                 if (error_code != MYFILE_ERR_NONE) {
 349                                         free(entry_path);
 350                                         return MYFILE_ERR_INVALID_FILE_PATH;
 351                                 }
 352                         } else {
 353                                 free(entry_path);
 354                                 return MYFILE_ERR_INVALID_FILE_PATH;
 355                         }
 356                 }
 357                 if (ecore_file_is_dir(entry_path) == false) {
 358                         ug_mf_debug("path is not a directory");
 359                         free(entry_path);
 360                         return MYFILE_ERR_INVALID_DIR_PATH;
 361                 }
 362
 363                 if (ugd->ug_Status.ug_pPath) {
 364                         g_string_free(ugd->ug_Status.ug_pPath, TRUE);
 365                         ugd->ug_Status.ug_pPath = NULL;
 366                 }
 367                 ugd->ug_Status.ug_pEntryPath = g_strdup(entry_path);
 368                 ugd->ug_Status.ug_pPath = g_string_new(entry_path);
 369                 if (g_strcmp0(entry_path, PHONE_FOLDER) == 0) {
 370                         ugd->ug_Status.ug_iViewType = mf_ug_view_root;
 371                 } else {
 372                         ugd->ug_Status.ug_iViewType = mf_ug_view_normal;
 373                 }
 374                 free(entry_path);
 375         } else {
 376                 return MYFILE_ERR_ALLOCATE_FAIL;
 377         }
 378         UG_TRACE_END;
 379         return error_code;
 380 }
 381
 382
 383 /******************************
 384 ** Prototype    : __mf_ug_main_set_select_mode
 385 ** Description  : Samsung
 386 ** Input        : void *data
 387 **                char *select_mode
 388 ** Output       : None
 389 ** Return Value :
 390 ** Calls        :
 391 ** Called By    :
 392 **
 393 **  History        :
 394 **  1.Date         : 2010/12/10
 395 **    Author       : Samsung
 396 **    Modification : Created function
 397 **
 398 ******************************/
 399
 400 static void __mf_ug_main_set_select_mode(void *data, const char *select_mode)
 401 {
 402         UG_TRACE_BEGIN;
 403         ugData *ugd = (ugData *)data;
 404         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 405
 406         if (select_mode != NULL) {
 407                 if (!strncmp(select_mode, UG_SELECT_MODE_SINGLE_FILE, strlen(select_mode))) {
 408                         ugd->ug_UiGadget.ug_iSelectMode = SINGLE_FILE_MODE;
 409                 } else if (!strncmp(select_mode, UG_SELECT_MODE_MULTI_FILE, strlen(select_mode))) {
 410                         ugd->ug_UiGadget.ug_iSelectMode = MULTI_FILE_MODE;
 411                 } else if (!strncmp(select_mode, UG_SELECT_MODE_SINGLE_ALL, strlen(select_mode))) {
 412                         ugd->ug_UiGadget.ug_iSelectMode = SINGLE_ALL_MODE;
 413                 } else if (!strncmp(select_mode, UG_SELECT_MODE_MULTI_ALL, strlen(select_mode))) {
 414                         ugd->ug_UiGadget.ug_iSelectMode = MULTI_ALL_MODE;
 415                 } else if(!strncmp(select_mode, UG_SELECT_MODE_IMPORT, strlen(select_mode))) {
 416                         ugd->ug_UiGadget.ug_iSelectMode = IMPORT_MODE;
 417                 } else if(!strncmp(select_mode, UG_SELECT_MODE_EXPORT, strlen(select_mode))) {
 418                         ugd->ug_UiGadget.ug_iSelectMode = EXPORT_MODE;
 419                 } else if (!strncmp(select_mode, UG_SELECT_MODE_IMPORT_SINGLE, strlen(select_mode))) {
 420                         ugd->ug_UiGadget.ug_iSelectMode = IMPORT_SINGLE;
 421                         ugd->ug_Status.ug_iViewType = mf_ug_view_normal;
 422                 }
 423                 else if (!strncmp(select_mode, UG_SELECT_MODE_SAVE, strlen(select_mode))) {
 424                         ugd->ug_UiGadget.ug_iSelectMode = SAVE_MODE;
 425                 }
 426                 else {
 427                         ugd->ug_UiGadget.ug_iSelectMode = SINGLE_FILE_MODE;
 428                 }
 429         } else {
 430                 ugd->ug_UiGadget.ug_iSelectMode = SINGLE_FILE_MODE;
 431         }
 432         UG_TRACE_END;
 433
 434 }
 435
 436
 437
 438 /******************************
 439 ** Prototype    : __mf_ug_main_set_filter_mode
 440 ** Description  : Samsung
 441 ** Input        : void *data
 442 **                char *file_filter
 443 ** Output       : None
 444 ** Return Value :
 445 ** Calls        :
 446 ** Called By    :
 447 **
 448 **  History        :
 449 **  1.Date         : 2010/12/10
 450 **    Author       : Samsung
 451 **    Modification : Created function
 452 **
 453 ******************************/
 454
 455 static void __mf_ug_main_set_filter_mode(void *data, const char *file_filter)
 456 {
 457         UG_TRACE_BEGIN;
 458         ugData *ugd = (ugData *)data;
 459         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 460
 461         if (file_filter != NULL) {
 462                 if (!strncmp(file_filter, UG_FILE_FILTER_ALL, strlen(file_filter))) {
 463                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_ALL_LIST;
 464                 } else if (!strncmp(file_filter, UG_FILE_FILTER_IMAGE, strlen(file_filter))) {
 465                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_IMAGE_LIST;
 466                 } else if (!strncmp(file_filter, UG_FILE_FILTER_SOUND, strlen(file_filter))) {
 467                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_SOUND_LIST;
 468                 } else if (!strncmp(file_filter, UG_FILE_FILTER_VIDEO, strlen(file_filter))) {
 469                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_VIDEO_LIST;
 470                 } else if (!strncmp(file_filter, UG_FILE_FILTER_FLASH, strlen(file_filter))) {
 471                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_FLASH_LIST;
 472                 } else if (!strncmp(file_filter, UG_FILE_FILTER_FOLDER, strlen(file_filter))) {
 473                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_FOLDER_LIST;
 474                 } else if (!strncmp(file_filter, UG_FILE_FILTER_IV, strlen(file_filter))) {
 475                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_IMAGE_VIDEO_LIST;
 476                 } else if (!strncmp(file_filter, UG_FILE_FILTER_IS, strlen(file_filter))) {
 477                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_IMAGE_SOUND_LIST;
 478                 } else if (!strncmp(file_filter, UG_FILE_FILTER_VS, strlen(file_filter))) {
 479                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_VIDEO_SOUND_LIST;
 480                 } else {
 481                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_BY_EXTENSION;
 482                         ugd->ug_UiGadget.ug_pExtension = strdup(file_filter);
 483                         if (g_strcmp0(file_filter, "opml") == 0) {
 484                                 ugd->ug_UiGadget.ug_iImportMode = 1;
 485                         }
 486                 }
 487         } else {
 488                 ugd->ug_UiGadget.ug_iFilterMode = SHOW_ALL_LIST;
 489                 ugd->ug_UiGadget.ug_pExtension = NULL;
 490         }
 491
 492         if (ugd->ug_UiGadget.ug_iFilterMode != SHOW_BY_EXTENSION) {
 493                 ugd->ug_UiGadget.ug_iFileFilter = mf_ug_fm_svc_wapper_get_file_filter(ugd->ug_UiGadget.ug_iFilterMode);
 494         }
 495
 496
 497         if (ugd->ug_UiGadget.ug_iFilterMode == SHOW_SOUND_LIST && ugd->ug_UiGadget.ug_iSelectMode == SINGLE_FILE_MODE) {
 498                 ugd->ug_Status.ug_iCtrlBarType = CTRL_BAR_MUSIC;
 499         } else {
 500                 ugd->ug_Status.ug_iCtrlBarType = CTRL_BAR_MULTI;
 501         }
 502         UG_TRACE_END;
 503 }
 504
 505
 506
 507 /******************************
 508 ** Prototype    : __mf_ug_main_set_marked_mode
 509 ** Description  : Samsung
 510 ** Input        : void *data
 511 **                char *marked_mode
 512 ** Output       : None
 513 ** Return Value :
 514 ** Calls        :
 515 ** Called By    :
 516 **
 517 **  History        :
 518 **  1.Date         : 2010/12/10
 519 **    Author       : Samsung
 520 **    Modification : Created function
 521 **
 522 ******************************/
 523
 524 static void __mf_ug_main_set_marked_mode(void *data, const char *marked_mode)
 525 {
 526
 527         UG_TRACE_BEGIN;
 528         ugData *ugd = (ugData *)data;
 529         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 530
 531         if (marked_mode != NULL) {
 532                 ugd->ug_UiGadget.ug_iMarkedMode = MARKED_ON;
 533                 mf_ug_util_get_params_path(&ugd->ug_UiGadget.ug_pMultiSelectFileList, marked_mode);
 534         } else {
 535                 ugd->ug_UiGadget.ug_iMarkedMode = MARKED_OFF;
 536         }
 537         UG_TRACE_END;
 538 }
 539
 540
 541 /******************************
 542 ** Prototype    : __mf_ug_main_set_drm_filter_mode
 543 ** Description  : Samsung
 544 ** Input        : void *data
 545 **                char *drm_filter
 546 ** Output       : None
 547 ** Return Value :
 548 ** Calls        :
 549 ** Called By    :
 550 **
 551 **  History        :
 552 **  1.Date         : 2010/12/10
 553 **    Author       : Samsung
 554 **    Modification : Created function
 555 **
 556 ******************************/
 557
 558 static void __mf_ug_main_set_drm_filter_mode(void *data, const char *drm_filter)
 559 {
 560
 561         UG_TRACE_BEGIN;
 562         ugData *ugd = (ugData *)data;
 563         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 564         if (drm_filter != NULL) {
 565                 if (!strncmp(drm_filter, UG_DRM_FILTER_NONE, strlen(drm_filter))) {
 566                         ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_NONE;
 567                 } else if (!strncmp(drm_filter, UG_DRM_FILTER_ALL, strlen(drm_filter))) {
 568                         ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_ALL;
 569                 } else if (!strncmp(drm_filter, UG_DRM_FILTER_WITHOUT_FL, strlen(drm_filter))) {
 570                         ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_WITHOUT_FL;
 571                 } else {
 572                         ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_NONE;
 573                 }
 574         } else {
 575                 ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_NONE;
 576         }
 577
 578         ugd->ug_UiGadget.ug_iDrmFilter = mf_ug_fm_svc_wapper_get_drm_filter(ugd->ug_UiGadget.ug_iDrmFilterMode, ugd->ug_UiGadget.ug_iFileFilter);
 579         UG_TRACE_END;
 580 }
 581
 582
 583 /******************************
 584 ** Prototype    : __mf_ug_main_set_option_status
 585 ** Description  : Samsung
 586 ** Input        : void *data
 587 **                service_h  service
 588 ** Output       : None
 589 ** Return Value :
 590 ** Calls        :
 591 ** Called By    :
 592 **
 593 **  History        :
 594 **  1.Date         : 2010/12/10
 595 **    Author       : Samsung
 596 **    Modification : Created function
 597 **
 598 ******************************/
 599
 600 static void __mf_ug_main_set_option_status(void *data, service_h service)
 601 {
 602         UG_TRACE_BEGIN;
 603         ugData *ugd = (ugData *)data;
 604         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 605         char *key[UG_OPTION_COUNT] = { "path", "select_type", "file_type", "marked_mode", "drm_type"};
 606         char *path = NULL;
 607         char *select_mode = NULL;
 608         char *filter_mode = NULL;
 609         char *marked_mode = NULL;
 610         char *drm_filter_mode = NULL;
 611
 612         service_get_extra_data(service, key[0], &path);
 613         service_get_extra_data(service, key[1], &select_mode);
 614         service_get_extra_data(service, key[2], &filter_mode);
 615         service_get_extra_data(service, key[3], &marked_mode);
 616         service_get_extra_data(service, key[4], &drm_filter_mode);
 617
 618         __mf_ug_main_set_select_mode(ugd, select_mode);
 619         __mf_ug_main_set_path_option(ugd, path);
 620         __mf_ug_main_set_filter_mode(ugd, filter_mode);
 621         __mf_ug_main_set_marked_mode(ugd, marked_mode);
 622         __mf_ug_main_set_drm_filter_mode(ugd, drm_filter_mode);
 623         UG_TRACE_END;
 624 }
 625
 626 /******************************
 627 ** Prototype    : __mf_ug_main_create_default_layout
 628 ** Description  : Samsung
 629 ** Input        : Evas_Object* parent
 630 **                void* data
 631 ** Output       : None
 632 ** Return Value :
 633 ** Calls        :
 634 ** Called By    :
 635 **
 636 **  History        :
 637 **  1.Date         : 2010/12/10
 638 **    Author       : Samsung
 639 **    Modification : Created function
 640 **
 641 ******************************/
 642 static Evas_Object *__mf_ug_main_create_default_layout(Evas_Object *parent, void *data)
 643 {
 644         ugData *ugd = (ugData *)data;
 645         ug_mf_retvm_if(ugd == NULL, NULL, "ugd is NULL");
 646         ug_mf_retvm_if(parent == NULL, NULL, "parent is NULL");
 647         Evas_Object *pContent = NULL;
 648         int tab_item_count = 1;
 649
 650         int mmc_card = 0;
 651         int error_code = 0;
 652         /*/check if mmc mounted */
 653         error_code = mf_ug_util_get_mmc_state(&mmc_card);
 654         if (error_code == 0 && mmc_card == 1) {
 655                 tab_item_count++;
 656         }
 657         /*/check if usb otg mounted
 658            {
 659            Todo: we need to add something to record what should on
 660            }
 661            create phone navi */
 662         ugNaviBar *pNavi_phone = calloc(1, sizeof(ugNaviBar));
 663         ug_mf_retvm_if(pNavi_phone == NULL, NULL, "pNavi_phone is NULL");
 664
 665         ugd->ug_MainWindow.ug_pNaviBar = mf_ug_navi_bar_create_navi_bar(parent);
 666         if (ugd->ug_MainWindow.ug_pNaviBar == NULL) {
 667                 ug_debug("ugd->ug_MainWindow.ug_pNaviBar is NULL");
 668                 free(pNavi_phone);
 669                 pNavi_phone = NULL;
 670                 UG_TRACE_END;
 671                 return NULL;
 672         }
 673
 674         pNavi_phone->ug_bNaviFlagInUse = TRUE;
 675
 676         UG_SAFE_FREE_CHAR(pNavi_phone->ug_pCurrentPath);
 677         pNavi_phone->ug_pCurrentPath = g_strdup(ugd->ug_Status.ug_pPath->str);
 678
 679         UG_SAFE_FREE_CHAR(pNavi_phone->ug_pNaviLabel);
 680         pNavi_phone->ug_pNaviLabel = strdup(MF_UG_LABEL_PHONE);
 681         /*/insert phone navi into the navi_list */
 682         /**    Todo:   if we need to check ap->mf_MainWindow.plistNaviBar?*/
 683         ugd->ug_MainWindow.ug_pNaviBarList = eina_list_append(ugd->ug_MainWindow.ug_pNaviBarList, pNavi_phone);
 684
 685         UG_TRACE_END;
 686         return ugd->ug_MainWindow.ug_pNaviBar;
 687 }
 688
 689 /******************************
 690 ** Prototype    : __mf_ug_main_start
 691 ** Description  :
 692 ** Input        : void *data
 693 ** Output       : None
 694 ** Return Value :
 695 ** Calls        :
 696 ** Called By    :
 697 **
 698 **  History        :
 699 **  1.Date         : 2010/12/10
 700 **    Author       : Samsung
 701 **    Modification : Created function
 702 **
 703 ******************************/
 704
 705 static void __mf_ug_main_start(void *data)
 706 {
 707         UG_TRACE_BEGIN;
 708         ugData *ugd = (ugData *)data;
 709         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 710         Evas_Object *pContent = NULL;
 711         int error_code = 0;
 712         int mmc_card = 0;
 713
 714         pContent = __mf_ug_main_create_default_layout(ugd->ug_MainWindow.ug_pMainLayout, ugd);
 715
 716         if (pContent != NULL) {
 717                 elm_object_part_content_set(ugd->ug_MainWindow.ug_pMainLayout, "elm.swallow.content", pContent);
 718                 mf_ug_navi_bar_create_default_view(ugd);
 719                 mf_ug_ctrl_bar_set_item_disable(ugd);
 720                 mf_ug_navi_bar_set_blocking(data, false);
 721         } else {
 722                 return;
 723         }
 724         ug_debug("done");
 725         UG_TRACE_END;
 726
 727         return;
 728 }
 729
 730
 731
 732 /******************************
 733 ** Prototype    : on_create
 734 ** Description  : Samsung
 735 ** Input        : ui_gadget_h  ug
 736 **                enum ug_mode mode
 737 **                service_h service
 738 **                void *priv
 739 ** Output       : None
 740 ** Return Value :
 741 ** Calls        :
 742 ** Called By    :
 743 **
 744 **  History        :
 745 **  1.Date         : 2010/12/10
 746 **    Author       : Samsung
 747 **    Modification : Created function
 748 **
 749 ******************************/
 750
 751 static void *on_create(ui_gadget_h ug, enum ug_mode mode, service_h service, void *priv)
 752 {
 753         UG_TRACE_BEGIN;
 754
 755         Evas_Object *win = NULL;
 756         ugData *ugd = NULL;
 757
 758         ug_mf_retv_if(NULL == priv, NULL);
 759
 760         ugd = priv;
 761         ugd->ug = ug;
 762
 763         bindtextdomain(UGPACKAGE, UGLOCALEDIR);
 764
 765         win = (Evas_Object *)ug_get_window();
 766         ug_mf_retv_if(NULL == win, NULL);
 767
 768         ugd->ug_MainWindow.ug_pWindow = win;
 769         ugd->ug_Status.ug_bInstallFlag = false;
 770         ugd->ug_Status.ug_bCancelDisableFlag = false;
 771         ugd->ug_UiGadget.ug_iImportMode = 0;
 772         ugd->ug_MainWindow.ug_pMainLayout = __mf_ug_main_create_main_layout(ugd->ug_MainWindow.ug_pWindow);
 773         ugd->ug_MainWindow.ug_pBackGround = mf_ug_main_create_bg(ugd->ug_MainWindow.ug_pWindow);
 774         elm_object_part_content_set(ugd->ug_MainWindow.ug_pMainLayout, "elm.swallow.bg", ugd->ug_MainWindow.ug_pBackGround);
 775
 776         __mf_ug_main_init_data(ugd);
 777         __mf_ug_main_set_option_status(ugd, service);
 778         //mf_ug_player_vol_set(ugd->ug_Status.ug_pPath->str);
 779         int err = media_content_connect();
 780         if (err != MEDIA_CONTENT_ERROR_NONE) {
 781                 ug_debug("media_content_connect failed!");
 782         }
 783
 784         power_set_changed_cb(mf_ug_cb_lcd_state_changed_cb, ugd);
 785
 786         __mf_ug_main_start(ugd);
 787
 788         UG_TRACE_END;
 789         return ugd->ug_MainWindow.ug_pMainLayout;
 790 }
 791
 792 /******************************
 793 ** Prototype    : on_start
 794 ** Description  :
 795 ** Input        : ui_gadget_h ug
 796 **                service_h service
 797 **                void *priv
 798 ** Output       : None
 799 ** Return Value :
 800 ** Calls        :
 801 ** Called By    :
 802 **
 803 **  History        :
 804 **  1.Date         : 2010/12/10
 805 **    Author       : Samsung
 806 **    Modification : Created function
 807 **
 808 ******************************/
 809 static void on_start(ui_gadget_h ug, service_h service, void *priv)
 810 {
 811 }
 812
 813
 814 /******************************
 815 ** Prototype    : on_pause
 816 ** Description  :
 817 ** Input        : ui_gadget_h ug
 818 **                service_h service
 819 **                void *priv
 820 ** Output       : None
 821 ** Return Value :
 822 ** Calls        :
 823 ** Called By    :
 824 **
 825 **  History        :
 826 **  1.Date         : 2010/12/10
 827 **    Author       : Samsung
 828 **    Modification : Created function
 829 **
 830 ******************************/
 831 static void on_pause(ui_gadget_h ug, service_h service, void *priv)
 832 {
 833         UG_TRACE_BEGIN;
 834         if (!priv)
 835                 return;
 836         ugData *ugd = (ugData *)priv;
 837
 838         if (0 != ugd->ug_ListPlay.ug_Player) {
 839                 mf_ug_list_play_pause(ugd);
 840                 //mf_ug_list_play_destory_playing_file(ugd);
 841         }
 842 }
 843
 844 /******************************
 845 ** Prototype    : on_resume
 846 ** Description  :
 847 ** Input        : ui_gadget_h ug
 848 **                bundle *data
 849 **                void *priv
 850 ** Output       : None
 851 ** Return Value :
 852 ** Calls        :
 853 ** Called By    :
 854 **
 855 **  History        :
 856 **  1.Date         : 2010/12/10
 857 **    Author       : Samsung
 858 **    Modification : Created function
 859 **
 860 ******************************/
 861 inline bool __mf_ug_main_check_exist(const char *path)
 862 {
 863         if (path && (access(path, F_OK) == 0)) {
 864                 return true;
 865         }
 866         return false;
 867 }
 868
 869 static void on_resume(ui_gadget_h ug, service_h service, void *priv)
 870 {
 871         UG_TRACE_BEGIN;
 872         ug_mf_retm_if(NULL == priv, "priv is NULL");
 873         ugData *ugd = priv;
 874
 875         if (!__mf_ug_main_check_exist(ugd->ug_Status.ug_pPath->str)) {
 876                 ugNaviBar *pNavi_s = mf_ug_navi_bar_get_in_use_navi(ugd);
 877                 GString *parent_path = mf_ug_fm_svc_wrapper_get_file_parent_path(ugd->ug_Status.ug_pPath);
 878                 int storage = mf_ug_fm_svc_wapper_get_location(ugd->ug_Status.ug_pPath->str);
 879
 880                 g_string_free(ugd->ug_Status.ug_pPath, TRUE);
 881                 ugd->ug_Status.ug_pPath = NULL;
 882                 free(pNavi_s->ug_pCurrentPath);
 883                 pNavi_s->ug_pCurrentPath = NULL;
 884
 885                 if (parent_path && parent_path->str) {
 886                         if (__mf_ug_main_check_exist(parent_path->str)) {
 887                                 ug_debug("paretn is [%s]  exit", parent_path->str);
 888                                 ugd->ug_Status.ug_pPath = g_string_new(parent_path->str);
 889                                 pNavi_s->ug_pCurrentPath = g_strdup(parent_path->str);
 890                         } else {
 891                                 ug_debug("paretn is [%s]  not exit", parent_path->str);
 892                                 if (storage == MF_UG_PHONE) {
 893                                         ugd->ug_Status.ug_pPath = g_string_new(PHONE_FOLDER);
 894                                         pNavi_s->ug_pCurrentPath = strdup(PHONE_FOLDER);
 895                                 } else {
 896                                         ugd->ug_Status.ug_pPath = g_string_new(MEMORY_FOLDER);
 897                                         pNavi_s->ug_pCurrentPath = strdup(MEMORY_FOLDER);
 898                                 }
 899                         }
 900                 } else {
 901                         ug_debug("get parent failed");
 902                         if (storage == MF_UG_PHONE) {
 903                                 ugd->ug_Status.ug_pPath = g_string_new(PHONE_FOLDER);
 904                                 pNavi_s->ug_pCurrentPath = strdup(PHONE_FOLDER);
 905                         } else {
 906                                 ugd->ug_Status.ug_pPath = g_string_new(MEMORY_FOLDER);
 907                                 pNavi_s->ug_pCurrentPath = strdup(MEMORY_FOLDER);
 908                         }
 909                 }
 910
 911                 mf_ug_navi_bar_create_default_view(ugd);
 912                 mf_ug_ctrl_bar_set_item_disable(ugd);
 913                 g_string_free(parent_path, TRUE);
 914                 parent_path = NULL;
 915         }
 916
 917         UG_TRACE_END;
 918 }
 919
 920 /******************************
 921 ** Prototype    : on_message
 922 ** Description  :
 923 ** Input        : ui_gadget_h ug
 924 **                bundle *msg
 925 **                bundle *data
 926 **                void *priv
 927 ** Output       : None
 928 ** Return Value :
 929 ** Calls        :
 930 ** Called By    :
 931 **
 932 **  History        :
 933 **  1.Date         : 2010/12/10
 934 **    Author       : Samsung
 935 **    Modification : Created function
 936 **
 937 ******************************/
 938 static void on_message(ui_gadget_h ug, service_h msg, service_h service, void *priv)
 939 {
 940 }
 941
 942 /******************************
 943 ** Prototype    : on_event
 944 ** Description  :
 945 ** Input        : ui_gadget_h ug
 946 **                enum ug_event event
 947 **                service_h service
 948 **                void *priv
 949 ** Output       : None
 950 ** Return Value :
 951 ** Calls        :
 952 ** Called By    :
 953 **
 954 **  History        :
 955 **  1.Date         : 2010/12/10
 956 **    Author       : Samsung
 957 **    Modification : Created function
 958 **
 959 ******************************/
 960 static void on_event(ui_gadget_h ug, enum ug_event event, service_h service, void *priv)
 961 {
 962         UG_TRACE_BEGIN;
 963         switch (event) {
 964         case UG_EVENT_LOW_MEMORY:
 965                 break;
 966
 967         case UG_EVENT_LOW_BATTERY:
 968                 break;
 969
 970         case UG_EVENT_LANG_CHANGE:
 971                 break;
 972
 973         case UG_EVENT_ROTATE_PORTRAIT:
 974                 break;
 975
 976         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 977                 break;
 978
 979         case UG_EVENT_ROTATE_LANDSCAPE:
 980                 break;
 981
 982         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 983                 break;
 984
 985         default:
 986                 break;
 987         }
 988         UG_TRACE_END;
 989 }
 990
 991
 992
 993 /******************************
 994 ** Prototype    : on_key_event
 995 ** Description  : Samsung
 996 ** Input        : ui_gadget_h ug
 997 **                enum ug_key_event event
 998 **                service_h service
 999 **                void *priv
1000 ** Output       : None
1001 ** Return Value :
1002 ** Calls        :
1003 ** Called By    :
1004 **
1005 **  History        :
1006 **  1.Date         : 2010/12/10
1007 **    Author       : Samsung
1008 **    Modification : Created function
1009 **
1010 ******************************/
1011
1012 static void on_key_event(ui_gadget_h ug, enum ug_key_event event, service_h service, void *priv)
1013 {
1014         UG_TRACE_BEGIN;
1015         ugData *ugd = (ugData *)priv;
1016         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
1017
1018         switch (event) {
1019         case UG_KEY_EVENT_END:
1020                 if (ugd->ug_MainWindow.ug_pNormalPopup) {
1021                         evas_object_del(ugd->ug_MainWindow.ug_pNormalPopup);
1022                         ugd->ug_MainWindow.ug_pNormalPopup = NULL;
1023                 }
1024                 if (0 != ugd->ug_ListPlay.ug_Player) {
1025                         mf_ug_list_play_destory_playing_file(ugd);
1026                         UG_SAFE_FREE_CHAR(ugd->ug_ListPlay.ug_pPlayFilePath);
1027                 }
1028                 ug_destroy_me(ug);
1029                 break;
1030         default:
1031                 break;
1032         }
1033         UG_TRACE_END;
1034 }
1035
1036 /******************************
1037 ** Prototype    : on_destroy
1038 ** Description  :
1039 ** Input        : ui_gadget_h ug
1040 **                service_h service
1041 **                void *priv
1042 ** Output       : None
1043 ** Return Value :
1044 ** Calls        :
1045 ** Called By    :
1046 **
1047 **  History        :
1048 **  1.Date         : 2010/12/10
1049 **    Author       : Samsung
1050 **    Modification : Created function
1051 **
1052 ******************************/
1053 static void on_destroy(ui_gadget_h ug, service_h service, void *priv)
1054 {
1055         UG_TRACE_BEGIN;
1056         ugData *ugd = (ugData *)priv;
1057         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
1058
1059         __mf_ug_main_free_data(ugd);
1060
1061         if (ugd->ug_Status.ug_bInstallFlag == true) {
1062                 mf_ug_util_destory_dir_monitor(ugd);
1063                 mf_ug_util_destory_mmc_state_cb();
1064                 media_content_disconnect();
1065                 power_unset_changed_cb();
1066         }
1067
1068         ug_ecore_idler_del(ugd->ug_Status.search_idler);
1069         ug_ecore_idler_del(ugd->ug_Status.popup_del_idler);
1070         ug_ecore_idler_del(ugd->ug_Status.popup_create_idler);
1071         ug_ecore_idler_del(ugd->ug_Status.msg_finish_idler);
1072         UG_SAFE_DEL_ECORE_TIMER(ugd->ug_Status.pPopupTimer);
1073
1074         if (0 != ugd->ug_ListPlay.ug_Player) {
1075                 mf_ug_list_play_destory_playing_file(ugd);
1076                 UG_SAFE_FREE_CHAR(ugd->ug_ListPlay.ug_pPlayFilePath);
1077         }
1078
1079         if (ugd->ug_Status.ug_pThumbUpdateTimer != NULL) {
1080                 ecore_timer_del(ugd->ug_Status.ug_pThumbUpdateTimer);
1081                 ugd->ug_Status.ug_pThumbUpdateTimer = NULL;
1082         }
1083         __mf_ug_main_free_evas_object(ugd);
1084         UG_TRACE_END;
1085 }
1086
1087
1088 /******************************
1089 ** Prototype    : UG_MODULE_INIT
1090 ** Description  :
1091 ** Input        : struct ug_module_ops *ops
1092 ** Output       : None
1093 ** Return Value :
1094 ** Calls        :
1095 ** Called By    :
1096 **
1097 **  History        :
1098 **  1.Date         : 2010/12/10
1099 **    Author       : Samsung
1100 **    Modification : Created function
1101 **
1102 ******************************/
1103 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
1104 {
1105         UG_TRACE_BEGIN;
1106         ugData *ugd;
1107
1108         if (!ops) {
1109                 return -1;
1110         }
1111
1112         ugd = calloc(1, sizeof(ugData));
1113         if (!ugd) {
1114                 return -1;
1115         }
1116
1117         ops->create = on_create;
1118         ops->start = on_start;
1119         ops->pause = on_pause;
1120         ops->resume = on_resume;
1121         ops->destroy = on_destroy;
1122         ops->message = on_message;
1123         ops->event = on_event;
1124         ops->key_event = on_key_event;
1125         ops->priv = ugd;
1126         ops->opt = UG_OPT_INDICATOR_ENABLE;
1127         UG_TRACE_END;
1128         return 0;
1129 }
1130
1131
1132
1133 /******************************
1134 ** Prototype    : UG_MODULE_EXIT
1135 ** Description  :
1136 ** Input        : struct ug_module_ops *ops
1137 ** Output       : None
1138 ** Return Value :
1139 ** Calls        :
1140 ** Called By    :
1141 **
1142 **  History        :
1143 **  1.Date         : 2010/12/10
1144 **    Author       : Samsung
1145 **    Modification : Created function
1146 **
1147 ******************************/
1148 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
1149 {
1150         UG_TRACE_BEGIN;
1151         ugData *ugd;
1152
1153         if (!ops) {
1154                 return;
1155         }
1156         ugd = ops->priv;
1157
1158         if (ugd) {
1159                 free(ugd);
1160         }
1161         UG_TRACE_END;
1162 }