sbDeviceUtils.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-2010 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 __SBDEVICEUTILS__H__
#define __SBDEVICEUTILS__H__

#include <nscore.h>
#include <nsCOMPtr.h>
#include <nsIMutableArray.h>
#include <nsStringGlue.h>
#include <prlog.h>

#include <sbIMediaListListener.h>
#include <sbITranscodingConfigurator.h>

#include "sbBaseDevice.h"
#include "sbIDeviceStatus.h"

// Mozilla forwards
class nsIFile;
class nsIMutableArray;

// Songbird forwards
class sbIDeviceLibraryMediaSyncSettings;
class sbIDeviceLibrarySyncSettings;
class sbIMediaFormat;

struct sbExtensionToContentFormatEntry_t {
  char const * Extension;
  char const * MimeType;
  char const * ContainerFormat;
  char const * Codec;
  char const * VideoType;
  char const * AudioType;
  PRUint32 ContentType;
  PRUint32 TranscodeType;
};

class sbDeviceUtils
{
public:
  static nsresult GetOrganizedPath(/* in */ nsIFile *aParent,
                                   /* in */ sbIMediaItem *aItem,
                                   nsIFile **_retval);

  static nsresult BulkSetProperty(sbIMediaList *aMediaList,
                                  const nsAString& aPropertyId,
                                  const nsAString& aPropertyValue,
                                  sbIPropertyArray* aPropertyFilter = nsnull,
                                  PRInt32 *aAbortFlag = nsnull);

  static nsresult DeleteByProperty(sbIMediaList *aMediaList,
                                   nsAString const & aProperty,
                                   nsAString const & aValue);
  static nsresult DeleteUnavailableItems(/* in */ sbIMediaList *aMediaList);

  static nsresult GetDeviceLibraryForItem(/* in */  sbIDevice* aDevice,
                                          /* in */  sbIMediaItem* aItem,
                                          /* out */ sbIDeviceLibrary** _retval);

  static nsresult NewDeviceLibraryURI(sbIDeviceLibrary* aDeviceLibrary,
                                      const nsCString&  aSpec,
                                      nsIURI**          aURI);

  static nsresult GetDeviceLibraryForLibrary(
                                  /* in */  sbIDevice* aDevice,
                                  /* in */  sbILibrary* aLibrary,
                                  /* out */ sbIDeviceLibrary** _retval);

  static nsresult GetMediaItemByDevicePersistentId
                    (/* in */  sbILibrary*      aLibrary,
                     /* in */  const nsAString& aDevicePersistentId,
                     /* out */ sbIMediaItem**   aItem);

  static nsresult GetOriginMediaItemByDevicePersistentId
                    (/* in */  sbILibrary*      aLibrary,
                     /* in */  const nsAString& aDevicePersistentId,
                     /* out */ sbIMediaItem**   aItem);

  static nsresult GetDeviceWriteLength(sbIDeviceLibrary* aDeviceLibrary,
                                       sbIMediaItem*     aMediaItem,
                                       PRUint64*         aWriteLength);

  static nsresult QueryUserSpaceExceeded
                    (/* in */  sbIDevice*        aDevice,
                     /* in */  sbIDeviceLibrary* aLibrary,
                     /* in */  PRInt64           aSpaceNeeded,
                     /* in */  PRInt64           aSpaceAvailable,
                     /* out */ PRBool*           aAbort);

  static nsresult QueryUserAbortRip(PRBool*     aAbort);

  static nsresult QueryUserViewErrors(sbIDevice* aDevice);

  static nsresult ShowDeviceErrors(sbIDevice* aDevice);

  static nsresult SetLinkedSyncPartner(sbIDevice* aDevice);

  static bool ArePlaylistsSupported(sbIDevice * aDevice);

  static nsresult GetFormatTypeForItem(
                     sbIMediaItem * aItem,
                     sbExtensionToContentFormatEntry_t & aFormatType,
                     PRUint32 & aBitRate,
                     PRUint32 & aSampleRate);

  static nsresult GetFormatTypeForItem(
                     sbIMediaItem * aItem,
                     sbExtensionToContentFormatEntry_t & aFormatType,
                     PRUint32 & aSampleRate,
                     PRUint32 & aChannels,
                     PRUint32 & aBitRate);

  static nsresult GetFormatTypeForURI
                    (nsIURI*                            aURI,
                     sbExtensionToContentFormatEntry_t& aFormatType);

  static nsresult GetFormatTypeForURL
                    (const nsAString&                   aURL,
                     sbExtensionToContentFormatEntry_t& aFormatType);

  static nsresult GetFormatTypesForMimeType
    (const nsAString&                             aMimeType,
     const PRUint32                               aContentType,
     nsTArray<sbExtensionToContentFormatEntry_t>& aFormatTypeList);

  static nsresult GetAudioMimeTypeForFormatTypes(const nsAString& aContainer,
                                                 const nsAString& aCodec,
                                                 nsAString&       aMimeType);

  static  nsresult
  DoesItemNeedTranscoding(sbExtensionToContentFormatEntry_t & aFormatType,
                          PRUint32 & aBitRate,
                          PRUint32 & aSampleRate,
                          sbIDevice * aDevice,
                          bool & aNeedsTranscoding);

  static nsresult DoesItemNeedTranscoding(PRUint32 aTranscodeType,
                                          sbIMediaFormat * aMediaFormat,
                                          sbIDevice * aDevice,
                                          bool & aNeedsTranscoding);
  static nsresult GetTranscodeProfiles(PRUint32 aType, nsIArray ** aProfiles);

  static nsresult GetSupportedTranscodeProfiles(PRUint32 aType,
                                                sbIDevice * aDevice,
                                                nsIArray ** aProfiles);

  static nsresult ApplyPropertyPreferencesToProfile(sbIDevice *aDevice,
                                                    nsIArray *aPropertyArray,
                                                    nsString aPrefNameBase);

  static nsresult GetTranscodedFileExtension(sbITranscodeProfile *aProfile,
                                             nsCString &aExtension);

  static nsresult GetCodecAndContainerForMimeType(nsCString aMimeType,
                                                  nsCString &aContainer,
                                                  nsCString &aCodec,
                                                  nsCString &aVideoType,
                                                  nsCString &aAudioType);

  /* Get an appropriate transcoding configurator for this type of transcoding */
  static nsresult GetTranscodingConfigurator(
                              PRUint32 aTranscodeType,
                              sbIDeviceTranscodingConfigurator **aConfigurator);


  static bool
  IsItemDRMProtected(sbIMediaItem * aMediaItem);

  static nsresult
  GetDeviceCapsTypeFromListContentType(PRUint16 aListContentType,
                                       PRUint32 *aContentType,
                                       PRUint32 *aFunctionType);

  static nsresult
  GetDeviceCapsTypeFromMediaItem(sbIMediaItem *aMediaItem,
                                 PRUint32 *aContentType,
                                 PRUint32 *aFunctionType);

  static PRBool
  IsMediaItemSupported(sbIDevice *aDevice,
                       sbIMediaItem *aMediaItem);

  static PRBool
  IsMediaListContentTypeSupported(sbIDevice *aDevice,
                                  PRUint16 aListContentType);

  static nsresult AddSupportedFileExtensions
                    (sbIDevice*          aDevice,
                     PRUint32            aContentType,
                     nsTArray<nsString>& aFileExtensionList);

  static nsresult GetMediaSettings(
                            sbIDeviceLibrary * aDevLib,
                            PRUint32 aMediaType,
                            sbIDeviceLibraryMediaSyncSettings ** aMediaSettings);

  static nsresult GetMgmtTypeForMedia(sbIDeviceLibrary * aDevLib,
                                      PRUint32 aMediaType,
                                      PRUint32 & aMgmtType);

  static nsresult GetDeviceLibrary(nsAString const & aDeviceLibGuid,
                                    sbIDevice * aDevice,
                                    sbIDeviceLibrary ** aDeviceLibrar);

  static nsresult GetDeviceLibrary(nsAString const & aDevLibGuid,
                                   nsID const * aDeviceID,
                                   sbIDeviceLibrary ** aDeviceLibrary);

  static nsresult SetOriginIsInMainLibrary(sbIMediaItem * aMediaItem,
                                           sbILibrary * aDevLibrary,
                                           PRBool aMark);

static nsresult GetSyncItemInLibrary(sbIMediaItem*  aMediaItem,
                                     sbILibrary*    aTargetLibrary,
                                     sbIMediaItem** aSyncItem);

#ifdef PR_LOGGING

  static nsresult
  LogDeviceCapabilities(sbIDeviceCapabilities *aDeviceCaps,
                        PRLogModuleInfo *aLogModule);
#endif

  static bool ShouldLogDeviceInfo();

  static nsCString GetDeviceIdentifier(sbIDevice * aDevice);
};

class sbDeviceListenerIgnore
{
public:
  enum ListenerType
  {
    MEDIA_LIST = 1,
    LIBRARY = 2,
    ALL = 3
  };
  sbDeviceListenerIgnore(sbBaseDevice * aDevice,
                         PRUint32 aListenerType = ALL) :
    mDevice(aDevice),
    mIgnoring(PR_FALSE),
    mListenerType(aListenerType),
    mMediaItem(nsnull) {

    SetIgnore(PR_TRUE);
  }
  sbDeviceListenerIgnore(sbBaseDevice * aDevice,
                         sbIMediaItem * aItem);

  ~sbDeviceListenerIgnore();

  void SetIgnore(PRBool aIgnore);
private:
  sbBaseDevice * mDevice; // Non-owning pointer
  PRBool mIgnoring;
  PRUint32 mListenerType;
  sbIMediaItem * mMediaItem; // nsCOMPtr required definition of sbIMediaItem

  // Prevent copying and assignment
  sbDeviceListenerIgnore(sbDeviceListenerIgnore const &);
  sbDeviceListenerIgnore & operator =(sbDeviceListenerIgnore const &);
};

extern sbExtensionToContentFormatEntry_t const
  MAP_FILE_EXTENSION_CONTENT_FORMAT[];
extern PRUint32 const MAP_FILE_EXTENSION_CONTENT_FORMAT_LENGTH;

#endif /* __SBDEVICEUTILS__H__ */