setting-storage/src/setting-storage-USB.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19 #include <dd-usbhost.h>
  20
  21 #include "setting-storage-utils.h"
  22 #include "setting-storage-USB.h"
  23
  24 enum {
  25     STORAGEUG_USB_REQ_NONE,
  26     STORAGEUG_USB_REQ_MOUNT,
  27     STORAGEUG_USB_REQ_UNMOUNT,
  28     STORAGEUG_USB_REQ_UNMOUNT_BEFORE_FORMAT,
  29     STORAGEUG_USB_REQ_FORMAT
  30 };
  31
  32 static inline void storageUg_USB_unmount(SettingStorageUG *ad)
  33 {
  34         int ret;
  35         ret = unmount_usb_storage(ad->usb_otg_path);
  36         if (ret < 0) {
  37                 SETTING_TRACE_ERROR("unmount_usb_storage(%s) Fail(%d)", ad->usb_otg_path, ret);
  38                 storageUg_fail_popup(ad);
  39                 ad->usb_request = STORAGEUG_USB_REQ_NONE;
  40         } else {
  41                 ad->popup = setting_create_popup_with_progressbar(ad, ad->win, PROGRESSBAR_STYLE,
  42                                                                   NULL, STORAGEUG_STR_UNMOUNTING, storageUg_popup_del, 0, TRUE, TRUE);
  43         }
  44 }
  45
  46 static inline void storageUg_USB_mount(SettingStorageUG *ad)
  47 {
  48         int ret;
  49
  50         ret = mount_usb_storage(ad->usb_otg_path);
  51         if (ret < 0) {
  52                 SETTING_TRACE_ERROR("mount_usb_storage(%s) Fail(%d)", ad->usb_otg_path, ret);
  53                 storageUg_fail_popup(ad);
  54                 ad->usb_request = STORAGEUG_USB_REQ_NONE;
  55         } else {
  56                 ad->popup = setting_create_popup_with_progressbar(ad, ad->win, PROGRESSBAR_STYLE,
  57                                                                   NULL, NULL, storageUg_popup_del, 2, TRUE, TRUE);
  58                 ad->usb_request = STORAGEUG_USB_REQ_MOUNT;
  59         }
  60 }
  61
  62 static inline int storageUg_USB_format(SettingStorageUG *ad)
  63 {
  64         int ret;
  65
  66         ret = format_usb_storage(ad->usb_otg_path);
  67         if (ret < 0) {
  68                 SETTING_TRACE_ERROR("format_usb_storage(%s) Fail(%d)", ad->usb_otg_path, ret);
  69                 storageUg_fail_popup(ad);
  70                 return SETTING_RETURN_FAIL;
  71         } else {
  72                 ad->popup = setting_create_popup_with_progressbar(ad, ad->win, PROGRESSBAR_STYLE,
  73                                                                   NULL, STORAGEUG_STR_FORMATTING, storageUg_popup_del, 0, TRUE, TRUE);
  74         }
  75         return SETTING_RETURN_SUCCESS;
  76 }
  77
  78 static void storageUg_USB_unmount_resp(void *data, Evas_Object *obj,
  79                                        void *event_info)
  80 {
  81         int response_type;
  82         SettingStorageUG *ad = data;
  83
  84         ret_if(data == NULL);
  85
  86         response_type = btn_type(obj);
  87         if (ad->popup) {
  88                 evas_object_del(ad->popup);
  89                 ad->popup = NULL;
  90         }
  91
  92         if (POPUP_RESPONSE_OK == response_type) {
  93                 ad->usb_request = STORAGEUG_USB_REQ_UNMOUNT;
  94                 storageUg_USB_unmount(ad);
  95         }
  96 }
  97
  98 static void storageUg_USB_format_se_confirm(void *data, Evas_Object *obj,
  99                                             void *event_info)
 100 {
 101         int response_type;
 102         SettingStorageUG *ad = data;
 103
 104         ret_if(data == NULL);
 105
 106         response_type = btn_type(obj);
 107         if (ad->popup) {
 108                 evas_object_del(ad->popup);
 109                 ad->popup = NULL;
 110         }
 111
 112         if (POPUP_RESPONSE_OK == response_type) {
 113                 ad->usb_request = STORAGEUG_USB_REQ_UNMOUNT_BEFORE_FORMAT;
 114                 storageUg_USB_unmount(ad);
 115         }
 116 }
 117
 118 static void storageUg_USB_format_first_confirm(void *data,
 119                                                Evas_Object *obj, void *event_info)
 120 {
 121         int response_type;
 122         SettingStorageUG *ad = data;
 123
 124         ret_if(data == NULL);
 125
 126         response_type = btn_type(obj);
 127         if (ad->popup) {
 128                 evas_object_del(ad->popup);
 129                 ad->popup = NULL;
 130         }
 131
 132         if (POPUP_RESPONSE_OK == response_type) {
 133                 if (ad->popup)
 134                         evas_object_del(ad->popup);
 135
 136                 ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
 137                                                           STORAGEUG_STR_USB_FORMAT_SECOND_Q, storageUg_USB_format_se_confirm, 0,
 138                                                           2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 139         }
 140
 141 }
 142
 143 static void storageUg_main_USB_sel(void *data, Evas_Object *obj, void *event_info)
 144 {
 145         SettingStorageUG *ad = data;
 146         Elm_Object_Item *item = event_info;
 147         Setting_GenGroupItem_Data *list_item;
 148
 149         ret_if(NULL == data);
 150         ret_if(NULL == event_info);
 151
 152         elm_genlist_item_selected_set(item, 0);
 153         list_item = elm_object_item_data_get(item);
 154
 155         SETTING_TRACE("clicking item[%s]", list_item->keyStr);
 156
 157         if (ad->popup) {
 158                 evas_object_del(ad->popup);
 159                 ad->popup = NULL;
 160         }
 161
 162         if (list_item == ad->usb_mount) {
 163                 storageUg_USB_mount(ad);
 164         } else if (list_item == ad->usb_unmount) {
 165                 ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
 166                                                           STORAGEUG_STR_USB_UNMOUNT_POPUP_MSG, storageUg_USB_unmount_resp, 0,
 167                                                           2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 168
 169         } else if (list_item == ad->usb_format) {
 170                 ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
 171                                                           STORAGEUG_STR_USB_FORMAT_Q, storageUg_USB_format_first_confirm, 0,
 172                                                           2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 173         }
 174 }
 175
 176 static inline void storageUg_USB_remove_info(SettingStorageUG *ad)
 177 {
 178         if (ad->usb_card) {
 179                 elm_object_item_del(ad->usb_card->item);
 180                 ad->usb_card = NULL;
 181         }
 182         if (ad->usb_mount) {
 183                 elm_object_item_del(ad->usb_mount->item);
 184                 ad->usb_mount = NULL;
 185         }
 186         if (ad->usb_total) {
 187                 elm_object_item_del(ad->usb_total->item);
 188                 ad->usb_total = NULL;
 189         }
 190         if (ad->usb_available) {
 191                 elm_object_item_del(ad->usb_available->item);
 192                 ad->usb_available = NULL;
 193         }
 194         if (ad->usb_unmount) {
 195                 elm_object_item_del(ad->usb_unmount->item);
 196                 ad->usb_unmount = NULL;
 197         }
 198         if (ad->usb_format) {
 199                 elm_object_item_del(ad->usb_format->item);
 200                 ad->usb_format = NULL;
 201         }
 202         if (ad->usb_sep_item) {
 203                 elm_object_item_del(ad->usb_sep_item);
 204                 ad->usb_sep_item = NULL;
 205         }
 206 }
 207
 208 static inline void storageUg_USB_append_mounted_info(SettingStorageUG *ad)
 209 {
 210         double total = 0.0;
 211         double avail = 0.0;
 212         char total_str[STORAGEUG_MAX_STR_LEN] = {0};
 213         char avail_str[STORAGEUG_MAX_STR_LEN] = {0};
 214
 215         storageUg_get_external_storage_status(ad->usb_otg_path, &total, &avail);
 216         storageUg_size_to_str(total, total_str, sizeof(total_str));
 217         storageUg_size_to_str(avail, avail_str, sizeof(avail_str));
 218
 219         /* Total space */
 220         ad->usb_total = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_2text_2),
 221                                                          NULL, ad, SWALLOW_Type_INVALID, NULL, NULL, 0, STORAGEUG_STR_TOTAL,
 222                                                          total_str, NULL);
 223         if (ad->usb_total) {
 224                 ad->usb_total->userdata = ad;
 225                 ad->usb_total->group_style = SETTING_GROUP_STYLE_TOP;
 226                 elm_genlist_item_select_mode_set(ad->usb_total->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 227         } else {
 228                 SETTING_TRACE_ERROR("ad->usb_total is NULL");
 229         }
 230
 231         /* Avaliable */
 232         ad->usb_available = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_2text_2),
 233                                                              NULL, ad, SWALLOW_Type_INVALID, NULL, NULL, 0, STORAGEUG_STR_AVAIL_SPACE,
 234                                                              avail_str, NULL);
 235         if (ad->usb_available) {
 236                 ad->usb_available->userdata = ad;
 237                 ad->usb_available->group_style = SETTING_GROUP_STYLE_CENTER;
 238                 elm_genlist_item_select_mode_set(ad->usb_available->item,
 239                                                  ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 240         } else {
 241                 SETTING_TRACE_ERROR("ad->usb_available is NULL");
 242         }
 243
 244         /* Usb Unmount*/
 245         ad->usb_unmount = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_1text),
 246                                                            storageUg_main_USB_sel, ad, SWALLOW_Type_INVALID, NULL, NULL, 0,
 247                                                            STORAGEUG_STR_UNMOUNT_USB, NULL, NULL);
 248         if (ad->usb_unmount) {
 249                 ad->usb_unmount->userdata = ad;
 250                 ad->usb_unmount->group_style = SETTING_GROUP_STYLE_CENTER;
 251         } else {
 252                 SETTING_TRACE_ERROR("ad->usb_unmount is NULL");
 253         }
 254
 255         /* Usb Format*/
 256         ad->usb_format = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_1text),
 257                                                           storageUg_main_USB_sel, ad, SWALLOW_Type_INVALID, NULL, NULL, 0,
 258                                                           STORAGEUG_STR_FORMAT_USB, NULL, NULL);
 259         if (ad->usb_format) {
 260                 ad->usb_format->userdata = ad;
 261                 ad->usb_format->group_style = SETTING_GROUP_STYLE_BOTTOM;
 262         } else {
 263                 SETTING_TRACE_ERROR("ad->usb_format is NULL");
 264         }
 265 }
 266
 267 static inline void storageUg_main_append_USB_info(SettingStorageUG *ad)
 268 {
 269         ret_if(NULL == ad);
 270
 271         if (ad->usb_card)
 272                 storageUg_USB_remove_info(ad);
 273
 274         if (ad->usb_otg_status == SETTING_STORAGE_USB_OTG_REMOVE)
 275                 return;
 276
 277         /* USB OTG storage */
 278         ad->usb_card = setting_create_Gendial_field_titleItem(ad->gl_main,
 279                                                               &(ad->itc_group_item), STORAGEUG_STR_USB, NULL);
 280
 281         if (SETTING_STORAGE_USB_OTG_MOUNT == ad->usb_otg_status) {
 282                 storageUg_USB_append_mounted_info(ad);
 283         } else {
 284                 /* Usb Mount*/
 285                 ad->usb_mount = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_1text),
 286                                                                  storageUg_main_USB_sel, ad, SWALLOW_Type_INVALID, NULL, NULL, 0,
 287                                                                  STORAGEUG_STR_MOUNT_USB, NULL, NULL);
 288                 if (ad->usb_mount) {
 289                         ad->usb_mount->userdata = ad;
 290                         ad->usb_mount->group_style = SETTING_GROUP_STYLE_TOP;
 291                 } else {
 292                         SETTING_TRACE_ERROR("ad->usb_mount is NULL");
 293                 }
 294         }
 295
 296         ad->usb_sep_item = storageUg_append_separator(ad->gl_main, ad);
 297 }
 298
 299 static void storageUg_USB_cb(char *type, char *path, int mount, void *data)
 300 {
 301         int ret;
 302         SettingStorageUG *ad = data;
 303
 304         ret_if(NULL == type);
 305         ret_if(NULL == path);
 306         ret_if(NULL == data);
 307
 308         SETTING_TRACE_DEBUG("path:%s type:%s", path, type);
 309
 310         FREE(ad->usb_otg_path);
 311         ad->usb_otg_path = SAFE_STRDUP(path);
 312
 313         if (ad->popup) {
 314                 evas_object_del(ad->popup);
 315                 ad->popup = NULL;
 316         }
 317
 318         if (!strcmp(type, "storage_remove")) {
 319                 ad->usb_otg_status = SETTING_STORAGE_USB_OTG_REMOVE;
 320         } else if (!strcmp(type, "storage_mount")) {
 321                 ad->usb_otg_status = SETTING_STORAGE_USB_OTG_MOUNT;
 322                 if (STORAGEUG_USB_REQ_UNMOUNT == ad->usb_request) {
 323                         SETTING_TRACE_ERROR("unmount_usb_storage() Fail");
 324                         storageUg_fail_popup(ad);
 325                 }
 326         } else if (!strcmp(type, "storage_unmount")) {
 327                 ad->usb_otg_status = SETTING_STORAGE_USB_OTG_UNMOUNT;
 328                 if (STORAGEUG_USB_REQ_UNMOUNT_BEFORE_FORMAT == ad->usb_request) {
 329                         ret = storageUg_USB_format(ad);
 330                         if (SETTING_RETURN_SUCCESS == ret) {
 331                                 ad->usb_request = STORAGEUG_USB_REQ_FORMAT;
 332                         } else {
 333                                 ad->usb_request = STORAGEUG_USB_REQ_NONE;
 334                                 storageUg_USB_mount(ad);
 335                         }
 336                         return;
 337                 } else if (STORAGEUG_USB_REQ_FORMAT == ad->usb_request) {
 338                         SETTING_TRACE_ERROR("format_usb_storage() Fail");
 339                         storageUg_fail_popup(ad);
 340                 } else if (STORAGEUG_USB_REQ_MOUNT == ad->usb_request) {
 341                         SETTING_TRACE_ERROR("mount_usb_storage() Fail");
 342                         storageUg_fail_popup(ad);
 343                 }
 344         } else if (!strcmp(type, "storage_updated")) {
 345                 if (mount == 0)
 346                         ad->usb_otg_status = SETTING_STORAGE_USB_OTG_UNMOUNT;
 347                 else
 348                         ad->usb_otg_status = SETTING_STORAGE_USB_OTG_MOUNT;
 349         }
 350         ad->usb_request = STORAGEUG_USB_REQ_NONE;
 351         storageUg_main_append_USB_info(ad);
 352 }
 353
 354 void storageUg_init_USB(SettingStorageUG *ad)
 355 {
 356         int ret;
 357
 358         ret = init_usbhost_signal();
 359         retm_if(ret < 0, "init_usbhost_signal() Fail(%d)", ret);
 360
 361         ret = register_usb_storage_change_handler(storageUg_USB_cb, ad);
 362         if (ret < 0) {
 363                 SETTING_TRACE_ERROR("register_usb_storage_change_handler() Fail(%d)", ret);
 364                 deinit_usbhost_signal();
 365                 return;
 366         }
 367
 368         ret = request_usb_storage_info();
 369         warn_if(ret < 0, "request_usb_storage_info() Fail(%d)", ret);
 370 }
 371
 372 void storageUg_deinit_USB()
 373 {
 374         deinit_usbhost_signal();
 375 }