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