sbiTunesImporter.h

Go to the documentation of this file.

/*
//
// BEGIN SONGBIRD GPL
//
// This file is part of the Songbird web player.
//
// Copyright(c) 2005-2009 POTI, Inc.
// http://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 SBITUNESIMPORTER_H_
#define SBITUNESIMPORTER_H_

#include <map>
#include <memory>
#include <vector>

#include <nsDataHashtable.h>
#include <nsIRunnable.h>
#include <nsStringAPI.h>

#include <sbILibraryImporter.h>
#include <sbIiTunesXMLParserListener.h>

#include "sbiTunesDatabaseServices.h"
#include "sbiTunesImporterCommon.h"
#include "sbiTunesImporterStatus.h"
#include "sbiTunesSignature.h"
#include "sbiTunesXMLParser.h"

// Mozilla forwards
class nsIArray;
class nsIIOService;
class nsIInputStream;

// Songbird forwards
class sbIAlbumArtFetcherSet;
class sbILibrary;
class sbILocalDatabaseLibrary;
class sbIMediacoreTypeSniffer;
class sbIMediaList;
class sbIPropertyArray;
#ifdef SB_ENABLE_TEST_HARNESS
class sbITimingService;
#endif
class sbPrefBranch;

// Component constants
#define SBITUNESIMPORTER_CONTRACTID                     \
  "@songbirdnest.com/Songbird/ITunesImporter;1"
#define SBITUNESIMPORTER_CLASSNAME                      \
  "iTunes Library Importer"
// {56202248-E7AB-4e45-BFF3-F296844688C4}
#define SBITUNESIMPORTER_CID                            \
{ 0x56202248, 0xe7ab, 0x4e45, { 0xbf, 0xf3, 0xf2, 0x96, 0x84, 0x46, 0x88, 0xc4 } }

class sbiTunesImporter : public sbILibraryImporter,
                         public sbIiTunesXMLParserListener
{
public:
  enum OSType {
    UNINITIALIZED,
    MAC_OS,
    LINUX_OS,
    WINDOWS_OS,
    UNKNOWN_OS
  };

  NS_DECL_ISUPPORTS
  NS_DECL_SBILIBRARYIMPORTER
  NS_DECL_SBIITUNESXMLPARSERLISTENER
  
  sbiTunesImporter();

private:
  virtual ~sbiTunesImporter();
  
  struct iTunesTrack;
  static PRUint32 const BATCH_SIZE = 100;
  static PRUint32 const DATA_FORMAT_VERSION = 2;

  // Various nCOMPtr handy typedefs
  typedef nsCOMPtr<nsIThread>                   nsIThreadPtr;

  typedef nsCOMPtr<sbIAlbumArtFetcherSet>       sbIAlbumArtFetcherSetPtr;
  typedef nsCOMPtr<sbIMediacoreTypeSniffer>     sbIMediacoreTypeSnifferPtr;
  typedef nsCOMPtr<nsIInputStream>              nsIInputStreamPtr;
  typedef nsCOMPtr<nsIIOService>                nsIIOServicePtr;
  typedef nsCOMPtr<sbILibraryImporterListener>  sbILibraryImporterListenerPtr;
  typedef nsCOMPtr<sbILibrary>                  sbILibraryPtr;
  typedef nsCOMPtr<sbILocalDatabaseLibrary>     sbILocalDatabaseLibraryPtr;
#ifdef SB_ENABLE_TEST_HARNESS
  typedef nsCOMPtr<sbITimingService>            sbITimingServicePtr;
#endif  
  typedef nsRefPtr<sbiTunesXMLParser>           sbiTunesXMLParserPtr;
  typedef std::auto_ptr<sbiTunesImporterStatus> sbiTunesImporterStatusPtr;
  typedef nsDataHashtable<nsStringHashKey, nsString> StringMap;
  
  typedef std::vector<iTunesTrack *>            TrackBatch;
  typedef std::map<nsString, nsString>          TrackIDMap;
  typedef std::map<nsString, PRUint32>          TracksByID;

  struct iTunesTrack {
    iTunesTrack();
    ~iTunesTrack();
    nsresult Initialize(sbIStringMap * aProperties);
    nsString GetContentType(sbIStringMap *aProperties);
    nsresult GetPropertyArray(sbIPropertyArray ** aPropertyArray);
    nsresult GetTrackURI(sbiTunesImporter::OSType aOSType, 
                         nsIIOService * aIOService,
                         sbiTunesSignature & aSignanture, 
                         nsIURI ** aURI);
    nsString mTrackID;
    nsString mSBGuid;
    StringMap mProperties;
    nsCOMPtr<nsIURI> mURI;
  };

  sbIAlbumArtFetcherSetPtr mAlbumArtFetcher;
  PRBool mBatchEnded;
  PRInt32 mDataFormatVersion;
  PRBool mFoundChanges;
  PRBool mImport;
  PRBool mImportPlaylists;
  nsIIOServicePtr mIOService;
  nsIInputStreamPtr mStream;
  sbiTunesDatabaseServices miTunesDBServices;
  nsString miTunesLibID;
  sbiTunesSignature miTunesLibSig;
  sbILocalDatabaseLibraryPtr mLDBLibrary;
  sbILibraryPtr mLibrary;
  nsString mLibraryPath;
  sbILibraryImporterListenerPtr mListener;
  PRUint32 mMissingMediaCount;
  OSType mOSType;
  sbiTunesXMLParserPtr mParser;
  nsString mPlaylistAction;
  nsString mPlaylistBlacklist;
  nsString mSongbirdFolderID;
  sbiTunesImporterStatusPtr mStatus;
#ifdef SB_ENABLE_TEST_HARNESS
  sbITimingServicePtr mTimingService;
#endif

  nsString mTimingServiceIdentifier;
  PRUint32 mTrackCount;
  TrackBatch mTrackBatch;
  TrackIDMap mTrackIDMap;
  sbIMediacoreTypeSnifferPtr mTypeSniffer;
  PRUint32 mUnsupportedMediaCount;
  PRInt64 mBytesRead;
  
  nsresult Cancel();
  nsresult DBModified(sbPrefBranch & aPrefs,
                      nsAString const & aLibPath,
                      PRBool * aModified);
  inline
  static void DestructiTunesTrack(iTunesTrack * aTrack);
  nsresult GetDirtyPlaylistAction(nsAString const & aPlaylistName,
                                  nsAString & aAction);
  OSType GetOSType();
  nsresult ImportPlaylist(sbIStringMap *aProperties, 
                          PRInt32 *aTrackIds, 
                          PRUint32 aTrackIdsCount,
                          sbIMediaList * aMediaList);
  nsresult ProcessCreatedItems(
    nsIArray * aCreatedItems,
    TracksByID const & aTrackMap);
  nsresult ProcessNewItems(TracksByID & aTrackMap,
                           nsIArray ** aNewItems);
  nsresult ProcessPlaylistItems(sbIMediaList * aMediaList,
                                PRInt32 * aTrackIds,
                                PRUint32 aTrackIdsCount);
  nsresult ProcessTrackBatch();
  nsresult ProcessUpdates();
  nsresult Run();
  PRBool ShouldImportPlaylist(sbIStringMap * aProperties);
  nsresult UpdateProgress();

};

#endif /* SBITUNESIMPORTER_H_ */