/*

* Copyright (c) 2006-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 mount tasks*

*/

#include <driveinfo.h>

#ifdef __WINSCW__

#include <pathinfo.h>

#endif

#include <placeholderdata.h>

#include "mmcmounttaskao.h"

#include "mmcmonitorplugin.h"

#include "harvesterlog.h"

#include "mdsfileserverpluginclient.h"

#include "mdeharvestersession.h"

#include "harvesterdata.h"

#include "mdsutils.h"

#include "harvestercenreputil.h"

#include "fsutil.h"

#include "harvesterplugininfo.h"

#include "harvesterpluginfactory.h"

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

// CMMCMountTaskAO

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

CMMCMountTaskAO* CMMCMountTaskAO::NewL()

	{

	WRITELOG( "CMMCMountTaskAO::NewL" );

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

void CMMCMountTaskAO::ConstructL()

	{

	WRITELOG("CMMCMountTaskAO::ConstructL");

	CActiveScheduler::Add( this );

	User::LeaveIfError( iFs.Connect() );

	iNextRequest = ERequestIdle;

	iMmcFileList = CMmcFileList::NewL();

	iCacheEvents = EFalse;

	iHEM = CHarvesterEventManager::GetInstanceL();

	}

CMMCMountTaskAO::CMMCMountTaskAO() :

		CActive( KHarvesterPriorityMonitorPlugin )

	{

	WRITELOG( "CMMCMountTaskAO::CMMCMountTaskAO" );

	}

CMMCMountTaskAO::~CMMCMountTaskAO()

	{

	WRITELOG( "CMMCMountTaskAO::~CMMCMountTaskAO" );

	Cancel();

	iFs.Close();

	iMountDataQueue.ResetAndDestroy();

	iEntryArray.ResetAndDestroy();

	iHarvestEntryArray.ResetAndDestroy();

	delete iMdeSession;

	Deinitialize();

	if (iHEM)

		{

		iHEM->ReleaseInstance();

		}

	delete iMmcFileList;

	iHdArray.ResetAndDestroy();

	iHdArray.Close();

	}

void CMMCMountTaskAO::SetMonitorObserver( MMonitorPluginObserver& aObserver )

	{

	WRITELOG( "CMMCMountTaskAO::SetMonitorObserver" );

	iObserver = &aObserver;

	}

void CMMCMountTaskAO::SetMdeSession( CMdEHarvesterSession* aMdeSession )

	{

	iMdeSession = aMdeSession;

	}

void CMMCMountTaskAO::SetHarvesterPluginFactory( CHarvesterPluginFactory* aPluginFactory )

	{

	iHarvesterPluginFactory = aPluginFactory;

	}

void CMMCMountTaskAO::StartMount( TMountData& aMountData )

	{

	WRITELOG("CMMCMountTaskAO::StartMount");

	iMountDataQueue.Append( &aMountData );

	if ( iNextRequest == ERequestIdle )

		{

		SetNextRequest( ERequestStartTask );

		}

	}

void CMMCMountTaskAO::StartUnmount(TMountData& aMountData)

	{

	WRITELOG("CMMCMountTaskAO::StartUnmount");

	// make sure that drive is not currently mounting

	if ( iMountData )

		{

		if ( iMountData->iDrivePath.Compare( aMountData.iDrivePath ) == 0 )

			{

			Cancel();

			Deinitialize();

			}

		}

	iMountDataQueue.Append( &aMountData );

	SetNextRequest( ERequestStartTask );

	}

void CMMCMountTaskAO::RunL()

	{

	WRITELOG1( "CMMCMountTaskAO::RunL iStatus: %d", iStatus.Int() );

	User::LeaveIfError( iStatus.Int() );

	if ( iCacheEvents )

		{

		if ( iMountData )

			{

			iMountDataQueue.Insert( iMountData, 0 );

			iMountData = NULL;

			}

		Deinitialize();

		return;

		}

	switch( iNextRequest )

		{

		case ERequestStartTask:

			{

			WRITELOG( "CMMCMountTaskAO::RunL - ERequestStartTask" );

			if ( iMountData )

				{

				delete iMountData;

				iMountData = NULL;

				}

			iHdArray.ResetAndDestroy();

			if( iMountDataQueue.Count() > 0 )

				{

				iMountData = iMountDataQueue[0];

				iMountDataQueue.Remove(0);

				WRITELOG1( "iMountData.iMountType: %d", iMountData->iMountType );

				WRITELOG1( "iMountData.iDrivePath: %S", &iMountData->iDrivePath );

				WRITELOG1( "iMountData.iMediaID: %d", iMountData->iMediaID );

				if ( iMountData->iMountType == TMountData::EMount )

					{

					SetNextRequest( ERequestMount );

					}

				else if ( iMountData->iMountType == TMountData::EUnmount )

					{

					SetNextRequest( ERequestUnmount );

					}

				else if ( iMountData->iMountType == TMountData::EFormat )

					{

					SetNextRequest( ERequestFormat );

					}

				}

			else

				{

				SetNextRequest( ERequestIdle );

				iMountDataQueue.Compress();

				}

			}

		break;

		case ERequestMount:

			{

			WRITELOG( "CMMCMountTaskAO::RunL - ERequestMount" );

			Initialize();

			StartNotifyL();

			SetNotPresentToMDE();

			TRAPD( err, iMmcFileList->BuildFileListL( iFs, iMountData->iDrivePath, iEntryArray ));

			if ( err == KErrNoMemory )

				{

				iMountDataQueue.Insert( iMountData, 0 );

				iMountData = NULL;

				Deinitialize();

				SetNextRequest( ERequestStartTask );

				break;

				}

			// send start event

			const TInt entryCount = iEntryArray.Count();

			if( entryCount > 0 )

				{

				iHEM->IncreaseItemCount( EHEObserverTypeMMC, entryCount );

				iHEM->SendEventL( EHEObserverTypeMMC, EHEStateStarted, iHEM->ItemCount( EHEObserverTypeMMC ) );

				}

			SetNextRequest( ERequestHandleFileEntry );

			}

		break;

		case ERequestUnmount:

			{

			WRITELOG( "CMMCMountTaskAO::RunL - ERequestUnmount" );

			const TUint entryCount = iEntryArray.Count();

			WRITELOG1( "CMMCMountTaskAO::RunL - ERequestUnmount entryCount = %d", entryCount );

            if( entryCount )

        		{

        		iHEM->DecreaseItemCountL( EHEObserverTypeMMC, entryCount );

		        }

            const TUint harvestEntryCount = iHarvestEntryArray.Count();

            WRITELOG1( "CMMCMountTaskAO::RunL - ERequestUnmount harvestEntryCount = %d", harvestEntryCount );

            if( harvestEntryCount )

                {

                iHEM->DecreaseItemCountL( EHEObserverTypeMMC, harvestEntryCount );

                }

			RMsgQueue<TInt> unmountQueue;

			_LIT( KUnmountHandlerAOString, "unmounthandlerao" );

			const TInt err = unmountQueue.OpenGlobal( KUnmountHandlerAOString );

			if( err == KErrNone )

				{

				unmountQueue.Send( iMountData->iMediaID );

				}

			SetNotPresentToMDE();

			StopNotifyL();

			SetNextRequest( ERequestCleanup );

			}

		break;

		case ERequestFormat:

			{

			WRITELOG( "CMMCMountTaskAO::RunL - ERequestFormat" );

			SetNotPresentToMDE();

			RemoveNotPresentFromMDE();

			StopNotifyL();

			SetNextRequest( ERequestCleanup );

			}

		break;

		case ERequestHandleFileEntry:

			{

			WRITELOG( "CMMCMountTaskAO::RunL - ERequestHandleFileEntry" );

			if( iNextRequest == ERequestStartTask )

                {

                WRITELOG( "CMMCMountTaskAO::RunL - ERequestHandleFileEntry stop processing media is unmounted");

                SetNextRequest( ERequestStartTask );

				return;

                }

            else if ( iEntryArray.Count() > 0 )

				{

				TRAPD( err, iMmcFileList->HandleFileEntryL( *iMdeSession, iEntryArray, 

						iHarvestEntryArray, iMountData->iMediaID, iHarvesterPluginFactory ));

				if ( err != KErrNone )

					{

					if( err == KErrNoMemory )

						{

						iMountDataQueue.Insert( iMountData, 0 );

						iMountData = NULL;

						}

					Deinitialize();

					SetNextRequest( ERequestStartTask );

					break;

					}

	            if ( iEntryArray.Count() > 0 )

	                {

	                SetNextRequest( ERequestHandleFileEntry );

	                break;

	                }

				}

		    if ( iHarvestEntryArray.Count() > 0 )

				{

				SetNextRequest( ERequestHandleReharvest );

				break;

				}

			else

				{

                // All detected entries are set as present at this stage, clear not present entries

                RemoveNotPresentFromMDE();

                SetNextRequest( ERequestCleanup );

                break;

				}

			}

		case ERequestHandleReharvest:

			{

			WRITELOG( "CMMCMountTaskAO::RunL - ERequestHandleReharvest" );

			if( iNextRequest == ERequestStartTask )

                {

                WRITELOG( "CMMCMountTaskAO::RunL - ERequestHandleReharvest stop processing media is unmounted");

                SetNextRequest( ERequestStartTask );

				return;

                }

         	else if ( iHarvestEntryArray.Count() > 0 )

				{

				HandleReharvestL( iHarvestEntryArray );

				SetNextRequest( ERequestHandleReharvest );

				break;

				}

          	else

				{

                if ( iObserver )

                    {

                    if( iHdArray.Count() > 0)

                        {

                        iObserver->MonitorEvent( iHdArray );

                        }

                    }

                iHdArray.Reset();

                iHdArray.Compress();

				SetNextRequest( ERequestHandleFileEntry );

				break;

				}

			}

		case ERequestCleanup:

			{

			WRITELOG( "CMMCMountTaskAO::RunL - ERequestCleanup" );

			TBool present = (iMountData->iMountType == TMountData::EMount);

			iMdeSession->SetMediaL( iMountData->iMediaID, iMountData->iDrivePath[0], present );

			Deinitialize();

			SetNextRequest( ERequestStartTask );

			}

		break;

		case ERequestIdle:

			{

			WRITELOG( "CMMCMountTaskAO::RunL - ERequestIdle" );

			// all done

			}

		break;

		default:

            User::Leave( KErrNotSupported );

		break;

		}

	}

#ifdef _DEBUG

TInt CMMCMountTaskAO::RunError( TInt aError )

#else

TInt CMMCMountTaskAO::RunError( TInt )

#endif

	{

	WRITELOG1( "CMMCMountTaskAO::RunError with error code: %d", aError );

	Deinitialize();

	return KErrNone;

	}

void CMMCMountTaskAO::DoCancel()

	{

	WRITELOG( "CMMCMountTaskAO::DoCancel" );

	}

void CMMCMountTaskAO::SetNextRequest( TRequest aRequest )

	{

	WRITELOG("CMMCMountTaskAO::SetNextRequest" );

	if ( !IsActive() )

		{

		iNextRequest = aRequest;

		TRequestStatus* ptrStatus = &iStatus;

		User::RequestComplete( ptrStatus, KErrNone );

		SetActive();

		}

	}

void CMMCMountTaskAO::SetNotPresentToMDE()

	{

	WRITELOG1("CMMCMountTaskAO::SetNotPresentToMDE - MediaID %d", iMountData->iMediaID);

	if ( iMountData->iMediaID )

		{

		iMdeSession->SetFilesToNotPresent( iMountData->iMediaID );

		}

	else

		{

		WRITELOG("CMMCMountTaskAO::SetNotPresentToMDE - MediaID 0, not setting");

		}

	}

void CMMCMountTaskAO::HandleReharvestL( RPointerArray<CPlaceholderData>& aArray )

	{

	WRITELOG("CMMCMountTaskAO::HandleReharvestL");

	const TInt count( aArray.Count() );

	TInt batchSize( KMmcEntryBufferSize );

	if ( count < KMmcEntryBufferSize )

		{

	    batchSize = count;

		}

	const TInt endIndex( count - batchSize );

	for ( TInt i = count; --i >= endIndex; )

		{

		CPlaceholderData* ei = aArray[i];

		HBufC* fileName = ei->Uri().AllocLC();

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

		hd->SetOrigin( MdeConstants::Object::EOther );

		CleanupStack::Pop( fileName );

		if ( ei->PresentState() == EMdsPlaceholder || 

			 ei->PresentState() == EMdsModified )

			{

			hd->SetEventType( EHarvesterEdit );

			hd->SetObjectType( ENormal );

			delete ei;

			}

		else

			{

			hd->SetEventType( EHarvesterAdd );

			hd->SetObjectType( EPlaceholder );

			hd->SetClientData( ei );

			}

		iHdArray.Append( hd );

		aArray.Remove( i );

		}

    if( aArray.Count() == 0 )

        {

        aArray.Compress();

        }

	}

void CMMCMountTaskAO::RemoveNotPresentFromMDE()

	{

	WRITELOG( "CMMCMountTaskAO::RemoveNotPresentFromMDE" );

	iMdeSession->RemoveFilesNotPresent( iMountData->iMediaID );

	}

void CMMCMountTaskAO::StartNotifyL()

	{

	WRITELOG( "CMMCMountTaskAO::StartNotify" );

	CHarvesterCenRepUtil* cenRepoUtil = CHarvesterCenRepUtil::NewLC();

	cenRepoUtil->AddIgnorePathsToFspL( iMountData->iDrivePath );

	cenRepoUtil->FspEngine().AddNotificationPath( iMountData->iDrivePath );

	CleanupStack::PopAndDestroy( cenRepoUtil );

	}

void CMMCMountTaskAO::StopNotifyL()

	{

	WRITELOG( "CMMCMountTaskAO::StopNotify" );

	CHarvesterCenRepUtil* cenRepoUtil = CHarvesterCenRepUtil::NewLC();

	cenRepoUtil->RemoveIgnorePathsFromFspL( iMountData->iDrivePath );

	cenRepoUtil->FspEngine().RemoveNotificationPath( iMountData->iDrivePath );

	CleanupStack::PopAndDestroy( cenRepoUtil );

	}

void CMMCMountTaskAO::Initialize()

	{

	WRITELOG( "CMMCMountTaskAO::Initialize" );

    iEntryArray.ResetAndDestroy();

    iHarvestEntryArray.ResetAndDestroy();

	}

void CMMCMountTaskAO::Deinitialize()

	{

	WRITELOG( "CMMCMountTaskAO::Deinitialize" );

    WRITELOG1( "CMMCMountTaskAO::Deinitialize - iEntryArray.Count() = %d", iEntryArray.Count() );

    if( iEntryArray.Count() > 0)

        {

        TRAP_IGNORE( iHEM->DecreaseItemCountL( EHEObserverTypeMMC, iEntryArray.Count() ) );

        }

    WRITELOG1( "CMMCMountTaskAO::Deinitialize - iHarvestEntryArray.Count() = %d", iHarvestEntryArray.Count() );

    if( iHarvestEntryArray.Count() > 0)

        {

        TRAP_IGNORE( iHEM->DecreaseItemCountL( EHEObserverTypeMMC, iHarvestEntryArray.Count() ) );

        }

	iEntryArray.ResetAndDestroy();

	iHarvestEntryArray.ResetAndDestroy();

	if ( iMountData )

		{

		delete iMountData;

		iMountData = NULL;

		}

	}

TUint32 CMMCMountTaskAO::GetInternalDriveMediaId()

	{

    WRITELOG( "CMMCMountTaskAO::GetInternalDriveMediaId" );