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