/*

* Copyright (c) 2002-2009 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 FILES

#include <pathinfo.h>

#include <driveinfo.h>

#include <s32mem.h>

#include <bautils.h>

#include <mdeobjectquery.h>

#include <mdeconstants.h>

#include <collate.h>

#include "CLFConsts.h"

#include "CLFPanics.h"

#include "CCLFServerProxy.h"

#include "mdsutils.h"

// CONSTANTS

const TInt KCLFDefaultBufferLength( 64 );

const TInt KCLFDefaultArrayGranularity( 4 );

_LIT( KCLFDriveLetterFormatString, ":\\" );

const TInt KCLFDriveC( 'C' );

const TInt KDelayNotityCLFGetUpdateEventMaxTimes = 30;

const TInt KCLFWrapperHarvesterEventInterval = 60;

_LIT( KExtensionMp3,    "mp3" );

_LIT( KExtensionAac,    "aac" );

_LIT( KExtensionAmr,    "amr" );

_LIT( KExtensionAwb,    "awb" );

_LIT( KExtensionMid,    "mid" );

_LIT( KExtensionMidi,   "midi" );

_LIT( KExtensionSpMid,  "spmid" );

_LIT( KExtensionRng,    "rng" );

_LIT( KExtensionMxmf,   "mxmf" );

_LIT( KExtensionWav,    "wav" );

_LIT( KExtensionAu,     "au" );

_LIT( KExtensionWma,    "wma" );

_LIT( KExtensionNrt,    "nrt" );

_LIT( KExtensionRa,    "ra" );

_LIT( KExtJpg, "JPG" );

_LIT( KExtJpeg, "JPEG" );

_LIT( KExtJp2, "JP2" );

_LIT( KExtJ2k, "J2K" ); 

_LIT( KExtJpx, "JPX" ); 

_LIT( KExtJpf, "JPF" );

_LIT( KExtMbm, "MBM" ); 

_LIT( KExtPng, "PNG" );

_LIT( KExtGif, "GIF" );

_LIT( KExtBmp, "BMP" );

_LIT( KExtTif, "TIF" );

_LIT( KExtTiff, "TIFF" );

_LIT( KExtOta, "OTA" );

_LIT( KExtWbmp, "WBMP" );

_LIT( KExtWmf, "WMF" ); 

_LIT( KExtOtb, "OTB" ); 

_LIT(KExtOma1, "dcf");

_LIT(KExtOma2, "odf");

_LIT(KExtOma3, "dm");

_LIT(KExtOma4, "o4a");

_LIT(KExtOma5, "o4v");

_LIT( KExtensionMp4,   "mp4" );

_LIT( KExtensionMpg4,  "mpg4" );

_LIT( KExtensionMpeg4, "mpeg4" );

_LIT( KExtensionM4v,   "m4v" );

_LIT( KExtensionM4a,   "m4a" );

_LIT( KExtension3gp,   "3gp" );

_LIT( KExtension3gpp,  "3gpp" );

_LIT( KExtension3g2,   "3g2" );

_LIT( KExtensionRm,    "rm" );

_LIT( KExtensionRmvb,  "rmvb" );

_LIT( KExtensionRam,   "ram" );

_LIT( KExtensionRv,    "rv" );

_LIT( KExtensionWmv,    "wmv" );

_LIT( KExtensionAvi,    "avi" );

// ======== MEMBER FUNCTIONS ========

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

// CItemsDeletedHandler::CUpdateItemsHandler

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

//

inline CUpdateItemsHandler::CUpdateItemsHandler()

    : iWasNotificationHandled( EFalse ), iParentObserver( NULL ),

      iParentPresentObserver( NULL ), iRemoveObserver( EFalse )

    {

    }

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

// CUpdateIDsHandler::Start

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

//

void CUpdateItemsHandler::StartScheduler()

    {

    if( !iScheduler.IsStarted() )

        {

        iScheduler.Start();

        }

    }

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

// CUpdateIDsHandler::AsyncStop

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

//

void CUpdateItemsHandler::AsyncStopScheduler()

    {

    iScheduler.AsyncStop();

    }

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

// CUpdateIDsHandler::WasNotificationHandled

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

//

TBool CUpdateItemsHandler::WasNotificationHandled() const

    {

    return iWasNotificationHandled;

    }

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

// CUpdateIDsHandler::WasNotificationHandled

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

//

void CUpdateItemsHandler::SetRemoveObserverFlag( TBool aRemove )

    {

    iRemoveObserver = aRemove;

    }

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

// CUpdateIDsHandler::NewL

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

//

CUpdateIDsHandler* CUpdateIDsHandler::NewL( const TArray< TCLFItemId >& aItemIDArray )

    {

    CUpdateIDsHandler* self = new( ELeave ) CUpdateIDsHandler( aItemIDArray );

    return self;

    }

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

// CUpdateIDsHandler::~CUpdateIDsHandler

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

//

CUpdateIDsHandler::~CUpdateIDsHandler()

    {

    iIdsPendingUpdate.Reset();

    if ( iScheduler.IsStarted() )

        {

        iScheduler.AsyncStop();

        }

    }

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

// CUpdateFoldersHandler::~CUpdateFoldersHandler

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

//

void CUpdateIDsHandler::StartHandlingL()

    {

    // Pass through.

    }

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

// CUpdateIDsHandler::HandleObjectNotification

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

//

void CUpdateIDsHandler::HandleObjectNotification( const TItemId aId, TObserverNotificationType /* aType */ )

    {

    iWasNotificationHandled = EFalse;

    const TInt index = iIdsPendingUpdate.Find( aId );

    if ( index != KErrNotFound )

        {

        iWasNotificationHandled = ETrue;

        iIdsPendingUpdate.Remove( index );

        }

    }

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

// CUpdateIDsHandler::AllDone

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

//

TBool CUpdateIDsHandler::AllDone() const

    {

    return iIdsPendingUpdate.Count() == 0 ? ETrue : EFalse;

    }

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

// CUpdateIDsHandler::CUpdateIDsHandler

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

//

inline CUpdateIDsHandler::CUpdateIDsHandler( const TArray< TCLFItemId >& aItemIDArray )

    {

    const TInt idCount( aItemIDArray.Count() );

    for ( TInt i = 0; i < idCount; ++i )

        {

        if ( iIdsPendingUpdate.Find( aItemIDArray[ i ] ) == KErrNotFound )

            {

            iIdsPendingUpdate.Append( aItemIDArray[ i ] );

            }

        }

    }

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

// CItemsDeletedHandler::NewL

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

//

CItemsDeletedHandler* CItemsDeletedHandler::NewL( CMdESession& aMdESession, 

                                                                                    const CDesCArray& aUriArray,

                                                                                    MMdEObjectObserver* aParentObserver,

                                                                                    MMdEObjectPresentObserver* aParentPresentObserver )

    {

    CItemsDeletedHandler* self = new( ELeave ) CItemsDeletedHandler( aMdESession );

    CleanupStack::PushL( self );

    self->ConstructL( aUriArray, aParentObserver, aParentPresentObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CItemsDeletedHandler::~CUpdateItemsHandlerWithIDs

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

//

CItemsDeletedHandler::~CItemsDeletedHandler()

    {

    if( iRemoveObserver )

        {

        TRAP_IGNORE( iMdESession.RemoveObjectObserverL( *iParentObserver ) );

        TRAP_IGNORE( iMdESession.RemoveObjectPresentObserverL( *iParentPresentObserver ) );

        }

    iIdsPendingRemoval.Reset();

    iObjectsPendingRemoval.ResetAndDestroy();

    if ( iScheduler.IsStarted() )

        {

        iScheduler.AsyncStop();

        }

    }

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

// CUpdateFoldersHandler::StartHandlingL

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

//

void CItemsDeletedHandler::StartHandlingL()

    {

    const TInt count( iObjectsPendingRemoval.Count() );

    for ( TInt i = 0; i < count; ++i )

        {

        // If object for URI to be removed is in MDS, then remove it from MDS. Obviates

        // the need to rely on unreliable filemonitorplugin.

        const TItemId id = iMdESession.RemoveObjectL( iObjectsPendingRemoval[ i ]->Id() );

        if ( id != KNoId )

            {

            iIdsPendingRemoval.Append( id );

            }

        }

    iObjectsPendingRemoval.ResetAndDestroy();

    }

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

// CItemsDeletedHandler::HandleObjectNotification

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

//

void CItemsDeletedHandler::HandleObjectNotification( const TItemId aId, TObserverNotificationType aType )

    {

    iWasNotificationHandled = EFalse;

    if ( aType == ENotifyRemove )

        {

        const TInt index = iIdsPendingRemoval.Find( aId );

        if ( index != KErrNotFound )

            {

            iWasNotificationHandled = ETrue;

            iIdsPendingRemoval.Remove( index );

            }

        }

    }

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

// CUpdateIDsHandler::AllDone

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

//

TBool CItemsDeletedHandler::AllDone() const

    {

    return iIdsPendingRemoval.Count() == 0 ? ETrue : EFalse;

    }

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

// CItemsDeletedHandler::CItemsDeletedHandler

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

//

inline CItemsDeletedHandler::CItemsDeletedHandler( CMdESession& aMdESession )

      : iMdESession( aMdESession )

    {

    }

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

// CItemsDeletedHandler::ConstructL

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

//

inline void CItemsDeletedHandler::ConstructL( const CDesCArray& aUriArray,

                                                                            MMdEObjectObserver* aParentObserver,

                                                                            MMdEObjectPresentObserver* aParentPresentObserver)

    {

    iParentObserver = aParentObserver;

    iParentPresentObserver = aParentPresentObserver;

    // This leave is needed, if the handler was deleted earlier and the parent observer was removed 

    TRAP_IGNORE( iMdESession.AddObjectObserverL( *iParentObserver ) );

    TRAP_IGNORE( iMdESession.AddObjectPresentObserverL( *iParentPresentObserver ) );

    const TInt uriCount( aUriArray.Count() );

    for ( TInt i = 0; i < uriCount; ++i )

        {

        CMdEObject* object = NULL;

        object = iMdESession.GetObjectL( aUriArray.MdcaPoint( i ));

        CleanupStack::PushL( object );

        if ( object )

            {

            iObjectsPendingRemoval.AppendL( object );

            }

        CleanupStack::Pop( object );

        }

    iRemoveObserver = ETrue;

    }

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

// CUpdateFoldersHandler::NewL

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

//

CUpdateFoldersHandler* CUpdateFoldersHandler::NewL( CMdESession& aMdESession, const CDesCArray& aUriArray,

                                                                                       MMdEObjectObserver* aParentObserver, 

                                                                                       MMdEObjectPresentObserver* aParentPresentObserver, 

																					   RFs& aFs,

																					   RHarvesterClient& aHarvester,

																					   CDesCArray* aSupportedTypes )

    {

    CUpdateFoldersHandler* self = new( ELeave ) CUpdateFoldersHandler( aMdESession, 

                                                                            aFs, aHarvester, aSupportedTypes );

    CleanupStack::PushL( self );

    self->ConstructL( aUriArray, aParentObserver, aParentPresentObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpdateFoldersHandler::~CUpdateFoldersHandler

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

//

CUpdateFoldersHandler::~CUpdateFoldersHandler()

    {

    if( iRemoveObserver )

        {

        TRAP_IGNORE( iMdESession.RemoveObjectObserverL( *iParentObserver ) );

        TRAP_IGNORE( iMdESession.RemoveObjectPresentObserverL( *iParentPresentObserver ) );

        }

    iUrisFound.Reset();

    iFoldersFound.Reset();

    iIdsPendingRemoval.Reset();

    iIdsPendingUpdate.Reset();

    iIdsHandled.Reset();

    if ( iScheduler.IsStarted() )

        {

        iScheduler.AsyncStop();

        }

    }

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

// CUpdateFoldersHandler::StartHandlingL

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

//

void CUpdateFoldersHandler::StartHandlingL()

    {

    CMdEObjectQuery* query = NULL;

    iIdsPendingRemoval.Reset();

    iIdsPendingUpdate.Reset();

    iIdsHandled.Reset();

    iStartingHandling = ETrue;

    DoQueryL( query, iFoldersFound );

    CleanupStack::PushL( query );

    if( !iScheduler.IsStarted() )

        {

        iScheduler.Start();

        }

    TRAP_IGNORE( DetermineIdsToRemoveL( *query ) );

    TRAP_IGNORE( DetermineIdsToUpdateL( iUrisFound ) );

    CleanupStack::PopAndDestroy( query );

    iStartingHandling = EFalse;

    }

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

// CUpdateFoldersHandler::HandleObjectNotification

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

//

void CUpdateFoldersHandler::HandleObjectNotification( const TItemId aId, TObserverNotificationType aType )

    {

    iWasNotificationHandled = EFalse;

    if ( aType == ENotifyRemove )

        {

        const TInt index = iIdsPendingRemoval.Find( aId );

        if ( index != KErrNotFound )

            {

            iIdsPendingRemoval.Remove( index );

            iWasNotificationHandled = ETrue;

            }

        }

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

        {

        const TInt index = iIdsPendingUpdate.Find( aId );

        if ( index != KErrNotFound )

            {

            iIdsPendingUpdate.Remove( index );

            const TInt handledIndex = iIdsHandled.Find( aId );

            if( handledIndex != KErrNotFound )

                {

                iIdsHandled.Remove( handledIndex );

                }

            iWasNotificationHandled = ETrue;

            }

        else if( iHarvestingOngoing )

            { 

            iIdsHandled.Append( aId );

            iWasNotificationHandled = ETrue;

            }

        }

    }

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

// CUpdateFoldersHandler::AllDone

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

//

TBool CUpdateFoldersHandler::AllDone() const

    {

    return ( iIdsPendingRemoval.Count() == 0 &&

             iIdsPendingUpdate.Count() == 0 &&

             !iStartingHandling ) ? ETrue : EFalse;

    }

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

// CUpdateFoldersHandler::HandleQueryNewResults

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

//

void CUpdateFoldersHandler::HandleQueryNewResults( CMdEQuery& /* aQuery */, TInt /* aFirstNewItemIndex */, TInt /* aNewItemCount */ )

    {

    // Pass through.

    }

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

// CUpdateFoldersHandler::HandleQueryCompleted

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

//

void CUpdateFoldersHandler::HandleQueryCompleted( CMdEQuery& /* aQuery */, TInt /* aError */ )

    {

    iScheduler.AsyncStop();

    }

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

// CUpdateFoldersHandler::CUpdateFoldersHandler

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

//

inline CUpdateFoldersHandler::CUpdateFoldersHandler( CMdESession& aMdESession, 

                                                                                         RFs& aFs,

                                                                                         RHarvesterClient& aHarvester,

                                                                                         CDesCArray* aSupportedTypes )

    : iFs( aFs ),

      iUrisFound( KCLFDefaultArrayGranularity ),

      iFoldersFound( KCLFDefaultArrayGranularity ),

      iMdESession( aMdESession ),

      iHarvester( aHarvester ),

      iHarvestError( KErrNone ),

      iStartingHandling( EFalse ),

      iExtensionArray( aSupportedTypes ),

      iHarvestingOngoing( EFalse )

    {

    }

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

// CUpdateFoldersHandler::ConstructL

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

//

inline void CUpdateFoldersHandler::ConstructL( const CDesCArray& aUriArray,

                                                                             MMdEObjectObserver* aParentObserver,

                                                                             MMdEObjectPresentObserver* aParentPresentObserver )

    {

    iParentObserver = aParentObserver;

    iParentPresentObserver = aParentPresentObserver;

    // This leave is needed, if the handler was deleted earlier and the parent observer was removed 

    TRAP_IGNORE( iMdESession.AddObjectObserverL( *iParentObserver ) );

    TRAP_IGNORE( iMdESession.AddObjectPresentObserverL( *iParentPresentObserver ) );

    for ( TInt i = 0; i < aUriArray.MdcaCount(); ++i )

        {

        ScanNodeForUrisL( aUriArray.MdcaPoint( i ), iUrisFound, iFoldersFound );

        }

    iRemoveObserver = ETrue ;

    }

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

// CUpdateFoldersHandler::ScanNodeForUrisL

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

//