src/usb/usbotg-mobile.c

   1 /*
   2  *  system-popup
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
   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
  20 #include "popup-common.h"
  21 #include <appsvc.h>
  22 #include <app_control.h>
  23
  24
  25 #define MYFILES_APPNAME "org.tizen.myfile"
  26 #define GALLERY_APPNAME "org.tizen.gallery"
  27
  28 #define USB_MOUNT_ROOT_PATH     "/opt/storage"
  29 #define USB_MOUNT_PATH          "_DEVICE_PATH_"
  30
  31 #define BUF_MAX 128
  32
  33 #define DEVICED_PATH                    "/Org/Tizen/System/DeviceD"
  34 #define DEVICED_IFACE                   "org.tizen.system.deviced"
  35 #define DEVICED_PATH_USBHOST    DEVICED_PATH"/Usbhost"
  36 #define DEVICED_IFACE_USBHOST   DEVICED_IFACE".Usbhost"
  37 #define SIGNAL_NAME_UNMOUNT             "unmount_storage"
  38
  39 static char added_path[BUF_MAX];
  40 static char removed_path[BUF_MAX];
  41
  42 enum ext_app {
  43         EXT_MYFILES,
  44         EXT_GALLERY,
  45 };
  46
  47 static const struct popup_ops storage_mounted_ops;
  48 static const struct popup_ops unmount_storage_ops;
  49 static const struct popup_ops camera_added_ops;
  50 static const struct popup_ops storage_mount_failed_ops;
  51 static const struct popup_ops storage_removed_unsafe_ops;
  52
  53 static void remove_otg_popup(const struct popup_ops *ops, char *path)
  54 {
  55         int len;
  56         char *popup_path;
  57
  58         if (ops == &storage_mounted_ops)
  59                 popup_path = added_path;
  60         else if (ops == &unmount_storage_ops)
  61                 popup_path = removed_path;
  62         else
  63                 popup_path = NULL;
  64
  65         if (popup_path) {
  66                 if (!path)
  67                         return;
  68                 len = strlen(popup_path);
  69                 if (len != strlen(path))
  70                         return;
  71                 if (strncmp(popup_path, path, len))
  72                         return;
  73         }
  74
  75         unload_simple_popup(ops);
  76 }
  77
  78 static void set_myfiles_param(bundle *b)
  79 {
  80         if (!b)
  81                 return;
  82
  83         if (strlen(added_path) > 0)
  84                 appsvc_add_data(b, "path", added_path);
  85         else
  86                 appsvc_add_data(b, "path", USB_MOUNT_ROOT_PATH);
  87         appsvc_set_pkgname(b, MYFILES_APPNAME);
  88 }
  89
  90 static void set_gallery_param(bundle *b)
  91 {
  92         if (!b)
  93                 return;
  94         appsvc_add_data(b, "album-id", "GALLERY_ALBUM_PTP_ID");
  95         appsvc_set_pkgname(b, GALLERY_APPNAME);
  96 }
  97
  98 static struct ext_app_type {
  99         int type;
 100         void (*set_param)(bundle *b);
 101 } app_type[] = {
 102         { EXT_MYFILES   , set_myfiles_param     },
 103         { EXT_GALLERY   , set_gallery_param     },
 104 };
 105
 106 static void launch_app(int type)
 107 {
 108         app_control_h app_control;
 109
 110         int ret, i, type_len;
 111
 112         type_len = ARRAY_SIZE(app_type);
 113         for (i = 0 ; i < ARRAY_SIZE(app_type) ; i++) {
 114                 if (type == app_type[i].type)
 115                         break;
 116         }
 117         if (i == type_len) {
 118                 _E("Invalid type (%d)", type);
 119                 return;
 120         }
 121
 122         ret = app_control_create(&app_control);
 123         if (ret != APP_CONTROL_ERROR_NONE)
 124                 return;
 125
 126         ret = app_control_set_operation(app_control, APP_CONTROL_OPERATION_VIEW);
 127         if (ret != APP_CONTROL_ERROR_NONE) {
 128                 (void)app_control_destroy(app_control);
 129                 return;
 130         }
 131
 132         ret = app_control_send_launch_request(app_control, NULL, NULL);
 133         if (ret != APP_CONTROL_ERROR_NONE)
 134                 _E("Failed to send launch request");
 135
 136         (void)app_control_destroy(app_control);
 137 }
 138
 139 static void storage_browse(const struct popup_ops *ops)
 140 {
 141         unload_simple_popup(ops);
 142         launch_app(EXT_MYFILES);
 143         terminate_if_no_popup();
 144 }
 145
 146 static void camera_browse(const struct popup_ops *ops)
 147 {
 148         unload_simple_popup(ops);
 149         launch_app(EXT_GALLERY);
 150         terminate_if_no_popup();
 151 }
 152
 153 static void storage_unmount(const struct popup_ops *ops)
 154 {
 155         char *param[1];
 156         int ret;
 157
 158         unload_simple_popup(ops);
 159
 160         param[0] = removed_path;
 161
 162         ret = broadcast_dbus_signal(DEVICED_PATH_USBHOST,
 163                         DEVICED_IFACE_USBHOST,
 164                         SIGNAL_NAME_UNMOUNT, "s", param);
 165         if (ret < 0)
 166                 _E("FAIL: broadcast_dbus_signal()");
 167
 168         memset(removed_path, 0, sizeof(removed_path));
 169
 170         terminate_if_no_popup();
 171
 172 }
 173
 174 static int storage_mounted_launch(bundle *b, const struct popup_ops *ops)
 175 {
 176         int ret;
 177         struct object_ops *obj;
 178         char *path;
 179
 180         if (!ops)
 181                 return -1;
 182
 183         ret = get_object_by_ops(ops, &obj);
 184         if (ret < 0) {
 185                 _E("Failed to get object (%d)", ret);
 186                 return -2;
 187         }
 188
 189         path = (char *)bundle_get_val(obj->b, USB_MOUNT_PATH);
 190         if (!path) {
 191                 _E("Failed to get mount path");
 192                 return -3;
 193         }
 194
 195         _I("USB storage mount path (%s)", path);
 196         snprintf(added_path, sizeof(added_path), "%s", path);
 197         return 0;
 198 }
 199
 200 static int unmount_storage_launch(bundle *b, const struct popup_ops *ops)
 201 {
 202         int ret;
 203         struct object_ops *obj;
 204         char *path;
 205
 206         if (!ops)
 207                 return -1;
 208
 209         ret = get_object_by_ops(ops, &obj);
 210         _D("ops = %s obj = %s",ops, obj);
 211         if (ret < 0) {
 212                 _E("Failed to get object (%d)", ret);
 213                 return -2;
 214         }
 215
 216         path = (char *)bundle_get_val(obj->b, USB_MOUNT_PATH);
 217         if (!path) {
 218                 _E("Failed to get mount path");
 219                 return -3;
 220         }
 221
 222         remove_otg_popup(&storage_mounted_ops, path);
 223
 224         snprintf(removed_path, sizeof(removed_path), "%s", path);
 225         return 0;
 226 }
 227
 228 static int storage_unmounted(bundle *b, const struct popup_ops *ops)
 229 {
 230         char *path;
 231
 232         if (!b || !ops)
 233                 return -EINVAL;
 234
 235         path = (char *)bundle_get_val(b, USB_MOUNT_PATH);
 236         if (!path) {
 237                 _E("Failed to get mount path");
 238                 return -ENOENT;
 239         }
 240
 241         remove_otg_popup(&storage_mounted_ops, path);
 242         remove_otg_popup(&unmount_storage_ops, path);
 243
 244         terminate_if_no_popup();
 245         return 0;
 246 }
 247
 248 static int camera_removed(bundle *b, const struct popup_ops *ops)
 249 {
 250         remove_otg_popup(&camera_added_ops, NULL);
 251         terminate_if_no_popup();
 252         return 0;
 253 }
 254
 255 static const struct popup_ops storage_mounted_ops = {
 256         .name                   = "usbotg_storage_mounted",
 257         .show                   = load_simple_popup,
 258         .title                  = "IDS_ST_BODY_USB_STORAGE_ABB",
 259         .content                = "IDS_USB_BODY_BROWSE_STORAGE_CONNECTED_VIA_USB_Q",
 260         .left_text              = "IDS_COM_SK_CANCEL",
 261         .right_text             = "IDS_BT_SK_BROWSE",
 262         .right                  = storage_browse,
 263         .pre                    = storage_mounted_launch,
 264 };
 265
 266 static const struct popup_ops storage_unmounted_ops = {
 267         .name                   = "usbotg_storage_unmounted",
 268         .show                   = storage_unmounted,
 269 };
 270
 271 static const struct popup_ops unmount_storage_ops = {
 272         .name                   = "usbotg_unmount_storage",
 273         .show                   = load_simple_popup,
 274         .title                  = "IDS_ST_BODY_USB_STORAGE_ABB",
 275         .content                = "IDS_COM_POP_UNMOUNT_USB_MASS_STORAGE_BEFORE_REMOVING_TO_AVOID_DATA_LOSS",
 276         .left_text              = "IDS_COM_SK_CANCEL",
 277         .right_text             = "IDS_USB_BUTTON_UNMOUNT",
 278         .right                  = storage_unmount,
 279         .pre                    = unmount_storage_launch,
 280 };
 281
 282 static const struct popup_ops camera_added_ops = {
 283         .name                   = "usbotg_camera_added",
 284         .show                   = load_simple_popup,
 285         .title                  = "IDS_CAM_HEADER_CAMERA_M_APPLICATION",
 286         .content                = "IDS_USB_BODY_BROWSE_CAMERA_CONNECTED_VIA_USB_Q",
 287         .left_text              = "IDS_COM_SK_CANCEL",
 288         .right_text             = "IDS_BT_SK_BROWSE",
 289         .right                  = camera_browse,
 290 };
 291
 292 static const struct popup_ops camera_removed_ops = {
 293         .name                   = "usbotg_camera_removed",
 294         .show                   = camera_removed,
 295 };
 296
 297 static const struct popup_ops storage_mount_failed_ops = {
 298         .name                   = "usbotg_storage_mount_failed",
 299         .show                   = load_simple_popup,
 300         .title                  = "IDS_COM_HEADER_ATTENTION",
 301         .content                = "IDS_COM_BODY_USB_STORAGE_BLANK_OR_HAS_UNSUPPORTED_FILE_SYSTEM",
 302         .left_text              = "IDS_COM_SK_OK",
 303 };
 304
 305 static const struct popup_ops storage_removed_unsafe_ops = {
 306         .name                   = "usbotg_storage_removed_unsafe",
 307         .show                   = load_simple_popup,
 308         .title                  = "IDS_COM_HEADER_ATTENTION",
 309         .content                = "IDS_COM_POP_USB_MASS_STORAGE_UNEXPECTEDLY_REMOVED",
 310         .left_text              = "IDS_COM_SK_OK",
 311 };
 312
 313
 314 /* Constructor to register mount_failed button */
 315 static __attribute__ ((constructor)) void usbotg_register_popup(void)
 316 {
 317         register_popup(&storage_mounted_ops);
 318         register_popup(&storage_unmounted_ops);
 319         register_popup(&unmount_storage_ops);
 320         register_popup(&camera_added_ops);
 321         register_popup(&camera_removed_ops);
 322         register_popup(&storage_mount_failed_ops);
 323         register_popup(&storage_removed_unsafe_ops);
 324 }