/*

* 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.

*

*/

#include "mediafilehandler.h"

#include "mediafilelistdebug.h"

#include "mediafiledialogstate.h"

#include "mediafilelist.h"

#include <pathinfo.h>

#include <bautils.h>

/******************************************************************************

 * class CMediaFileData

 ******************************************************************************/

// -----------------------------------------------------------------------------

// CMediaFileData::NewL

// 

// -----------------------------------------------------------------------------

//

CMediaFileData* CMediaFileData::NewL()

    {

    CMediaFileData* self = new (ELeave) CMediaFileData();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// Destructor

// 

// -----------------------------------------------------------------------------

//

CMediaFileData::~CMediaFileData()

    {

    delete iFullName;

    delete iName;

    delete iArtist;

    delete iAlbum;

    delete iGenre;

    delete iComposer;

    }

// -----------------------------------------------------------------------------

// CMediaFileData::CMediaFileData

// 

// -----------------------------------------------------------------------------

//

CMediaFileData::CMediaFileData()

    {

    iMediaFileType = KErrNotFound;

    }

// -----------------------------------------------------------------------------

// CMediaFileData::ConstructL

// 

// -----------------------------------------------------------------------------

//

void CMediaFileData::ConstructL()

    {

    iFullName  = HBufC::NewL( 0 );

    iName      = HBufC::NewL( 0 );

    iArtist    = HBufC::NewL( 0 );

    iAlbum     = HBufC::NewL( 0 );

    iGenre     = HBufC::NewL( 0 );

    iComposer  = HBufC::NewL( 0 );

    }

// -----------------------------------------------------------------------------

// CMediaFileData::Attr

// 

// -----------------------------------------------------------------------------

//

const TDesC& CMediaFileData::Attr( TInt aAttr )

    {

    if ( aAttr == CMediaFileHandler::EAttrFullName )

        {

        return *iFullName;

        }

    if ( aAttr == CMediaFileHandler::EAttrSongName )

        {

        return *iName;

        }

    if ( aAttr == CMediaFileHandler::EAttrArtist )

        {

        return *iArtist;

        }

    if ( aAttr == CMediaFileHandler::EAttrAlbum )

        {

        return *iAlbum;

        }

    if ( aAttr == CMediaFileHandler::EAttrGenre )

        {

        return *iGenre;

        }

    if ( aAttr == CMediaFileHandler::EAttrComposer )

        {

        return *iComposer;

        }

    return KNullDesC;

    }

// -----------------------------------------------------------------------------

// CMediaFileData::SetAttrL

// 

// -----------------------------------------------------------------------------

//

void CMediaFileData::SetAttrL( TInt aAttr, const TDesC& aValue )

    {

    if ( aAttr == CMediaFileHandler::EAttrFullName )

        {

        delete iFullName;

        iFullName = NULL;

        iFullName = aValue.AllocL();

        }

    if ( aAttr == CMediaFileHandler::EAttrSongName )

        {

        delete iName;

        iName = NULL;

        iName = aValue.AllocL();

        }

    if ( aAttr == CMediaFileHandler::EAttrArtist )

        {

        delete iArtist;

        iArtist = NULL;

        iArtist = aValue.AllocL();

        }

    if ( aAttr == CMediaFileHandler::EAttrAlbum )

        {

        delete iAlbum;

        iAlbum = NULL;

        iAlbum = aValue.AllocL();

        }

    if ( aAttr == CMediaFileHandler::EAttrGenre )

        {

        delete iGenre;

        iGenre = NULL;

        iGenre = aValue.AllocL();

        }

    if ( aAttr == CMediaFileHandler::EAttrComposer )

        {

        delete iComposer;

        iComposer = NULL;

        iComposer = aValue.AllocL();

        }

    }

// -----------------------------------------------------------------------------

// CMediaFileData::GetAttr

// 

// -----------------------------------------------------------------------------

//

void CMediaFileData::GetAttr( TInt aAttr, TDes& aValue )

    {

    if ( aAttr == CMediaFileHandler::EAttrFullName )

        {

        TMFDialogUtil::StrCopy( aValue, iFullName->Des() );

        }

    else if ( aAttr == CMediaFileHandler::EAttrSongName )

        {

        TMFDialogUtil::StrCopy( aValue, iName->Des() );

        }

    else if ( aAttr == CMediaFileHandler::EAttrArtist )

        {

        TMFDialogUtil::StrCopy( aValue, iArtist->Des() );

        }

    else if ( aAttr == CMediaFileHandler::EAttrAlbum )

        {

        TMFDialogUtil::StrCopy( aValue, iAlbum->Des() );

        }

    else if ( aAttr == CMediaFileHandler::EAttrGenre )

        {

        TMFDialogUtil::StrCopy( aValue, iGenre->Des() );

        }

    else if ( aAttr == CMediaFileHandler::EAttrComposer )

        {

        TMFDialogUtil::StrCopy( aValue, iComposer->Des() );

        }

    else

        {

        aValue = KNullDesC;

        }

    }

/******************************************************************************

 * class CMediaFileHandler

 ******************************************************************************/

// -----------------------------------------------------------------------------

// CMediaFileHandler::NewL

// 

// -----------------------------------------------------------------------------

//

CMediaFileHandler* CMediaFileHandler::NewL()

    {

    CMediaFileHandler* self = new (ELeave) CMediaFileHandler();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

    }

// -----------------------------------------------------------------------------

// Destructor

// 

// -----------------------------------------------------------------------------

//

CMediaFileHandler::~CMediaFileHandler()

    {

    delete iSearchList;

    delete iQueryCaller;

    delete iObjectNotificationCaller;

    delete iDriveUtil;

    delete iExcludedMimeTypes;

    delete iIdle;

    delete iQuery;

    delete iArtistQuery;

    delete iSession;

    delete iRomFileList;

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::CMediaFileHandler

// 

// -----------------------------------------------------------------------------

//

CMediaFileHandler::CMediaFileHandler()

    {

    iSessionOpen = EFalse;

    iObserverCallEnabled = ETrue;

    iMaxFileSize = KErrNotFound;

    iQueryId = KErrNotFound;

    iQueryType = KErrNotFound;

    iQueryError = KErrNone;

    iQueryEvent = KErrNotFound;

    iVideoSearchDisabled = EFalse;

    iMediaFileCounter = 0;

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::ConstructL

// 

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::ConstructL()

    {

    iSession = CMdESession::NewL( *this );

    iSearchList = CSearchList::NewL();

    iQueryCaller = CMFActiveCaller::NewL( this );

    iObjectNotificationCaller = CMFActiveCaller::NewL( this );

    iDriveUtil = CDriveUtil::NewL();

    iArtistQuery = CArtistQuery::NewL();

    iExcludedMimeTypes = CMimeTypeList::NewL();

    iRomFileList = CRomFileList::NewL();

    iQueryinProgress = EFalse;

    iRomScanState = MMediaFileHandlerObserver::ENoneRomScan;

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::SetAttr

// 

// -----------------------------------------------------------------------------

void CMediaFileHandler::SetAttrL( TInt aAttr, TInt aValue )

    {

    switch ( aAttr )

        {

        case CMediaFileList::EAttrFileSize:

            {

            iMaxFileSize = aValue;

            break;

            }

        case CMediaFileList::EAttrExcludeFolder:

            {

            if ( aValue == CMediaFileList::EFolderVideos )

                {

                iVideoSearchDisabled = ETrue;

                }

            break;

            }

        default:

            {

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::SetAttrL

// 

// -----------------------------------------------------------------------------

void CMediaFileHandler::SetAttrL( TInt aAttr, const TDesC& aValue )

    {

    if ( aAttr == CMediaFileList::EAttrExcludeMimeType )

        {

        iExcludedMimeTypes->AddMimeTypeL( aValue );

        }

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::SetAttr

// 

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::SetAttrL( TInt /*aAttr*/, TAny* /*aValue*/ )

    {

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::HandleSessionOpened (from MMdESessionObserver)

// 

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::HandleSessionOpened( CMdESession& /*aSession*/, TInt aError )

    {

    if ( aError != KErrNone )

        {

        delete iSession;

        iSession = NULL;

        iSessionOpen = EFalse;

        }

    else

        {

        iSessionOpen = ETrue;

        TRAP_IGNORE( AddObjectObserverL() );

        }

    CallObserver( MMediaFileHandlerObserver::EInitComplete, aError );

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::AddObjectObserverL

// 

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::AddObjectObserverL()

    {

    if ( iSessionOpen )

        {

        TUint32 notificationType = ENotifyAdd | ENotifyModify | ENotifyRemove;

        CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();

        iSession->AddObjectObserverL( *this, NULL, notificationType, &defNS );

        iSession->AddObjectPresentObserverL( *this );

        }

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::HandleSessionError (from MMdESessionObserver)

// 

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::HandleSessionError( CMdESession& /*aSession*/, TInt aError )

    {

    if ( aError == KErrNone )

        {

        return;

        }

    delete iSession;

    iSession = NULL;

    iSessionOpen = EFalse;

    CallObserver( MMediaFileHandlerObserver::EError, aError );

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::HandleQueryNewResults (from MMdEQueryObserver)

// 

// This observer function is called during query. Calling frequency is defined

// in second parameter of CMdEQuery::FindL.

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::HandleQueryNewResults( CMdEQuery& /*aQuery*/, 

                                               TInt /*aFirstNewItemIndex*/,

                                               TInt /*aNewItemCount*/ )

    {

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::HandleObjectNotification (MMdEObjectObserver)

// 

// Called when metadata database changes.

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::HandleObjectNotification( CMdESession& /*aSession*/, 

			                 			TObserverNotificationType aType,

						                const RArray<TItemId>& aObjectIdArray )

    {

    const TInt KObserverCallStep = 100;

    if ( aType == ENotifyAdd || aType == ENotifyModify || aType == ENotifyRemove )

        {

        if ( iObserver )

            {

            TInt count = aObjectIdArray.Count();

            FLOG( _L("CMediaFileHandler::HandleObjectNotification: count is %d"), count );

            iMediaFileCounter = iMediaFileCounter + count;

            if ( iMediaFileCounter >= KObserverCallStep )

                {

                iMediaFileCounter = 0;

                TRAP_IGNORE( iObserver->HandleMFEventL(

                             MMediaFileHandlerObserver::EMediaFileChanged, KErrNone ) );

                }

            else 

                {

                // delayed call to avoid many consecutive observer calls

                CallObserverWithDelay();

                }

            }

        }

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::HandleObjectPresentNotification (MMdEObjectPresentObserver)

// 

// Called when previously used memory card is inserted and hidden

// metadata files are made present again.

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::HandleObjectPresentNotification( CMdESession& /*aSession*/, 

			             TBool /*aPresent*/, const RArray<TItemId>& aObjectIdArray )

    {

    if ( iObserver )

        {

        TInt count = aObjectIdArray.Count();

        FLOG( _L("CMediaFileHandler::HandleObjectPresentNotification: count is %d"), count );

        // delayed call to avoid many consecutive observer calls

        CallObserverWithDelay();

        }

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::HandleQueryCompleted (MMdEQueryObserver)

// 

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::HandleQueryCompleted( CMdEQuery& aQuery, TInt aError )

    {

    TInt err = KErrNone;

    TRAP( err, HandleQueryCompletedL( aQuery, aError ) );

    if ( err == KErrCancel )

        {

        CallObserver( MMediaFileHandlerObserver::EQueryCanceled, KErrNone );

        }

    else if ( err != KErrNone )

        {

        iSearchList->Reset();

        TRAP_IGNORE( iArtistQuery->ResetL() );

        CallObserver( MMediaFileHandlerObserver::EError, err );

        }

    }

// -----------------------------------------------------------------------------

// CMediaFileHandler::HandleQueryCompletedL

// 

// -----------------------------------------------------------------------------

//

void CMediaFileHandler::HandleQueryCompletedL( CMdEQuery& /*aQuery*/, TInt aError )

    {

    TInt err = aError;

    if ( !iQuery && ( iRomScanState != MMediaFileHandlerObserver::ERomScanComplete 

    		&& (iQueryType == EQueryTone || iQueryType == ESearchTones )) )