/*

* Copyright (c) 2007-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:  Handles monitored file creations, modifications and deletions.*

*/

#include <collate.h>

#include <mdeobject.h>

#include "fileeventhandlerao.h"

#include "harvesterlog.h"

#include "fsutil.h"

#include "mdeconstants.h"

#include "mdeharvestersession.h"

#include "processoriginmapper.h"

#include "mdenamespacedef.h"

#include "mdeobjectdef.h"

#include "FolderRenamer.h"

#include "mdsutils.h"

#include "harvesterpluginfactory.h"

#include "mdsfspqueue.h"

#include "harvestercommon.h"

#include <centralrepository.h>

using namespace MdeConstants;

const TUid KRepositoryUid = { 0x20007182 };

const TUint32 KCacheSizeKey = 0x00000001;

const TInt KMaxEventsAtTime = 25;

const TInt KMaxEventsGranularity = 20;

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

// CFileEventHandlerAO::NewL()

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

//

CFileEventHandlerAO* CFileEventHandlerAO::NewL( MMonitorPluginObserver& aObserver,

		CMdEHarvesterSession* aMdeSession, CHarvesterPluginFactory* aHarvesterPluginFactory )

    {

    WRITELOG( "CFileEventHandlerAO::NewL" );

    CFileEventHandlerAO* self = new (ELeave) CFileEventHandlerAO;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver, aMdeSession, aHarvesterPluginFactory );

    CleanupStack::Pop( self );

    return self;

    }

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

// CFileEventHandlerAO::ConstructL()

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

//

void CFileEventHandlerAO::ConstructL( MMonitorPluginObserver& aObserver,

		CMdEHarvesterSession* aMdeSession, CHarvesterPluginFactory* aHarvesterPluginFactory )

    {

    WRITELOG( "CFileEventHandlerAO::ConstructL" );

    iObserver = &aObserver;

    iHarvesterPluginFactory = aHarvesterPluginFactory;

    iMdeSession = aMdeSession;

    iNextRequest = ERequestIdle;

    iCacheEvents = EFalse;

    CActiveScheduler::Add( this );

    iMapper = CProcessOriginMapper::NewL();

    iMoveTimer = CMoveTimer::NewL(this);

    iFolderRenamer = CFolderRenamer::NewL(*this);

    TRAPD( error, iMapper->ReadFileL() );

    if ( error != KErrNone )

    	{

    	WRITELOG1( "CFileEventHandlerAO::ConstructL - iMapper->ReadFileL() error %d", error );

    	}

    error = iFs.Connect();

    User::LeaveIfError( error );

    TRAP( error, ReadCacheSizeFromCenrepL() );

    if ( error == KErrNone )

    	{

    	iQueue.Reserve( iCacheSize );

    	}

    iEventArray = new (ELeave) CArrayFixSeg< TMdsFSPStatus >( KMaxEventsGranularity );

    }

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

// CFileEventHandlerAO::~CFileEventHandlerAO()

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

//

CFileEventHandlerAO::~CFileEventHandlerAO()

    {

    WRITELOG( "CFileEventHandlerAO::~CFileEventHandlerAO" );

    Cancel();

    iFs.Close();

    delete iMapper;

    delete iMoveTimer;

    delete iFolderRenamer;

    delete iEventArray;

    iQueue.ResetAndDestroy();

    iQueue.Close();

    iUriArray.ResetAndDestroy();

    iUriArray.Close();

    }

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

// CFileEventHandlerAO::RunL()

// From CActive

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

//

void CFileEventHandlerAO::RunL()

    {

    WRITELOG( "CFileEventHandlerAO::RunL" );

    switch( iNextRequest )

    	{

    	case ( ERequestIdle ):

    		{

    	    iQueue.Compress();

    	    iEventArray->Compress();

    	    iUriArray.Compress();

        	break;

    		}

    	case ( ERequestProcessing ):

    		{

    		if( iQueue.Count() > 0 && !iCacheEvents )

    			{

    			CMdsFSPQueueItem* item = iQueue[0];

    			iQueue.Remove( 0 );

    			ResetEvent();

    			item->GetAsFspStatus(iEvent);

    			delete item;

    			if( iEvent.iFileEventType == EMdsFileDeleted )

    			    {

    			    iEventArray->AppendL( iEvent );

    			    TInt limit( KMaxEventsAtTime );

    			    const TInt count( iQueue.Count() );

    			    if( count >= KMaxEventsAtTime )

    			        {

    			        limit = KMaxEventsAtTime;

    			        }

    			    else

    			        {

    			        limit = count;

    			        }

    	            for( TInt i( 0 ); i < limit; i++ )

    	                {

    	                CMdsFSPQueueItem* tempItem = iQueue[0];

    	                TMdsFSPStatus status;

    	                tempItem->GetAsFspStatus( status );

    	                if( status.iFileEventType == EMdsFileDeleted  )

    	                    {

    	                    iQueue.Remove( 0 );

    	                    delete tempItem;

    	                    tempItem = NULL;

    	                    iEventArray->AppendL( status );

    	                    }

    	                else

    	                    {

    	                    break;

    	                    }

    	                }

    			    }

    			if( iEventArray->Count() > 1 )

    			    {

    			    iFolderRenamer->HandleFileEventsL(iEventArray);

    			    }

    			else

    			    {

    			    iFolderRenamer->HandleFileEventL(iEvent);

    			    }

    			SetNextRequest( ERequestProcessing );

    			}

    		else

    			{

    			SetNextRequest( ERequestIdle );

    			}

        	break;

    		}

    	default:

    		break;

    	}

    }

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

// CFileEventHandlerAO::HandleNotificationL()

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

//

void CFileEventHandlerAO::HandleNotificationL(TMdsFSPStatus &aEvent)

    {

    WRITELOG( "CFileEventHandlerAO::HandleNotificationL" );

    TMdsFSPStatus& status = aEvent;

    if ( !iObserver )

        {

        WRITELOG( "-- ERROR -- CFileEventHandlerAO::HandleNotificationL - no observer" );

        return;

        }

    TBool fastHarvest( EFalse );

    TOrigin origin = MdeConstants::Object::EOther;

    if ( iMapper )

        {

        origin = iMapper->OriginL( status.iProcessId );

        if ( origin == KOriginIgnored )

            {

            WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - ignored origin for %S", &status.iFileName );

            return;

            }

        else if( origin == KOriginFastHarvest )

            {

            WRITELOG( "CFileEventHandlerAO::HandleNotificationL - potential fast harvest file detected" );

            fastHarvest = ETrue;

            }

        _LIT(KCameraTemp,"camcordertmp");

        if ( origin == MdeConstants::Object::ECamera &&

        		(aEvent.iFileEventType == EMdsFileCreated || 

				aEvent.iFileName.FindF(KCameraTemp) != KErrNotFound) )        		

            {

            WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - ignored camera origin for %S", &status.iFileName );

            return;

            }

        if( (origin == KOriginIgnoreAttribsChanged ||

             origin == MdeConstants::Object::ECamera ) &&

            aEvent.iFileEventType == EMdsFileAttribsChanged )

            {

            WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - ignored attribs changed event for %S", &status.iFileName );

            return;        

            }

        }

    // ignore created file event if extension is not supported by any harverter plugin

    if( EMdsFileCreated == status.iFileEventType && 

    		status.iFileName.Length() > 0 )

    	{

    	if( !iHarvesterPluginFactory->IsSupportedFileExtension( 

    			status.iFileName ) )

    		{

    		WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - file extension not supported: %S", &status.iFileName );

    		return;

    		}

    	}

    switch( status.iFileEventType )

        {

        case EMdsFileCreated:

            {

            WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - EmdsFileCreated: %S", &status.iFileName );

            HBufC* fn = status.iFileName.AllocLC();

            CHarvesterData* hd = CHarvesterData::NewL( fn );

            CleanupStack::Pop( fn );

            hd->SetEventType( EHarvesterAdd );

            hd->SetOrigin( origin );

            CleanupStack::PushL( hd );

            iMoveTimer->AddHarvesterDataL( hd );

            CleanupStack::Pop( hd );

            }

        break;

        case EMdsFileRenamed:

            {

            WRITELOG2( "CFileEventHandlerAO::HandleNotificationL - EMdsFileRenamed: %S to %S", &status.iFileName, &status.iNewFileName );

            RenameToMDEL( status.iFileName, status.iNewFileName, origin );

            }

        break;

        case EMdsFileModified:

        case EMdsFileAttribsChanged:

            {

            WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - EmdsFileModified: %S", &status.iFileName );

            ModifyL( status.iFileName, origin, fastHarvest );

            }

        break;

        case EMdsFileReplaced:

            {

            WRITELOG2( "CFileEventHandlerAO::HandleNotificationL - EMdsFileReplaced: %S to %S", &status.iFileName, &status.iNewFileName );

            ReplaceL( status.iFileName, status.iNewFileName, origin, fastHarvest );

            }

        break;

        case EMdsFileDeleted:

            {

            WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - EmdsFileDeleted: %S", &status.iFileName );

            CHarvesterData* hd = iMoveTimer->CheckUriL( status.iFileName );

            if ( hd )

            	{

            	// move event

            	CleanupStack::PushL( hd );

            	RenameToMDEL( status.iFileName, hd->Uri(), hd->Origin() );

            	CleanupStack::PopAndDestroy( hd );

            	}

            else

                {

                DeleteFromMDEL( status.iFileName );

                }

            }

        break;

        case EMdsDriveFormatted:

        	{

        	WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - EMdsDriveFormatted: %d", status.iDriveNumber );

        	// format drive

        	FormatL( status.iDriveMediaId, status.iProcessId.iUid != 0 );

        	}

        break;

        default:

            WRITELOG1( "CFileEventHandlerAO::HandleNotificationL - KErrNotSupported %d", status.iFileEventType );

            User::Leave( KErrNotSupported );

        break;

        }

    }

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

// CFileEventHandlerAO::HandleMultideletionL()

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

//

void CFileEventHandlerAO::HandleMultideletionL( CArrayFixSeg< TMdsFSPStatus >* aEvents )

    {

    WRITELOG( "CFileEventHandlerAO::HandleMultideletionL" );

    if ( !iObserver )

        {

        WRITELOG( "-- ERROR -- CFileEventHandlerAO::HandleMultideletionL - no observer" );

        return;

        }

    const TInt count( aEvents->Count() );

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

        {

        TMdsFSPStatus& status = (*aEvents)[i];

        TOrigin origin = MdeConstants::Object::EOther;

        if ( iMapper )

            {

            origin = iMapper->OriginL( status.iProcessId );

            // Used only for delete events so fast harvest origin is not used

            if ( origin == KOriginIgnored )

                {

                WRITELOG1( "CFileEventHandlerAO::HandleMultideletionL - ignored origin for %S", &status.iFileName );

                continue;

                }

            }

        WRITELOG1( "CFileEventHandlerAO::HandleMultideletionL - EmdsFileDeleted: %S", &status.iFileName );

        CHarvesterData* hd = iMoveTimer->CheckUriL( status.iFileName );

        if ( hd )

            {

            // move event

            CleanupStack::PushL( hd );

            RenameToMDEL( status.iFileName, hd->Uri(), hd->Origin() );

            CleanupStack::PopAndDestroy( hd );

            }

        else

            {

            iUriArray.Append( &(status.iFileName) );

            }

        }

    MultiDeleteFromMDEL( iUriArray );

    }

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

// CFileEventHandlerAO::ResetMdsFSPStatus()

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

//

void CFileEventHandlerAO::ResetEvent()

    {

    WRITELOG( "CFileEventHandlerAO::ResetEvent" );

    iEvent.iDriveNumber = 0;

    iEvent.iFileEventType = EMdsFileUnknown;

    iEvent.iFileName.Zero();

    iEvent.iNewFileName.Zero();

    iEvent.iProcessId = TUid::Null();

    iEventArray->Reset();

    iUriArray.Reset();

    }

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

// CFileEventHandlerAO::RenameToMDEL()

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

//

void CFileEventHandlerAO::RenameToMDEL( const TDesC& aOldUrl, 

		const TDesC& aNewUrl, TOrigin aOrigin )

    {

    WRITELOG( "CFileEventHandlerAO::RenameToMDEL" );

    CMdEObject* oldObject = iMdeSession->Session()->OpenObjectL( aOldUrl );

    if ( oldObject )

        {

        CleanupStack::PushL( oldObject );

        }

    CMdEObject* newObject = iMdeSession->Session()->GetObjectL( aNewUrl );

    if ( newObject )

        {

        CleanupStack::PushL( newObject );

        }

    // check if not in mde, harvest

    if ( !oldObject && !newObject && iObserver )

        {

        HBufC* fn = aNewUrl.AllocLC();

        CHarvesterData* hd = CHarvesterData::NewL( fn );

        CleanupStack::Pop( fn );

        hd->SetEventType( EHarvesterAdd );

        hd->SetOrigin( aOrigin );

        iObserver->MonitorEvent( hd );

        }

    // set old url to new url

    if ( oldObject && !newObject )

        {

        SetTitleL( oldObject , aNewUrl );

        oldObject->SetUriL( aNewUrl );

        TUint32 mediaId = FSUtil::MediaID( iFs, aNewUrl );

        oldObject->SetMediaId( mediaId );

        }

    // if old and new then destroy new and change old

    if ( oldObject && newObject && ( oldObject->Id() != newObject->Id()) )

        {

        const TItemId removedId = iMdeSession->Session()->RemoveObjectL( 

        		newObject->Id() );

        if ( removedId != KNoId )

        	{

	        oldObject->SetUriL( aNewUrl );

	        TUint32 mediaId = FSUtil::MediaID( iFs, aNewUrl );

	        oldObject->SetMediaId( mediaId );

        	}

        }

    if ( newObject )

        {

        CleanupStack::PopAndDestroy( newObject );

        }

    if ( oldObject )

        {

        SetModifiedTimeL( oldObject, aNewUrl );

        TOrigin origin = OriginFromMdEObjectL( *oldObject );

        if( origin == MdeConstants::Object::EOther)

        	{

        	OriginToMdEObjectL( *oldObject, aOrigin );

        	}

        iMdeSession->Session()->CommitObjectL( *oldObject );

        CleanupStack::PopAndDestroy( oldObject );

        }

    }

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

// CFileEventHandlerAO::OriginFromMdEObject()

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

//

TOrigin CFileEventHandlerAO::OriginFromMdEObjectL( CMdEObject& aObject )

	{

	TOrigin retVal = MdeConstants::Object::EOther;

	if( !iOriginPropertyDef )

		{

		CMdEObjectDef& objDef = aObject.Def();

		iOriginPropertyDef = &objDef.GetPropertyDefL( Object::KOriginProperty );

		}

	CMdEProperty* property = NULL;

	TInt err = aObject.Property( *iOriginPropertyDef, property );

	if( err >= KErrNone && property )

		{

		CMdEUint8Property* uint8Property = (CMdEUint8Property*)property;

		retVal = (TOrigin) uint8Property->Value();

		}

	return retVal;

	}

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

// CFileEventHandlerAO::OriginFromMdEObject()

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

//

void CFileEventHandlerAO::OriginToMdEObjectL( CMdEObject& aObject, 

		TOrigin aOrigin )

	{

	if( !iOriginPropertyDef )

		{

		CMdEObjectDef& objDef = aObject.Def();

		iOriginPropertyDef = &objDef.GetPropertyDefL( 

				Object::KOriginProperty );

		}

	CMdEProperty* property = NULL;

	TInt err = aObject.Property( *iOriginPropertyDef, property );

	if(err < KErrNone)

		{

		return;

		}

	if( property )