components/storage_monitor/media_transfer_protocol_device_observer_linux.cc

   1 // Copyright 2014 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 #include "components/storage_monitor/media_transfer_protocol_device_observer_linux.h"
   6
   7 #include <vector>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/stl_util.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_split.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "components/storage_monitor/media_storage_util.h"
  15 #include "components/storage_monitor/removable_device_constants.h"
  16 #include "device/media_transfer_protocol/mtp_storage_info.pb.h"
  17
  18 namespace storage_monitor {
  19
  20 namespace {
  21
  22 // Device root path constant.
  23 const char kRootPath[] = "/";
  24
  25 // Constructs and returns the location of the device using the |storage_name|.
  26 std::string GetDeviceLocationFromStorageName(const std::string& storage_name) {
  27   // Construct a dummy device path using the storage name. This is only used
  28   // for registering device media file system.
  29   // E.g.: If the |storage_name| is "usb:2,2:12345" then "/usb:2,2:12345" is the
  30   // device location.
  31   DCHECK(!storage_name.empty());
  32   return kRootPath + storage_name;
  33 }
  34
  35 // Returns the storage identifier of the device from the given |storage_name|.
  36 // E.g. If the |storage_name| is "usb:2,2:65537", the storage identifier is
  37 // "65537".
  38 std::string GetStorageIdFromStorageName(const std::string& storage_name) {
  39   std::vector<std::string> name_parts;
  40   base::SplitString(storage_name, ':', &name_parts);
  41   return name_parts.size() == 3 ? name_parts[2] : std::string();
  42 }
  43
  44 // Returns a unique device id from the given |storage_info|.
  45 std::string GetDeviceIdFromStorageInfo(const MtpStorageInfo& storage_info) {
  46   const std::string storage_id =
  47       GetStorageIdFromStorageName(storage_info.storage_name());
  48   if (storage_id.empty())
  49     return std::string();
  50
  51   // Some devices have multiple data stores. Therefore, include storage id as
  52   // part of unique id along with vendor, model and volume information.
  53   const std::string vendor_id = base::UintToString(storage_info.vendor_id());
  54   const std::string model_id = base::UintToString(storage_info.product_id());
  55   return StorageInfo::MakeDeviceId(
  56       StorageInfo::MTP_OR_PTP,
  57       kVendorModelVolumeStoragePrefix + vendor_id + ":" + model_id + ":" +
  58           storage_info.volume_identifier() + ":" + storage_id);
  59 }
  60
  61 // Returns the |data_store_id| string in the required format.
  62 // If the |data_store_id| is 65537, this function returns " (65537)".
  63 std::string GetFormattedIdString(const std::string& data_store_id) {
  64   return ("(" + data_store_id + ")");
  65 }
  66
  67 // Helper function to get device label from storage information.
  68 base::string16 GetDeviceLabelFromStorageInfo(
  69     const MtpStorageInfo& storage_info) {
  70   std::string device_label;
  71   const std::string& vendor_name = storage_info.vendor();
  72   device_label = vendor_name;
  73
  74   const std::string& product_name = storage_info.product();
  75   if (!product_name.empty()) {
  76     if (!device_label.empty())
  77       device_label += " ";
  78     device_label += product_name;
  79   }
  80
  81   // Add the data store id to the device label.
  82   if (!device_label.empty()) {
  83     const std::string& volume_id = storage_info.volume_identifier();
  84     if (!volume_id.empty()) {
  85       device_label += GetFormattedIdString(volume_id);
  86     } else {
  87       const std::string data_store_id =
  88           GetStorageIdFromStorageName(storage_info.storage_name());
  89       if (!data_store_id.empty())
  90         device_label += GetFormattedIdString(data_store_id);
  91     }
  92   }
  93   return base::UTF8ToUTF16(device_label);
  94 }
  95
  96 // Helper function to get the device storage details such as device id, label
  97 // and location. On success and fills in |id|, |label|, |location|,
  98 // |vendor_name|, and |product_name|.
  99 void GetStorageInfo(const std::string& storage_name,
 100                     device::MediaTransferProtocolManager* mtp_manager,
 101                     std::string* id,
 102                     base::string16* label,
 103                     std::string* location,
 104                     base::string16* vendor_name,
 105                     base::string16* product_name) {
 106   DCHECK(!storage_name.empty());
 107   const MtpStorageInfo* storage_info =
 108       mtp_manager->GetStorageInfo(storage_name);
 109
 110   if (!storage_info)
 111     return;
 112
 113   *id = GetDeviceIdFromStorageInfo(*storage_info);
 114   *label = GetDeviceLabelFromStorageInfo(*storage_info);
 115   *location = GetDeviceLocationFromStorageName(storage_name);
 116   *vendor_name = base::UTF8ToUTF16(storage_info->vendor());
 117   *product_name = base::UTF8ToUTF16(storage_info->product());
 118 }
 119
 120 }  // namespace
 121
 122 MediaTransferProtocolDeviceObserverLinux::
 123 MediaTransferProtocolDeviceObserverLinux(
 124     StorageMonitor::Receiver* receiver,
 125     device::MediaTransferProtocolManager* mtp_manager)
 126     : mtp_manager_(mtp_manager),
 127       get_storage_info_func_(&GetStorageInfo),
 128       notifications_(receiver) {
 129   mtp_manager_->AddObserver(this);
 130   EnumerateStorages();
 131 }
 132
 133 // This constructor is only used by unit tests.
 134 MediaTransferProtocolDeviceObserverLinux::
 135 MediaTransferProtocolDeviceObserverLinux(
 136     StorageMonitor::Receiver* receiver,
 137     device::MediaTransferProtocolManager* mtp_manager,
 138     GetStorageInfoFunc get_storage_info_func)
 139     : mtp_manager_(mtp_manager),
 140       get_storage_info_func_(get_storage_info_func),
 141       notifications_(receiver) {
 142 }
 143
 144 MediaTransferProtocolDeviceObserverLinux::
 145 ~MediaTransferProtocolDeviceObserverLinux() {
 146   mtp_manager_->RemoveObserver(this);
 147 }
 148
 149 bool MediaTransferProtocolDeviceObserverLinux::GetStorageInfoForPath(
 150     const base::FilePath& path,
 151     StorageInfo* storage_info) const {
 152   DCHECK(storage_info);
 153
 154   if (!path.IsAbsolute())
 155     return false;
 156
 157   std::vector<base::FilePath::StringType> path_components;
 158   path.GetComponents(&path_components);
 159   if (path_components.size() < 2)
 160     return false;
 161
 162   // First and second component of the path specifies the device location.
 163   // E.g.: If |path| is "/usb:2,2:65537/DCIM/Folder_a", "/usb:2,2:65537" is the
 164   // device location.
 165   StorageLocationToInfoMap::const_iterator info_it =
 166       storage_map_.find(GetDeviceLocationFromStorageName(path_components[1]));
 167   if (info_it == storage_map_.end())
 168     return false;
 169
 170   *storage_info = info_it->second;
 171   return true;
 172 }
 173
 174 void MediaTransferProtocolDeviceObserverLinux::EjectDevice(
 175     const std::string& device_id,
 176     base::Callback<void(StorageMonitor::EjectStatus)> callback) {
 177   std::string location;
 178   if (!GetLocationForDeviceId(device_id, &location)) {
 179     callback.Run(StorageMonitor::EJECT_NO_SUCH_DEVICE);
 180     return;
 181   }
 182
 183   // TODO(thestig): Change this to tell the mtp manager to eject the device.
 184
 185   StorageChanged(false, location);
 186   callback.Run(StorageMonitor::EJECT_OK);
 187 }
 188
 189 // device::MediaTransferProtocolManager::Observer override.
 190 void MediaTransferProtocolDeviceObserverLinux::StorageChanged(
 191     bool is_attached,
 192     const std::string& storage_name) {
 193   DCHECK(!storage_name.empty());
 194
 195   // New storage is attached.
 196   if (is_attached) {
 197     std::string device_id;
 198     base::string16 storage_label;
 199     std::string location;
 200     base::string16 vendor_name;
 201     base::string16 product_name;
 202     get_storage_info_func_(storage_name, mtp_manager_,
 203                            &device_id, &storage_label, &location,
 204                            &vendor_name, &product_name);
 205
 206     // Keep track of device id and device name to see how often we receive
 207     // empty values.
 208     MediaStorageUtil::RecordDeviceInfoHistogram(false, device_id,
 209                                                 storage_label);
 210     if (device_id.empty() || storage_label.empty())
 211       return;
 212
 213     DCHECK(!ContainsKey(storage_map_, location));
 214
 215     StorageInfo storage_info(device_id, location, storage_label,
 216                              vendor_name, product_name, 0);
 217     storage_map_[location] = storage_info;
 218     notifications_->ProcessAttach(storage_info);
 219   } else {
 220     // Existing storage is detached.
 221     StorageLocationToInfoMap::iterator it =
 222         storage_map_.find(GetDeviceLocationFromStorageName(storage_name));
 223     if (it == storage_map_.end())
 224       return;
 225     notifications_->ProcessDetach(it->second.device_id());
 226     storage_map_.erase(it);
 227   }
 228 }
 229
 230 void MediaTransferProtocolDeviceObserverLinux::EnumerateStorages() {
 231   typedef std::vector<std::string> StorageList;
 232   StorageList storages = mtp_manager_->GetStorages();
 233   for (StorageList::const_iterator storage_iter = storages.begin();
 234        storage_iter != storages.end(); ++storage_iter) {
 235     StorageChanged(true, *storage_iter);
 236   }
 237 }
 238
 239 bool MediaTransferProtocolDeviceObserverLinux::GetLocationForDeviceId(
 240     const std::string& device_id, std::string* location) const {
 241   for (StorageLocationToInfoMap::const_iterator it = storage_map_.begin();
 242        it != storage_map_.end(); ++it) {
 243     if (it->second.device_id() == device_id) {
 244       *location = it->first;
 245       return true;
 246     }
 247   }
 248
 249   return false;
 250 }
 251
 252 }  // namespace storage_monitor