/*
* 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 implements the methods which wrap functionality related
*                to landmark encoding into a simpler interface.
*
*/







// INCLUDE FILES

#include <e32base.h>
#include <e32std.h>
#include <AknQueryDialog.h>
#include <StringLoader.h>
#include <lmkui.rsg>
#include <EPos_CPosLandmarkDatabase.h>
#include <EPos_CPosLandmarkEncoder.h>
#include "LmkConsts.h"
#include "Debug.h"
#include "LmkFileUtils.h"
#include "CLmkAOOperation.h"
#include "CLmkEncoder.h"
#include "CLmkEncodeUnsavedLandmarksOp.h"
#include <lmkerrors.h>

// CONSTANTS
/// Unnamed namespace for local definitions
namespace {

_LIT8( KLandmarkMimeType, "application/vnd.nokia.landmarkcollection+xml" );
// We wrap two async. tasks (export and write to file) into one
// using estimated 0.8/0.2 progress distribution:
const TReal32 KLmkExportMaxProgress( TReal32( 0.8 ) );

#if defined(_DEBUG)
_LIT( KPanicMsg, "CLmkEncoder" );

void Panic( TPanicCode aReason )
    {
    User::Panic( KPanicMsg, aReason );
    }
#endif
}  // namespace

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

// -----------------------------------------------------------------------------
// CLmkEncoder::CLmkEncoder
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CLmkEncoder::CLmkEncoder(
	CPosLandmarkDatabase& aDb,
	MLmkAOOperationObserver& aObserver,
	TBool aProgressNote )
	: iDb( aDb ),
	iObserver( aObserver ),
	iProgressNote( aProgressNote )
	{
	}

// -----------------------------------------------------------------------------
// CLmkEncoder::NewL()
// -----------------------------------------------------------------------------
//
EXPORT_C CLmkEncoder* CLmkEncoder::NewL(
	CPosLandmarkDatabase& aDb,
	MLmkAOOperationObserver& aObserver,
	TBool aProgressNote )
	{
	CLmkEncoder* self =
	new ( ELeave ) CLmkEncoder( aDb, aObserver, aProgressNote );
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop(); //self
	return self;
	}

// -----------------------------------------------------------------------------
// CLmkEncoder::ConstructL()
// -----------------------------------------------------------------------------
//
void CLmkEncoder::ConstructL()
	{
	}

// -----------------------------------------------------------------------------
// CLmkEncoder::~CLmkEncoder()
// -----------------------------------------------------------------------------
//
CLmkEncoder::~CLmkEncoder()
	{
	delete iAOOperation;
	delete iEncoder;
	}

// -----------------------------------------------------------------------------
// CLmkEncoder::HandleOperationL
// -----------------------------------------------------------------------------
//
void CLmkEncoder::HandleOperationL(
	TOperationTypes aType,
	TReal32 aProgress,
	TInt aStatus )
	{
	DEBUG2( CLmkEncoder::HandleOperationL entered: progress=%d status=%d,
	aProgress, aStatus );

	__ASSERT_DEBUG( aType == EEncode, Panic( KLmkPanicUnknownOperation ) );

	if ( aStatus != KPosLmOperationNotComplete )
		{
		__ASSERT_DEBUG( iAOOperation, Panic( KLmkPanicNullMember ) );

		delete iAOOperation;
		iAOOperation = NULL;

		if ( iExporting && aStatus == KErrNone )
			{ // start second part of asynchronous task
			FinalizeEncodingL();
			aStatus = KPosLmOperationNotComplete;
			}
		}

	// Modify progress information because we have wrapped two tasks into one:
	if ( iExporting && aStatus == KPosLmOperationNotComplete )
		{
		aProgress = aProgress * KLmkExportMaxProgress;
		}
	else if ( !iExporting && aStatus == KPosLmOperationNotComplete )
		{ // Progress of writing to file is between KLmkExportMaxProgress...1
		aProgress = KLmkExportMaxProgress +
		aProgress * ( 1 - KLmkExportMaxProgress );
		}

	if( iProgressNote || aStatus != KPosLmOperationNotComplete )
		{ // Caller either requested to receive all events, or we
		// have completed entirely and inform that to the caller.
		iObserver.HandleOperationL( aType, aProgress, aStatus );
		}
}

// -----------------------------------------------------------------------------
// CLmkEncoder::SetPackageNameL
// -----------------------------------------------------------------------------
//
//EXPORT_C void CLmkEncoder::SetPackageNameL( const TDesC& aName )
void CLmkEncoder::SetPackageNameL( const TDesC& aName )
	{
	iEncoder->AddCollectionDataL( EPosLmCollDataCollectionName, aName );
	}

// -----------------------------------------------------------------------------
// CLmkEncoder::StartEncodingL
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkEncoder::StartEncodingL(
	const TDesC& aFileName,
	const RArray<TPosLmItemId>& aLandmarkIdArray )
	{
	DEBUG( CLmkEncoder::StartEncodingL entered );
	LeaveIfInUseL();
    PrepareEncoderL(aFileName);
	if (aLandmarkIdArray.Count() > 1) // Only if multiple Landmarks Are selected
		{
	    // Set the package name here
		SetPackageNameL(aFileName);
		}

	CPosLmOperation* operation =
	iDb.ExportLandmarksL( *iEncoder,
	                      aLandmarkIdArray,
	                      CPosLandmarkDatabase::EIncludeCategories );
	CleanupStack::PushL( operation );
	iAOOperation = CLmkAOOperation::NewL( operation,
	                                  *this,
	                                  EEncode,
	                                  iProgressNote );
	CleanupStack::Pop( operation ); // ownership transferred

	iExporting = ETrue; // exporting part of encoding is being done

	DEBUG( CLmkEncoder::StartEncodingL: starting operation );
	iAOOperation->StartOperation();
	}

// -----------------------------------------------------------------------------
// CLmkEncoder::CancelEncodeOperationL
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkEncoder::CancelEncodeOperationL()
	{
	if ( iAOOperation )
		{
		iAOOperation->Cancel();
		delete iAOOperation;
		iAOOperation = NULL;
		}
	}

// -----------------------------------------------------------------------------
// CLmkEncoder::FinalizeEncodingL
// -----------------------------------------------------------------------------
//
void CLmkEncoder::FinalizeEncodingL()
    {
    DEBUG( CLmkEncoder::FinalizeEncodingL entered );

    LeaveIfInUseL();

    CPosLmOperation* operation = iEncoder->FinalizeEncodingL();
    CleanupStack::PushL( operation );
    iAOOperation = CLmkAOOperation::NewL( operation,
                                          *this,
                                          EEncode,
                                          iProgressNote );
    CleanupStack::Pop( operation ); // ownership transferred

    iExporting = EFalse; // write to file -part of encoding is being done

    DEBUG( CLmkEncoder::FinalizeEncodingL: starting operation );
    iAOOperation->StartOperation();
    }

// -----------------------------------------------------------------------------
// CLmkEncoder::LeaveIfInUseL
// -----------------------------------------------------------------------------
//
void CLmkEncoder::LeaveIfInUseL()
    {
    if ( iAOOperation )
        {
        User::Leave( KErrInUse );
        }
    }

// -----------------------------------------------------------------------------
// CLmkEncoder::PrepareEncoderL
// -----------------------------------------------------------------------------
//
void CLmkEncoder::PrepareEncoderL(const TDesC& aFileName)
    {
    // Full path name (Private path c:\\Provate\\UID3 + pacakge File name)
    HBufC* nameBuf = HBufC::NewLC( 2 * KLmkPackageNameMaxLen +  KLmkEncodedDataFileExtension().Length() );

	// For getting private path
	TPtr ptr = 	nameBuf->Des();
	RFs fs;
    User::LeaveIfError(fs.Connect());
    CleanupClosePushL(fs);
    fs.SessionPath(ptr);
    fs.MkDirAll(ptr);
    CleanupStack::PopAndDestroy(); // fs

	ptr.Append(aFileName);
	ptr.Append(KLmkEncodedDataFileExtension);
	TInt err = KErrNone;

	if ( !iEncoder )
		{
		DEBUG( CLmkEncoder::StartEncodingL: creating encoder );
		TRAP(err, iEncoder = CPosLandmarkEncoder::NewL( KLandmarkMimeType ));
		DEBUG( CLmkEncoder::StartEncodingL: encoder created);
		}
    if(err != KErrNone)
		{
		LmkFileUtils::DeleteFileL( ptr ); // Delete old file if it exists
	    CleanupStack::PopAndDestroy(nameBuf); //nameBuf
	    User::LeaveIfError( err );
		}
    LmkFileUtils::DeleteFileL( ptr ); // Delete old file if it exists
	iEncoder->SetOutputFileL( ptr );
    CleanupStack::PopAndDestroy(nameBuf); //nameBuf
    }

// -----------------------------------------------------------------------------
// CLmkEncoder::StartEncodingL
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkEncoder::StartEncodingL(
	const TDesC& aFileName,
	const RPointerArray<CLmkLandmark>& aLandmarks )
	{
	DEBUG( CLmkEncoder::StartEncodingL entered );
	LeaveIfInUseL();
    PrepareEncoderL(aFileName);
	if (aLandmarks.Count() > 1) // Only if multiple Landmarks Are selected
		{
	    // Set the package name here
		SetPackageNameL(aFileName);
		}

    CPosLmOperation* operation =
            CLmkEncodeUnsavedLandmarksOp::NewL( *iEncoder,
                                                aLandmarks,
                                                    CPosLandmarkDatabase::EIncludeCategories);
	CleanupStack::PushL( operation );
	iAOOperation = CLmkAOOperation::NewL( operation,
	                                  *this,
	                                  EEncode,
	                                  iProgressNote );
	CleanupStack::Pop( operation ); // ownership transferred

	iExporting = ETrue; // exporting part of encoding is being done

	DEBUG( CLmkEncoder::StartEncodingL: starting operation );
	iAOOperation->StartOperation();
	}
//  End of File