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 == IMPORT_SINGLE) {
 346                                 error_code = mf_ug_fm_svc_wrapper_create_p(entry_path);
 347                                 if (error_code != MYFILE_ERR_NONE) {
 348                                         free(entry_path);
 349                                         return MYFILE_ERR_INVALID_FILE_PATH;
 350                                 }
 351                         } else {
 352                                 free(entry_path);
 353                                 return MYFILE_ERR_INVALID_FILE_PATH;
 354                         }
 355                 }
 356                 if (ecore_file_is_dir(entry_path) == false) {
 357                         ug_mf_debug("path is not a directory");
 358                         free(entry_path);
 359                         return MYFILE_ERR_INVALID_DIR_PATH;
 360                 }
 361
 362                 if (ugd->ug_Status.ug_pPath) {
 363                         g_string_free(ugd->ug_Status.ug_pPath, TRUE);
 364                         ugd->ug_Status.ug_pPath = NULL;
 365                 }
 366                 ugd->ug_Status.ug_pEntryPath = g_strdup(entry_path);
 367                 ugd->ug_Status.ug_pPath = g_string_new(entry_path);
 368                 if (g_strcmp0(entry_path, PHONE_FOLDER) == 0) {
 369                         ugd->ug_Status.ug_iViewType = mf_ug_view_root;
 370                 } else {
 371                         ugd->ug_Status.ug_iViewType = mf_ug_view_normal;
 372                 }
 373                 free(entry_path);
 374         } else {
 375                 return MYFILE_ERR_ALLOCATE_FAIL;
 376         }
 377         UG_TRACE_END;
 378         return error_code;
 379 }
 380
 381
 382 /******************************
 383 ** Prototype    : __mf_ug_main_set_select_mode
 384 ** Description  : Samsung
 385 ** Input        : void *data
 386 **                char *select_mode
 387 ** Output       : None
 388 ** Return Value :
 389 ** Calls        :
 390 ** Called By    :
 391 **
 392 **  History        :
 393 **  1.Date         : 2010/12/10
 394 **    Author       : Samsung
 395 **    Modification : Created function
 396 **
 397 ******************************/
 398
 399 static void __mf_ug_main_set_select_mode(void *data, const char *select_mode)
 400 {
 401         UG_TRACE_BEGIN;
 402         ugData *ugd = (ugData *)data;
 403         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 404
 405         if (select_mode != NULL) {
 406                 if (!strncmp(select_mode, UG_SELECT_MODE_SINGLE_FILE, strlen(select_mode))) {
 407                         ugd->ug_UiGadget.ug_iSelectMode = SINGLE_FILE_MODE;
 408                 } else if (!strncmp(select_mode, UG_SELECT_MODE_MULTI_FILE, strlen(select_mode))) {
 409                         ugd->ug_UiGadget.ug_iSelectMode = MULTI_FILE_MODE;
 410                 } else if (!strncmp(select_mode, UG_SELECT_MODE_SINGLE_ALL, strlen(select_mode))) {
 411                         ugd->ug_UiGadget.ug_iSelectMode = SINGLE_ALL_MODE;
 412                 } else if (!strncmp(select_mode, UG_SELECT_MODE_MULTI_ALL, strlen(select_mode))) {
 413                         ugd->ug_UiGadget.ug_iSelectMode = MULTI_ALL_MODE;
 414                 } else if(!strncmp(select_mode, UG_SELECT_MODE_IMPORT, strlen(select_mode))) {
 415                         ugd->ug_UiGadget.ug_iSelectMode = IMPORT_MODE;
 416                 } else if(!strncmp(select_mode, UG_SELECT_MODE_EXPORT, strlen(select_mode))) {
 417                         ugd->ug_UiGadget.ug_iSelectMode = EXPORT_MODE;
 418                 } else if (!strncmp(select_mode, UG_SELECT_MODE_IMPORT_SINGLE, strlen(select_mode))) {
 419                         ugd->ug_UiGadget.ug_iSelectMode = IMPORT_SINGLE;
 420                         ugd->ug_Status.ug_iViewType = mf_ug_view_normal;
 421                 }
 422                 else {
 423                         ugd->ug_UiGadget.ug_iSelectMode = SINGLE_FILE_MODE;
 424                 }
 425         } else {
 426                 ugd->ug_UiGadget.ug_iSelectMode = SINGLE_FILE_MODE;
 427         }
 428         UG_TRACE_END;
 429
 430 }
 431
 432
 433
 434 /******************************
 435 ** Prototype    : __mf_ug_main_set_filter_mode
 436 ** Description  : Samsung
 437 ** Input        : void *data
 438 **                char *file_filter
 439 ** Output       : None
 440 ** Return Value :
 441 ** Calls        :
 442 ** Called By    :
 443 **
 444 **  History        :
 445 **  1.Date         : 2010/12/10
 446 **    Author       : Samsung
 447 **    Modification : Created function
 448 **
 449 ******************************/
 450
 451 static void __mf_ug_main_set_filter_mode(void *data, const char *file_filter)
 452 {
 453         UG_TRACE_BEGIN;
 454         ugData *ugd = (ugData *)data;
 455         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 456
 457         if (file_filter != NULL) {
 458                 if (!strncmp(file_filter, UG_FILE_FILTER_ALL, strlen(file_filter))) {
 459                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_ALL_LIST;
 460                 } else if (!strncmp(file_filter, UG_FILE_FILTER_IMAGE, strlen(file_filter))) {
 461                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_IMAGE_LIST;
 462                 } else if (!strncmp(file_filter, UG_FILE_FILTER_SOUND, strlen(file_filter))) {
 463                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_SOUND_LIST;
 464                 } else if (!strncmp(file_filter, UG_FILE_FILTER_VIDEO, strlen(file_filter))) {
 465                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_VIDEO_LIST;
 466                 } else if (!strncmp(file_filter, UG_FILE_FILTER_FLASH, strlen(file_filter))) {
 467                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_FLASH_LIST;
 468                 } else if (!strncmp(file_filter, UG_FILE_FILTER_FOLDER, strlen(file_filter))) {
 469                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_FOLDER_LIST;
 470                 } else if (!strncmp(file_filter, UG_FILE_FILTER_IV, strlen(file_filter))) {
 471                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_IMAGE_VIDEO_LIST;
 472                 } else if (!strncmp(file_filter, UG_FILE_FILTER_IS, strlen(file_filter))) {
 473                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_IMAGE_SOUND_LIST;
 474                 } else if (!strncmp(file_filter, UG_FILE_FILTER_VS, strlen(file_filter))) {
 475                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_VIDEO_SOUND_LIST;
 476                 } else {
 477                         ugd->ug_UiGadget.ug_iFilterMode = SHOW_BY_EXTENSION;
 478                         ugd->ug_UiGadget.ug_pExtension = strdup(file_filter);
 479                         if (g_strcmp0(file_filter, "opml") == 0) {
 480                                 ugd->ug_UiGadget.ug_iImportMode = 1;
 481                         }
 482                 }
 483         } else {
 484                 ugd->ug_UiGadget.ug_iFilterMode = SHOW_ALL_LIST;
 485                 ugd->ug_UiGadget.ug_pExtension = NULL;
 486         }
 487
 488         if (ugd->ug_UiGadget.ug_iFilterMode != SHOW_BY_EXTENSION) {
 489                 ugd->ug_UiGadget.ug_iFileFilter = mf_ug_fm_svc_wapper_get_file_filter(ugd->ug_UiGadget.ug_iFilterMode);
 490         }
 491
 492
 493         if (ugd->ug_UiGadget.ug_iFilterMode == SHOW_SOUND_LIST && ugd->ug_UiGadget.ug_iSelectMode == SINGLE_FILE_MODE) {
 494                 ugd->ug_Status.ug_iCtrlBarType = CTRL_BAR_MUSIC;
 495         } else {
 496                 ugd->ug_Status.ug_iCtrlBarType = CTRL_BAR_MULTI;
 497         }
 498         UG_TRACE_END;
 499 }
 500
 501
 502
 503 /******************************
 504 ** Prototype    : __mf_ug_main_set_marked_mode
 505 ** Description  : Samsung
 506 ** Input        : void *data
 507 **                char *marked_mode
 508 ** Output       : None
 509 ** Return Value :
 510 ** Calls        :
 511 ** Called By    :
 512 **
 513 **  History        :
 514 **  1.Date         : 2010/12/10
 515 **    Author       : Samsung
 516 **    Modification : Created function
 517 **
 518 ******************************/
 519
 520 static void __mf_ug_main_set_marked_mode(void *data, const char *marked_mode)
 521 {
 522
 523         UG_TRACE_BEGIN;
 524         ugData *ugd = (ugData *)data;
 525         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 526
 527         if (marked_mode != NULL) {
 528                 ugd->ug_UiGadget.ug_iMarkedMode = MARKED_ON;
 529                 mf_ug_util_get_params_path(&ugd->ug_UiGadget.ug_pMultiSelectFileList, marked_mode);
 530         } else {
 531                 ugd->ug_UiGadget.ug_iMarkedMode = MARKED_OFF;
 532         }
 533         UG_TRACE_END;
 534 }
 535
 536
 537 /******************************
 538 ** Prototype    : __mf_ug_main_set_drm_filter_mode
 539 ** Description  : Samsung
 540 ** Input        : void *data
 541 **                char *drm_filter
 542 ** Output       : None
 543 ** Return Value :
 544 ** Calls        :
 545 ** Called By    :
 546 **
 547 **  History        :
 548 **  1.Date         : 2010/12/10
 549 **    Author       : Samsung
 550 **    Modification : Created function
 551 **
 552 ******************************/
 553
 554 static void __mf_ug_main_set_drm_filter_mode(void *data, const char *drm_filter)
 555 {
 556
 557         UG_TRACE_BEGIN;
 558         ugData *ugd = (ugData *)data;
 559         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 560         if (drm_filter != NULL) {
 561                 if (!strncmp(drm_filter, UG_DRM_FILTER_NONE, strlen(drm_filter))) {
 562                         ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_NONE;
 563                 } else if (!strncmp(drm_filter, UG_DRM_FILTER_ALL, strlen(drm_filter))) {
 564                         ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_ALL;
 565                 } else if (!strncmp(drm_filter, UG_DRM_FILTER_WITHOUT_FL, strlen(drm_filter))) {
 566                         ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_WITHOUT_FL;
 567                 } else {
 568                         ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_NONE;
 569                 }
 570         } else {
 571                 ugd->ug_UiGadget.ug_iDrmFilterMode = DRM_FILTER_NONE;
 572         }
 573
 574         ugd->ug_UiGadget.ug_iDrmFilter = mf_ug_fm_svc_wapper_get_drm_filter(ugd->ug_UiGadget.ug_iDrmFilterMode, ugd->ug_UiGadget.ug_iFileFilter);
 575         UG_TRACE_END;
 576 }
 577
 578
 579 /******************************
 580 ** Prototype    : __mf_ug_main_set_option_status
 581 ** Description  : Samsung
 582 ** Input        : void *data
 583 **                service_h  service
 584 ** Output       : None
 585 ** Return Value :
 586 ** Calls        :
 587 ** Called By    :
 588 **
 589 **  History        :
 590 **  1.Date         : 2010/12/10
 591 **    Author       : Samsung
 592 **    Modification : Created function
 593 **
 594 ******************************/
 595
 596 static void __mf_ug_main_set_option_status(void *data, service_h service)
 597 {
 598         UG_TRACE_BEGIN;
 599         ugData *ugd = (ugData *)data;
 600         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 601         char *key[UG_OPTION_COUNT] = { "path", "select_type", "file_type", "marked_mode", "drm_type"};
 602         char *path = NULL;
 603         char *select_mode = NULL;
 604         char *filter_mode = NULL;
 605         char *marked_mode = NULL;
 606         char *drm_filter_mode = NULL;
 607
 608         service_get_extra_data(service, key[0], &path);
 609         service_get_extra_data(service, key[1], &select_mode);
 610         service_get_extra_data(service, key[2], &filter_mode);
 611         service_get_extra_data(service, key[3], &marked_mode);
 612         service_get_extra_data(service, key[4], &drm_filter_mode);
 613
 614         __mf_ug_main_set_select_mode(ugd, select_mode);
 615         __mf_ug_main_set_path_option(ugd, path);
 616         __mf_ug_main_set_filter_mode(ugd, filter_mode);
 617         __mf_ug_main_set_marked_mode(ugd, marked_mode);
 618         __mf_ug_main_set_drm_filter_mode(ugd, drm_filter_mode);
 619         UG_TRACE_END;
 620 }
 621
 622 /******************************
 623 ** Prototype    : __mf_ug_main_create_default_layout
 624 ** Description  : Samsung
 625 ** Input        : Evas_Object* parent
 626 **                void* data
 627 ** Output       : None
 628 ** Return Value :
 629 ** Calls        :
 630 ** Called By    :
 631 **
 632 **  History        :
 633 **  1.Date         : 2010/12/10
 634 **    Author       : Samsung
 635 **    Modification : Created function
 636 **
 637 ******************************/
 638 static Evas_Object *__mf_ug_main_create_default_layout(Evas_Object *parent, void *data)
 639 {
 640         ugData *ugd = (ugData *)data;
 641         ug_mf_retvm_if(ugd == NULL, NULL, "ugd is NULL");
 642         ug_mf_retvm_if(parent == NULL, NULL, "parent is NULL");
 643         Evas_Object *pContent = NULL;
 644         int tab_item_count = 1;
 645
 646         int mmc_card = 0;
 647         int error_code = 0;
 648         /*/check if mmc mounted */
 649         error_code = mf_ug_util_get_mmc_state(&mmc_card);
 650         if (error_code == 0 && mmc_card == 1) {
 651                 tab_item_count++;
 652         }
 653         /*/check if usb otg mounted
 654            {
 655            Todo: we need to add something to record what should on
 656            }
 657            create phone navi */
 658         ugNaviBar *pNavi_phone = calloc(1, sizeof(ugNaviBar));
 659         ug_mf_retvm_if(pNavi_phone == NULL, NULL, "pNavi_phone is NULL");
 660
 661         ugd->ug_MainWindow.ug_pNaviBar = mf_ug_navi_bar_create_navi_bar(parent);
 662         if (ugd->ug_MainWindow.ug_pNaviBar == NULL) {
 663                 ug_debug("ugd->ug_MainWindow.ug_pNaviBar is NULL");
 664                 free(pNavi_phone);
 665                 pNavi_phone = NULL;
 666                 UG_TRACE_END;
 667                 return NULL;
 668         }
 669
 670         pNavi_phone->ug_bNaviFlagInUse = TRUE;
 671
 672         UG_SAFE_FREE_CHAR(pNavi_phone->ug_pCurrentPath);
 673         pNavi_phone->ug_pCurrentPath = g_strdup(ugd->ug_Status.ug_pPath->str);
 674
 675         UG_SAFE_FREE_CHAR(pNavi_phone->ug_pNaviLabel);
 676         pNavi_phone->ug_pNaviLabel = strdup(MF_UG_LABEL_PHONE);
 677         /*/insert phone navi into the navi_list */
 678         /**    Todo:   if we need to check ap->mf_MainWindow.plistNaviBar?*/
 679         ugd->ug_MainWindow.ug_pNaviBarList = eina_list_append(ugd->ug_MainWindow.ug_pNaviBarList, pNavi_phone);
 680
 681         UG_TRACE_END;
 682         return ugd->ug_MainWindow.ug_pNaviBar;
 683 }
 684
 685 /******************************
 686 ** Prototype    : __mf_ug_main_start
 687 ** Description  :
 688 ** Input        : void *data
 689 ** Output       : None
 690 ** Return Value :
 691 ** Calls        :
 692 ** Called By    :
 693 **
 694 **  History        :
 695 **  1.Date         : 2010/12/10
 696 **    Author       : Samsung
 697 **    Modification : Created function
 698 **
 699 ******************************/
 700
 701 static void __mf_ug_main_start(void *data)
 702 {
 703         UG_TRACE_BEGIN;
 704         ugData *ugd = (ugData *)data;
 705         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
 706         Evas_Object *pContent = NULL;
 707         int error_code = 0;
 708         int mmc_card = 0;
 709
 710         pContent = __mf_ug_main_create_default_layout(ugd->ug_MainWindow.ug_pMainLayout, ugd);
 711
 712         if (pContent != NULL) {
 713                 elm_object_part_content_set(ugd->ug_MainWindow.ug_pMainLayout, "elm.swallow.content", pContent);
 714                 mf_ug_navi_bar_create_default_view(ugd);
 715                 mf_ug_ctrl_bar_set_item_disable(ugd);
 716                 mf_ug_navi_bar_set_blocking(data, false);
 717         } else {
 718                 return;
 719         }
 720         ug_debug("done");
 721         UG_TRACE_END;
 722
 723         return;
 724 }
 725
 726
 727
 728 /******************************
 729 ** Prototype    : on_create
 730 ** Description  : Samsung
 731 ** Input        : ui_gadget_h  ug
 732 **                enum ug_mode mode
 733 **                service_h service
 734 **                void *priv
 735 ** Output       : None
 736 ** Return Value :
 737 ** Calls        :
 738 ** Called By    :
 739 **
 740 **  History        :
 741 **  1.Date         : 2010/12/10
 742 **    Author       : Samsung
 743 **    Modification : Created function
 744 **
 745 ******************************/
 746
 747 static void *on_create(ui_gadget_h ug, enum ug_mode mode, service_h service, void *priv)
 748 {
 749         UG_TRACE_BEGIN;
 750
 751         Evas_Object *win = NULL;
 752         ugData *ugd = NULL;
 753
 754         ug_mf_retv_if(NULL == priv, NULL);
 755
 756         ugd = priv;
 757         ugd->ug = ug;
 758
 759         bindtextdomain(UGPACKAGE, UGLOCALEDIR);
 760
 761         win = (Evas_Object *)ug_get_window();
 762         ug_mf_retv_if(NULL == win, NULL);
 763
 764         ugd->ug_MainWindow.ug_pWindow = win;
 765         ugd->ug_Status.ug_bInstallFlag = false;
 766         ugd->ug_Status.ug_bCancelDisableFlag = false;
 767         ugd->ug_UiGadget.ug_iImportMode = 0;
 768         ugd->ug_MainWindow.ug_pMainLayout = __mf_ug_main_create_main_layout(ugd->ug_MainWindow.ug_pWindow);
 769         ugd->ug_MainWindow.ug_pBackGround = mf_ug_main_create_bg(ugd->ug_MainWindow.ug_pWindow);
 770         elm_object_part_content_set(ugd->ug_MainWindow.ug_pMainLayout, "elm.swallow.bg", ugd->ug_MainWindow.ug_pBackGround);
 771
 772         __mf_ug_main_init_data(ugd);
 773         __mf_ug_main_set_option_status(ugd, service);
 774         //mf_ug_player_vol_set(ugd->ug_Status.ug_pPath->str);
 775         int err = media_content_connect();
 776         if (err != MEDIA_CONTENT_ERROR_NONE) {
 777                 ug_debug("media_content_connect failed!");
 778         }
 779
 780         power_set_changed_cb(mf_ug_cb_lcd_state_changed_cb, ugd);
 781
 782         __mf_ug_main_start(ugd);
 783
 784         UG_TRACE_END;
 785         return ugd->ug_MainWindow.ug_pMainLayout;
 786 }
 787
 788 /******************************
 789 ** Prototype    : on_start
 790 ** Description  :
 791 ** Input        : ui_gadget_h ug
 792 **                service_h service
 793 **                void *priv
 794 ** Output       : None
 795 ** Return Value :
 796 ** Calls        :
 797 ** Called By    :
 798 **
 799 **  History        :
 800 **  1.Date         : 2010/12/10
 801 **    Author       : Samsung
 802 **    Modification : Created function
 803 **
 804 ******************************/
 805 static void on_start(ui_gadget_h ug, service_h service, void *priv)
 806 {
 807 }
 808
 809
 810 /******************************
 811 ** Prototype    : on_pause
 812 ** Description  :
 813 ** Input        : ui_gadget_h ug
 814 **                service_h service
 815 **                void *priv
 816 ** Output       : None
 817 ** Return Value :
 818 ** Calls        :
 819 ** Called By    :
 820 **
 821 **  History        :
 822 **  1.Date         : 2010/12/10
 823 **    Author       : Samsung
 824 **    Modification : Created function
 825 **
 826 ******************************/
 827 static void on_pause(ui_gadget_h ug, service_h service, void *priv)
 828 {
 829         UG_TRACE_BEGIN;
 830         if (!priv)
 831                 return;
 832         ugData *ugd = (ugData *)priv;
 833
 834         if (0 != ugd->ug_ListPlay.ug_Player) {
 835                 //mf_ug_list_play_destory_playing_file(ugd);
 836         }
 837 }
 838
 839 /******************************
 840 ** Prototype    : on_resume
 841 ** Description  :
 842 ** Input        : ui_gadget_h ug
 843 **                bundle *data
 844 **                void *priv
 845 ** Output       : None
 846 ** Return Value :
 847 ** Calls        :
 848 ** Called By    :
 849 **
 850 **  History        :
 851 **  1.Date         : 2010/12/10
 852 **    Author       : Samsung
 853 **    Modification : Created function
 854 **
 855 ******************************/
 856 inline bool __mf_ug_main_check_exist(const char *path)
 857 {
 858         if (path && (access(path, F_OK) == 0)) {
 859                 return true;
 860         }
 861         return false;
 862 }
 863
 864 static void on_resume(ui_gadget_h ug, service_h service, void *priv)
 865 {
 866         UG_TRACE_BEGIN;
 867         ug_mf_retm_if(NULL == priv, "priv is NULL");
 868         ugData *ugd = priv;
 869
 870         if (!__mf_ug_main_check_exist(ugd->ug_Status.ug_pPath->str)) {
 871                 ugNaviBar *pNavi_s = mf_ug_navi_bar_get_in_use_navi(ugd);
 872                 GString *parent_path = mf_ug_fm_svc_wrapper_get_file_parent_path(ugd->ug_Status.ug_pPath);
 873                 int storage = mf_ug_fm_svc_wapper_get_location(ugd->ug_Status.ug_pPath->str);
 874
 875                 g_string_free(ugd->ug_Status.ug_pPath, TRUE);
 876                 ugd->ug_Status.ug_pPath = NULL;
 877                 free(pNavi_s->ug_pCurrentPath);
 878                 pNavi_s->ug_pCurrentPath = NULL;
 879
 880                 if (parent_path && parent_path->str) {
 881                         if (__mf_ug_main_check_exist(parent_path->str)) {
 882                                 ug_debug("paretn is [%s]  exit", parent_path->str);
 883                                 ugd->ug_Status.ug_pPath = g_string_new(parent_path->str);
 884                                 pNavi_s->ug_pCurrentPath = g_strdup(parent_path->str);
 885                         } else {
 886                                 ug_debug("paretn is [%s]  not exit", parent_path->str);
 887                                 if (storage == MF_UG_PHONE) {
 888                                         ugd->ug_Status.ug_pPath = g_string_new(PHONE_FOLDER);
 889                                         pNavi_s->ug_pCurrentPath = strdup(PHONE_FOLDER);
 890                                 } else {
 891                                         ugd->ug_Status.ug_pPath = g_string_new(MEMORY_FOLDER);
 892                                         pNavi_s->ug_pCurrentPath = strdup(MEMORY_FOLDER);
 893                                 }
 894                         }
 895                 } else {
 896                         ug_debug("get parent failed");
 897                         if (storage == MF_UG_PHONE) {
 898                                 ugd->ug_Status.ug_pPath = g_string_new(PHONE_FOLDER);
 899                                 pNavi_s->ug_pCurrentPath = strdup(PHONE_FOLDER);
 900                         } else {
 901                                 ugd->ug_Status.ug_pPath = g_string_new(MEMORY_FOLDER);
 902                                 pNavi_s->ug_pCurrentPath = strdup(MEMORY_FOLDER);
 903                         }
 904                 }
 905
 906                 mf_ug_navi_bar_create_default_view(ugd);
 907                 mf_ug_ctrl_bar_set_item_disable(ugd);
 908                 g_string_free(parent_path, TRUE);
 909                 parent_path = NULL;
 910         }
 911
 912         UG_TRACE_END;
 913 }
 914
 915 /******************************
 916 ** Prototype    : on_message
 917 ** Description  :
 918 ** Input        : ui_gadget_h ug
 919 **                bundle *msg
 920 **                bundle *data
 921 **                void *priv
 922 ** Output       : None
 923 ** Return Value :
 924 ** Calls        :
 925 ** Called By    :
 926 **
 927 **  History        :
 928 **  1.Date         : 2010/12/10
 929 **    Author       : Samsung
 930 **    Modification : Created function
 931 **
 932 ******************************/
 933 static void on_message(ui_gadget_h ug, service_h msg, service_h service, void *priv)
 934 {
 935 }
 936
 937 /******************************
 938 ** Prototype    : on_event
 939 ** Description  :
 940 ** Input        : ui_gadget_h ug
 941 **                enum ug_event event
 942 **                service_h service
 943 **                void *priv
 944 ** Output       : None
 945 ** Return Value :
 946 ** Calls        :
 947 ** Called By    :
 948 **
 949 **  History        :
 950 **  1.Date         : 2010/12/10
 951 **    Author       : Samsung
 952 **    Modification : Created function
 953 **
 954 ******************************/
 955 static void on_event(ui_gadget_h ug, enum ug_event event, service_h service, void *priv)
 956 {
 957         UG_TRACE_BEGIN;
 958         switch (event) {
 959         case UG_EVENT_LOW_MEMORY:
 960                 break;
 961
 962         case UG_EVENT_LOW_BATTERY:
 963                 break;
 964
 965         case UG_EVENT_LANG_CHANGE:
 966                 break;
 967
 968         case UG_EVENT_ROTATE_PORTRAIT:
 969                 break;
 970
 971         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 972                 break;
 973
 974         case UG_EVENT_ROTATE_LANDSCAPE:
 975                 break;
 976
 977         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 978                 break;
 979
 980         default:
 981                 break;
 982         }
 983         UG_TRACE_END;
 984 }
 985
 986
 987
 988 /******************************
 989 ** Prototype    : on_key_event
 990 ** Description  : Samsung
 991 ** Input        : ui_gadget_h ug
 992 **                enum ug_key_event event
 993 **                service_h service
 994 **                void *priv
 995 ** Output       : None
 996 ** Return Value :
 997 ** Calls        :
 998 ** Called By    :
 999 **
1000 **  History        :
1001 **  1.Date         : 2010/12/10
1002 **    Author       : Samsung
1003 **    Modification : Created function
1004 **
1005 ******************************/
1006
1007 static void on_key_event(ui_gadget_h ug, enum ug_key_event event, service_h service, void *priv)
1008 {
1009         UG_TRACE_BEGIN;
1010         ugData *ugd = (ugData *)priv;
1011         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
1012
1013         switch (event) {
1014         case UG_KEY_EVENT_END:
1015                 if (ugd->ug_MainWindow.ug_pNormalPopup) {
1016                         evas_object_del(ugd->ug_MainWindow.ug_pNormalPopup);
1017                         ugd->ug_MainWindow.ug_pNormalPopup = NULL;
1018                 }
1019                 if (0 != ugd->ug_ListPlay.ug_Player) {
1020                         mf_ug_list_play_destory_playing_file(ugd);
1021                         UG_SAFE_FREE_CHAR(ugd->ug_ListPlay.ug_pPlayFilePath);
1022                 }
1023                 ug_destroy_me(ug);
1024                 break;
1025         default:
1026                 break;
1027         }
1028         UG_TRACE_END;
1029 }
1030
1031 /******************************
1032 ** Prototype    : on_destroy
1033 ** Description  :
1034 ** Input        : ui_gadget_h ug
1035 **                service_h service
1036 **                void *priv
1037 ** Output       : None
1038 ** Return Value :
1039 ** Calls        :
1040 ** Called By    :
1041 **
1042 **  History        :
1043 **  1.Date         : 2010/12/10
1044 **    Author       : Samsung
1045 **    Modification : Created function
1046 **
1047 ******************************/
1048 static void on_destroy(ui_gadget_h ug, service_h service, void *priv)
1049 {
1050         UG_TRACE_BEGIN;
1051         ugData *ugd = (ugData *)priv;
1052         ug_mf_retm_if(ugd == NULL, "ugd is NULL");
1053
1054         __mf_ug_main_free_data(ugd);
1055
1056         if (ugd->ug_Status.ug_bInstallFlag == true) {
1057                 mf_ug_util_destory_dir_monitor(ugd);
1058                 mf_ug_util_destory_mmc_state_cb();
1059                 media_content_disconnect();
1060                 power_unset_changed_cb();
1061         }
1062
1063         ug_ecore_idler_del(ugd->ug_Status.search_idler);
1064         ug_ecore_idler_del(ugd->ug_Status.popup_del_idler);
1065         ug_ecore_idler_del(ugd->ug_Status.popup_create_idler);
1066         ug_ecore_idler_del(ugd->ug_Status.msg_finish_idler);
1067         UG_SAFE_DEL_ECORE_TIMER(ugd->ug_Status.pPopupTimer);
1068
1069         if (0 != ugd->ug_ListPlay.ug_Player) {
1070                 mf_ug_list_play_destory_playing_file(ugd);
1071                 UG_SAFE_FREE_CHAR(ugd->ug_ListPlay.ug_pPlayFilePath);
1072         }
1073
1074         if (ugd->ug_Status.ug_pThumbUpdateTimer != NULL) {
1075                 ecore_timer_del(ugd->ug_Status.ug_pThumbUpdateTimer);
1076                 ugd->ug_Status.ug_pThumbUpdateTimer = NULL;
1077         }
1078         __mf_ug_main_free_evas_object(ugd);
1079         UG_TRACE_END;
1080 }
1081
1082
1083 /******************************
1084 ** Prototype    : UG_MODULE_INIT
1085 ** Description  :
1086 ** Input        : struct ug_module_ops *ops
1087 ** Output       : None
1088 ** Return Value :
1089 ** Calls        :
1090 ** Called By    :
1091 **
1092 **  History        :
1093 **  1.Date         : 2010/12/10
1094 **    Author       : Samsung
1095 **    Modification : Created function
1096 **
1097 ******************************/
1098 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
1099 {
1100         UG_TRACE_BEGIN;
1101         ugData *ugd;
1102
1103         if (!ops) {
1104                 return -1;
1105         }
1106
1107         ugd = calloc(1, sizeof(ugData));
1108         if (!ugd) {
1109                 return -1;
1110         }
1111
1112         ops->create = on_create;
1113         ops->start = on_start;
1114         ops->pause = on_pause;
1115         ops->resume = on_resume;
1116         ops->destroy = on_destroy;
1117         ops->message = on_message;
1118         ops->event = on_event;
1119         ops->key_event = on_key_event;
1120         ops->priv = ugd;
1121         ops->opt = UG_OPT_INDICATOR_ENABLE;
1122         UG_TRACE_END;
1123         return 0;
1124 }
1125
1126
1127
1128 /******************************
1129 ** Prototype    : UG_MODULE_EXIT
1130 ** Description  :
1131 ** Input        : struct ug_module_ops *ops
1132 ** Output       : None
1133 ** Return Value :
1134 ** Calls        :
1135 ** Called By    :
1136 **
1137 **  History        :
1138 **  1.Date         : 2010/12/10
1139 **    Author       : Samsung
1140 **    Modification : Created function
1141 **
1142 ******************************/
1143 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
1144 {
1145         UG_TRACE_BEGIN;
1146         ugData *ugd;
1147
1148         if (!ops) {
1149                 return;
1150         }
1151         ugd = ops->priv;
1152
1153         if (ugd) {
1154                 free(ugd);
1155         }
1156         UG_TRACE_END;
1157 }