chromeos/dbus/cros_disks_client.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_
   6 #define CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/callback.h"
  13 #include "chromeos/chromeos_export.h"
  14 #include "chromeos/dbus/dbus_client_implementation_type.h"
  15
  16 namespace dbus {
  17 class Bus;
  18 class Response;
  19 }
  20
  21 // TODO(tbarzic): We should move these enums inside CrosDisksClient,
  22 // to be clearer where they come from. Also, most of these are partially or
  23 // completely duplicated in third_party/dbus/service_constants.h. We should
  24 // probably use enums from service_contstants directly.
  25 namespace chromeos {
  26
  27 // Enum describing types of mount used by cros-disks.
  28 enum MountType {
  29   MOUNT_TYPE_INVALID,
  30   MOUNT_TYPE_DEVICE,
  31   MOUNT_TYPE_ARCHIVE,
  32   MOUNT_TYPE_GOOGLE_DRIVE,
  33   MOUNT_TYPE_NETWORK_STORAGE,
  34 };
  35
  36 // Type of device.
  37 enum DeviceType {
  38   DEVICE_TYPE_UNKNOWN,
  39   DEVICE_TYPE_USB,  // USB stick.
  40   DEVICE_TYPE_SD,  // SD card.
  41   DEVICE_TYPE_OPTICAL_DISC,  // e.g. Optical disc excluding DVD.
  42   DEVICE_TYPE_MOBILE,  // Storage on a mobile device (e.g. Android).
  43   DEVICE_TYPE_DVD,  // DVD.
  44 };
  45
  46 // Mount error code used by cros-disks.
  47 enum MountError {
  48   MOUNT_ERROR_NONE = 0,
  49   MOUNT_ERROR_UNKNOWN = 1,
  50   MOUNT_ERROR_INTERNAL = 2,
  51   MOUNT_ERROR_INVALID_ARGUMENT = 3,
  52   MOUNT_ERROR_INVALID_PATH = 4,
  53   MOUNT_ERROR_PATH_ALREADY_MOUNTED = 5,
  54   MOUNT_ERROR_PATH_NOT_MOUNTED = 6,
  55   MOUNT_ERROR_DIRECTORY_CREATION_FAILED = 7,
  56   MOUNT_ERROR_INVALID_MOUNT_OPTIONS = 8,
  57   MOUNT_ERROR_INVALID_UNMOUNT_OPTIONS = 9,
  58   MOUNT_ERROR_INSUFFICIENT_PERMISSIONS = 10,
  59   MOUNT_ERROR_MOUNT_PROGRAM_NOT_FOUND = 11,
  60   MOUNT_ERROR_MOUNT_PROGRAM_FAILED = 12,
  61   MOUNT_ERROR_INVALID_DEVICE_PATH = 100,
  62   MOUNT_ERROR_UNKNOWN_FILESYSTEM = 101,
  63   MOUNT_ERROR_UNSUPPORTED_FILESYSTEM = 102,
  64   MOUNT_ERROR_INVALID_ARCHIVE = 201,
  65   MOUNT_ERROR_NOT_AUTHENTICATED = 601,
  66   MOUNT_ERROR_PATH_UNMOUNTED = 901,
  67   // TODO(tbarzic): Add more error codes as they get added to cros-disks and
  68   // consider doing explicit translation from cros-disks error_types.
  69 };
  70
  71 // Format error reported by cros-disks.
  72 enum FormatError {
  73   FORMAT_ERROR_NONE,
  74   FORMAT_ERROR_UNKNOWN,
  75   FORMAT_ERROR_INTERNAL,
  76   FORMAT_ERROR_INVALID_DEVICE_PATH,
  77   FORMAT_ERROR_DEVICE_BEING_FORMATTED,
  78   FORMAT_ERROR_UNSUPPORTED_FILESYSTEM,
  79   FORMAT_ERROR_FORMAT_PROGRAM_NOT_FOUND,
  80   FORMAT_ERROR_FORMAT_PROGRAM_FAILED,
  81   FORMAT_ERROR_DEVICE_NOT_ALLOWED,
  82 };
  83
  84 // Event type each corresponding to a signal sent from cros-disks.
  85 enum MountEventType {
  86   CROS_DISKS_DISK_ADDED,
  87   CROS_DISKS_DISK_REMOVED,
  88   CROS_DISKS_DISK_CHANGED,
  89   CROS_DISKS_DEVICE_ADDED,
  90   CROS_DISKS_DEVICE_REMOVED,
  91   CROS_DISKS_DEVICE_SCANNED,
  92   CROS_DISKS_FORMATTING_FINISHED,
  93 };
  94
  95 // Additional unmount flags to be added to unmount request.
  96 enum UnmountOptions {
  97   UNMOUNT_OPTIONS_NONE,
  98   UNMOUNT_OPTIONS_LAZY,  // Do lazy unmount.
  99 };
 100
 101 // A class to represent information about a disk sent from cros-disks.
 102 class DiskInfo {
 103  public:
 104   DiskInfo(const std::string& device_path, dbus::Response* response);
 105   ~DiskInfo();
 106
 107   // Device path. (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1)
 108   const std::string& device_path() const { return device_path_; }
 109
 110   // Disk mount path. (e.g. /media/removable/VOLUME)
 111   const std::string& mount_path() const { return mount_path_; }
 112
 113   // Disk system path given by udev.
 114   // (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1)
 115   const std::string& system_path() const { return system_path_; }
 116
 117   // Is a drive or not. (i.e. true with /dev/sdb, false with /dev/sdb1)
 118   bool is_drive() const { return is_drive_; }
 119
 120   // Does the disk have media content.
 121   bool has_media() const { return has_media_; }
 122
 123   // Is the disk on deveice we booted the machine from.
 124   bool on_boot_device() const { return on_boot_device_; }
 125
 126   // Disk file path (e.g. /dev/sdb).
 127   const std::string& file_path() const { return file_path_; }
 128
 129   // Disk label.
 130   const std::string& label() const { return label_; }
 131
 132   // Vendor ID of the device (e.g. "18d1").
 133   const std::string& vendor_id() const { return vendor_id_; }
 134
 135   // Vendor name of the device (e.g. "Google Inc.").
 136   const std::string& vendor_name() const { return vendor_name_; }
 137
 138   // Product ID of the device (e.g. "4e11").
 139   const std::string& product_id() const { return product_id_; }
 140
 141   // Product name of the device (e.g. "Nexus One").
 142   const std::string& product_name() const { return product_name_; }
 143
 144   // Disk model. (e.g. "TransMemory")
 145   const std::string& drive_label() const { return drive_model_; }
 146
 147   // Device type. Not working well, yet.
 148   DeviceType device_type() const { return device_type_; }
 149
 150   // Total size of the disk in bytes.
 151   uint64 total_size_in_bytes() const { return total_size_in_bytes_; }
 152
 153   // Is the device read-only.
 154   bool is_read_only() const { return is_read_only_; }
 155
 156   // Returns true if the device should be hidden from the file browser.
 157   bool is_hidden() const { return is_hidden_; }
 158
 159   // Returns file system uuid.
 160   const std::string& uuid() const { return uuid_; }
 161
 162  private:
 163   void InitializeFromResponse(dbus::Response* response);
 164
 165   std::string device_path_;
 166   std::string mount_path_;
 167   std::string system_path_;
 168   bool is_drive_;
 169   bool has_media_;
 170   bool on_boot_device_;
 171
 172   std::string file_path_;
 173   std::string label_;
 174   std::string vendor_id_;
 175   std::string vendor_name_;
 176   std::string product_id_;
 177   std::string product_name_;
 178   std::string drive_model_;
 179   DeviceType device_type_;
 180   uint64 total_size_in_bytes_;
 181   bool is_read_only_;
 182   bool is_hidden_;
 183   std::string uuid_;
 184 };
 185
 186 // A class to make the actual DBus calls for cros-disks service.
 187 // This class only makes calls, result/error handling should be done
 188 // by callbacks.
 189 class CHROMEOS_EXPORT CrosDisksClient {
 190  public:
 191   // A callback to be called when DBus method call fails.
 192   typedef base::Callback<void()> ErrorCallback;
 193
 194   // A callback to handle the result of Mount.
 195   typedef base::Callback<void()> MountCallback;
 196
 197   // A callback to handle the result of Unmount.
 198   // The argument is the device path.
 199   typedef base::Callback<void(const std::string& device_path)> UnmountCallback;
 200
 201   // A callback to handle the result of EnumerateAutoMountableDevices.
 202   // The argument is the enumerated device paths.
 203   typedef base::Callback<void(const std::vector<std::string>& device_paths)
 204                          > EnumerateAutoMountableDevicesCallback;
 205
 206   // A callback to handle the result of FormatDevice.
 207   // The first argument is the device path.
 208   // The second argument is true when formatting succeeded, false otherwise.
 209   typedef base::Callback<void(const std::string& device_path,
 210                               bool format_succeeded)> FormatDeviceCallback;
 211
 212   // A callback to handle the result of GetDeviceProperties.
 213   // The argument is the information about the specified device.
 214   typedef base::Callback<void(const DiskInfo& disk_info)
 215                          > GetDevicePropertiesCallback;
 216
 217   // A callback to handle MountCompleted signal.
 218   // The first argument is the error code.
 219   // The second argument is the source path.
 220   // The third argument is the mount type.
 221   // The fourth argument is the mount path.
 222   typedef base::Callback<void(MountError error_code,
 223                               const std::string& source_path,
 224                               MountType mount_type,
 225                               const std::string& mount_path)
 226                          > MountCompletedHandler;
 227
 228   // A callback to handle mount events.
 229   // The first argument is the event type.
 230   // The second argument is the device path.
 231   typedef base::Callback<void(MountEventType event_type,
 232                               const std::string& device_path)
 233                          > MountEventHandler;
 234
 235   virtual ~CrosDisksClient();
 236
 237   // Calls Mount method.  |callback| is called after the method call succeeds,
 238   // otherwise, |error_callback| is called.
 239   // When mounting an archive, caller may set two optional arguments:
 240   // - The |source_format| argument passes the file extension (with the leading
 241   //   dot, for example ".zip"). If |source_format| is empty then the source
 242   //   format is auto-detected.
 243   // - The |mount_label| argument passes an optional mount label to be used as
 244   //   the directory name of the mount point. If |mount_label| is empty, the
 245   //   mount label will be based on the |source_path|.
 246   virtual void Mount(const std::string& source_path,
 247                      const std::string& source_format,
 248                      const std::string& mount_label,
 249                      MountType type,
 250                      const MountCallback& callback,
 251                      const ErrorCallback& error_callback) = 0;
 252
 253   // Calls Unmount method.  |callback| is called after the method call succeeds,
 254   // otherwise, |error_callback| is called.
 255   virtual void Unmount(const std::string& device_path,
 256                        UnmountOptions options,
 257                        const UnmountCallback& callback,
 258                        const UnmountCallback& error_callback) = 0;
 259
 260   // Calls EnumerateAutoMountableDevices method.  |callback| is called after the
 261   // method call succeeds, otherwise, |error_callback| is called.
 262   virtual void EnumerateAutoMountableDevices(
 263       const EnumerateAutoMountableDevicesCallback& callback,
 264       const ErrorCallback& error_callback) = 0;
 265
 266   // Calls FormatDevice method.  |callback| is called after the method call
 267   // succeeds, otherwise, |error_callback| is called.
 268   virtual void FormatDevice(const std::string& device_path,
 269                             const std::string& filesystem,
 270                             const FormatDeviceCallback& callback,
 271                             const ErrorCallback& error_callback) = 0;
 272
 273   // Calls GetDeviceProperties method.  |callback| is called after the method
 274   // call succeeds, otherwise, |error_callback| is called.
 275   virtual void GetDeviceProperties(const std::string& device_path,
 276                                    const GetDevicePropertiesCallback& callback,
 277                                    const ErrorCallback& error_callback) = 0;
 278
 279   // Registers given callback for events.
 280   // |mount_event_handler| is called when mount event signal is received.
 281   // |mount_completed_handler| is called when MountCompleted signal is received.
 282   virtual void SetUpConnections(
 283       const MountEventHandler& mount_event_handler,
 284       const MountCompletedHandler& mount_completed_handler) = 0;
 285
 286   // Factory function, creates a new instance and returns ownership.
 287   // For normal usage, access the singleton via DBusThreadManager::Get().
 288   static CrosDisksClient* Create(DBusClientImplementationType type,
 289                                  dbus::Bus* bus);
 290
 291  protected:
 292   // Create() should be used instead.
 293   CrosDisksClient();
 294
 295  private:
 296   DISALLOW_COPY_AND_ASSIGN(CrosDisksClient);
 297 };
 298
 299 }  // namespace chromeos
 300
 301 #endif  // CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_