/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Album collection plugin definition

*

*/

#ifndef C_GLXTESTPLUGIN_H

#define C_GLXTESTPLUGIN_H

// INCLUDES

#include <e32cmn.h>

#include "glxcollectionplugintestbase.h"

#include "mglxtnthumbnailcreatorclient.h"

#include <mpxmediageneraldefs.h>

#include <glxmediaid.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

// FORWARD DECLARATIONS

class CGlxtnThumbnailCreator;

// CONSTANTS

// CLASS DECLARATION

/**

* Test collection plugin 

*/

NONSHARABLE_CLASS(CGlxTestCollectionPlugin) : public CGlxCollectionPluginTestBase,

		public MGlxtnThumbnailCreatorClient

    {

public: // Constructors and destructor

    /**

    * Two-phased constructor

    *

    * @param aObs observer

    * @return object of constructed

    */

    static CGlxTestCollectionPlugin* NewL(TAny* aObs);

    /**

    * Destructor

    */

    ~CGlxTestCollectionPlugin();

private: // Functions from base classes

// from CMPXCollectionPlugin

    /** 

    * DEPRECATED, Executes a command on the selected collection

    *

    * @param aCmd a command

    * @param aArg optional argument

    */

    virtual void CommandL(TMPXCollectionCommand aCmd, TInt aArg = 0);

    /** 

    * Executes a command

    *

    * @param aCmd a command

    */

    virtual void CommandL(const CMPXCommand& aCmd); 

    /** 

    * Navigates to the given path

    *

    * @param aPath a path

    * @param aAttrs, attributes requested

    * @param aFilter, filter to apply or NULL if none

    */

    virtual void OpenL(const CMPXCollectionPath& aPath,

                   const TArray<TMPXAttribute>& aAttrs,

                   CMPXFilter* aFilter); 

    /** 

    *  Media properties of the current file (async)

    *  Note: if selection is set in aPath, HandleMedia will return an array of 

    *        media properties of current selected items.

    *        if no selection is set in aPath, HandleMedia will return media 

    *        properities of current item.

    *

    * @param aPath path for the media file

    * @param aAttr attributes requested

    * @param aCaps platsec capabilities of client requesting media; plug-in should also

    *        verify its process capabilities

    * @aParam aSpecs, specifications for attributes

    */

    virtual void MediaL(const CMPXCollectionPath& aPath, 

                        const TArray<TMPXAttribute>& aAttrs,

                        const TArray<TCapability>& aCaps,

                        CMPXAttributeSpecs* aSpecs);

    /**

    *  Adds an item or items to the collection

    *

    *  @param aNewProperties, Properties of the item

    */

    virtual void AddL(const CMPXMedia& aNewMedia);

    /**

    * Remove a collection path

    * Note that the selection indicies are hidden within the path

    * @param aPath, path to remove

    *

    */

    virtual void RemoveL(const CMPXCollectionPath& aPath );

    /**

    *  Remove an item or items from the collection

    *

    *  @param aProperties, Properties of the item. It may cantain URI only

    *                      or meta data, all of items matched properties 

    *                      will be removed.

    */

    virtual void RemoveL(const CMPXMedia& aMedia);

    /**

    *  Sets/updates the media for the item

    *  specified in the path

    *

    *  @param aMedia, new value

    */

    virtual void SetL(const CMPXMedia& aMedia);

    /**

    *  Find a list of items matched (async)

    *

    *  @param aCriteria, properties to be searched

    *  @param aAttrs, attributes to return

    */

    virtual void FindAllL(const CMPXSearchCriteria& aCriteria, 

                          const TArray<TMPXAttribute>& aAttrs);

    /**

    * Find a list of items matched (sync)

    *

    *  @param aCriteria, properties to be searched

    *  @param aAttrs, attributes to return

    *  @return results of the search        

    */

    virtual CMPXMedia* FindAllSyncL(const CMPXSearchCriteria& aCriteria,

                                    const TArray<TMPXAttribute>& aAttrs);

    /**

    * Get the list of supported capabilities

    * @return TCollectionCapability, bitmask of supported capabilities

    */

    virtual TCollectionCapability GetCapabilities();

    /**

    * Generate the next available title from the given title (async).

    * Generated title is returned via callback HandleGenerateTitle

    *

    * @param aCategory specifies the category for the title

    * @param aBaseTitle specifies the base title for new title generation

    */

    virtual void GenerateTitleL( TMPXGeneralCategory aCategory,

                                 const TDesC& aBaseTitle );

    /**

    * Generate the next available title from the given title (sync).

    *

    * @param aCategory specifies the category for the title

    * @param aBaseTitle specifies the base title for new title generation

    * @return generated title

    */

    virtual HBufC* GenerateTitleSyncL( TMPXGeneralCategory aCategory,

                                       const TDesC& aBaseTitle );

private:

	virtual void HandleThumbnailRequestCompleteL(const TGlxMediaId& iId,

		TGlxThumbnailQuality aQuality, TInt aErrorCode);

private:    // From MGlxtnThumbnailCreatorClient

    void ThumbnailFetchComplete(const TGlxMediaId& aItemId,

                            TGlxThumbnailQuality aQuality, TInt aErrorCode);

    void ThumbnailDeletionComplete(const TGlxMediaId& aItemId, TInt aErrorCode);

    void FilterAvailableComplete( const RArray<TGlxMediaId>& aIdArray,

                                    TInt aErrorCode );

    void FetchFileInfoL(CGlxtnFileInfo* aInfo, const TGlxMediaId& aItemId,

                    TRequestStatus* aStatus);

    void CancelFetchUri(const TGlxMediaId& aItemId);

    MGlxtnThumbnailStorage* ThumbnailStorage();

private: 

    /**

    * Constructor

    * @param aObs MMPXCollectionPluginObserver instance

    */

    CGlxTestCollectionPlugin(MMPXCollectionPluginObserver* aObs);

    void ConstructL();

private:

	CGlxtnThumbnailCreator* iThumbnailCreator;

	struct CItem : public CBase

		{

		~CItem()

			{

			delete iFilename;

			delete iTitle;

			delete iDrive;

			}

		void SetFilenameL(const TDesC& aFilename)

			{

			HBufC* fn = aFilename.AllocL();

			delete iFilename;

			iFilename = fn;

			}

		void SetTitleL(const TDesC& aTitle)

			{

			HBufC* title = aTitle.AllocL();

			delete iTitle;

			iTitle = title;

			}

		void SetDriveL(const TDesC& aDrive)

			{

			HBufC* drive = aDrive.AllocL();

			delete iDrive;

			iDrive = drive;

			}

		TGlxMediaId iId;

		HBufC* iFilename; 

		HBufC* iTitle;

		TTime  iDateTime;

		TInt   iFileSize;

		HBufC*  iDrive; 

		};

	void AddItemL(const TDesC& aFileName, 

	              const TDesC& aTitle, 

	              RPointerArray<CItem>& aDatabase, 

	              TTime aDateTime = TTime(0), 

	              TInt  aFileSize = 0,

	              const TDesC& aDrive = KNullDesC);

	CItem* Item(const TGlxMediaId& aItemId) const;

	CItem* ItemL(const CMPXCollectionPath& aPath, TInt aIndex) const;

	TInt PopulateMediaWithItemL(CMPXMedia*& aMedia, const CItem* aItem, const TArray<TMPXAttribute>& aAttrs);

	void PopulateMediaWithArrayL(CMPXMedia*& aMedia, CMPXMediaArray* aArray);

    CItem* iSelf;

	RPointerArray<CItem> _iItemDBHackAlbums;    // TEMP

	RPointerArray<CItem> _iItemDBHackContent;   // TEMP

	RFs iFs;

    // Media to send back to client

    CMPXMedia* iMedia;

    CMPXMedia* iOpenEntries;

	// TEMP RW

	TInt iItemAddedId;	

    };

#endif  // C_GLXTESTPLUGIN_H