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         {
  38                 SETTING_TRACE_ERROR("unmount_usb_storage(%s) Fail(%d)", ad->usb_otg_path, ret);
  39                 storageUg_fail_popup(ad);
  40                 ad->usb_request = STORAGEUG_USB_REQ_NONE;
  41         }
  42         else
  43         {
  44                 ad->popup = setting_create_popup_with_progressbar(ad, ad->win, PROGRESSBAR_STYLE,
  45                                 NULL, STORAGEUG_STR_UNMOUNTING, storageUg_popup_del, 0, TRUE, TRUE);
  46         }
  47 }
  48
  49 static inline void storageUg_USB_mount(SettingStorageUG *ad)
  50 {
  51         int ret;
  52
  53         ret = mount_usb_storage(ad->usb_otg_path);
  54         if (ret < 0)
  55         {
  56                 SETTING_TRACE_ERROR("mount_usb_storage(%s) Fail(%d)", ad->usb_otg_path, ret);
  57                 storageUg_fail_popup(ad);
  58                 ad->usb_request = STORAGEUG_USB_REQ_NONE;
  59         }
  60         else
  61         {
  62                 ad->popup = setting_create_popup_with_progressbar(ad, ad->win, PROGRESSBAR_STYLE,
  63                                 NULL, NULL, storageUg_popup_del, 2, TRUE, TRUE);
  64                 ad->usb_request = STORAGEUG_USB_REQ_MOUNT;
  65         }
  66 }
  67
  68 static inline int storageUg_USB_format(SettingStorageUG *ad)
  69 {
  70         int ret;
  71
  72         ret = format_usb_storage(ad->usb_otg_path);
  73         if (ret < 0)
  74         {
  75                 SETTING_TRACE_ERROR("format_usb_storage(%s) Fail(%d)", ad->usb_otg_path, ret);
  76                 storageUg_fail_popup(ad);
  77                 return SETTING_RETURN_FAIL;
  78         }
  79         else
  80         {
  81                 ad->popup = setting_create_popup_with_progressbar(ad, ad->win, PROGRESSBAR_STYLE,
  82                                 NULL, STORAGEUG_STR_FORMATTING, storageUg_popup_del, 0, TRUE, TRUE);
  83         }
  84         return SETTING_RETURN_SUCCESS;
  85 }
  86
  87 static void storageUg_USB_unmount_resp(void *data, Evas_Object *obj,
  88                 void *event_info)
  89 {
  90         int response_type;
  91         SettingStorageUG *ad = data;
  92
  93         ret_if(data == NULL);
  94
  95         response_type = btn_type(obj);
  96         if (ad->popup)
  97         {
  98                 evas_object_del(ad->popup);
  99                 ad->popup = NULL;
 100         }
 101
 102         if (POPUP_RESPONSE_OK == response_type)
 103         {
 104                 ad->usb_request = STORAGEUG_USB_REQ_UNMOUNT;
 105                 storageUg_USB_unmount(ad);
 106         }
 107 }
 108
 109 static void storageUg_USB_format_se_confirm(void *data, Evas_Object *obj,
 110                 void *event_info)
 111 {
 112         int response_type;
 113         SettingStorageUG *ad = data;
 114
 115         ret_if(data == NULL);
 116
 117         response_type = btn_type(obj);
 118         if (ad->popup)
 119         {
 120                 evas_object_del(ad->popup);
 121                 ad->popup = NULL;
 122         }
 123
 124         if (POPUP_RESPONSE_OK == response_type)
 125         {
 126                 ad->usb_request = STORAGEUG_USB_REQ_UNMOUNT_BEFORE_FORMAT;
 127                 storageUg_USB_unmount(ad);
 128         }
 129 }
 130
 131 static void storageUg_USB_format_first_confirm(void *data,
 132                 Evas_Object *obj, void *event_info)
 133 {
 134         int response_type;
 135         SettingStorageUG *ad = data;
 136
 137         ret_if(data == NULL);
 138
 139         response_type = btn_type(obj);
 140         if (ad->popup)
 141         {
 142                 evas_object_del(ad->popup);
 143                 ad->popup = NULL;
 144         }
 145
 146         if (POPUP_RESPONSE_OK == response_type)
 147         {
 148                 if (ad->popup)
 149                         evas_object_del(ad->popup);
 150
 151                 ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
 152                                 STORAGEUG_STR_USB_FORMAT_SECOND_Q, storageUg_USB_format_se_confirm, 0,
 153                                 2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 154         }
 155
 156 }
 157
 158 static void storageUg_main_USB_sel(void *data, Evas_Object *obj, void *event_info)
 159 {
 160         SettingStorageUG *ad = data;
 161         Elm_Object_Item *item = event_info;
 162         Setting_GenGroupItem_Data *list_item;
 163
 164         ret_if(NULL == data);
 165         ret_if(NULL == event_info);
 166
 167         elm_genlist_item_selected_set(item, 0);
 168         list_item = elm_object_item_data_get(item);
 169
 170         SETTING_TRACE("clicking item[%s]", list_item->keyStr);
 171
 172         if (ad->popup)
 173         {
 174                 evas_object_del(ad->popup);
 175                 ad->popup = NULL;
 176         }
 177
 178         if (list_item == ad->usb_mount)
 179         {
 180                 storageUg_USB_mount(ad);
 181         }
 182         else if (list_item == ad->usb_unmount)
 183         {
 184                 ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
 185                                 STORAGEUG_STR_USB_UNMOUNT_POPUP_MSG, storageUg_USB_unmount_resp, 0,
 186                                 2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 187
 188         }
 189         else if (list_item == ad->usb_format)
 190         {
 191                 ad->popup = setting_create_popup_with_btn(ad, ad->win, NULL,
 192                                 STORAGEUG_STR_USB_FORMAT_Q, storageUg_USB_format_first_confirm, 0,
 193                                 2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 194         }
 195 }
 196
 197 static inline void storageUg_USB_remove_info(SettingStorageUG *ad)
 198 {
 199         if (ad->usb_card)
 200         {
 201                 elm_object_item_del(ad->usb_card->item);
 202                 ad->usb_card = NULL;
 203         }
 204         if (ad->usb_mount)
 205         {
 206                 elm_object_item_del(ad->usb_mount->item);
 207                 ad->usb_mount = NULL;
 208         }
 209         if (ad->usb_total)
 210         {
 211                 elm_object_item_del(ad->usb_total->item);
 212                 ad->usb_total = NULL;
 213         }
 214         if (ad->usb_available)
 215         {
 216                 elm_object_item_del(ad->usb_available->item);
 217                 ad->usb_available = NULL;
 218         }
 219         if (ad->usb_unmount)
 220         {
 221                 elm_object_item_del(ad->usb_unmount->item);
 222                 ad->usb_unmount = NULL;
 223         }
 224         if (ad->usb_format)
 225         {
 226                 elm_object_item_del(ad->usb_format->item);
 227                 ad->usb_format = NULL;
 228         }
 229         if (ad->usb_sep_item)
 230         {
 231                 elm_object_item_del(ad->usb_sep_item);
 232                 ad->usb_sep_item = NULL;
 233         }
 234 }
 235
 236 static inline void storageUg_USB_append_mounted_info(SettingStorageUG *ad)
 237 {
 238         double total = 0.0;
 239         double avail = 0.0;
 240         char total_str[STORAGEUG_MAX_STR_LEN] = {0};
 241         char avail_str[STORAGEUG_MAX_STR_LEN] = {0};
 242
 243         storageUg_get_external_storage_status(ad->usb_otg_path, &total, &avail);
 244         storageUg_size_to_str(total, total_str, sizeof(total_str));
 245         storageUg_size_to_str(avail, avail_str, sizeof(avail_str));
 246
 247         /* Total space */
 248         ad->usb_total = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_2text_2),
 249                         NULL, ad, SWALLOW_Type_INVALID, NULL, NULL, 0, STORAGEUG_STR_TOTAL,
 250                         total_str, NULL);
 251         if (ad->usb_total)
 252         {
 253                 ad->usb_total->userdata = ad;
 254                 ad->usb_total->group_style = SETTING_GROUP_STYLE_TOP;
 255                 elm_genlist_item_select_mode_set(ad->usb_total->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 256         }
 257         else
 258         {
 259                 SETTING_TRACE_ERROR("ad->usb_total is NULL");
 260         }
 261
 262         /* Avaliable */
 263         ad->usb_available = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_2text_2),
 264                         NULL, ad, SWALLOW_Type_INVALID, NULL,NULL, 0, STORAGEUG_STR_AVAIL_SPACE,
 265                         avail_str,NULL);
 266         if (ad->usb_available)
 267         {
 268                 ad->usb_available->userdata = ad;
 269                 ad->usb_available->group_style = SETTING_GROUP_STYLE_CENTER;
 270                 elm_genlist_item_select_mode_set(ad->usb_available->item,
 271                                 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 272         }
 273         else
 274         {
 275                 SETTING_TRACE_ERROR("ad->usb_available is NULL");
 276         }
 277
 278         /* Usb Unmount*/
 279         ad->usb_unmount = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_1text),
 280                         storageUg_main_USB_sel, ad, SWALLOW_Type_INVALID, NULL, NULL, 0,
 281                         STORAGEUG_STR_UNMOUNT_USB, NULL, NULL);
 282         if (ad->usb_unmount)
 283         {
 284                 ad->usb_unmount->userdata = ad;
 285                 ad->usb_unmount->group_style = SETTING_GROUP_STYLE_CENTER;
 286         }
 287         else
 288         {
 289                 SETTING_TRACE_ERROR("ad->usb_unmount is NULL");
 290         }
 291
 292         /* Usb Format*/
 293         ad->usb_format = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_1text),
 294                         storageUg_main_USB_sel, ad, SWALLOW_Type_INVALID, NULL, NULL, 0,
 295                         STORAGEUG_STR_FORMAT_USB, NULL, NULL);
 296         if (ad->usb_format)
 297         {
 298                 ad->usb_format->userdata = ad;
 299                 ad->usb_format->group_style = SETTING_GROUP_STYLE_BOTTOM;
 300         }
 301         else
 302         {
 303                 SETTING_TRACE_ERROR("ad->usb_format is NULL");
 304         }
 305 }
 306
 307 static inline void storageUg_main_append_USB_info(SettingStorageUG *ad)
 308 {
 309         ret_if(NULL == ad);
 310
 311         if (ad->usb_card)
 312                 storageUg_USB_remove_info(ad);
 313
 314         if (ad->usb_otg_status == SETTING_STORAGE_USB_OTG_REMOVE)
 315                 return;
 316
 317         /* USB OTG storage */
 318         ad->usb_card = setting_create_Gendial_field_titleItem(ad->gl_main,
 319                         &(ad->itc_group_item), STORAGEUG_STR_USB, NULL);
 320
 321         if (SETTING_STORAGE_USB_OTG_MOUNT == ad->usb_otg_status)
 322         {
 323                 storageUg_USB_append_mounted_info(ad);
 324         }
 325         else
 326         {
 327                 /* Usb Mount*/
 328                 ad->usb_mount = setting_create_Gendial_field_def(ad->gl_main, &(ad->itc_1text),
 329                                 storageUg_main_USB_sel, ad, SWALLOW_Type_INVALID, NULL, NULL, 0,
 330                                 STORAGEUG_STR_MOUNT_USB, NULL, NULL);
 331                 if (ad->usb_mount)
 332                 {
 333                         ad->usb_mount->userdata = ad;
 334                         ad->usb_mount->group_style = SETTING_GROUP_STYLE_TOP;
 335                 }
 336                 else
 337                 {
 338                         SETTING_TRACE_ERROR("ad->usb_mount is NULL");
 339                 }
 340         }
 341
 342         ad->usb_sep_item = storageUg_append_separator(ad->gl_main, ad);
 343 }
 344
 345 static void storageUg_USB_cb(char *type, char *path, int mount, void *data)
 346 {
 347         int ret;
 348         SettingStorageUG *ad = data;
 349
 350         ret_if(NULL == type);
 351         ret_if(NULL == path);
 352         ret_if(NULL == data);
 353
 354         SETTING_TRACE_DEBUG("path:%s type:%s", path, type);
 355
 356         FREE(ad->usb_otg_path);
 357         ad->usb_otg_path = SAFE_STRDUP(path);
 358
 359         if (ad->popup)
 360         {
 361                 evas_object_del(ad->popup);
 362                 ad->popup = NULL;
 363         }
 364
 365         if (!strcmp(type, "storage_remove"))
 366         {
 367                 ad->usb_otg_status = SETTING_STORAGE_USB_OTG_REMOVE;
 368         }
 369         else if (!strcmp(type, "storage_mount"))
 370         {
 371                 ad->usb_otg_status = SETTING_STORAGE_USB_OTG_MOUNT;
 372                 if (STORAGEUG_USB_REQ_UNMOUNT == ad->usb_request)
 373                 {
 374                         SETTING_TRACE_ERROR("unmount_usb_storage() Fail");
 375                         storageUg_fail_popup(ad);
 376                 }
 377         }
 378         else if (!strcmp(type, "storage_unmount"))
 379         {
 380                 ad->usb_otg_status = SETTING_STORAGE_USB_OTG_UNMOUNT;
 381                 if (STORAGEUG_USB_REQ_UNMOUNT_BEFORE_FORMAT == ad->usb_request)
 382                 {
 383                         ret = storageUg_USB_format(ad);
 384                         if (SETTING_RETURN_SUCCESS == ret)
 385                         {
 386                                 ad->usb_request = STORAGEUG_USB_REQ_FORMAT;
 387                         }
 388                         else
 389                         {
 390                                 ad->usb_request = STORAGEUG_USB_REQ_NONE;
 391                                 storageUg_USB_mount(ad);
 392                         }
 393                         return;
 394                 }
 395                 else if (STORAGEUG_USB_REQ_FORMAT == ad->usb_request)
 396                 {
 397                         SETTING_TRACE_ERROR("format_usb_storage() Fail");
 398                         storageUg_fail_popup(ad);
 399                 }
 400                 else if (STORAGEUG_USB_REQ_MOUNT == ad->usb_request)
 401                 {
 402                         SETTING_TRACE_ERROR("mount_usb_storage() Fail");
 403                         storageUg_fail_popup(ad);
 404                 }
 405         }
 406         else if (!strcmp(type, "storage_updated"))
 407         {
 408                 if (mount == 0)
 409                         ad->usb_otg_status = SETTING_STORAGE_USB_OTG_UNMOUNT;
 410                 else
 411                         ad->usb_otg_status = SETTING_STORAGE_USB_OTG_MOUNT;
 412         }
 413         ad->usb_request = STORAGEUG_USB_REQ_NONE;
 414         storageUg_main_append_USB_info(ad);
 415 }
 416
 417 void storageUg_init_USB(SettingStorageUG *ad)
 418 {
 419         int ret;
 420
 421         ret = init_usbhost_signal();
 422         retm_if(ret < 0, "init_usbhost_signal() Fail(%d)", ret);
 423
 424         ret = register_usb_storage_change_handler(storageUg_USB_cb, ad);
 425         if (ret < 0)
 426         {
 427                 SETTING_TRACE_ERROR("register_usb_storage_change_handler() Fail(%d)", ret);
 428                 deinit_usbhost_signal();
 429                 return;
 430         }
 431
 432         ret = request_usb_storage_info();
 433         warn_if(ret < 0, "request_usb_storage_info() Fail(%d)", ret);
 434 }
 435
 436 void storageUg_deinit_USB()
 437 {
 438         deinit_usbhost_signal();
 439 }