Home | History | Annotate | Download | only in dbus 
      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_
    299