/*

* Copyright (c) 2007 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:   Used to interact with the MDE. 

*

*/

#ifndef MEDIAFILEHANDLER_H

#define MEDIAFILEHANDLER_H

// INCLUDES

#include "mediafiledialogutils.h"

#include <mdesession.h>

#include <mdequery.h>

#include <mdelogiccondition.h>

#include <mdeconstants.h>

#include <mdeobjectquery.h>

#include <mdccommon.h>

#include <mdeitem.h>

#include <mdeobject.h>

// FORWARD DECLARATIONS

class CSearchList;

class CRomFileList;

class CArtistQuery;

// CONSTANTS

_LIT( KMimeTypeAMR, "audio/amr" );

_LIT( KMimeTypeWAV, "audio/wav" );

_LIT( KMimeMp3, "mp3" );

_LIT( KDriveZ, "z:\\" );

_LIT( KSpace, " " );

/**

* CMediaFileData

* 

* Used for storing metadata information for one media file.

*/

NONSHARABLE_CLASS (CMediaFileData) : public CBase

    {

    public:

        static CMediaFileData* NewL();

        virtual ~CMediaFileData();

    private:

        CMediaFileData();

        void ConstructL();

    public:

        const TDesC& Attr( TInt aAttr );

        void GetAttr( TInt aAttr, TDes& aValue );

        void SetAttrL( TInt aAttr, const TDesC& aValue );

    public:

        TInt iMediaFileType;

    private:

        HBufC* iFullName;

        HBufC* iName;

        HBufC* iArtist;

        HBufC* iAlbum;

        HBufC* iGenre;

        HBufC* iComposer;

    };

/**

* MMediaFileHandlerObserver

*

* For observing CMediaFileHandler events.  

*/

NONSHARABLE_CLASS (MMediaFileHandlerObserver)

	{

    public:

    enum TMediaFileHandlerEvent

        {

        EInitComplete,

        EQueryComplete,

        EQueryCanceled,

        EUnknownQueryComplete,

        EMediaFileChanged,

        EScanRomComplete,

        EError

        };

    enum TScanRomState

        {

        ENoneRomScan,

        ERomScanInProgress,

        ERomScanComplete,

        ERomScanError

        };

	public:

		virtual void HandleMFEventL( TInt aEvent, TInt aError ) = 0;

	};

/**

* CMediaFileHandler

*

* Used for making media file queries. For example get all songs for

* one artist. Uses metadata engine.

*/

NONSHARABLE_CLASS (CMediaFileHandler) : public CBase, 

                                        public MMdESessionObserver,

                                        public MMdEQueryObserver,

                                        public MMdEObjectObserver,

                                        public MMdEObjectPresentObserver,

                                        public MMFActiveCallerObserver

    {

    public:

    enum TMediaType

        {

        EMediaTypeTone = 0,

        EMediaTypeVideo,

        EMediaTypeRecording,

        EMediaTypeMusic

        };

    enum TStorageType

         {

         EPhoneMemory = 0,

         ERomStorage,

         EMassStorage,

         EMemoryCard

         };

    enum TQueryAttribute

        {

        EAttrMediaType = 20,  // integer

        EAttrFileSize,        // integer

        EAttrStorageType,     // integer

        EAttrMediaFileId,     // integer

        EAttrFileName,     // string

        EAttrFullName,     // string

        EAttrSongName,     // string

        EAttrArtist,       // string

        EAttrAlbum,        // string

        EAttrGenre,        // string

        EAttrComposer      // string

        };

    enum TQueryType

        {

        EQueryNone = 0,

        EQueryAudio,

        EQueryMusic,

        EQueryVideo,

        EQueryRecording,

        EQueryTone,

        ESearchAudio,

        ESearchVideo,

        ESearchMusic,

        ESearchTones,

        EQueryEmpty,

        EQueryUnknown,

        EQueryArtist,

        EQueryArtistAlbum,

        EQueryArtistAll,

        EQueryArtistUnknown,

        EQueryArtistEmpty,

        };

    public:

        static CMediaFileHandler* NewL();

        virtual ~CMediaFileHandler();

    private:

	    CMediaFileHandler();

        void ConstructL();

    public:

        void SetAttrL( TInt aAttr, TInt aValue );

        void SetAttrL( TInt aAttr, const TDesC& aValue );

        void SetAttrL( TInt aAttr, TAny* aValue );

    public:

        void QueryMusicL( TInt aAttr );

        void QueryMusicL( TInt aAttr, const TDesC& aFindText );

        void QueryMusicUnknownL( TInt aAttr );

        void QueryMusicUnknownCountL( TInt aAttr );

        void QueryAttributeValuesL( TInt aAttr );

        void QueryArtistL( TInt aAttr, const TDesC& aArtist, 

                           const TDesC& aAlbum, TBool aRefresh = EFalse );

        void QueryArtistEmptyL();

        void QueryEmptyL();

        void QueryRomEmptyL( TInt aQueryType );

        void QueryVideosL( TInt aAttr );

        void QueryRecordingsL( TInt aAttr );

        void QueryTonesL( TInt aAttr );

        void QueryDefaultTonesL( TInt /*aAttr*/ );

        void SearchL( const TDesC& aSearchText );

        void SearchAudioL( const TDesC& aSearchText );

        void StartRomScaning( TInt aQueryType );

    public:

        TInt UnknownArtistCount();

        TInt UnknownArtistCountL();

        TInt ResultCount();

        TBool QueryReady();

        TInt Attribute( TInt aIndex, TInt aAttr, TInt aQueryId );

        void GetAttributeL( TInt aIndex, TInt aAttr, TDes& aValue, TInt aQueryId );

        void GetAttribute( TInt aIndex, TInt aAttr, TDes& aValue, TInt aQueryId );

        CMediaFileData* ReadMediaFileDataL( TInt aId );

        void CancelQuery();

    public:

        TInt ItemIndex( const TDesC& aItemText, TInt aIndex );

        TInt ItemIndex( TInt aItemId, TInt aIndex );

    private:

        void SearchVideoL( const TDesC& aSearchText );

        void SearchMusicL( const TDesC& aSearchText );

        void SearchTonesL( const TDesC& aSearchText );

        static TInt SearchTones( TAny *aObj );

        static TInt SearchVideo( TAny *aObj );

    public:

        void SetObserver( MMediaFileHandlerObserver* aObserver );

        void SetQueryId( TInt aId );

        void EnableObserverCall( TBool aEnable );

    public:

	CMediaFileData* RomMediaFileDataL( TInt aId ,TInt aMediaType );

    private:

        CMdEPropertyDef& PropertyDefL( TInt aAttr );

        void StrCopy( TDes& aTarget, const TDesC& aSource );

        void CheckAttrL( TInt aAttr );

        void CallObserverWithDelay();

        void CallObserver( TInt aEvent, TInt aError );

        void AddObjectObserverL();

    public:

        static CMdEPropertyDef& PropertyDefL( CMdESession* aSession, TInt aAttr );

    private:

        void ExcludeRecordingsL( CMdELogicCondition& aCondition );

        void ExcludeRomFilesL( CMdELogicCondition& aCondition );

        void ExcludeMimeTypesL( CMdELogicCondition& aCondition, TInt aAttr );

        void IncludeMusicPropertiesL( CMdELogicCondition& aCondition );

        void ExcludeMusicPropertiesL( CMdELogicCondition& aCondition );

        void IncludeMusicSearchConditionL( CMdELogicCondition& aCondition,

                                           const TDesC& aSearchText );

        void IncludeToneSearchConditionL( CMdELogicCondition& aCondition,

                                           const TDesC& aSearchText );

        void IncludeVideoSearchConditionL( CMdELogicCondition& aCondition,

                                           const TDesC& aSearchText );

    private:

        void LeaveIfSessionClosedL();

        void Panic( TInt aReason );

        TInt MediaType( TInt aQueryType );

    private:  // from MMdESessionObserver

        void HandleSessionOpened(CMdESession& aSession, TInt aError);

        void HandleSessionError(CMdESession& aSession, TInt aError);

    private:  // from MMdEQueryObserver (mdequery.h)

        void HandleQueryNewResults( CMdEQuery& aQuery, TInt aFirstNewItemIndex,

                                    TInt aNewItemCount );

        void HandleQueryCompleted( CMdEQuery& aQuery, TInt aError );

        void HandleQueryCompletedL( CMdEQuery& aQuery, TInt aError );

    private:  // from MMdEObjectObserver

        void HandleObjectNotification( CMdESession& aSession, 

                                       TObserverNotificationType aType,

                                       const RArray<TItemId>& aObjectIdArray);

    private:  // from MMdEObjectPresentObserver

        void HandleObjectPresentNotification( CMdESession& aSession, 

                         TBool aPresent, const RArray<TItemId>& aObjectIdArray);

    private:   // from MMFActiveCallerObserver

         void HandleActiveCallL( TInt aCallId );

    private:

        // media file event observer

        MMediaFileHandlerObserver* iObserver;

        // session to metadata engine

        CMdESession* iSession;

        // metadata query

        CMdEObjectQuery* iQuery;

        // used for optimizing artist queries

        CArtistQuery* iArtistQuery;

        // search result list - ui shows items from this list

        CSearchList* iSearchList;

        // metadata search text

        TBuf<KBufSize128> iSearchText;

        // for generating active object calls

        CMFActiveCaller* iQueryCaller;

        // for generating active object calls

        CMFActiveCaller* iObjectNotificationCaller;

        // for finding out file drive type

        CDriveUtil* iDriveUtil;

        // mime types that are exluded from queries

        CMimeTypeList* iExcludedMimeTypes;

        // for starting video query after short delay

        CIdle* iIdle;

        // used to prevent observer call when query is canceled fro ui

        TBool iObserverCallEnabled;

        // query id from UI, not used in this class

        TInt iQueryId;

        // max audio file file size

        TInt iMaxFileSize;

        // is metadata session open

        TBool iSessionOpen;

        // query type 

        TInt iQueryType;

        // query error

        TInt iQueryError;

        // query event

        TInt iQueryEvent;

	    TBool iVideoSearchDisabled; 

        TInt iMediaFileCounter;

        //for scan data from rom

        CRomFileList* iRomFileList;

	    //Record the rom scan state.

	    TInt iRomScanState;

	    //Tone query in progress

	    TBool iQueryinProgress;

    };

/**

* CSearchListItem

*

* Data for one media file item CSearchList.

*/

NONSHARABLE_CLASS (CSearchListItem) : public CBase 

    {

    public:

        static CSearchListItem* NewLC();

        static CSearchListItem* NewL();

        virtual ~CSearchListItem();

    private:

        CSearchListItem();

        void ConstructL();

    public:

        void SetTitleL( const TDesC& aText, TBool aFullName );

        const TDesC& Title() const;

    public:

        TInt iId;

        TInt iMediaType;

        TInt iStorageType;

    private:

        HBufC* iTitle;

    };

/**

* CRomFileList

* 

* Used for reading media files from rom.

*/

NONSHARABLE_CLASS (CRomFileList) : public CBase

    {

    public:

        static CRomFileList* NewL();

        virtual ~CRomFileList();

    private:

        CRomFileList();

        void ConstructL();

    public:

        void ReadDirectoryL( const TDesC& aDirectory, RArray<TFileName>& aList );

        void ReadDirectoryL( const TDesC& aDirectory, 

                                         RPointerArray<CSearchListItem>& aList );

        void ReadRomFilesL();

        void ReadRomVediosL();

        const TDesC& Item( TInt aIndex , TInt aType );

        TInt RomFileItem( CSearchListItem* aItem, TInt aIndex);

        TInt RomVedioItem( CSearchListItem* aItem, TInt aIndex);

        TInt Count( TInt aType );

        void Reset();

    public:

//    //Used to return the rom file attribute in rom;

//    TInt RomFileAttribute(TInt aIndex, TInt aAttr);

    //Used to return the title of rom item

    TInt GetRomFileName(TInt aIndex, TInt aType, TDes& aValue);

private:

    CSearchListItem* SearchListItemFromRomL(const TDesC& aFileName,

            TInt aIndex);

	//Used to get the title of rom item

	void RomItemTitle(TInt aIndex, TDes& aTitle );

private:

        TFileName iFileName;

        RArray<TFileName> iList;

        RArray<TFileName> iVedioList;

        RPointerArray<CSearchListItem> iRomToneList;

        RPointerArray<CSearchListItem> iRomVideoList;

    };

/**

* CSearchList

*

* List for storing search result for one (most recent) metadata query.

*/

NONSHARABLE_CLASS (CSearchList) : public CBase 

    {

    public:

        static CSearchList* NewL();

        virtual ~CSearchList();

    private:

        CSearchList();

        void ConstructL();

    public:

        void SetSession( CMdESession* aSession );

        void SetRomFileList( CRomFileList* aRomFileList );

        void TakeResultL( CMdEObjectQuery* aQuery, TInt aMediaType );

        void TakeArtistResultL( CArtistQuery* aArtistQuery );

        void TakeDistinctResultL( CMdEObjectQuery* aQuery, TInt aMediaType );

        void SearchInToneL( CRomFileList* aQuery,  const TDesC& aSearchText );

        void VideoSearchInRomL( CRomFileList* aQuery,  const TDesC& aSearchText );

        void AddAlbumItemL( const TDesC& aAlbum );

        void AddItemL( CMdEObject& aObject, TInt aMediaType );

        void AddRomItemL( CRomFileList* aRomList, TInt aMediaType );

        void AddArtistItemL( CMdEObject& aObject, TInt aQueryType, const TDesC& aAlbum );

        void Reset();

        void Sort();

        TInt Count();

        void GetAttributeL( TInt aIndex, TInt aAttr, TDes& aValue );

        TInt Attribute( TInt aIndex, TInt aAttr );

        void SetSearchId( TInt aId );

        TInt SearchId();

    public:

        TInt ItemIndex( TInt aId );

        TInt ItemIndex( const TDesC& aText );

        TInt ItemIndex( const TDesC& aText, TInt aIndex );

        TInt ItemIndex( TInt aId, TInt aIndex );

    private:

        static TInt Compare( const CSearchListItem& aFirst, 

                             const CSearchListItem& aSecond );

        void Panic( TInt aReason );

        const TDesC& TextL( CMdEObject& aObject, TInt aId );

    private:

        CMdESession* iSession;  // does not own

        CRomFileList* iRomFileList; //does not own

        // list of search results

        RPointerArray<CSearchListItem> iList;

        // for finding out drive type (eg memory card)

        CDriveUtil* iDriveUtil;

        // search id - not used in this class

        TInt iSearchId;

    };

/**

* CArtistQuery

* 

* CArtistQuery is for storing all metadata for one artist.

* Once CArtistQuery is initialized it can be used to get artist 

* subqueries without making more metadata queries.