DeviceBase.h

Go to the documentation of this file.

/*
//
// BEGIN SONGBIRD GPL
// 
// This file is part of the Songbird web player.
//
// Copyright(c) 2005-2008 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 __DEVICE_BASE_H__
#define __DEVICE_BASE_H__

#include "sbIDeviceBase.h"

#include <sbILibrary.h>
#include <sbIMediaList.h>
#include <sbIMediaListListener.h>
#include <sbIMediaItem.h>

#include <sbILocalDatabaseLibrary.h>
#include <sbILocalDatabaseSimpleMediaList.h>

#include <nsAutoPtr.h>
#include <nsIMutableArray.h>
#include <nsInterfaceHashtable.h>
#include <nsClassHashtable.h>
#include <nsDataHashtable.h>
#include <nsIThread.h>
#include <nsIRunnable.h>
#include <nsIURI.h>
#include <nsRefPtrHashtable.h>

#include <nsCOMPtr.h>
#include <nsStringGlue.h>

#define SONGBIRD_DeviceBase_CONTRACTID                    \
  "@songbirdnest.com/Songbird/Device/DeviceBase;1"
#define SONGBIRD_DeviceBase_CLASSNAME                     \
  "Songbird Device Base"
#define SONGBIRD_DeviceBase_CID                           \
{ /* 937d0ae7-9ba1-475d-82fd-609ff5f78508 */              \
  0x937d0ae7,                                             \
  0x9ba1,                                                 \
  0x475d,                                                 \
  {0x82, 0xfd, 0x60, 0x9f, 0xf5, 0xf7, 0x85, 0x8}         \
}

// FUNCTIONS ==================================================================
void 
ReplaceChars(nsAString& aOldString,
             const nsAString& aOldChars,
             const PRUnichar aNewChar);

void 
ReplaceChars(nsACString& aOldString,
             const nsACString& aOldChars,
             const char aNewChar);

// CLASSES ====================================================================
class sbDeviceBaseLibraryListener : public sbIMediaListListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_SBIMEDIALISTLISTENER

  sbDeviceBaseLibraryListener();
  virtual ~sbDeviceBaseLibraryListener();

  nsresult Init(const nsAString &aDeviceIdentifier,
                sbIDeviceBase* aDevice);

  nsresult SetIgnoreListener(PRBool aIgnoreListener);
  nsresult SetManagePlaylists(PRBool aManagePlaylists);

protected:
  static PLDHashOperator PR_CALLBACK
    ShiftIndexesCallback(nsISupportsHashKey::KeyType aKey,
                         PRUint32& aEntry,
                         void* aUserData);

  // The device owns the listener, so use a non-owning reference here
  sbIDeviceBase* mDevice;
  nsString mDeviceIdentifier;

  PRBool mIgnoreListener;
  PRBool mManagePlaylists;

  typedef nsDataHashtable<nsISupportsHashKey, PRUint32> sbRemovedItemIndexes;
  nsClassHashtable<nsISupportsHashKey, sbRemovedItemIndexes> mBeforeRemoveIndexes;
};

class sbDeviceBaseLibraryCopyListener : public sbILocalDatabaseMediaListCopyListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_SBILOCALDATABASEMEDIALISTCOPYLISTENER

  sbDeviceBaseLibraryCopyListener();
  virtual ~sbDeviceBaseLibraryCopyListener();

  nsresult Init(const nsAString &aDeviceIdentifier,
                sbIDeviceBase* aDevice);

protected:
  nsCOMPtr<sbIDeviceBase> mDevice;
  nsString mDeviceIdentifier;

};

class sbDeviceBaseCallbackProxy
{
public:
    NS_IMETHOD_(nsrefcnt) AddRef(void);
    NS_IMETHOD_(nsrefcnt) Release(void);

    sbDeviceBaseCallbackProxy();
    virtual ~sbDeviceBaseCallbackProxy();
    nsresult Init(sbIDeviceBaseCallback* aCallback);

    nsCOMPtr<sbIDeviceBaseCallback> mCallbackProxy;
    nsCOMPtr<nsIEventTarget> mOwningThread;

protected:
    nsAutoRefCnt mRefCnt;
    NS_DECL_OWNINGTHREAD
};

class sbDeviceBase
{
  friend class sbDeviceThread;

public:
  sbDeviceBase();
  virtual ~sbDeviceBase();

  nsresult Init();

  nsresult CreateDeviceLibrary(const nsAString &aDeviceIdentifier, 
                               nsIURI *aDeviceDatabaseURI,
                               sbIDeviceBase *aDevice);

  nsresult RemoveDeviceLibrary(const nsAString &aDeviceIdentifier);

  nsresult GetLibraryForDevice(const nsAString &aDeviceIdentifier,
                               sbILibrary* *aDeviceLibrary);

  nsresult RegisterDeviceLibrary(sbILibrary* aDeviceLibrary);

  nsresult UnregisterDeviceLibrary(sbILibrary* aDeviceLibrary);

  nsresult CreateTransferQueue(const nsAString &aDeviceIdentifier);

  nsresult RemoveTransferQueue(const nsAString &aDeviceIdentifier);

  nsresult AddItemToTransferQueue(const nsAString &aDeviceIdentifier, 
                                  sbIMediaItem* aMediaItem);

  nsresult RemoveItemFromTransferQueue(const nsAString &aDeviceIdentifier,
                                       sbIMediaItem* aMediaItem);
  nsresult GetNextItemFromTransferQueue(const nsAString &aDeviceIdentifier,
                                        sbIMediaItem* *aMediaItem);
  nsresult GetItemByIndexFromTransferQueue(const nsAString &aDeviceIdentifier,
                                           PRUint32 aItemIndex,
                                           sbIMediaItem* *aMediaItem);
  nsresult GetTransferQueue(const nsAString &aDeviceIdentifier,
                            nsIMutableArray* *aTransferQueue);
  
  nsresult ClearTransferQueue(const nsAString &aDeviceIdentifier);

  nsresult IsTransferQueueEmpty(const nsAString &aDeviceIdentifier, 
                                PRBool &aEmpty);

  nsresult AddCallback(sbIDeviceBaseCallback* aCallback);

  nsresult RemoveCallback(sbIDeviceBaseCallback* aCallback);

  void DoTransferStartCallback(sbIMediaItem* aMediaItem);

  void DoTransferCompleteCallback(sbIMediaItem* aMediaItem,
                                  PRInt32 aStatus);

  void DoDeviceConnectCallback(const nsAString& aDeviceIdentifier);

  void DoDeviceDisconnectCallback(const nsAString& aDeviceIdentifier);

  void DoStateChangedCallback(const nsAString& aDeviceIdentifier,
                              PRUint32 aState);

  nsresult GetDeviceState(const nsAString& aDeviceIdentifier, 
                          PRUint32* aDeviceState);
  nsresult SetDeviceState(const nsAString& aDeviceIdentifier,
                          PRUint32 aDeviceState);

  nsresult InitDeviceState(const nsAString& aDeviceIdentifier);

  nsresult ClearDeviceState(const nsAString& aDeviceIdentifier);

  nsresult SetListenerForDeviceLibrary(const nsAString& aDeviceIdentifier,
                                       sbIMediaListListener *aMediaListListener);
  nsresult GetListenerForDeviceLibrary(const nsAString& aDeviceIdentifier,
                                       sbIMediaListListener* *aMediaListListener);
  nsresult RemoveListenerForDeviceLibrary(const nsAString& aDeviceIdentifier);
protected:
  nsInterfaceHashtableMT<nsStringHashKey, sbILibrary> mDeviceLibraries;
  nsInterfaceHashtableMT<nsStringHashKey, nsIMutableArray> mDeviceQueues;
  nsRefPtrHashtableMT<nsISupportsHashKey, sbDeviceBaseCallbackProxy> mDeviceCallbacks;
  nsDataHashtableMT<nsStringHashKey, PRUint32> mDeviceStates;

  nsInterfaceHashtableMT<nsStringHashKey, sbIMediaListListener> mDeviceLibraryListeners;
};

#endif // __DEVICE_BASE_H__