sbBaseDevice.h

Go to the documentation of this file.

/* vim: set sw=2 :miv */
/*
 *=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 __SBBASEDEVICE__H__
#define __SBBASEDEVICE__H__

#include <algorithm>
#include <list>
#include <map>
#include <vector>

#include "sbIDevice.h"
#include "sbBaseDeviceEventTarget.h"
#include "sbBaseDeviceVolume.h"
#include "sbDeviceLibrary.h"

#include <nsArrayUtils.h>
#include <nsAutoPtr.h>
#include <nsClassHashtable.h>
#include <nsCOMPtr.h>
#include <nsCOMArray.h>
#include <nsDataHashtable.h>
#include <nsIRunnable.h>
#include <nsISupportsImpl.h>
#include <nsITimer.h>
#include <nsIFile.h>
#include <nsIURL.h>
#include <nsTArray.h>

#include <sbAutoRWLock.h>
#include <sbILibraryChangeset.h>
#include <sbIMediaItem.h>
#include <sbIMediaList.h>
#include "sbRequestItem.h"
#include "sbDeviceRequestThreadQueue.h"
#include <sbITemporaryFileFactory.h>
#include <sbITranscodeManager.h>

#include <sbMemoryUtils.h>
#include <nsComponentManagerUtils.h>

#include "sbDeviceStatistics.h"

class nsIArray;
class nsIMutableArray;
class nsIPrefBranch;

class sbAutoIgnoreWatchFolderPath;
class sbBaseDeviceLibraryListener;
class sbDeviceBaseLibraryCopyListener;
class sbDeviceStatusHelper;
class sbDeviceSupportsItemHelper;
class sbDeviceTranscoding;
class sbDeviceImages;
class sbBaseDeviceMediaListListener;
class sbIDeviceInfoRegistrar;
class sbIDeviceLibrary;
class sbITranscodeProfile;
class sbITranscodeAlbumArt;
class sbIMediaFormat;

// Device property XML namespace.
#define SB_DEVICE_PROPERTY_NS "http://songbirdnest.com/device/1.0"

#define SB_SYNC_PARTNER_PREF NS_LITERAL_STRING("SyncPartner")

class NS_HIDDEN sbBaseDevice : public sbIDevice,
                               public sbBaseDeviceEventTarget
{
public:
  // Friend declarations for classes used to divide up device work
  friend class sbDeviceTranscoding;
  friend class sbDeviceImages;
  friend class sbBaseDeviceVolume;
  friend class sbDeviceRequestThreadQueue;
  friend class sbDevieEnsureSpaceForWrite;

  typedef sbRequestThreadQueue::Batch Batch;

  struct TransferRequest : public sbRequestItem {
    /* types of requests. not all types necessarily apply to all types of
     * devices, and devices may have custom types.
     * Request types that should result in delaying shutdown (e.g. writing to
     * the device) should have the write flag set.
     * The specific device may internally define more request types.
     */

    static const int REQUEST_FLAG_USER  = sbIDevice::REQUEST_FLAG_USER;
    static const int REQUEST_FLAG_WRITE = sbIDevice::REQUEST_FLAG_WRITE;

    /* note that type 0 is reserved */
    enum {
      /* read requests */
      REQUEST_MOUNT         = sbIDevice::REQUEST_MOUNT,
      REQUEST_READ          = sbIDevice::REQUEST_READ,
      REQUEST_EJECT         = sbIDevice::REQUEST_EJECT,
      REQUEST_SUSPEND       = sbIDevice::REQUEST_SUSPEND,

      /* write requests */
      REQUEST_WRITE         = sbIDevice::REQUEST_WRITE,
      REQUEST_DELETE        = sbIDevice::REQUEST_DELETE,
      REQUEST_SYNC          = sbIDevice::REQUEST_SYNC,
      REQUEST_IMAGESYNC     = sbIDevice::REQUEST_IMAGESYNC,
      REQUEST_WRITE_FILE    = sbIDevice::REQUEST_WRITE_FILE,
      REQUEST_DELETE_FILE   = sbIDevice::REQUEST_DELETE_FILE,
      /* delete all files */
      REQUEST_WIPE          = sbIDevice::REQUEST_WIPE,
      /* move an item in one playlist */
      REQUEST_MOVE          = sbIDevice::REQUEST_MOVE,
      REQUEST_UPDATE        = sbIDevice::REQUEST_UPDATE,
      REQUEST_NEW_PLAYLIST  = sbIDevice::REQUEST_NEW_PLAYLIST,
      REQUEST_FORMAT        = sbIDevice::REQUEST_FORMAT,
      REQUEST_SYNC_COMPLETE = sbIDevice::REQUEST_SYNC_COMPLETE
    };

    enum {
      REQUESTBATCH_UNKNOWN       = 0,
      REQUESTBATCH_AUDIO         = 1,
      REQUESTBATCH_VIDEO         = 2,
      REQUESTBATCH_IMAGE         = 4
    };

    nsCOMPtr<sbIMediaItem> item;     /* the item this request pertains to */
    nsCOMPtr<sbIMediaList> list;     /* the list this request is to act on */
    nsCOMPtr<nsISupports>  data;     /* optional data that may or may not be used by a type of request */
    sbITranscodeProfile * transcodeProfile; /* Transcode profile to use if available
                                               this is manually ref counted so
                                               we don't have all of our consumers
                                               have to include the transcode profile
                                               directory */
    PRUint32 index;                  /* the index in the list for this action */
    PRUint32 otherIndex;             /* any secondary index needed */

    PRUint32 itemType;               /* Item type: Audio, Video... */

    /* Write request fields. */
    PRBool contentSrcSet;            /* if true, the content source URI for the
                                        destination item has been set */
    PRBool destinationMediaPresent;  /* if true, the destination media is
                                        present on the device (e.g., it's been
                                        copied or transcoded to the device) */
    /* This determines how much this item will be transferred onto the device */
    typedef enum {
      COMPAT_UNSUPPORTED,            /* this item cannot be transferred */
      COMPAT_SUPPORTED,              /* this item is directly supported on the device */
      COMPAT_NEEDS_TRANSCODING       /* this item needs to be transcoded */
    } CompatibilityType;
    CompatibilityType destinationCompatibility;
    PRBool transcoded;               /* if true, write item media was
                                        transcoded */
    nsCOMPtr<sbITranscodeAlbumArt> albumArt; /* Album art transcoding object,
                                                or null if no album art
                                                transcoding should be done */
    /* Factory for creating temporary files.  All temporary files are removed
       when factory is destroyed. */
    nsCOMPtr<sbITemporaryFileFactory> temporaryFileFactory;

    nsCOMPtr<nsIFile> downloadedFile; /* used if request item content source had
                                         to be downloaded */

    PRBool IsPlaylist() const;

    PRBool IsCountable() const;

    static TransferRequest * New(PRUint32 aType,
                                 sbIMediaItem * aItem,
                                 sbIMediaList * aList,
                                 PRUint32 aIndex,
                                 PRUint32 aOtherIndex,
                                 nsISupports * aData);

    /* Don't allow manual construction/destruction, but allow sub-classing. */
  protected:
    TransferRequest();

    ~TransferRequest(); /* we're refcounted, no manual deleting! */
  };

public:
  /* selected methods from sbIDevice */
  NS_IMETHOD Connect();
  NS_IMETHOD Disconnect();
  NS_IMETHOD GetPreference(const nsAString & aPrefName, nsIVariant **_retval);
  NS_IMETHOD SetPreference(const nsAString & aPrefName, nsIVariant *aPrefValue);
  NS_IMETHOD GetIsDirectTranscoding(PRBool *aIsDirect);
  NS_IMETHOD GetIsBusy(PRBool *aIsBusy);
  NS_IMETHOD GetCanDisconnect(PRBool *aCanDisconnect);
  NS_IMETHOD GetState(PRUint32 *aState);
  NS_IMETHOD SetState(PRUint32 aState);
  NS_IMETHOD GetPreviousState(PRUint32 *aState);
  NS_IMETHOD SyncLibraries(void);
  NS_IMETHOD Eject(void);
  NS_IMETHOD Format(void);
  NS_IMETHOD GetSupportsReformat(PRBool *_retval);
  NS_IMETHOD SupportsMediaItem(sbIMediaItem*                  aMediaItem,
                               sbIDeviceSupportsItemCallback* aCallback);
  NS_IMETHOD GetDefaultLibrary(sbIDeviceLibrary** aDefaultLibrary);
  NS_IMETHOD SetDefaultLibrary(sbIDeviceLibrary* aDefaultLibrary);
  NS_IMETHOD GetPrimaryLibrary(sbIDeviceLibrary** aPrimaryLibrary);
  NS_IMETHOD SubmitRequest(PRUint32 aRequest,
                           nsIPropertyBag2 *aRequestParameters);
  NS_IMETHOD CancelRequests();

  NS_IMETHOD ImportFromDevice(sbILibrary * aImportToLibrary,
                              sbILibraryChangeset * aImportChangeset);

  NS_IMETHOD ExportToDevice(sbIDeviceLibrary*    aDevLibrary,
                            sbILibraryChangeset* aChangeset);

public:

  sbBaseDevice();
  virtual ~sbBaseDevice();

  nsresult  PushRequest(const PRUint32 aType,
                        sbIMediaItem* aItem = nsnull,
                        sbIMediaList* aList = nsnull,
                        PRUint32 aIndex = PR_UINT32_MAX,
                        PRUint32 aOtherIndex = PR_UINT32_MAX,
                        nsISupports * aData = nsnull);

  nsresult BatchBegin();

  nsresult BatchEnd();
  nsresult ClearRequests();

  nsresult GetRequestTemporaryFileFactory
             (TransferRequest*          aRequest,
              sbITemporaryFileFactory** aTemporaryFileFactory);

  nsresult DownloadRequestItem(TransferRequest*       aRequest,
                               PRUint32               aBatchCount,
                               sbDeviceStatusHelper*  aDeviceStatusHelper);

  nsresult SetPreferenceInternal(nsIPrefBranch*   aPrefBranch,
                                 const nsAString& aPrefName,
                                 nsIVariant*      aPrefValue,
                                 PRBool*          aHasChanged);

  nsresult HasPreference(nsAString& aPrefName,
                         PRBool*    aHasPreference);

  virtual nsresult ProcessBatch(Batch & aBatch) = 0;

  nsresult SetPreviousState(PRUint32 aState);

  nsresult CreateDeviceLibrary(const nsAString& aId,
                               nsIURI* aLibraryLocation,
                               sbIDeviceLibrary** _retval);

  nsresult InitializeDeviceLibrary(sbDeviceLibrary* aDevLib,
                                   const nsAString& aId,
                                   nsIURI*          aLibraryLocation);

  nsresult InitializeDeviceLibraryPreferences(sbDeviceLibrary* aDevLib);

  void FinalizeDeviceLibrary(sbIDeviceLibrary* aDevLib);

  nsresult AddLibrary(sbIDeviceLibrary* aDevLib);

  virtual nsresult CheckAccess(sbIDeviceLibrary* aDevLib);

  nsresult RemoveLibrary(sbIDeviceLibrary* aDevLib);

  nsresult UpdateLibraryProperty(sbILibrary*      aLibrary,
                                 const nsAString& aPropertyID,
                                 const nsAString& aPropertyValue);

  nsresult UpdateDefaultLibrary(sbIDeviceLibrary* aDevLib);

  virtual nsresult OnDefaultLibraryChanged();

  nsresult ListenToList(sbIMediaList* aList);

  typedef struct {
    sbBaseDevice*        device;
    nsCOMPtr<sbILibrary> library;
  } EnumerateFinalizeMediaListListenersInfo;

  static NS_HIDDEN_(PLDHashOperator)
           EnumerateFinalizeMediaListListeners
            (nsISupports* aKey,
             nsRefPtr<sbBaseDeviceMediaListListener>& aData,
             void* aClosure);

  static NS_HIDDEN_(PLDHashOperator) EnumerateIgnoreMediaListListeners(nsISupports* aKey,
                                                                       nsRefPtr<sbBaseDeviceMediaListListener> aData,
                                                                       void* aClosure);

  nsresult SetIgnoreMediaListListeners(PRBool aIgnoreListener);

  nsresult SetIgnoreLibraryListener(PRBool aIgnoreListener);

  nsresult SetMediaListsHidden(sbIMediaList *aLibrary, PRBool aHidden);

  nsresult IgnoreMediaItem(sbIMediaItem * aItem);

  nsresult UnignoreMediaItem(sbIMediaItem * aItem);

  nsresult DeleteItem(sbIMediaList *aLibrary, sbIMediaItem *aItem);

  virtual nsresult GetItemContentType(sbIMediaItem* aMediaItem,
                                      PRUint32*     aContentType);

  nsresult UpdateOriginAndContentSrc(TransferRequest* aRequest,
                                     nsIURI*          aURI);

  nsresult CreateTransferRequest(PRUint32 aRequestType,
                                 nsIPropertyBag2 *aRequestParameters,
                                 TransferRequest **aTransferRequest);

  nsresult CreateAndDispatchEvent(PRUint32 aType,
                                  nsIVariant *aData,
                                  PRBool aAsync = PR_TRUE,
                                  sbIDeviceEventTarget* aTarget = nsnull);

  nsresult CreateAndDispatchDeviceManagerEvent(PRUint32 aType,
                                               nsIVariant *aData,
                                               PRBool aAsync = PR_TRUE);

  nsresult RegenerateMediaURL(sbIMediaItem *aItem, nsIURI **_retval);

  virtual nsresult GenerateFilename(sbIMediaItem * aItem,
                                    nsACString & aFilename);

  nsresult CreateUniqueMediaFile(nsIURI  *aFileURI,
                                 nsIFile **aUniqueFile,
                                 nsIURI  **aUniqueFileURI);

  nsresult ReqProcessingStart();

  nsresult ReqProcessingStop(nsIRunnable * aShutdownAction);

  bool CheckAndResetRequestAbort();
  bool GetEnsureSpaceChecked() const {
    return mEnsureSpaceChecked;
  }

  void SetEnsureSpaceChecked(bool aChecked) {
    mEnsureSpaceChecked = aChecked;
  }

  NS_SCRIPTABLE NS_IMETHOD SetWarningDialogEnabled(const nsAString & aWarning, PRBool aEnabled);
  NS_SCRIPTABLE NS_IMETHOD GetWarningDialogEnabled(const nsAString & aWarning, PRBool *_retval);
  NS_SCRIPTABLE NS_IMETHOD ResetWarningDialogs(void);
  NS_SCRIPTABLE NS_IMETHOD OpenInputStream(nsIURI*          aURI,
                                           nsIInputStream** retval);

  virtual PRBool IsRequestAborted();

  sbDeviceTranscoding * GetDeviceTranscoding() const {
    return mDeviceTranscoding;
  }
  PRLock * StateLock() {
    return mStateLock;
  }
  PRUint32 GetDeviceState() {
    return mState;
  }

  sbDeviceImages* GetDeviceImages() const {
    return mDeviceImages;
  }

protected:
  friend class sbBaseDeviceInitHelper;
  friend class sbDeviceEnsureSpaceForWrite;
  friend class sbDeviceStatistics;
  friend class sbDeviceReqAddedEvent;
  nsresult Init();
  virtual nsresult InitDevice() { return NS_OK; }

  virtual nsresult ChangeState(PRUint32 aState);

private:
  virtual nsresult DeviceSpecificDisconnect() = 0;
  nsresult GetFirstRequest(bool aRemove, TransferRequest** _retval);
protected:


  PRLock *mStateLock;
  PRUint32 mState;
  PRLock *mPreviousStateLock;
  PRUint32 mPreviousState;
  PRInt32 mIgnoreMediaListCount; // Allows us to know if we're ignoring lists
  PRUint32 mPerTrackOverhead; // estimated bytes of overhead per track
  nsAutoPtr<sbDeviceStatusHelper> mStatus;

  nsCOMPtr<sbIDeviceLibrary> mDefaultLibrary;
  nsCOMPtr<sbILibrary> mMainLibrary;
  nsRefPtr<sbBaseDeviceLibraryListener> mLibraryListener;
  nsRefPtr<sbDeviceBaseLibraryCopyListener> mLibraryCopyListener;
  nsDataHashtableMT<nsISupportsHashKey, nsRefPtr<sbBaseDeviceMediaListListener> > mMediaListListeners;
  nsCOMPtr<sbIDeviceInfoRegistrar> mInfoRegistrar;
  PRUint32 mInfoRegistrarType;
  nsCOMPtr<sbIDeviceCapabilities> mCapabilities;
  PRLock*  mPreferenceLock;
  PRUint32 mMusicLimitPercent;
  sbDeviceTranscoding * mDeviceTranscoding;
  sbDeviceImages *mDeviceImages;

  enum {
    CAN_TRANSCODE_UNKNOWN = 0,
    CAN_TRANSCODE_YES = 1,
    CAN_TRANSCODE_NO = 2
  };
  PRUint32 mCanTranscodeAudio;
  PRUint32 mCanTranscodeVideo;

  // This is a hack so that the UI has the information of what kind of media
  // the set of sync changes contains. TODO: XXX we should look at replacing
  // this at some point.
  PRUint32 mSyncType;

  bool mEnsureSpaceChecked;

  //
  //   mConnectLock             Connect lock.
  //   mConnected               True if device is connected.
  //   mDeferredSetupDeviceTimer Timer used to defer presentation of the device
  //                             setup dialog.
  //   mRequestThreadQueue      This contains the logic to process requests
  //                            for the device thread

  PRRWLock* mConnectLock;
  PRBool mConnected;
  nsCOMPtr<nsITimer> mDeferredSetupDeviceTimer;
  nsRefPtr<sbDeviceRequestThreadQueue> mRequestThreadQueue;

  // cache data for media management preferences
  struct OrganizeData {
    PRBool    organizeEnabled;
    nsCString dirFormat;
    nsCString fileFormat;
    OrganizeData() : organizeEnabled(PR_FALSE) {}
  };
  nsClassHashtableMT<nsIDHashKey, OrganizeData> mOrganizeLibraryPrefs;

  nsClassHashtable<nsUint32HashKey, nsString> mMediaFolderURLTable;

  static const PRUint32 DEFAULT_PER_TRACK_OVERHEAD = 10000;

  static const PRUint32 SYNC_PLAYLIST_AVAILABLE_PCT = 95;

  static const PRUint32 DEFER_DEVICE_SETUP_DELAY = 2000;

  nsresult EnsureSpaceForWrite(sbILibraryChangeset* aChangeset,
                               sbIDeviceLibrary* aDevLibrary);

  nsresult WaitForBatchEnd();

  static void WaitForBatchEndCallback(nsITimer* aTimer,
                                      void* aClosure);

  void WaitForBatchEndCallback();

  nsresult GetMusicFreeSpace(sbILibrary* aLibrary,
                             PRInt64*    aFreeMusicSpace);

  nsresult GetMusicAvailableSpace(sbILibrary* aLibrary,
                                  PRInt64*    aMusicAvailableSpace);

  nsresult SupportsMediaItem(sbIMediaItem*                  aMediaItem,
                             sbDeviceSupportsItemHelper*    aCallback,
                             PRBool                         aReportErrors,
                             PRBool*                        _retval);

  nsDataHashtableMT<nsStringHashKey, PRBool> mTrackSourceTable;

  nsresult UpdateStreamingItemSupported(Batch & aBatch);

  friend class sbDeviceSupportsItemHelper;

  virtual nsresult SupportsMediaItemDRM(sbIMediaItem* aMediaItem,
                                        PRBool        aReportErrors,
                                        PRBool*       _retval);

  //----------------------------------------------------------------------------
  //
  // Device volume services.
  //
  //----------------------------------------------------------------------------

  //
  //   mVolumeLock              Volume lock.
  //   mVolumeList              List of volumes.
  //   mVolumeGUIDTable         Table mapping volume GUIDs to volumes.
  //   mVolumeLibraryGUIDTable  Table mapping library GUIDs to volumes.
  //   mPrimaryVolume           Primary volume (usually internal storage).
  //   mDefaultVolume           Default volume when none specified.
  //

  PRLock*                                    mVolumeLock;
  nsTArray< nsRefPtr<sbBaseDeviceVolume> >   mVolumeList;
  nsInterfaceHashtableMT<nsStringHashKey,
                         sbBaseDeviceVolume> mVolumeGUIDTable;
  nsInterfaceHashtableMT<nsStringHashKey,
                         sbBaseDeviceVolume> mVolumeLibraryGUIDTable;
  nsRefPtr<sbBaseDeviceVolume>               mPrimaryVolume;
  nsRefPtr<sbBaseDeviceVolume>               mDefaultVolume;

  nsresult AddVolume(sbBaseDeviceVolume* aVolume);

  nsresult RemoveVolume(sbBaseDeviceVolume* aVolume);

  nsresult GetVolumeForItem(sbIMediaItem*        aItem,
                            sbBaseDeviceVolume** aVolume);

  //----------------------------------------------------------------------------
  //
  // Device settings services.
  //
  //----------------------------------------------------------------------------

  virtual nsresult GetDeviceSettingsDocument
                     (class nsIDOMDocument** aDeviceSettingsDocument);

  nsresult GetDeviceSettingsDocument
             (nsIFile*               aDeviceSettingsFile,
              class nsIDOMDocument** aDeviceSettingsDocument);

  nsresult GetDeviceSettingsDocument
             (nsTArray<PRUint8>&     aDeviceSettingsContent,
              class nsIDOMDocument** aDeviceSettingsDocument);
  virtual nsresult ApplyDeviceSettingsDocument();

  virtual nsresult ApplyDeviceSettings
                     (class nsIDOMDocument* aDeviceSettingsDocument);

  nsresult ApplyDeviceSettingsToProperty
             (class nsIDOMDocument*  aDeviceSettingsDocument,
              const nsAString&       aPropertyName);

  virtual nsresult ApplyDeviceSettingsToProperty
                     (const nsAString& aPropertyName,
                      nsIVariant*      aPropertyValue);

  nsresult ApplyDeviceSettingsDeviceInfo
             (class nsIDOMDocument* aDeviceSettingsDocument);

  nsresult ApplyDeviceSettingsToCapabilities
            (class nsIDOMDocument* aDeviceSettingsDocument);


  //----------------------------------------------------------------------------
  //
  // Device properties services.
  //
  //----------------------------------------------------------------------------

  virtual nsresult InitializeProperties();

  virtual nsresult UpdateProperties();

  virtual nsresult UpdateProperty(const nsAString& aName);

  virtual nsresult UpdateStatisticsProperties();

  nsresult UpdateVolumeNames();

  virtual nsresult UpdateVolumeName(sbBaseDeviceVolume* aVolume);


  //----------------------------------------------------------------------------
  //
  // Device preference services.
  //
  //----------------------------------------------------------------------------

  /* get the prefbranch root for this device */
  nsresult GetPrefBranchRoot(nsACString& aRoot);

  /* get a prefbranch for this device */
  nsresult GetPrefBranch(nsIPrefBranch** aPrefBranch);

  /* get a prefbranch for a device library */
  nsresult GetPrefBranch(sbIDeviceLibrary* aLibrary,
                         nsIPrefBranch**   aPrefBranch);

  /* Helper function to get a particular pref branch */
  nsresult GetPrefBranch(const char *aPrefBranchName,
                         nsIPrefBranch** aPrefBranch);

  /* Get a preference from a specific pref branch */
  nsresult GetPreferenceInternal(nsIPrefBranch *aPrefBranch,
                                 const nsAString & aPrefName,
                                 nsIVariant **_retval);

  /* Set a preference on a specific pref branch */
  nsresult SetPreferenceInternal(nsIPrefBranch *aPrefBranch,
                                 const nsAString & aPrefName,
                                 nsIVariant *aPrefValue);

  /* Set a preference, not sending an event if the preference changed */
  nsresult SetPreferenceInternalNoNotify(const nsAString & aPrefName,
                                         nsIVariant *aPrefValue,
                                         PRBool *aPrefChanged);


  virtual nsresult ApplyPreference(const nsAString& aPrefName,
                                   nsIVariant*      aPrefValue);

  PRBool GetIsLibraryPreference(const nsAString& aPrefName);

  nsresult GetPreferenceLibrary(const nsAString&   aPrefName,
                                sbIDeviceLibrary** aLibrary,
                                nsAString&         aLibraryPrefBase);

  nsresult GetLibraryPreference(sbIDeviceLibrary* aLibrary,
                                const nsAString&  aLibraryPrefName,
                                nsIVariant**      aPrefValue);

  nsresult GetLibraryPreference(const nsAString& aLibraryPrefBase,
                                const nsAString& aLibraryPrefName,
                                nsIVariant**     aPrefValue);

  virtual nsresult ApplyLibraryPreference(sbIDeviceLibrary* aLibrary,
                                          const nsAString&  aLibraryPrefName,
                                          nsIVariant*       aPrefValue);

  virtual nsresult ApplyLibraryOrganizePreference(sbIDeviceLibrary* aLibrary,
                                                  const nsAString&  aLibraryPrefName,
                                                  const nsAString&  aLibraryPrefBase,
                                                  nsIVariant*       aPrefValue);

  nsresult GetLibraryPreferenceName(const nsAString& aPrefName,
                                    nsAString&       aLibraryPrefName);

  nsresult GetLibraryPreferenceName(const nsAString&  aPrefName,
                                    const nsAString&  aLibraryPrefBase,
                                    nsAString&        aLibraryPrefName);

  nsresult GetLibraryPreferenceBase(sbIDeviceLibrary* aLibrary,
                                    nsAString&        aPrefBase);

  nsresult GetCapabilitiesPreference(nsIVariant** aCapabilities);

  nsresult GetLocalDeviceDir(nsIFile** aLocalDeviceDir);


  //----------------------------------------------------------------------------
  //
  // Device sync services.
  //
  //----------------------------------------------------------------------------

  nsresult SendSyncCompleteRequest();

  nsresult HandleSyncRequest(TransferRequest* aRequest);

  nsresult HandleSyncCompletedRequest(TransferRequest* aRequest);

  nsresult EnsureSpaceForSync(sbILibraryChangeset* aChangeset,
                              PRBool*              aCapacityExceeded,
                              PRBool*              aAbort);

  nsresult SyncCreateAndSyncToList
             (sbILibrary*                                   aSrcLib,
              sbIDeviceLibrary*                             aDstLib,
              PRInt64                                       aAvailableSpace);

  nsresult SyncCreateSyncMediaList(sbILibrary*       aSrcLib,
                                   sbIDeviceLibrary* aDstLib,
                                   PRInt64           aAvailableSpace,
                                   sbIMediaList**    aSyncMediaList);

  nsresult SyncToMediaList(sbIDeviceLibrary* aDstLib,
                           sbIMediaList*     aMediaList);

  PRInt64 GetChangeSize(sbIDeviceLibrary * aDestLibrary,
                        sbILibraryChange * aChange);
  nsresult SyncGetSyncItemSizes(sbIDeviceLibrary * aDestLibrary,
                                sbILibraryChangeset* aChangeset,
                                PRInt64 aAvailableSpace,
                                PRUint32& aLastChangeThatFit,
                                PRInt64& aTotalSyncSize);

  nsresult SyncGetSyncAvailableSpace(sbILibrary* aLibrary,
                                     PRInt64*    aAvailableSpace);

  nsresult SyncProduceChangeset(TransferRequest*      aRequest,
                                sbILibraryChangeset** aExportChangeset,
                                sbILibraryChangeset** aImportChangeset);

  nsresult SyncMainLibraryFlag(sbIMediaItem * aMediaItem);

  nsresult PromptForEjectDuringPlayback(PRBool* aEject);

  virtual nsresult UpdateMediaFolders();

  nsresult GetDeviceWriteDestURI(sbIMediaItem* aWriteDstItem,
                                 nsIURI*       aContentSrcBaseURI,
                                 nsIURI*       aWriteSrcURI,
                                 nsIURI **     aDestinationURI);

  nsresult ListenToMediaLists(sbILibrary * aLibrary);

  nsresult SetupDevice();

  static void DeferredSetupDevice(nsITimer* aTimer,
                                  void*     aClosure);

  nsresult DeferredSetupDevice();

  nsresult RegisterDeviceInfo();
  nsresult RegisterDeviceCapabilities(sbIDeviceCapabilities * aCapabilities);

  nsresult ProcessInfoRegistrars();

   virtual nsresult GetSupportedTranscodeProfiles(PRUint32 aType,
                                                  nsIArray **aSupportedProfiles);

  nsresult GetDeviceTranscodingProperty(PRUint32         aTranscodeType,
                                        const nsAString& aPropertyName,
                                        nsIVariant**     aPropertyValue);

  nsresult DispatchTranscodeErrorEvent(sbIMediaItem*    aMediaItem,
                                       const nsAString& aErrorMessage);

  /* Return an array of sbIImageFormatType describing all the supported
   * album art formats for the device.
   *
   * The array may be empty; this should be interpreted as "unknown" rather than
   * "album art is not supported"
   */
  nsresult GetSupportedAlbumArtFormats(nsIArray * *aFormats);

  nsresult GetShouldLimitMusicSpace(const nsAString & aPrefBase,
                                    PRBool *aOutShouldLimitSpace);

  nsresult GetMusicLimitSpacePercent(const nsAString & aPrefBase,
                                     PRUint32 *aOutLimitPercentage);

  static PLDHashOperator RemoveLibraryEnumerator(
                                             nsISupports * aList,
                                             nsCOMPtr<nsIMutableArray> & aItems,
                                             void * aUserArg);

  class AutoListenerIgnore
  {
  public:
    AutoListenerIgnore(sbBaseDevice * aDevice);
    ~AutoListenerIgnore();
  private:
    sbBaseDevice * mDevice;
  };

  template <class T>
  nsresult RemoveLibraryItems(T iter, T end)
  {
    nsresult rv;
    nsInterfaceHashtable<nsISupportsHashKey, nsIMutableArray> groupedItems;
    groupedItems.Init();

    while (iter != end) {
      sbBaseDevice::TransferRequest * request = *iter;
      PRUint32 type = request->GetType();

      // If this is a request that adds an item to the device we need to remove
      // it from the device since it never was copied
      switch (type) {
        case sbBaseDevice::TransferRequest::REQUEST_WRITE:
        case sbBaseDevice::TransferRequest::REQUEST_READ: {
          if (request->list && request->item) {
            nsCOMPtr<nsIMutableArray> items;
            groupedItems.Get(request->list, getter_AddRefs(items));
            if (!items) {
              items = do_CreateInstance(
                               "@songbirdnest.com/moz/xpcom/threadsafe-array;1",
                               &rv);
              NS_ENSURE_TRUE(groupedItems.Put(request->list, items),
                             NS_ERROR_OUT_OF_MEMORY);
            }
            rv = items->AppendElement(request->item, PR_FALSE);
            NS_ENSURE_SUCCESS(rv, rv);
          }
        }
        break;
      }
      ++iter;
    }
    AutoListenerIgnore ignore(this);
    groupedItems.Enumerate(RemoveLibraryEnumerator, this);
    return NS_OK;
  }

  nsresult GetNameBase(nsAString& aName);
  nsresult GetProductNameBase(char const * aDefaultModelNumberString,
                              nsAString& aProductName);
  nsresult
  IgnoreWatchFolderPath(nsIURI * aURI,
                        sbAutoIgnoreWatchFolderPath ** aIgnorePath);
  void LogDeviceFolders();
  static PLDHashOperator LogDeviceFoldersEnum(const unsigned int& aKey,
                                              nsString*           aData,
                                              void*               aUserArg);
  nsresult  GetExcludedFolders(nsTArray<nsString> & aExcludedFolders);

  nsresult UpdateMediaLists(nsIArray * aMediaLists);

  nsresult AddMediaLists(sbILibrary * aLibrary,
                         nsIArray * aMediaLists);

  static nsresult GetImportSettings(sbIDeviceLibrary * aDevLibrary,
                                    PRBool * aImportAudio,
                                    PRBool * aImportVideo);

  nsresult CopyChangedMediaItemsToMediaList(sbILibraryChange * aChange,
                                            sbIMediaList * aMediaList);
};


void SBWriteRequestSplitBatches(const sbBaseDevice::Batch & aInput,
                                sbBaseDevice::Batch & aNonTranscodeItems,
                                sbBaseDevice::Batch & aTrancodeItems,
                                sbBaseDevice::Batch & aPlaylistItems);
//
// Auto-disposal class wrappers.
//
//   sbAutoResetEnsureSpaceChecked
//                              Wrapper to automatically reset the space
//                              checked flag.

SB_AUTO_NULL_CLASS(sbAutoResetEnsureSpaceChecked,
                   sbBaseDevice*,
                   mValue->SetEnsureSpaceChecked(false));

#endif /* __SBBASEDEVICE__H__ */