sbCDDevice.h

Go to the documentation of this file.

/*
 *=BEGIN SONGBIRD GPL
 *
 * This file is part of the Songbird web player.
 *
 * Copyright(c) 2005-2011 POTI, Inc.
 * http://www.songbirdnest.com
 *
 * This file may be licensed under the terms of of the
 * GNU General Public License Version 2 (the ``GPL'').
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the GPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the GPL along with this
 * program. If not, go to http://www.gnu.org/licenses/gpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *=END SONGBIRD GPL
 */

#ifndef SBCDDEVICE_H_
#define SBCDDEVICE_H_

#include <sbAutoRWLock.h>
#include <sbBaseDevice.h>
#include <sbICDDevice.h>
#include <sbDeviceCapabilities.h>
#include <sbIDeviceProperties.h>
#include <sbITranscodeManager.h>
#include <sbIMetadataLookupManager.h>
#include <sbIMetadataLookupProvider.h>
#include <sbIMetadataLookupData.h>
#include <sbMemoryUtils.h>

#include <nsID.h>
#include <nsIRunnable.h>
#include <nsIThread.h>

class sbIDeviceContent;
class nsIPropertyBag;
class sbIDeviceContent;
class nsIPropertyBag;

//------------------------------------------------------------------------------
//
// Thread support strategy:
//
//   The CD device base services provide support for multi-threaded access
// using a combination of locks and request queues.  Certain CD device object
// fields may only be accessed from the request thread.
//   The CD device base object fields are divided into different categories
// depending upon their access policy.
//
//   Fields within the "not locked" category are created during initialization
// and may be accessed at any time without acquiring a lock.
//
//   Fields within the "connect lock" category must only be accessed within the
// connect lock, mConnectLock.  All of these fields except mConnected are only
// usable when the device is connected.  These fields are initialized during
// device connection and finalized when the device is disconnected.
//   The connect lock is a read/write lock.  Only the Connect and Disconnect
// methods acquire a write lock on the connect lock.  All other methods acquire
// read locks.
//   In order to access the "connect lock" fields, a method must first acquire a
// read lock on the connect lock and check the mConnected field to see if the
// device is connected.  If the device is not connected, the method must release
// the connect lock and not access any other "connect lock" field.  If the
// device is connected, the method may access any "connect lock" field as long
// as it hold the connect lock.
//   Since the connect lock is a read/write lock, acquiring a read lock does not
// lock out other threads from acquiring a read lock.  This allows the request
// thread to maintain a long lived read lock on the connect lock without locking
// out other threads; it only locks out device disconnect.
//   The "connect lock" only ensures that the "connect lock" fields won't be
// finalized from a disconnect.  Some "connect lock" fields may need to be
// protected with another lock to ensure thread safety.
//
//   Fields within the "Request Thread" category may only be accessed from the
// request thread.
//
//   Fields within the "properties lock" category must only be accessed within
// the properties lock.  While the properties object itself may be thread-safe,
// code that reads and conditionally writes properties requires locks (e.g.,
// property udpates).
//
// Connect lock
//
//   mConnected
//   mMountPath
//   mMountURI
//   mReqThread
//   mReqWaitMonitor
//   mDeviceLibrary
//   mCapabilities
//
// Request Thread
//
//   mTranscodeManager
//
// Properties lock
//   mProperties
//   mPrevFriendlyNameInitialized;
//   mPrevFriendlyName;
//   mPrevFriendlyNameExists;
//
// Not locked
//
//   mConnectLock
//   mDeviceID
//   mControllerID
//   mCreationProperties
//   mAbortRequests
//   mIsHandlingRequests
//   mDeviceContent
//   mDeviceSettingsLock
//   mPropertiesLock
//
//------------------------------------------------------------------------------

// Preference keys
#define PREF_CDDEVICE_RIPBRANCH         "songbird.cdrip."
#define PREF_CDDEVICE_AUTOEJECT         "oncomplete.autoeject"
#define PREF_CDDEVICE_NOTIFYSOUND       "oncomplete.notifysound"
#define PREF_CDDEVICE_RIPFORMAT         "format"
#define PREF_CDDEVICE_RIPQUALITY        "quality"

class sbCDDevice : public sbBaseDevice,
                   public sbIJobProgressListener,
                   public nsIClassInfo
{
public:
  //
  // Implemented interfaces.
  //

  NS_DECL_ISUPPORTS
  NS_DECL_SBIDEVICE
  NS_DECL_SBIJOBPROGRESSLISTENER
  NS_DECL_NSICLASSINFO

  sbCDDevice(const nsID & aControllerId,
             nsIPropertyBag *aProperties);

  virtual ~sbCDDevice();

  virtual nsresult InitDevice();

  static nsresult New(const nsID & aControllerId,
                      nsIPropertyBag *aProperties,
                      sbCDDevice **aOutCDDevice);

  virtual PRBool IsRequestAborted();
private:
  PRMonitor* mPropertiesLock;

  PRRWLock* mConnectLock;

  nsCOMPtr<sbITranscodeManager> mTranscodeManager;


  nsID mDeviceID;

  nsID mControllerID;

  nsCOMPtr<sbICDDevice> mCDDevice;

  nsCOMPtr<sbIDeviceLibrary> mDeviceLibrary;

  nsCOMPtr<sbIDeviceCapabilities> mCapabilities;

  nsCOMPtr<nsIPropertyBag> mCreationProperties;

  nsCOMPtr<sbIDeviceProperties> mProperties;

  nsCOMPtr<sbIDeviceContent> mDeviceContent;

  nsString mDeviceLibraryPath;

  nsCOMPtr<sbITranscodeProfile> mTranscodeProfile;
  nsString mTranscodeBitrateStr;

  PRBool mPrefAutoEject;
  PRBool mPrefNotifySound;

  /* Initialize request handler */
  void InitRequestHandler();

  virtual nsresult DeviceSpecificDisconnect();

  nsresult InitializeProperties();

  nsresult CapabilitiesReset();

  nsresult CreateDeviceID(nsID* aDeviceID);

  nsresult Mount(sbBaseDeviceVolume* aVolume);

  nsresult Unmount(sbBaseDeviceVolume* aVolume);

  virtual nsresult ProcessBatch(Batch & aBatch);

  nsresult ReqHandleMount(TransferRequest* aRequest);

  nsresult UpdateDeviceLibrary(sbIDeviceLibrary* aLibrary);

  nsresult GetMediaFiles(nsIArray ** aURIList);

  nsresult GetMediaProperties(nsIArray ** aPropertyList);

  nsresult AttemptCDLookup();

  nsresult CompleteCDLookup(sbIJobProgress *aJob);

  nsresult ReqHandleUpdate(TransferRequest * aRequest);

  void ProxyCDLookup();

  nsresult ShowMetadataLookupDialog(const char *aLookupDialogURI,
                                    nsISimpleEnumerator *aLookupResultsEnum,
                                    PRBool aShouldReportEvents);

  nsresult HandleRipEnd();

  void ProxyHandleRipEnd();

  nsresult QueryUserViewErrors();

  void ProxyQueryUserViewErrors();

  nsresult GetCDDiscHash(sbICDDevice* aCDDevice,
                         nsAString&   aCDDiscHash);

  /* Override base class to get all profiles, not just those we can write to
   * the CD (i.e. none) */
  nsresult GetSupportedTranscodeProfiles(PRUint32 aType,
                                         nsIArray **aSupportedProfiles);

  /* Override base class to avoid popping up read-only dialog box */
  nsresult CheckAccess(sbIDeviceLibrary* aDevLib);

  nsresult GenerateFilename(sbIMediaItem *aItem,
                            nsACString & aOutFilename);

  nsresult ReqHandleRead(TransferRequest * aRequest, PRUint32 aBatchCount);

  nsresult GetBitrateFromProfile(PRUint32 * bitrate);
};

#define SB_CD_DEVICE_AUTO_INVOKE(aName, aMethod)                              \
  SB_AUTO_NULL_CLASS(aName, sbCDDevice*, mValue->aMethod)

#endif /* SBCDDEVICE_H_ */