/*

* 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 the License "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: 

* Pinplugindlg.cpp

*

*/

#include "tpinplugindlg.h"

#include <s32file.h>

const TInt KErrInvalidPinLength			= -1002;

_LIT(KPinPluginDailogPanicString,"CTestPinPluginDlgNotifier");

// Lib main entry point.

#ifdef _T_PINPLUGINDLG_TEXTSHELL

EXPORT_C CArrayPtr<MNotifierBase2>* NotifierArray()

#else

CArrayPtr<MNotifierBase2>* NotifierArray()

#endif

	{

	CArrayPtrFlat<MNotifierBase2>* subjects = NULL;

	CTestPinPluginDlgNotifier* notifier;

	TRAPD(err,

		subjects = new (ELeave) CArrayPtrFlat<MNotifierBase2>(1);

		CleanupStack::PushL(subjects);

		notifier = CTestPinPluginDlgNotifier::NewL();

		CleanupStack::PushL(notifier);

		subjects->AppendL(notifier);

		CleanupStack::Pop(2,subjects));	//notifier, subjects

	if (err != KErrNone)

		{

		subjects = NULL;

		}

	return subjects;

	}

// Ecom plugin implementation for UI notifier

#ifndef _T_PINPLUGINDLG_TEXTSHELL

const TImplementationProxy ImplementationTable[] =

	{

	IMPLEMENTATION_PROXY_ENTRY(KTPinPluginDlgNotiferUid, NotifierArray)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return (ImplementationTable);

	}

#endif

// TInputDetails

//

TInputDetails::TInputDetails(TPinPluginDialogOperation aOp, TInt aIndex, TInt aNewPinLength, TPinPluginDialogResult aCommandOutput) :

	iOp(aOp), iPinValue(0), iIndex(aIndex), iNewPinLength(aNewPinLength), iCommandOutput(aCommandOutput)

	{

	}

TInputDetails::TInputDetails(TPinPluginDialogOperation aOp, TPinValue& aPinValue, TPinPluginDialogResult aCommandOutput) :

	iOp(aOp), iPinValue(aPinValue), iCommandOutput(aCommandOutput)

	{

	}

// CTestPinPluginDlgNotifier

//

_LIT(KInputFile, "C:\\t_pinplugindlg_in.dat");

_LIT(KOutputFile, "C:\\t_pinplugindlg_out.dat");

CTestPinPluginDlgNotifier* CTestPinPluginDlgNotifier::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestPinPluginDlgNotifier::CTestPinPluginDlgNotifier()

	{

	iInfo.iUid = KUidPinPluginDialogNotifier;

	iInfo.iChannel = TUid::Uid(0x00001200); // test uid

	iInfo.iPriority = ENotifierPriorityHigh;

	}

void CTestPinPluginDlgNotifier::ConstructL()

	{

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

	}

TInt CTestPinPluginDlgNotifier::ReadDialogCountL()

	{

	RFileReadStream stream;

	TInt err = stream.Open(iFs, KOutputFile, EFileRead | EFileShareExclusive);

	// If the file doesn't exist yet just return zero

	if (err == KErrNotFound)

		{

		return 0;

		}

	User::LeaveIfError(err);

	stream.PushL();

	TInt dialogCount = stream.ReadInt32L();

	CleanupStack::PopAndDestroy(&stream); 

	return dialogCount;

	}

TPinValue CTestPinPluginDlgNotifier::ReadPinValueL()

	{

	TPinValue pinValue;

	RFileReadStream stream;

	TInt err = stream.Open(iFs, KOutputFile, EFileRead | EFileShareExclusive);

	// If the file doesn't exist yet just return zero

	if (err == KErrNotFound)

		{

		pinValue.Copy(_L("0"));

		return pinValue;

		}

	User::LeaveIfError(err);

	stream.PushL();

	stream.ReadInt32L();

	TInt pinValueSize = stream.ReadInt32L();

	HBufC8* pinValueBuf = HBufC8::NewMaxLC(pinValueSize);

	TPtr8 pinValuePtr(pinValueBuf->Des());

	stream.ReadL(pinValuePtr, pinValueSize);

	pinValue.Copy(pinValuePtr);

	CleanupStack::PopAndDestroy(2, &stream);	

	return pinValue;

	}

void CTestPinPluginDlgNotifier::WriteDialogCountL(TInt aCount)

	{

	RFileWriteStream stream;

	TInt err = stream.Replace(iFs, KOutputFile, EFileWrite | EFileShareExclusive);

	if (err == KErrNotFound)

		{

		err = stream.Create(iFs, KOutputFile, EFileWrite | EFileShareExclusive);

		}

	User::LeaveIfError(err);

	stream.PushL();

	stream.WriteInt32L(aCount);

	stream.CommitL();

	CleanupStack::PopAndDestroy(&stream); 

	}

void CTestPinPluginDlgNotifier::WritePinL(const TPinValue& aPinValue)

	{

	TInt dialogCount = ReadDialogCountL();

	RFileWriteStream stream;

	TInt err = stream.Replace(iFs, KOutputFile, EFileWrite | EFileShareExclusive);

	if (err == KErrNotFound)

		{

		err = stream.Create(iFs, KOutputFile, EFileWrite | EFileShareExclusive);

		}

	User::LeaveIfError(err);

	stream.PushL();

	stream.WriteInt32L(dialogCount);

	stream.WriteInt32L(aPinValue.Length());

	stream.WriteL(aPinValue);

	stream.CommitL();

	CleanupStack::PopAndDestroy(&stream); 

	}

void CTestPinPluginDlgNotifier::WriteMsgL(const TPinPluginInfoMessage& aMessage)

	{

	TInt dialogCount = ReadDialogCountL();

	TPinValue pinValue = ReadPinValueL();

	RFileWriteStream stream;

	TInt err = stream.Replace(iFs, KOutputFile, EFileWrite | EFileShareExclusive);

	if (err == KErrNotFound)

		{

		err = stream.Create(iFs, KOutputFile, EFileWrite | EFileShareExclusive);

		}

	User::LeaveIfError(err);

	stream.PushL();

	stream.WriteInt32L(dialogCount);

	stream.WriteInt32L(pinValue.Length());

	stream.WriteL(pinValue);

	stream.WriteInt32L(aMessage);

	stream.CommitL();

	CleanupStack::PopAndDestroy(&stream); 

	}

TInputDetails* CTestPinPluginDlgNotifier::ReadInputDetailsL(TUint aOperation)

	{

	RFileReadStream stream;

	User::LeaveIfError(stream.Open(iFs, KInputFile, EFileRead | EFileShareExclusive));

	stream.PushL();

	TPinValue pinvalue;

	TInt index, newLength,dialogNumber;

	TInt pinValueSize;

	TPinPluginDialogOperation op = static_cast<TPinPluginDialogOperation>(stream.ReadInt32L());

	pinValueSize = stream.ReadInt32L();

	HBufC8* pinValueBuf = HBufC8::NewMaxLC(pinValueSize);

	TPtr8 pinValuePtr(pinValueBuf->Des());

	stream.ReadL(pinValuePtr, pinValueSize);

	pinvalue.Copy(pinValuePtr);

	index = stream.ReadInt32L();

	if (index < 0 && index > 3)

		{

		index = 0;

		}

	newLength = stream.ReadInt32L();

	TPinPluginDialogResult outputCommand = static_cast<TPinPluginDialogResult>(stream.ReadInt32L());

	TPinPluginDialogOperation op1 = static_cast<TPinPluginDialogOperation>(stream.ReadInt32L());

	TPinPluginDialogResult finalOutputCommand = static_cast<TPinPluginDialogResult>(stream.ReadInt32L());

	dialogNumber = stream.ReadInt32L();

	if (op != aOperation)

		{

		op = op1;

		}

	else

		{

		// Update dialog count here so test code can see how many dialogs were

		// requested if there were more than expected

		TInt dialogCount = ReadDialogCountL() + 1;

		WriteDialogCountL(dialogCount);

		if (dialogNumber == dialogCount)

			{

			outputCommand = finalOutputCommand;

			}

		}

	TInputDetails* inputDetail = NULL;

	if (op == EPinPluginTraining)

		{

		inputDetail = new (ELeave) TInputDetails(op, index, newLength, outputCommand);

		}

	else if (op == EPinPluginIdentify) 

		{

		inputDetail = new (ELeave) TInputDetails(op, pinvalue, outputCommand);

		}

	CleanupStack::PopAndDestroy(1, pinValueBuf);	

	CleanupStack::PopAndDestroy(&stream); 

	return inputDetail;

	}

void CTestPinPluginDlgNotifier::DoSelectPinL(const TInputDetails& aDetail, const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	const TPinTrainingInput& input = reinterpret_cast<const TPinTrainingInput&>(*aBuffer.Ptr());

	TPinDialogOutput output;

	output.iIndex = aDetail.Index();

	TInt pinLength = aDetail.NewPinLength();

	if (pinLength == 0)

		{

		output.iNewPinLength = input.iCurrentPinLength;

		}

	else

		{

		output.iNewPinLength = pinLength;

		}

	output.iResult = aDetail.CommandOutput();

	TPinValue pinValue;

	switch(output.iIndex)

		{

		case 0:

			pinValue = input.iPinValue1;

			break; 

		case 1:

			pinValue = input.iPinValue2;

			break; 

		case 2:

			pinValue = input.iPinValue3;

			break; 

		case 3:

			pinValue = input.iPinValue4;

			break; 

		}

	WritePinL(pinValue);

	TPinDialogOutputBuf outputBuf(output);

	aMessage.WriteL(aReplySlot, outputBuf);

	}

void CTestPinPluginDlgNotifier::DoIdentifyPinL(const TInputDetails& aDetail, const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	const TPinIdentifyInput& input = reinterpret_cast<const TPinIdentifyInput&>(*aBuffer.Ptr());

	TPinDialogOutput output;

	const TPinValue& pinInput = reinterpret_cast<const TPinValue&>(aDetail.PinValue());

	TInt pinLength = pinInput.Length();

	if (pinLength >= input.iMinLength && pinLength <= input.iMaxLength)

		{

		output.iPinValue = pinInput;

		}

	else

		{

		User::Leave(KErrInvalidPinLength);	

		}

	WritePinL(pinInput);

	output.iResult = aDetail.CommandOutput();

	TPinDialogOutputBuf outputBuf(output);

	aMessage.WriteL(aReplySlot, outputBuf);

	}

void CTestPinPluginDlgNotifier::DoInfoPinL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	const TPinInfoInput& input = reinterpret_cast<const TPinInfoInput&>(*aBuffer.Ptr());

	WriteMsgL(input.iMessage);

	TPinDialogOutput output;

	TPinDialogOutputBuf outputBuf(output);

	aMessage.WriteL(aReplySlot, outputBuf);

	}

void CTestPinPluginDlgNotifier::Release()

	{

	delete this;

	}

CTestPinPluginDlgNotifier::TNotifierInfo CTestPinPluginDlgNotifier::RegisterL()

	{

	return iInfo;

	}

CTestPinPluginDlgNotifier::TNotifierInfo CTestPinPluginDlgNotifier::Info() const

	{

	return iInfo;

	}

void CTestPinPluginDlgNotifier::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	TRAPD(err, DoStartL(aBuffer, aReplySlot, aMessage));

	aMessage.Complete(err);

	}

void CTestPinPluginDlgNotifier::DoStartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	TUint operation = *reinterpret_cast<const TInt *>(aBuffer.Ptr()) & KPinPluginDialogOperationMask;

	TInputDetails* detail = NULL;

	TRAPD(err, detail = ReadInputDetailsL(operation));

	User::LeaveIfError(err);

	CleanupStack::PushL(detail);

	switch (operation)

		{

		case EPinPluginTraining:

			DoSelectPinL(*detail, aBuffer, aReplySlot, aMessage);

			break;

		case EPinPluginIdentify:

			DoIdentifyPinL(*detail, aBuffer, aReplySlot, aMessage);

			break;

		case EPinPluginInfo:

			DoInfoPinL(aBuffer, aReplySlot, aMessage);

			break;

		default:

			User::Panic(_L("CTestPinPluginDlgNotifier"), 0);

		}

	CleanupStack::PopAndDestroy(detail);

	}

TPtrC8 CTestPinPluginDlgNotifier::StartL( const TDesC8& /*aBuffer*/ )

	{

	User::Panic(_L("CTestPinPluginDlgNotifier"), 0);

	return TPtrC8(KNullDesC8);

	}

void CTestPinPluginDlgNotifier::Cancel()

	{

	// Don't think there is much we can do here. If a client deletes the

	// client-side pinplugin dialog instance, after calling a method that 

	// displays a dialog, this will not get called until the user dismisses

	// the dialog. We can't do anything then.

	}

TPtrC8 CTestPinPluginDlgNotifier::UpdateL( const TDesC8& /*aBuffer*/ )

	{

	User::Panic(KPinPluginDailogPanicString, 0);

	return NULL;

	}