content/browser/device_monitor_mac.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 "content/browser/device_monitor_mac.h"
   6
   7 #import <QTKit/QTKit.h>
   8
   9 #include <set>
  10
  11 #include "base/bind_helpers.h"
  12 #include "base/logging.h"
  13 #include "base/mac/scoped_nsobject.h"
  14 #include "base/threading/thread_checker.h"
  15 #include "content/public/browser/browser_thread.h"
  16 #import "media/video/capture/mac/avfoundation_glue.h"
  17
  18 namespace {
  19
  20 // This class is used to keep track of system devices names and their types.
  21 class DeviceInfo {
  22  public:
  23   enum DeviceType {
  24     kAudio,
  25     kVideo,
  26     kMuxed,
  27     kUnknown,
  28     kInvalid
  29   };
  30
  31   DeviceInfo(std::string unique_id, DeviceType type)
  32       : unique_id_(unique_id), type_(type) {}
  33
  34   // Operator== is needed here to use this class in a std::find. A given
  35   // |unique_id_| always has the same |type_| so for comparison purposes the
  36   // latter can be safely ignored.
  37   bool operator==(const DeviceInfo& device) const {
  38     return unique_id_ == device.unique_id_;
  39   }
  40
  41   const std::string& unique_id() const { return unique_id_; }
  42   DeviceType type() const { return type_; }
  43
  44  private:
  45   std::string unique_id_;
  46   DeviceType type_;
  47   // Allow generated copy constructor and assignment.
  48 };
  49
  50 // Base abstract class used by DeviceMonitorMac to interact with either a QTKit
  51 // or an AVFoundation implementation of events and notifications.
  52 class DeviceMonitorMacImpl {
  53  public:
  54   explicit DeviceMonitorMacImpl(content::DeviceMonitorMac* monitor)
  55       : monitor_(monitor),
  56         cached_devices_(),
  57         device_arrival_(nil),
  58         device_removal_(nil) {
  59     DCHECK(monitor);
  60     // Initialise the devices_cache_ with a not-valid entry. For the case in
  61     // which there is one single device in the system and we get notified when
  62     // it gets removed, this will prevent the system from thinking that no
  63     // devices were added nor removed and not notifying the |monitor_|.
  64     cached_devices_.push_back(DeviceInfo("invalid", DeviceInfo::kInvalid));
  65   }
  66   virtual ~DeviceMonitorMacImpl() {}
  67
  68   virtual void OnDeviceChanged() = 0;
  69
  70   // Method called by the default notification center when a device is removed
  71   // or added to the system. It will compare the |cached_devices_| with the
  72   // current situation, update it, and, if there's an update, signal to
  73   // |monitor_| with the appropriate device type.
  74   void ConsolidateDevicesListAndNotify(
  75       const std::vector<DeviceInfo>& snapshot_devices);
  76
  77  protected:
  78   content::DeviceMonitorMac* monitor_;
  79   std::vector<DeviceInfo> cached_devices_;
  80
  81   // Handles to NSNotificationCenter block observers.
  82   id device_arrival_;
  83   id device_removal_;
  84
  85  private:
  86   DISALLOW_COPY_AND_ASSIGN(DeviceMonitorMacImpl);
  87 };
  88
  89 void DeviceMonitorMacImpl::ConsolidateDevicesListAndNotify(
  90     const std::vector<DeviceInfo>& snapshot_devices) {
  91   bool video_device_added = false;
  92   bool audio_device_added = false;
  93   bool video_device_removed = false;
  94   bool audio_device_removed = false;
  95
  96   // Compare the current system devices snapshot with the ones cached to detect
  97   // additions, present in the former but not in the latter. If we find a device
  98   // in snapshot_devices entry also present in cached_devices, we remove it from
  99   // the latter vector.
 100   std::vector<DeviceInfo>::const_iterator it;
 101   for (it = snapshot_devices.begin(); it != snapshot_devices.end(); ++it) {
 102     std::vector<DeviceInfo>::iterator cached_devices_iterator =
 103         std::find(cached_devices_.begin(), cached_devices_.end(), *it);
 104     if (cached_devices_iterator == cached_devices_.end()) {
 105       video_device_added |= ((it->type() == DeviceInfo::kVideo) ||
 106                              (it->type() == DeviceInfo::kMuxed));
 107       audio_device_added |= ((it->type() == DeviceInfo::kAudio) ||
 108                              (it->type() == DeviceInfo::kMuxed));
 109       DVLOG(1) << "Device has been added, id: " << it->unique_id();
 110     } else {
 111       cached_devices_.erase(cached_devices_iterator);
 112     }
 113   }
 114   // All the remaining entries in cached_devices are removed devices.
 115   for (it = cached_devices_.begin(); it != cached_devices_.end(); ++it) {
 116     video_device_removed |= ((it->type() == DeviceInfo::kVideo) ||
 117                              (it->type() == DeviceInfo::kMuxed) ||
 118                              (it->type() == DeviceInfo::kInvalid));
 119     audio_device_removed |= ((it->type() == DeviceInfo::kAudio) ||
 120                              (it->type() == DeviceInfo::kMuxed) ||
 121                              (it->type() == DeviceInfo::kInvalid));
 122     DVLOG(1) << "Device has been removed, id: " << it->unique_id();
 123   }
 124   // Update the cached devices with the current system snapshot.
 125   cached_devices_ = snapshot_devices;
 126
 127   if (video_device_added || video_device_removed)
 128     monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 129   if (audio_device_added || audio_device_removed)
 130     monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE);
 131 }
 132
 133 class QTKitMonitorImpl : public DeviceMonitorMacImpl {
 134  public:
 135   explicit QTKitMonitorImpl(content::DeviceMonitorMac* monitor);
 136   virtual ~QTKitMonitorImpl();
 137
 138   virtual void OnDeviceChanged() OVERRIDE;
 139  private:
 140   void CountDevices();
 141   void OnAttributeChanged(NSNotification* notification);
 142
 143   id device_change_;
 144 };
 145
 146 QTKitMonitorImpl::QTKitMonitorImpl(content::DeviceMonitorMac* monitor)
 147     : DeviceMonitorMacImpl(monitor) {
 148   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
 149   device_arrival_ =
 150       [nc addObserverForName:QTCaptureDeviceWasConnectedNotification
 151                       object:nil
 152                        queue:nil
 153                   usingBlock:^(NSNotification* notification) {
 154                       OnDeviceChanged();}];
 155   device_removal_ =
 156       [nc addObserverForName:QTCaptureDeviceWasDisconnectedNotification
 157                       object:nil
 158                        queue:nil
 159                   usingBlock:^(NSNotification* notification) {
 160                       OnDeviceChanged();}];
 161   device_change_ =
 162       [nc addObserverForName:QTCaptureDeviceAttributeDidChangeNotification
 163                       object:nil
 164                        queue:nil
 165                   usingBlock:^(NSNotification* notification) {
 166                       OnAttributeChanged(notification);}];
 167 }
 168
 169 QTKitMonitorImpl::~QTKitMonitorImpl() {
 170   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
 171   [nc removeObserver:device_arrival_];
 172   [nc removeObserver:device_removal_];
 173   [nc removeObserver:device_change_];
 174 }
 175
 176 void QTKitMonitorImpl::OnAttributeChanged(
 177     NSNotification* notification) {
 178   if ([[[notification userInfo]
 179          objectForKey:QTCaptureDeviceChangedAttributeKey]
 180       isEqualToString:QTCaptureDeviceSuspendedAttribute]) {
 181     OnDeviceChanged();
 182   }
 183 }
 184
 185 void QTKitMonitorImpl::OnDeviceChanged() {
 186   std::vector<DeviceInfo> snapshot_devices;
 187
 188   NSArray* devices = [QTCaptureDevice inputDevices];
 189   for (QTCaptureDevice* device in devices) {
 190     DeviceInfo::DeviceType device_type = DeviceInfo::kUnknown;
 191     // Act as if suspended video capture devices are not attached.  For
 192     // example, a laptop's internal webcam is suspended when the lid is closed.
 193     if ([device hasMediaType:QTMediaTypeVideo] &&
 194         ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
 195         boolValue]) {
 196       device_type = DeviceInfo::kVideo;
 197     } else if ([device hasMediaType:QTMediaTypeMuxed] &&
 198         ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
 199         boolValue]) {
 200       device_type = DeviceInfo::kMuxed;
 201     } else if ([device hasMediaType:QTMediaTypeSound] &&
 202         ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
 203         boolValue]) {
 204       device_type = DeviceInfo::kAudio;
 205     }
 206     snapshot_devices.push_back(
 207         DeviceInfo([[device uniqueID] UTF8String], device_type));
 208   }
 209   ConsolidateDevicesListAndNotify(snapshot_devices);
 210 }
 211
 212 // Forward declaration for use by CrAVFoundationDeviceObserver.
 213 class SuspendObserverDelegate;
 214
 215 }  // namespace
 216
 217 // This class is a Key-Value Observer (KVO) shim. It is needed because C++
 218 // classes cannot observe Key-Values directly. Created, manipulated, and
 219 // destroyed on the Device Thread by SuspendedObserverDelegate.
 220 @interface CrAVFoundationDeviceObserver : NSObject {
 221  @private
 222   SuspendObserverDelegate* receiver_;  // weak
 223   // Member to keep track of the devices we are already monitoring.
 224   std::set<CrAVCaptureDevice*> monitoredDevices_;
 225 }
 226
 227 - (id)initWithChangeReceiver:(SuspendObserverDelegate*)receiver;
 228 - (void)startObserving:(CrAVCaptureDevice*)device;
 229 - (void)stopObserving:(CrAVCaptureDevice*)device;
 230
 231 @end
 232
 233 namespace {
 234
 235 // This class owns and manages the lifetime of a CrAVFoundationDeviceObserver.
 236 // Provides a callback for this device observer to indicate that there has been
 237 // a device change of some kind. Created by AVFoundationMonitorImpl in UI thread
 238 // but living in Device Thread.
 239 class SuspendObserverDelegate :
 240     public base::RefCountedThreadSafe<SuspendObserverDelegate> {
 241  public:
 242   explicit SuspendObserverDelegate(DeviceMonitorMacImpl* monitor)
 243       : avfoundation_monitor_impl_(monitor) {
 244     device_thread_checker_.DetachFromThread();
 245   }
 246
 247   void OnDeviceChanged();
 248   void StartObserver();
 249   void ResetDeviceMonitorOnUIThread();
 250
 251  private:
 252   friend class base::RefCountedThreadSafe<SuspendObserverDelegate>;
 253
 254   virtual ~SuspendObserverDelegate() {}
 255
 256   void OnDeviceChangedOnUIThread(
 257       const std::vector<DeviceInfo>& snapshot_devices);
 258
 259   base::ThreadChecker device_thread_checker_;
 260   base::scoped_nsobject<CrAVFoundationDeviceObserver> suspend_observer_;
 261   DeviceMonitorMacImpl* avfoundation_monitor_impl_;
 262 };
 263
 264 void SuspendObserverDelegate::OnDeviceChanged() {
 265   DCHECK(device_thread_checker_.CalledOnValidThread());
 266   NSArray* devices = [AVCaptureDeviceGlue devices];
 267   std::vector<DeviceInfo> snapshot_devices;
 268   for (CrAVCaptureDevice* device in devices) {
 269     [suspend_observer_ startObserving:device];
 270     BOOL suspended = [device respondsToSelector:@selector(isSuspended)] &&
 271         [device isSuspended];
 272     DeviceInfo::DeviceType device_type = DeviceInfo::kUnknown;
 273     if ([device hasMediaType:AVFoundationGlue::AVMediaTypeVideo()]) {
 274       if (suspended)
 275         continue;
 276       device_type = DeviceInfo::kVideo;
 277     } else if ([device hasMediaType:AVFoundationGlue::AVMediaTypeMuxed()]) {
 278       device_type = suspended ? DeviceInfo::kAudio : DeviceInfo::kMuxed;
 279     } else if ([device hasMediaType:AVFoundationGlue::AVMediaTypeAudio()]) {
 280       device_type = DeviceInfo::kAudio;
 281     }
 282     snapshot_devices.push_back(DeviceInfo([[device uniqueID] UTF8String],
 283                                           device_type));
 284   }
 285   // Post the consolidation of enumerated devices to be done on UI thread.
 286   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
 287       base::Bind(&SuspendObserverDelegate::OnDeviceChangedOnUIThread,
 288           this, snapshot_devices));
 289 }
 290
 291 void SuspendObserverDelegate::StartObserver() {
 292   DCHECK(device_thread_checker_.CalledOnValidThread());
 293   suspend_observer_.reset([[CrAVFoundationDeviceObserver alloc]
 294                                initWithChangeReceiver:this]);
 295   for (CrAVCaptureDevice* device in [AVCaptureDeviceGlue devices])
 296     [suspend_observer_ startObserving:device];
 297 }
 298
 299 void SuspendObserverDelegate::ResetDeviceMonitorOnUIThread() {
 300   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 301   avfoundation_monitor_impl_ = NULL;
 302 }
 303
 304 void SuspendObserverDelegate::OnDeviceChangedOnUIThread(
 305     const std::vector<DeviceInfo>& snapshot_devices) {
 306   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 307   // |avfoundation_monitor_impl_| might have been NULLed asynchronously before
 308   // arriving at this line.
 309   if (avfoundation_monitor_impl_) {
 310     avfoundation_monitor_impl_->ConsolidateDevicesListAndNotify(
 311         snapshot_devices);
 312   }
 313 }
 314
 315 // AVFoundation implementation of the Mac Device Monitor, registers as a global
 316 // device connect/disconnect observer and plugs suspend/wake up device observers
 317 // per device. Owns a SuspendObserverDelegate living in |device_task_runner_|
 318 // and gets notified when a device is suspended/resumed. This class is created
 319 // and lives in UI thread;
 320 class AVFoundationMonitorImpl : public DeviceMonitorMacImpl {
 321  public:
 322   AVFoundationMonitorImpl(
 323       content::DeviceMonitorMac* monitor,
 324       const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner);
 325   virtual ~AVFoundationMonitorImpl();
 326
 327   virtual void OnDeviceChanged() OVERRIDE;
 328
 329  private:
 330   base::ThreadChecker thread_checker_;
 331
 332   // {Video,AudioInput}DeviceManager's "Device" thread task runner used for
 333   // posting tasks to |suspend_observer_delegate_|; valid after
 334   // MediaStreamManager calls StartMonitoring().
 335   const scoped_refptr<base::SingleThreadTaskRunner> device_task_runner_;
 336
 337   scoped_refptr<SuspendObserverDelegate> suspend_observer_delegate_;
 338
 339   DISALLOW_COPY_AND_ASSIGN(AVFoundationMonitorImpl);
 340 };
 341
 342 AVFoundationMonitorImpl::AVFoundationMonitorImpl(
 343     content::DeviceMonitorMac* monitor,
 344     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner)
 345     : DeviceMonitorMacImpl(monitor),
 346       device_task_runner_(device_task_runner),
 347       suspend_observer_delegate_(new SuspendObserverDelegate(this)) {
 348   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
 349   device_arrival_ =
 350       [nc addObserverForName:AVFoundationGlue::
 351           AVCaptureDeviceWasConnectedNotification()
 352                       object:nil
 353                        queue:nil
 354                   usingBlock:^(NSNotification* notification) {
 355                       OnDeviceChanged();}];
 356   device_removal_ =
 357       [nc addObserverForName:AVFoundationGlue::
 358           AVCaptureDeviceWasDisconnectedNotification()
 359                       object:nil
 360                        queue:nil
 361                   usingBlock:^(NSNotification* notification) {
 362                       OnDeviceChanged();}];
 363   device_task_runner_->PostTask(FROM_HERE,
 364       base::Bind(&SuspendObserverDelegate::StartObserver,
 365                  suspend_observer_delegate_));
 366 }
 367
 368 AVFoundationMonitorImpl::~AVFoundationMonitorImpl() {
 369   DCHECK(thread_checker_.CalledOnValidThread());
 370   suspend_observer_delegate_->ResetDeviceMonitorOnUIThread();
 371   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
 372   [nc removeObserver:device_arrival_];
 373   [nc removeObserver:device_removal_];
 374 }
 375
 376 void AVFoundationMonitorImpl::OnDeviceChanged() {
 377   DCHECK(thread_checker_.CalledOnValidThread());
 378   device_task_runner_->PostTask(FROM_HERE,
 379       base::Bind(&SuspendObserverDelegate::OnDeviceChanged,
 380                  suspend_observer_delegate_));
 381 }
 382
 383 }  // namespace
 384
 385 @implementation CrAVFoundationDeviceObserver
 386
 387 - (id)initWithChangeReceiver:(SuspendObserverDelegate*)receiver {
 388   if ((self = [super init])) {
 389     DCHECK(receiver != NULL);
 390     receiver_ = receiver;
 391   }
 392   return self;
 393 }
 394
 395 - (void)dealloc {
 396   std::set<CrAVCaptureDevice*>::iterator it = monitoredDevices_.begin();
 397   while (it != monitoredDevices_.end())
 398     [self stopObserving:*it++];
 399   [super dealloc];
 400 }
 401
 402 - (void)startObserving:(CrAVCaptureDevice*)device {
 403   DCHECK(device != nil);
 404   // Skip this device if there are already observers connected to it.
 405   if (std::find(monitoredDevices_.begin(), monitoredDevices_.end(), device) !=
 406           monitoredDevices_.end()) {
 407     return;
 408   }
 409   [device addObserver:self
 410            forKeyPath:@"suspended"
 411               options:0
 412               context:device];
 413   [device addObserver:self
 414            forKeyPath:@"connected"
 415               options:0
 416               context:device];
 417   monitoredDevices_.insert(device);
 418 }
 419
 420 - (void)stopObserving:(CrAVCaptureDevice*)device {
 421   DCHECK(device != nil);
 422   std::set<CrAVCaptureDevice*>::iterator found =
 423       std::find(monitoredDevices_.begin(), monitoredDevices_.end(), device);
 424   DCHECK(found != monitoredDevices_.end());
 425   // Every so seldom, |device| might be gone when getting here, in that case
 426   // removing the observer causes a crash. Try to avoid it by checking sanity of
 427   // the |device| via its -observationInfo. http://crbug.com/371271.
 428   if ([device observationInfo]) {
 429     [device removeObserver:self
 430                 forKeyPath:@"suspended"];
 431     [device removeObserver:self
 432                 forKeyPath:@"connected"];
 433   }
 434   monitoredDevices_.erase(found);
 435 }
 436
 437 - (void)observeValueForKeyPath:(NSString*)keyPath
 438                       ofObject:(id)object
 439                         change:(NSDictionary*)change
 440                        context:(void*)context {
 441   if ([keyPath isEqual:@"suspended"])
 442     receiver_->OnDeviceChanged();
 443   if ([keyPath isEqual:@"connected"])
 444     [self stopObserving:static_cast<CrAVCaptureDevice*>(context)];
 445 }
 446
 447 @end  // @implementation CrAVFoundationDeviceObserver
 448
 449 namespace content {
 450
 451 DeviceMonitorMac::DeviceMonitorMac() {
 452   // Both QTKit and AVFoundation do not need to be fired up until the user
 453   // exercises a GetUserMedia. Bringing up either library and enumerating the
 454   // devices in the system is an operation taking in the range of hundred of ms,
 455   // so it is triggered explicitly from MediaStreamManager::StartMonitoring().
 456 }
 457
 458 DeviceMonitorMac::~DeviceMonitorMac() {}
 459
 460 void DeviceMonitorMac::StartMonitoring(
 461     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner) {
 462   DCHECK(thread_checker_.CalledOnValidThread());
 463   if (AVFoundationGlue::IsAVFoundationSupported()) {
 464     DVLOG(1) << "Monitoring via AVFoundation";
 465     device_monitor_impl_.reset(new AVFoundationMonitorImpl(this,
 466                                                            device_task_runner));
 467   } else {
 468     DVLOG(1) << "Monitoring via QTKit";
 469     device_monitor_impl_.reset(new QTKitMonitorImpl(this));
 470   }
 471 }
 472
 473 void DeviceMonitorMac::NotifyDeviceChanged(
 474     base::SystemMonitor::DeviceType type) {
 475   DCHECK(thread_checker_.CalledOnValidThread());
 476   // TODO(xians): Remove the global variable for SystemMonitor.
 477   base::SystemMonitor::Get()->ProcessDevicesChanged(type);
 478 }
 479
 480 }  // namespace content