// Copyright (c) 2001-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:

//

#include <btextnotifiers.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <btextnotifierspartner.h>

#endif

#include <e32cons.h>

#include <es_prot.h>

#include <networking/panuiinterfaces.h>

#include <e32debug.h>

#include "btuinotifiers.h"

#include <es_sock.h>

#include <e32msgqueue.h>

#define PIN_DEFAULT  "1234"

_LIT8(KDefaultPinCode, PIN_DEFAULT);

const TUint KDefaultAuthorisation = 1; // Accept

/*There can be any number of keypress notifications, I am taking 20 just for testing purpose*/

const TUint KMaxNumberOfKeyPressNotifications = 20;

const TUint KDefaultSSPAuthorisation = 1;

#define DEFAULT_PBAP_AUTH_PASSWORD "password"

_LIT8(KNotUsed, "Not used");

const TUid KTechViewScreenOutputChannel={0x10009D48};

const TInt KBTNotifierArrayIncrement = 2;

CArrayPtr<MEikSrvNotifierBase2>* NotifierArray()

	{

	CArrayPtrFlat<MEikSrvNotifierBase2>* subjects=NULL;

	TRAPD( err, subjects=new (ELeave)CArrayPtrFlat<MEikSrvNotifierBase2>(KBTNotifierArrayIncrement) );

	if( err == KErrNone )

		{

		TRAP( err, subjects->AppendL( CBTUIAutoPasskeyNotifier::NewL() ) );

		TRAP( err, subjects->AppendL( CBTUIAutoAuthNotifier::NewL() ) );

		TRAP( err, subjects->AppendL( CPbapUIAutoAuthNotifier::NewL() ) );

		TRAP( err, subjects->AppendL( CPanNapAuthAutoNotifier::NewL() ) );

		TRAP( err, subjects->AppendL( CSSPNumericComparisionAutoNotifier::NewL() ) );

		TRAP( err, subjects->AppendL( CSSPPassKeyAutoNotifier::NewL() ) );

		TRAP( err, subjects->AppendL( CBTUIAutoPinCodeNotifier::NewL() ));				

		return(subjects);

		}

	else

		{

		return NULL;

		}

	}

//Adding ECOM Support

#include <ecom/implementationproxy.h>

const TImplementationProxy ImplementationTable[] =

{

    IMPLEMENTATION_PROXY_ENTRY(0x10201D09, NotifierArray)

};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

{

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

	return ImplementationTable;

}

//Update the P&S key for the notifier type so test code can check which type of notifier has fired

//This is not critical so work on a best effort approach. If it fails then we don't care unless it's

//not defined

void UpdateLastNotifierType(TAutoNotifierType aType)

	{

	TInt err = RProperty::Set(KUidSystemCategory, KUidLastNotifierTypeRun, aType);

	if(err == KErrNotFound)

		{

		_LIT_SECURITY_POLICY_PASS(KPassPolicy);

		err = RProperty::Define(KUidSystemCategory, KUidLastNotifierTypeRun, RProperty::EInt, KPassPolicy, KPassPolicy);

		if(err == KErrNone || err == KErrAlreadyExists)

			{

			RProperty::Set(KUidSystemCategory, KUidLastNotifierTypeRun, ESspNumericComparisonNotifier);

			}

		}

	}

//  * * *         CBTUIAutoPasskeyNotifier * * *

CBTUIAutoPasskeyNotifier* CBTUIAutoPasskeyNotifier::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();	

	CleanupStack::Pop();

	return self;

	}

CBTUIAutoPasskeyNotifier::CBTUIAutoPasskeyNotifier() 

	{

	}

void CBTUIAutoPasskeyNotifier::ConstructL()

	{

	}

CBTUIAutoPasskeyNotifier::~CBTUIAutoPasskeyNotifier()

	{

	}

void CBTUIAutoPasskeyNotifier::Release()

	{

	delete this;

	}

CBTUIAutoPasskeyNotifier::TNotifierInfo CBTUIAutoPasskeyNotifier::RegisterL()

	{

	iInfo.iUid=KBTManPinNotifierUid;

	iInfo.iChannel=KTechViewScreenOutputChannel;

	iInfo.iPriority=ENotifierPriorityLow;

	return iInfo;

	}

CBTUIAutoPasskeyNotifier::TNotifierInfo CBTUIAutoPasskeyNotifier::Info() const

	{

	return iInfo;

	}

TPtrC8 CBTUIAutoPasskeyNotifier::StartL(const TDesC8&)

	{

	return TPtrC8(KNotUsed);

	}

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

	{

	iMessage = aMessage;

    iReplySlot = aReplySlot;	

	// read properties	

	TBTPinCode pinCode;

	TBuf<16> buf;

	TInt err = RProperty::Get(KUidSystemCategory, KUidAutoPropertyPinCode, buf);

	if (err == KErrNotFound)

		{

		// p+s key not defined, use default pin

		buf.Copy(KDefaultPinCode);

		}

	else

		{

		// make sure no other error occurred

		User::LeaveIfError(err);

		}

	for (TUint i=0; i<buf.Length(); i++)

		{

		pinCode().iPIN[i] = buf[i];

		}

	pinCode().iLength = buf.Length();

	TInt notifierError = KErrNone;	

	/* Get the value of the P&S key 'KUidErrorNotifiers' to see if need to complete the notifiers with an error

	 * If P&S key is not defined then we will proceed normally otherwise we will complete the notifiers 

	 * the specified error*/	

	err = RProperty::Get(KUidSystemCategory, KUidErrorNotifiers, notifierError);

	if (err == KErrNotFound)

		{

		PinInputComplete(pinCode, KErrNone);

		}

	else

		{

		/*If error is defined then complete the notifiers with an error*/

		PinInputComplete(pinCode, notifierError);

		}

	return;	

	}

void CBTUIAutoPasskeyNotifier::Cancel()

	{

	}

void CBTUIAutoPasskeyNotifier::UpdateL(const TDesC8& /*aBuffer*/, TInt /*aReplySlot*/, const RMessagePtr2& aMessage)

	{

	aMessage.Complete(KErrNone);

	}

TPtrC8 CBTUIAutoPasskeyNotifier::UpdateL(const TDesC8&)

	{

	TPtrC8 ret(KNullDesC8);

	return (ret);

	}

void CBTUIAutoPasskeyNotifier::PinInputComplete(const TBTPinCode& aPin, TInt aReason)

	{	

	// update executed status, ignore error, what can we do !?!

	RProperty::Set(KUidSystemCategory, KUidAuthenticationExecuted, 1);

	if (aReason == KErrNone)

		{		

		TInt err = iMessage.Write(iReplySlot, aPin);

		iMessage.Complete(err);

		}

	else

		{

		iMessage.Complete(aReason);

		}

	}

// CBTUIAutoAuthNotifier 

CBTUIAutoAuthNotifier* CBTUIAutoAuthNotifier::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();	

	CleanupStack::Pop();

	return self;

	}

CBTUIAutoAuthNotifier::CBTUIAutoAuthNotifier() 

	{

	}

void CBTUIAutoAuthNotifier::ConstructL()

	{

	}

CBTUIAutoAuthNotifier::~CBTUIAutoAuthNotifier()

	{

	}

void CBTUIAutoAuthNotifier::Release()

	{

	delete this;

	}

CBTUIAutoAuthNotifier::TNotifierInfo CBTUIAutoAuthNotifier::RegisterL()

	{

	iInfo.iUid=KBTManAuthNotifierUid;

	iInfo.iChannel=KTechViewScreenOutputChannel;

	iInfo.iPriority=ENotifierPriorityLow;

	return iInfo;

	}

CBTUIAutoAuthNotifier::TNotifierInfo CBTUIAutoAuthNotifier::Info() const

	{

	return iInfo;

	}

TPtrC8 CBTUIAutoAuthNotifier::StartL(const TDesC8&)

	{

	return TPtrC8(KNotUsed);

	}

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

	{

	iMessage = aMessage;

    iReplySlot = aReplySlot;

	// read properties

	TInt authoriseAccept;

	TInt err = RProperty::Get(KUidSystemCategory, KUidAutoPropertyAuthoriseAccept, authoriseAccept);

	if (err == KErrNotFound)

		{

		// p+s key not defined, use default (Yes)

		authoriseAccept = KDefaultAuthorisation;

		}

	else

		{

		// make sure no other error occurred

		User::LeaveIfError(err);

		}

	AuthorisationComplete(authoriseAccept);

	return;

	}

void CBTUIAutoAuthNotifier::Cancel()

	{

	}

void CBTUIAutoAuthNotifier::UpdateL(const TDesC8& /*aBuffer*/, TInt /*aReplySlot*/, const RMessagePtr2& aMessage)

	{

	aMessage.Complete(KErrNone);

	}

TPtrC8 CBTUIAutoAuthNotifier::UpdateL(const TDesC8&)

	{

	TPtrC8 ret(KNullDesC8);

	return (ret);

	}

void CBTUIAutoAuthNotifier::AuthorisationComplete(TInt aAuthorised)

	{

		TInt err = iMessage.Write(iReplySlot, TPckgBuf<TBool>(aAuthorised));

		// update executed status

		RProperty::Set(KUidSystemCategory, KUidAuthorisationExecuted, 1);		

		iMessage.Complete(err);

	}

//

// CPbapUIAutoAuthNotifier

//

CPbapUIAutoAuthNotifier* CPbapUIAutoAuthNotifier::NewL()

	{

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

	return self;

	}

CPbapUIAutoAuthNotifier::CPbapUIAutoAuthNotifier()

	{

	}

void CPbapUIAutoAuthNotifier::Release()

	{

	delete this;

	}

void CPbapUIAutoAuthNotifier::Cancel()

	{

	}

CPbapUIAutoAuthNotifier::~CPbapUIAutoAuthNotifier()

	{

	iProperty.Close();

	}

CPbapUIAutoAuthNotifier::TNotifierInfo CPbapUIAutoAuthNotifier::RegisterL()

	{

	iInfo.iUid=KPbapAuthNotifierUid;

	iInfo.iChannel=KTechViewScreenOutputChannel;

	iInfo.iPriority=ENotifierPriorityVHigh;

	return iInfo;

	}

CPbapUIAutoAuthNotifier::TNotifierInfo CPbapUIAutoAuthNotifier::Info() const

	{

	return iInfo;

	}

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

	{

	return KNullDesC8();

	}

void CPbapUIAutoAuthNotifier::StartL(const TDesC8& /*aBuffer*/, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	iReplySlot = aReplySlot;

	iMessage = RMessage2(aMessage);

	TBuf<16> buf;

	TInt err = iProperty.Get(KUidSystemCategory, KUidPbapAutoNotifierPassword, buf);

	if (err == KErrNotFound)

		{

		// p+s key not defined, use default password

		_LIT8(KDefaultPbapAuthPassword, DEFAULT_PBAP_AUTH_PASSWORD);

		buf.Copy(KDefaultPbapAuthPassword);

		}

	else	

		{

		// make sure no other error occurred

		User::LeaveIfError(err);

		}

	PasswordInputComplete(buf, KErrNone);

	}

void CPbapUIAutoAuthNotifier::UpdateL(const TDesC8& /*aBuffer*/, TInt /*aReplySlot*/, const RMessagePtr2& aMessage)

	{

	aMessage.Complete(KErrNone);

	}

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

	{

	return KNullDesC8();

	}

void CPbapUIAutoAuthNotifier::PasswordInputComplete(const TDesC& aPassword, TInt aReason)

	{

	// update executed status, ignore error, what can we do !?!

	RProperty::Set(KUidSystemCategory, KUidPbapAutoNotifierExecuted, 1);	

	if (aReason == KErrNone)

		{

		TPbapAuthNotifierResponsePckg pckg;

		pckg().SetPassword(aPassword);		

		TInt err = iMessage.Write(iReplySlot, pckg);

		iMessage.Complete(err);

		}

	else

		{

		iMessage.Complete(aReason);

		}

	}