/*

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

*

*/

#include "audiofetcherfilehandler.h"

#include "audiofetcherlog.h"

#include <pathinfo.h>

#include <bautils.h>

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

 * class CAudioFetcherFileHandler

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

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

// CAudioFetcherFileHandler::NewL

// 

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

//

CAudioFetcherFileHandler* CAudioFetcherFileHandler::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

// 

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

//

CAudioFetcherFileHandler::~CAudioFetcherFileHandler()

    {

    WLOG("CAudioFetcherFileHandler::~CAudioFetcherFileHandler >");

    if ( iSearchList )

        {

        iSearchList->Reset();

        }

    delete iSearchList;

    delete iQueryCaller;

    delete iObjectNotificationCaller;

    delete iDriveUtil;

    WLOG("CAudioFetcherFileHandler::~CAudioFetcherFileHandler before iQuery");

    if ( iQuery )

        {

        iQuery->Cancel();

        }

    delete iQuery;

    WLOG("CAudioFetcherFileHandler::~CAudioFetcherFileHandler after iQuery");

    delete iSession;

    WLOG("CAudioFetcherFileHandler::~CAudioFetcherFileHandler <");

    }

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

// CAudioFetcherFileHandler::CAudioFetcherFileHandler

// 

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

//

CAudioFetcherFileHandler::CAudioFetcherFileHandler()

    {

    iSessionOpen = EFalse;

    iObserverCallEnabled = ETrue;

    iMaxFileSize = KErrNotFound;

    iQueryId = KErrNotFound;

    iQueryType = KErrNotFound;

    iQueryError = KErrNone;

    iQueryEvent = KErrNotFound;

    }

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

// CAudioFetcherFileHandler::ConstructL

// 

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

//

void CAudioFetcherFileHandler::ConstructL()

    {

    WLOG("CAudioFetcherFileHandler::ConstructL >");

    iSession = CMdESession::NewL( *this );

    iSearchList = CSearchList::NewL();

    iQueryCaller = CActiveCaller::NewL( this );

    iObjectNotificationCaller = CActiveCaller::NewL( this );

    iDriveUtil = CDriveUtil::NewL();

    WLOG("CAudioFetcherFileHandler::ConstructL <");

    }

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

// CAudioFetcherFileHandler::HandleSessionOpened (from MMdESessionObserver)

// 

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

//

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

    {

    WLOG("CAudioFetcherFileHandler::HandleSessionOpened >");

    if ( aError != KErrNone )

        {

        delete iSession;

        iSession = NULL;

        iSessionOpen = EFalse;

        }

    else

        {

        iSessionOpen = ETrue;

        TRAP_IGNORE( AddObjectObserverL() );

        }

    CallObserver( MAudioFetcherFileHandlerObserver::EInitComplete, aError );

    WLOG("CAudioFetcherFileHandler::HandleSessionOpened <");

    }

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

// CAudioFetcherFileHandler::AddObjectObserverL

// 

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

//

void CAudioFetcherFileHandler::AddObjectObserverL()

    {

    WLOG("CAudioFetcherFileHandler::AddObjectObserverL >");

    if ( iSessionOpen )

        {

        TUint32 notificationType = ENotifyAdd | ENotifyModify | ENotifyRemove;

        CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();

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

        iSession->AddObjectPresentObserverL( *this );

        }

    WLOG("CAudioFetcherFileHandler::AddObjectObserverL <");

    }

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

// CAudioFetcherFileHandler::HandleSessionError (from MMdESessionObserver)

// 

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

//

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

    {

    WLOG("CAudioFetcherFileHandler::HandleSessionError >");

    if ( aError == KErrNone )

        {

        return;

        }

    delete iSession;

    iSession = NULL;

    iSessionOpen = EFalse;

    CallObserver( MAudioFetcherFileHandlerObserver::EError, aError );

    WLOG("CAudioFetcherFileHandler::HandleSessionError <");

    }

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

// CAudioFetcherFileHandler::HandleQueryNewResults (from MMdEQueryObserver)

// 

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

// in second parameter of CMdEQuery::FindL.

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

//

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

                                               TInt /*aFirstNewItemIndex*/,

                                               TInt /*aNewItemCount*/ )

    {

    }

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

// CAudioFetcherFileHandler::HandleObjectNotification (MMdEObjectObserver)

// 

// Called when metadata database changes.

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

//

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

                                        TObserverNotificationType aType,

                                        const RArray<TItemId>& aObjectIdArray )

    {

    WLOG("CAudioFetcherFileHandler::HandleObjectNotification >");

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

        {

        if ( iObserver )

            {

            TInt count = aObjectIdArray.Count();

            WLOG1("CAudioFetcherFileHandler::HandleObjectNotification: count is %d", count );

            // delayed call to avoid many consecutive observer calls

            CallObserverWithDelay();

            }

        }

    WLOG("CAudioFetcherFileHandler::HandleObjectNotification <");

    }

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

// CAudioFetcherFileHandler::HandleObjectPresentNotification (MMdEObjectPresentObserver)

// 

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

// metadata files are made present again.

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

//

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

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

    {

    WLOG("CAudioFetcherFileHandler::HandleObjectPresentNotification >");

    if ( iObserver )

        {

        TInt count = aObjectIdArray.Count();

        WLOG1("CAudioFetcherFileHandler::HandleObjectPresentNotification: count is %d", count );

        // delayed call to avoid many consecutive observer calls

        CallObserverWithDelay();

        }

    WLOG("CAudioFetcherFileHandler::HandleObjectPresentNotification <");

    }

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

// CAudioFetcherFileHandler::HandleQueryCompleted (MMdEQueryObserver)

// 

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

//

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

    {

    WLOG("CAudioFetcherFileHandler::HandleQueryCompleted >");

    TInt err = KErrNone;

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

    if ( err == KErrCancel )

        {

        CallObserver( MAudioFetcherFileHandlerObserver::EQueryCanceled, KErrNone );

        }

    else if ( err != KErrNone )

        {

        iSearchList->Reset();

        CallObserver( MAudioFetcherFileHandlerObserver::EError, err );

        }

    WLOG("CAudioFetcherFileHandler::HandleQueryCompleted <");

    }

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

// CAudioFetcherFileHandler::HandleQueryCompletedL

// 

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

//

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

    {

    WLOG("CAudioFetcherFileHandler::HandleQueryCompletedL >");

    TInt err = aError;

    if ( !iQuery )

        {

        err = KErrGeneral;

        }

    if ( err == KErrCancel )

        {

        iSearchList->Reset();

        return;

//        User::Leave( err );

        }

    if ( err != KErrNone )

        {

        User::Leave( err );

        }

    iSearchList->SetSession( iSession );

    TQueryResultMode resultMode = iQuery->ResultMode();

    if ( resultMode == EQueryResultModeCount )

        {

        // EQueryResultModeCount currently not used

        CallObserver( MAudioFetcherFileHandlerObserver::EUnknownQueryComplete, KErrNone );

        }

    else if ( resultMode == EQueryResultModeItem )

        {

        if ( iQueryType == ESearchAudio )

            {

            // ESearchAudio currently not used

            iSearchList->Reset();

            iSearchList->TakeResultL( iQuery, EMediaTypeMusic );           

            }

        else if ( iQueryType == ESearchMusic )

            {

            // search is done in 3 steps (music, tones and videos)

            iSearchList->Reset();

            iSearchList->TakeResultL( iQuery, EMediaTypeMusic );

            }

        else if ( iQueryType == ESearchTones )

            {

            iSearchList->TakeResultL( iQuery, EMediaTypeTone );

            }

        else if ( iQueryType == EQueryUnknown )

            {

            iSearchList->Reset();

            iSearchList->TakeResultL( iQuery, EMediaTypeMusic );

            iSearchList->SetSearchId( iQueryId );     

            CallObserver( MAudioFetcherFileHandlerObserver::EUnknownQueryComplete, KErrNone );

            }

        else

            {

            TInt mediaType = MediaType( iQueryType );

            iSearchList->TakeResultL( iQuery, mediaType );

            iSearchList->SetSearchId( iQueryId );

            iSearchList->Sort();

            CallObserver( MAudioFetcherFileHandlerObserver::EQueryComplete, KErrNone );

            }

        }

    else

        {

        CallObserver( MAudioFetcherFileHandlerObserver::EError, KErrNotSupported );

        }

    WLOG("CAudioFetcherFileHandler::HandleQueryCompletedL <");

    }

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

// CAudioFetcherFileHandler::EQueryImage

// 

// Finds image files.

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

//

void CAudioFetcherFileHandler::QueryImageL()

    {

    WLOG("CAudioFetcherFileHandler::EQueryImageL >");

    LeaveIfSessionClosedL();

    CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();

    CMdEObjectDef& imageObjectDef =

    defNS.GetObjectDefL( MdeConstants::Image::KImageObject );

    delete iQuery;

    iQuery = NULL;

    iQuery = iSession->NewObjectQueryL( defNS, imageObjectDef, this );

    // set attributes that are included in query result  

    CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );

    iQuery->AddPropertyFilterL( &namePropertyDef );

    CMdEPropertyDef& fileTypePropertyDef = PropertyDefL( EAttrMediaType );

    iQuery->AddPropertyFilterL( &fileTypePropertyDef );

    CMdELogicCondition& conditions = iQuery->Conditions();

    ExcludeRomFilesL( conditions );

    iQuery->SetResultMode( EQueryResultModeItem );

    iQuery->FindL();

    iQueryType = EMediaTypeImage;

    WLOG("CAudioFetcherFileHandler::QueryImageL <");

    }

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

// CAudioFetcherFileHandler::QueryAudioL

// 

// Finds music files.

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

//

void CAudioFetcherFileHandler::QueryAudioL()

    {

    WLOG("CAudioFetcherFileHandler::QueryAudioL >");

    LeaveIfSessionClosedL();

    CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();

    CMdEObjectDef& musicObjectDef =

    defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );

    delete iQuery;

    iQuery = NULL;

    iQuery = iSession->NewObjectQueryL( defNS, musicObjectDef, this );

    // set attributes that are included in query result  

    CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );

    iQuery->AddPropertyFilterL( &namePropertyDef );

    CMdEPropertyDef& fileTypePropertyDef = PropertyDefL( EAttrMediaType );

    iQuery->AddPropertyFilterL( &fileTypePropertyDef );

    CMdELogicCondition& conditions = iQuery->Conditions();

    ExcludeRomFilesL( conditions );

    // define sort order

    // iQuery->AppendOrderRuleL( TMdEOrderRule( namePropertyDef, ESortAscending ) );

    iQuery->SetResultMode( EQueryResultModeItem );

    iQuery->FindL();

    iQueryType = EMediaTypeMusic;

    WLOG("CAudioFetcherFileHandler::QueryAudioL <");

    }

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

// CAudioFetcherFileHandler::QueryAudioL

// 

// Finds music files.

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

//

void CAudioFetcherFileHandler::QueryVideoL()

    {

    WLOG("CAudioFetcherFileHandler::QueryVideoL >");

    LeaveIfSessionClosedL();

    CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();

    CMdEObjectDef& videoObjectDef =

    defNS.GetObjectDefL( MdeConstants::Video::KVideoObject );

    delete iQuery;

    iQuery = NULL;

    iQuery = iSession->NewObjectQueryL( defNS, videoObjectDef, this );

    // set attributes that are included in query result  

    CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );

    iQuery->AddPropertyFilterL( &namePropertyDef );

    CMdEPropertyDef& fileTypePropertyDef = PropertyDefL( EAttrMediaType );

    iQuery->AddPropertyFilterL( &fileTypePropertyDef );

    CMdELogicCondition& conditions = iQuery->Conditions();

    ExcludeRomFilesL( conditions );

    iQuery->SetResultMode( EQueryResultModeItem );

    iQuery->FindL();

    iQueryType = EMediaTypeVideo;

    WLOG("CAudioFetcherFileHandler::QueryVideoL <");

    }

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

// CAudioFetcherFileHandler::ResultCount

// 

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

//

TInt CAudioFetcherFileHandler::ResultCount()

    {

    WLOG("CAudioFetcherFileHandler::ResultCount");

    if ( !iSessionOpen )

        {

        return 0;

        }

    return iSearchList->Count();

    }

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

// CAudioFetcherFileHandler::CancelQuery

// 

// Cancels ongoing query.

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

//

void CAudioFetcherFileHandler::CancelQuery()

    {

    WLOG("CAudioFetcherFileHandler::CancelQuery >");

    if ( !iSessionOpen || !iQuery )

        {

        return;

        }

    if ( !iQuery->IsComplete() )

        {

        iQuery->Cancel(); // this calls HandleQueryCompleted synchronously

        }

    WLOG("CAudioFetcherFileHandler::CancelQuery <");

    }

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

// CAudioFetcherFileHandler::LeaveIfSessionClosedL

// 

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

//

void CAudioFetcherFileHandler::LeaveIfSessionClosedL()

    {

    WLOG("CAudioFetcherFileHandler::LeaveIfSessionClosedL >");

    if ( !iSession || !iSessionOpen )

        {

        User::Leave( KErrDisconnected );

        }

    WLOG("CAudioFetcherFileHandler::LeaveIfSessionClosedL <");

    }

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

// CAudioFetcherFileHandler::SetObserver

// 

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

//

void CAudioFetcherFileHandler::SetObserver( MAudioFetcherFileHandlerObserver* aObserver )