chrome/browser/storage_monitor/image_capture_device_manager.mm

   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 #include "chrome/browser/storage_monitor/image_capture_device_manager.h"
   6
   7 #import <ImageCaptureCore/ImageCaptureCore.h>
   8
   9 #import "chrome/browser/storage_monitor/image_capture_device.h"
  10 #include "chrome/browser/storage_monitor/storage_info.h"
  11 #include "content/public/browser/browser_thread.h"
  12
  13 namespace {
  14
  15 ImageCaptureDeviceManager* g_image_capture_device_manager = NULL;
  16
  17 }  // namespace
  18
  19 // This class is the surface for the Mac ICDeviceBrowser ImageCaptureCore API.
  20 // Owned by the ChromeBrowserParts and has browser process lifetime. Upon
  21 // creation, it gets a list of attached media volumes (asynchronously) which
  22 // it will eventually forward to StorageMonitor. It will also
  23 // set up an ImageCaptureCore listener to be told when new devices/volumes
  24 // are discovered and existing ones are removed.
  25 @interface ImageCaptureDeviceManagerImpl
  26     : NSObject<ICDeviceBrowserDelegate> {
  27  @private
  28   base::scoped_nsobject<ICDeviceBrowser> deviceBrowser_;
  29   base::scoped_nsobject<NSMutableArray> cameras_;
  30
  31   // Guaranteed to outlive this class.
  32   // TODO(gbillock): Update when ownership chains go up through
  33   // a StorageMonitor subclass.
  34   StorageMonitor::Receiver* notifications_;
  35 }
  36
  37 - (void)setNotifications:(StorageMonitor::Receiver*)notifications;
  38 - (void)close;
  39
  40 // The UUIDs passed here are available in the device attach notifications.
  41 // They're gotten by cracking the device ID and taking the unique ID output.
  42 - (ImageCaptureDevice*)deviceForUUID:(const std::string&)uuid;
  43
  44 @end
  45
  46 @implementation ImageCaptureDeviceManagerImpl
  47
  48 - (id)init {
  49   if ((self = [super init])) {
  50     cameras_.reset([[NSMutableArray alloc] init]);
  51     notifications_ = NULL;
  52
  53     deviceBrowser_.reset([[ICDeviceBrowser alloc] init]);
  54     [deviceBrowser_ setDelegate:self];
  55     [deviceBrowser_ setBrowsedDeviceTypeMask:
  56         ICDeviceTypeMaskCamera | ICDeviceLocationTypeMaskLocal];
  57     [deviceBrowser_ start];
  58   }
  59   return self;
  60 }
  61
  62 - (void)setNotifications:(StorageMonitor::Receiver*)notifications {
  63   notifications_ = notifications;
  64 }
  65
  66 - (void)close {
  67   [deviceBrowser_ setDelegate:nil];
  68   [deviceBrowser_ stop];
  69   deviceBrowser_.reset();
  70   cameras_.reset();
  71 }
  72
  73 - (ImageCaptureDevice*) deviceForUUID:(const std::string&)uuid {
  74   for (ICCameraDevice* camera in cameras_.get()) {
  75     NSString* camera_id = [camera UUIDString];
  76     if (base::SysNSStringToUTF8(camera_id) == uuid) {
  77       return [[[ImageCaptureDevice alloc]
  78           initWithCameraDevice:camera] autorelease];
  79     }
  80   }
  81   return nil;
  82 }
  83
  84 - (void)deviceBrowser:(ICDeviceBrowser*)browser
  85          didAddDevice:(ICDevice*)addedDevice
  86            moreComing:(BOOL)moreComing {
  87   if (!(addedDevice.type & ICDeviceTypeCamera))
  88     return;
  89
  90   // Ignore mass storage attaches -- those will be handled
  91   // by Mac's removable storage watcher.
  92   if ([addedDevice.transportType isEqualToString:ICTransportTypeMassStorage])
  93     return;
  94
  95   ICCameraDevice* cameraDevice =
  96       base::mac::ObjCCastStrict<ICCameraDevice>(addedDevice);
  97
  98   [cameras_ addObject:addedDevice];
  99
 100   // TODO(gbillock): use [cameraDevice mountPoint] here when possible.
 101   StorageInfo info(
 102       StorageInfo::MakeDeviceId(
 103           StorageInfo::MAC_IMAGE_CAPTURE,
 104           base::SysNSStringToUTF8([cameraDevice UUIDString])),
 105       base::SysNSStringToUTF16([cameraDevice name]),
 106       "",
 107       base::SysNSStringToUTF16([cameraDevice name]),
 108       base::string16(),
 109       base::string16(),
 110       0);
 111   notifications_->ProcessAttach(info);
 112 }
 113
 114 - (void)deviceBrowser:(ICDeviceBrowser*)browser
 115       didRemoveDevice:(ICDevice*)device
 116             moreGoing:(BOOL)moreGoing {
 117   if (!(device.type & ICDeviceTypeCamera))
 118     return;
 119
 120   std::string uuid = base::SysNSStringToUTF8([device UUIDString]);
 121
 122   // May delete |device|.
 123   [cameras_ removeObject:device];
 124
 125   notifications_->ProcessDetach(
 126       StorageInfo::MakeDeviceId(StorageInfo::MAC_IMAGE_CAPTURE, uuid));
 127 }
 128
 129 @end  // ImageCaptureDeviceManagerImpl
 130
 131 ImageCaptureDeviceManager::ImageCaptureDeviceManager() {
 132   device_browser_.reset([[ImageCaptureDeviceManagerImpl alloc] init]);
 133   g_image_capture_device_manager = this;
 134 }
 135
 136 ImageCaptureDeviceManager::~ImageCaptureDeviceManager() {
 137   g_image_capture_device_manager = NULL;
 138   [device_browser_ close];
 139 }
 140
 141 void ImageCaptureDeviceManager::SetNotifications(
 142     StorageMonitor::Receiver* notifications) {
 143   [device_browser_ setNotifications:notifications];
 144 }
 145
 146 void ImageCaptureDeviceManager::EjectDevice(
 147     const std::string& uuid,
 148     base::Callback<void(StorageMonitor::EjectStatus)> callback) {
 149   base::scoped_nsobject<ImageCaptureDevice> camera_device(
 150       [[device_browser_ deviceForUUID:uuid] retain]);
 151   [camera_device eject];
 152   [camera_device close];
 153   callback.Run(StorageMonitor::EJECT_OK);
 154 }
 155
 156 // static
 157 ImageCaptureDevice* ImageCaptureDeviceManager::deviceForUUID(
 158     const std::string& uuid) {
 159   ImageCaptureDeviceManagerImpl* manager =
 160       g_image_capture_device_manager->device_browser_;
 161   return [manager deviceForUUID:uuid];
 162 }
 163
 164 id<ICDeviceBrowserDelegate> ImageCaptureDeviceManager::device_browser() {
 165   return device_browser_.get();
 166 }