/*

* Copyright (c) 2002-2005 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:   This file contains methods which interact with Landmarks Framework

*                parser which does the job of parsing landmarks in the received

*                landmark package

*

*/

// INCLUDE FILES

#include "EPos_CPosLandmarkParser.h"

#include "EPos_CPosLandmarkDatabase.h"

#include "EPos_CPosLandmark.h"

#include "landmarks.hrh"

#include "LmkFileUtils.h"

#include "CLmkAOOperation.h"

#include "CLmkDbUtils.h"

#include "CLmkParser.h"

#include "CLmkParseAllWrapper.h"

#include <apgcli.h>

#include <lmkerrors.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

#if defined(_DEBUG)

_LIT( KPanicMsg, "CLmkParser" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

#endif

_LIT( KLmkTempDataFile, "c:\\system\\Temp\\LmkTemp.lmx" );

}  // namespace

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

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

// CLmkParser::CLmkParser

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CLmkParser::CLmkParser(

	CPosLandmarkDatabase& aDb,

	MLmkAOOperationObserver& aObserver,

	TBool aProgressNote )

	: iDb( aDb ),

	  iObserver( &aObserver ),

	  iProgressNote( aProgressNote )

	{

	}

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

// CLmkParser::NewL

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

//

EXPORT_C CLmkParser* CLmkParser::NewL(

	const TDesC& aFile,

	CPosLandmarkDatabase& aDb,

	MLmkAOOperationObserver& aObserver,

	TBool aProgressNote )

	{

	CLmkParser* self =

        new ( ELeave ) CLmkParser( aDb, aObserver, aProgressNote );

	CleanupStack::PushL( self );

	self->ConstructL( aFile );

	CleanupStack::Pop(); //self

    return self;

	}

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

// CLmkParser::NewL

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

//

EXPORT_C CLmkParser* CLmkParser::NewL(

	RFile& aFile,

	CPosLandmarkDatabase& aDb,

	MLmkAOOperationObserver& aObserver,

	TBool aProgressNote )

	{

	CLmkParser* self =

        new ( ELeave ) CLmkParser( aDb, aObserver, aProgressNote );

	CleanupStack::PushL( self );

	self->ConstructL( aFile );

	CleanupStack::Pop(); //self

	return self;

	}

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

// CLmkParser::ConstructL()

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

//

void CLmkParser::ConstructL( const TDesC& aFile )

	{

	iDbUtils = CLmkDbUtils::NewL( iDb, *this, iProgressNote );

	RFs fs;

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

	CleanupClosePushL(fs);

	RFile file;

	LmkFileUtils::DeleteFileL(KLmkTempDataFile);

	User::LeaveIfError(file.Create(fs, KLmkTempDataFile, EFileShareAny));

	CleanupClosePushL(file);

	RFile fileHandle;

	User::LeaveIfError(fileHandle.Open(fs, aFile, EFileShareAny));

	CleanupClosePushL(fileHandle);

	TDataType mimeType;

	User::LeaveIfError(ResolveMimeTypeL(fileHandle,mimeType));

	iParser = CPosLandmarkParser::NewL(  mimeType.Des8());

	HBufC8* tempBuf = HBufC8::NewLC(5000);  // to manage for 5 Landmarks at the most

	TPtr8 ptr = tempBuf->Des();

	User::LeaveIfError(fileHandle.Read( ptr ));

	User::LeaveIfError(file.Write( ptr ));

	CleanupStack::PopAndDestroy(); // File

	CleanupStack::PopAndDestroy(1); //tempBuf

	iParser->SetInputFileL( KLmkTempDataFile);

	iParseWrapper = CLmkParseAllWrapper::NewL( *iParser, *this, iDb );

	iFileName = HBufC::NewL(256);

	*iFileName = KLmkTempDataFile;

	iFileHandleFlag = EFalse;

    CleanupStack::PopAndDestroy(); // File Handle

	CleanupStack::PopAndDestroy(); // fs

	}

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

// CLmkParser::ConstructL()

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

//

void CLmkParser::ConstructL(RFile& aFile )

	{

	iDbUtils = CLmkDbUtils::NewL( iDb, *this, iProgressNote );

	TDataType mimeType;

	User::LeaveIfError(ResolveMimeTypeL(aFile,mimeType));

	iParser = CPosLandmarkParser::NewL(  mimeType.Des8());

	iParser->SetInputFileHandleL(aFile);

	iParseWrapper = CLmkParseAllWrapper::NewL( *iParser, *this, iDb );

	iFileHandle = &aFile;

	iFileHandleFlag = ETrue;

	}

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

// CLmkParser::~CLmkParser()

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

//

CLmkParser::~CLmkParser()

	{

	delete iAOOperation;

	delete iParser;

	delete iParseWrapper;

	delete iDbUtils;

	delete iFileName;

	iFileHandle = NULL;

	}

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

// CLmkParser::HandleOperationL

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

//

void CLmkParser::HandleOperationL(

TOperationTypes aType,

TReal32 aProgress,

TInt aStatus )

	{

	// Initialize operation is not done with iAOOperation so in that case

	// we don't delete iAOOperation.

	if ( aType != EInitialize && aStatus != KPosLmOperationNotComplete )

		{

		/* Parsing is done with iAOOperation when wrapper isn't used anymore.

		 * Remove the following if-statement when removing wrapper

		 */

		if( aType != EParse )

			{

			__ASSERT_DEBUG( iAOOperation, Panic( KLmkPanicNullMember ) );

			delete iAOOperation;

			iAOOperation = NULL;

			}

		}

	__ASSERT_DEBUG( iObserver, Panic( KLmkPanicNullMember ) );

	iObserver->HandleOperationL( aType, aProgress, aStatus );

	}

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

// CLmkParser::FileName

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

//

EXPORT_C TPtrC CLmkParser::FileName()

	{

	TInt error = KErrNone;

	if( !iFileName )

		{

		TRAP( error,iFileName = HBufC::NewL(256));

		}

	if( !error )

		{

		TPtr ptr = iFileName->Des();

		iFileHandle->Name( ptr );

		return *iFileName;

		}

	return TPtrC();

	}

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

// CLmkParser::FileHandle

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

//

EXPORT_C RFile& CLmkParser::FileHandle()

	{

	return *iFileHandle;

	}

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

// CLmkParser::IsFileHandle

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

//

EXPORT_C TBool CLmkParser::IsFileHandle()

    {

    return iFileHandleFlag;

    }

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

// CLmkParser::InitializeDbL

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

//

EXPORT_C void CLmkParser::InitializeDbL()

	{

	iDbUtils->InitializeDbL();

	}

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

// CLmkParser::StartParsingL

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

//

EXPORT_C void CLmkParser::StartParsingL()

	{

	LeaveIfInUseL();

	iParseWrapper->ParseAllL();

	}

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

// CLmkParser::NumOfParsedLandmarks

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

//

EXPORT_C TInt CLmkParser::NumOfParsedLandmarks()

	{

	return iParseWrapper->NumOfLandmarks();

	}

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

// CLmkParser::PackageName

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

//

EXPORT_C TPtrC CLmkParser::PackageName()

	{

	_LIT( KDot, "." );

	TPtrC ptr = iParser->CollectionData( EPosLmCollDataCollectionName );

	if( ptr.Length() == 0)

		{

		//get the position of '.' character

		TInt pos = FileName().Find(KDot);

		if( pos != KErrNotFound)

			{

			//get the left most string starting from '.' char

			return FileName().Left( pos );

			}

		else

			{

			return FileName();

			}

		}

	return ptr;

	}

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

// CLmkParser::LandmarkLC

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

//

EXPORT_C CPosLandmark* CLmkParser::LandmarkLC( TInt aIndex )

	{

	return iParseWrapper->LandmarkLC( aIndex );

	}

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

// CLmkParser::LmkLandmarkLC

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

//

EXPORT_C CLmkLandmark* CLmkParser::LmkLandmarkLC( TInt aIndex )

	{

	return iParseWrapper->LmkLandmarkLC(aIndex);

	}

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

// CLmkParser::CategoryNameLC

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

//

EXPORT_C CLmkLandMarkCategoriesName* CLmkParser::CategoryNameLC( TInt aIndex )

    {

    /* THIS FUNCTIONALITY WILL BE USED WHEN WRAPPER IS REMOVED:

    return iParser->LandmarkLC( aIndex );

    */

    return iParseWrapper->CategoryNameLC( aIndex );

    }

//

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

// CLmkParser::ChangeObserver

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

//

EXPORT_C void CLmkParser::ChangeObserver(

	MLmkAOOperationObserver& aNewObserver )

	{

	iObserver = &aNewObserver;

	}

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

// CLmkParser::StartImportingL

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

//

EXPORT_C void CLmkParser::StartImportingL(TBool aIncludeNewCategories)

	{

	LeaveIfInUseL();

	CPosLandmarkDatabase::TTransferOptions options;

    if ( aIncludeNewCategories )

	    {

	    options = CPosLandmarkDatabase::EIncludeCategories;

	    }

	else

		{

		options =  (CPosLandmarkDatabase::EIncludeCategories) |

		           (CPosLandmarkDatabase::ESupressCategoryCreation);

		}

	CPosLmOperation* operation =

	    iDb.ImportLandmarksL( *iParser, options );

	CleanupStack::PushL( operation );

	iAOOperation = CLmkAOOperation::NewL( operation,

	                                      *this,

	                                      EImport,

	                                      iProgressNote );

	CleanupStack::Pop( operation ); // ownership transferred

	iAOOperation->StartOperation();

	}

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

// CLmkParser::StartImportingL

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

//

EXPORT_C void CLmkParser::StartImportingL(

	const RArray<TUint>& aSelected, TBool aIncludeNewCategories)

	{

	LeaveIfInUseL();

    CPosLandmarkDatabase::TTransferOptions options;

    if ( aIncludeNewCategories )

	    {

	    options = CPosLandmarkDatabase::EIncludeCategories;

	    }

	else

		{

		options = (CPosLandmarkDatabase::EIncludeCategories) | (CPosLandmarkDatabase::ESupressCategoryCreation);

		}

	CPosLmOperation* operation =

	    iDb.ImportLandmarksL( *iParser, aSelected, options );

	CleanupStack::PushL( operation );

	iAOOperation = CLmkAOOperation::NewL( operation,

	                                      *this,

	                                      EImport,

	                                      iProgressNote );

	CleanupStack::Pop( operation ); // ownership transferred

	iAOOperation->StartOperation();

	}

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

// CLmkParser::CancelImporting

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

//

EXPORT_C void CLmkParser::CancelImporting()

	{

	if ( iAOOperation )

		{

		iAOOperation->Cancel();

		delete iAOOperation;

		iAOOperation = NULL;

		}

	}

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

// CLmkParser::LeaveIfInUseL

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

//

void CLmkParser::LeaveIfInUseL()

	{

	if ( iAOOperation )

		{

		User::Leave( KErrInUse );

		}

	}

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

// CLmkParser::ResolveMimeTypeL

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

//

TInt CLmkParser::ResolveMimeTypeL( RFile& aFile, TDataType& aDataType ) const

	{

	TInt result(KErrNotFound);

	RApaLsSession ls ;

	TDataRecognitionResult dataType;

	TInt err( ls.Connect() );

	if ( err == KErrNone )

		{

		CleanupClosePushL( ls );

		err = ls.RecognizeData(aFile, dataType);

		if(err == KErrNone &&

		   (dataType.iConfidence == CApaDataRecognizerType::EProbable

		    || dataType.iConfidence == CApaDataRecognizerType::ECertain

		    || dataType.iConfidence == CApaDataRecognizerType::EPossible))

			{

			aDataType = dataType.iDataType;

			result = KErrNone;

			}

		CleanupStack::PopAndDestroy(&ls);

		}

	return result;

	}

//  End of File