--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetooth/btexample/testui/BTUIAutoNotifiers/Src/btuinotifiers.cpp Fri Jan 15 08:13:17 2010 +0200
@@ -0,0 +1,984 @@
+// 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);
+ }
+ }
+
+
+//
+// CPanNapAuthAutoNotifier
+//
+CPanNapAuthAutoNotifier* CPanNapAuthAutoNotifier::NewL()
+ {
+ CPanNapAuthAutoNotifier* self = new (ELeave) CPanNapAuthAutoNotifier();
+ return self;
+ }
+
+CPanNapAuthAutoNotifier::CPanNapAuthAutoNotifier()
+ {
+ }
+
+void CPanNapAuthAutoNotifier::Release()
+ {
+ delete this;
+ }
+
+void CPanNapAuthAutoNotifier::Cancel()
+ {
+ }
+
+CPanNapAuthAutoNotifier::~CPanNapAuthAutoNotifier()
+ {
+ iProperty.Close();
+ }
+
+CPanNapAuthAutoNotifier::TNotifierInfo CPanNapAuthAutoNotifier::RegisterL()
+ {
+ iInfo.iUid=KBTPanNapUplinkAuthorisationNotifierUid;
+ iInfo.iChannel=KTechViewScreenOutputChannel;
+ iInfo.iPriority=ENotifierPriorityVHigh;
+ return iInfo;
+ }
+
+CPanNapAuthAutoNotifier::TNotifierInfo CPanNapAuthAutoNotifier::Info() const
+ {
+ return iInfo;
+ }
+
+TPtrC8 CPanNapAuthAutoNotifier::StartL(const TDesC8& /*aBuffer*/)
+ {
+ return KNullDesC8();
+ }
+
+void CPanNapAuthAutoNotifier::StartL(const TDesC8& /*aBuffer*/, TInt aReplySlot, const RMessagePtr2& aMessage)
+ {
+ iReplySlot = aReplySlot;
+ iMessage = RMessage2(aMessage);
+
+ TInt psResult;
+ TNapConnectionResult result = EAcceptNapConnectionAllowUplinkAccess; // Default value if P&S key is not setup
+ TInt err = iProperty.Get(KUidSystemCategory, KUidPanNapAutoNotifierResult, psResult);
+ if(err == KErrNone)
+ {
+ result = static_cast<TNapConnectionResult>(psResult);
+ if(result != EDisallowNewNapConnection &&
+ result != EAcceptNapConnectionAllowUplinkAccess &&
+ result != EAcceptNapConnectionDisallowUplinkAccess)
+ {
+ User::Leave(KErrArgument);
+ }
+ }
+ else
+ {
+ // Ensure no unexpected error occurred (KErrNotFound will be received if the key has not been
+ // setup)
+ if(err != KErrNotFound)
+ {
+ User::LeaveIfError(err);
+ }
+ }
+
+ PanNapNotifierComplete(result, KErrNone);
+ }
+
+TPtrC8 CPanNapAuthAutoNotifier::UpdateL(const TDesC8& /*aBuffer*/)
+ {
+ return KNullDesC8();
+ }
+
+void CPanNapAuthAutoNotifier::PanNapNotifierComplete(TNapConnectionResult aResult, TInt aReason)
+ {
+ if(aReason == KErrNone)
+ {
+ TNapConnectionResultPckg pckg;
+ pckg = aResult;
+ TInt err = iMessage.Write(iReplySlot, pckg);
+ iMessage.Complete(err);
+ }
+ else
+ {
+ iMessage.Complete(aReason);
+ }
+
+ // update executed status, ignore error, what can we do !?!
+ iProperty.Set(KUidSystemCategory, KUidPanNapAutoNotifierExecuted, 1);
+ }
+
+
+
+//
+// CSSPNumericComparisionAutoNotifier
+//
+
+CSSPNumericComparisionAutoNotifier* CSSPNumericComparisionAutoNotifier::NewL()
+ {
+ CSSPNumericComparisionAutoNotifier* self = new(ELeave) CSSPNumericComparisionAutoNotifier();
+ return self;
+ }
+
+CSSPNumericComparisionAutoNotifier::CSSPNumericComparisionAutoNotifier()
+ {
+ }
+
+void CSSPNumericComparisionAutoNotifier::Release()
+ {
+ delete this;
+ }
+
+void CSSPNumericComparisionAutoNotifier::Cancel()
+ {
+ }
+
+CSSPNumericComparisionAutoNotifier::~CSSPNumericComparisionAutoNotifier()
+ {
+ }
+
+CSSPNumericComparisionAutoNotifier::TNotifierInfo CSSPNumericComparisionAutoNotifier::RegisterL()
+ {
+ iInfo.iUid=KBTNumericComparisonNotifierUid;
+ iInfo.iChannel=KTechViewScreenOutputChannel;
+ iInfo.iPriority=ENotifierPriorityVHigh;
+ return iInfo;
+ }
+
+CSSPNumericComparisionAutoNotifier::TNotifierInfo CSSPNumericComparisionAutoNotifier::Info() const
+ {
+ return iInfo;
+ }
+
+TPtrC8 CSSPNumericComparisionAutoNotifier::StartL(const TDesC8& /*aBuffer*/)
+ {
+ User::Panic(KPanicCat, ESynchronousStartWithNumericComparison);
+ return KNullDesC8();
+ }
+
+void CSSPNumericComparisionAutoNotifier::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)
+ {
+ UpdateLastNotifierType(ESspNumericComparisonNotifier);
+ iReplySlot = aReplySlot;
+ iMessage = RMessage2(aMessage);
+ TBTNumericComparisonParamsPckg pckg;
+ pckg.Copy(aBuffer);
+
+ /*Update a P&S key for identifying who initiated the authentication*/
+ TInt err = RProperty::Set(KUidSystemCategory, KUidLocallyInitiated, pckg().LocallyInitiated());
+
+ if (err == KErrNotFound)
+ {
+ /* p+s key not defined by the test
+ * May be autonotifiers are not called for testing purpose (i.e. just running epoc in startupmode 4)
+ * so we should not panic here and hence do nothing
+ */
+ }
+ else
+ {
+ // make sure no other error occurred
+ User::LeaveIfError(err);
+ }
+
+ /*Read the Numeric Value*/
+ TInt numericValue;
+
+ numericValue = pckg().NumericalValue();
+
+ /*Now I need to update a P&S key which will have the NumericValue*/
+ err = RProperty::Set(KUidSystemCategory, KUidSspNumericValue, numericValue);
+
+ if (err == KErrNotFound)
+ {
+ /* p+s key not defined by the test
+ * May be autonotifiers are not called for testing purpose (i.e. just running epoc in startupmode 4)
+ * so we should not panic here and hence do nothing
+ */
+ }
+ else
+ {
+ // make sure no other error occurred
+ User::LeaveIfError(err);
+ }
+
+ /* Complete the Numeric comparision*/
+ TInt authoriseAccept;
+ err = RProperty::Get(KUidSystemCategory, KUidSspAuthorisation, authoriseAccept);
+
+ if (err == KErrNotFound)
+ {
+ // p+s key not defined, use default (Yes)
+ authoriseAccept = KDefaultSSPAuthorisation;
+ }
+ else
+ {
+ // make sure no other error occurred
+ User::LeaveIfError(err);
+ }
+
+ SSPNumericComparisonComplete(authoriseAccept);
+ }
+
+void CSSPNumericComparisionAutoNotifier::UpdateL(const TDesC8& /*aBuffer*/, TInt /*aReplySlot*/, const RMessagePtr2& aMessage)
+ {
+ aMessage.Complete(KErrNone);
+ }
+
+TPtrC8 CSSPNumericComparisionAutoNotifier::UpdateL(const TDesC8& /*aBuffer*/)
+ {
+ return KNullDesC8();
+ }
+
+void CSSPNumericComparisionAutoNotifier::SSPNumericComparisonComplete(TInt aAuthoriseAccept)
+ {
+ TInt err = iMessage.Write(iReplySlot, TPckgC<TBool>(aAuthoriseAccept));
+
+ if(err != KErrNone)
+ {
+ iMessage.Complete(err);
+ }
+ else
+ {
+ TInt notifierError = KErrNone;
+ /* Get the value of the P&S key 'KErrorNotifiers' 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)
+ {
+ iMessage.Complete(KErrNone);
+ }
+ else
+ {
+ /*If error is defined then complete the notifiers with an error*/
+ iMessage.Complete(notifierError);
+ }
+ }
+ }
+
+
+
+//
+// CSSPPassKeyAutoNotifier
+//
+
+CSSPPassKeyAutoNotifier* CSSPPassKeyAutoNotifier::NewL()
+ {
+ CSSPPassKeyAutoNotifier* self = new(ELeave) CSSPPassKeyAutoNotifier();
+ return self;
+ }
+
+CSSPPassKeyAutoNotifier::CSSPPassKeyAutoNotifier()
+ {
+ }
+
+void CSSPPassKeyAutoNotifier::Release()
+ {
+ delete this;
+ }
+
+void CSSPPassKeyAutoNotifier::Cancel()
+ {
+ if (iMessage.Handle())
+ {
+ iMessage.Complete(KErrCancel);
+ }
+ }
+
+CSSPPassKeyAutoNotifier::~CSSPPassKeyAutoNotifier()
+ {
+ }
+
+CSSPPassKeyAutoNotifier::TNotifierInfo CSSPPassKeyAutoNotifier::RegisterL()
+ {
+ iInfo.iUid=KBTPasskeyDisplayNotifierUid;
+ iInfo.iChannel=KTechViewScreenOutputChannel;
+ iInfo.iPriority=ENotifierPriorityVHigh;
+ return iInfo;
+ }
+
+CSSPPassKeyAutoNotifier::TNotifierInfo CSSPPassKeyAutoNotifier::Info() const
+ {
+ return iInfo;
+ }
+
+TPtrC8 CSSPPassKeyAutoNotifier::StartL(const TDesC8& )
+ {
+ User::Panic(KPanicCat, ESynchronousStartWithPasskeyDisplay);
+ return KNullDesC8();
+ }
+
+void CSSPPassKeyAutoNotifier::StartL(const TDesC8& aBuffer, TInt /*aReplySlot*/, const RMessagePtr2& aMessage)
+ {
+ UpdateLastNotifierType(ESspPassKeyNotifier);
+ TBTPasskeyDisplayParamsPckg pckg;
+ pckg.Copy(aBuffer);
+
+ /*Update a P&S key for identifying who initiated the authentication*/
+ TInt err = RProperty::Set(KUidSystemCategory, KUidLocallyInitiated, pckg().LocallyInitiated());
+
+ if (err == KErrNotFound)
+ {
+ /* p+s key not defined by the test
+ * May be autonotifiers are not called for testing purpose (i.e. just running epoc in startupmode 4)
+ * so we should not panic here and hence do nothing
+ */
+ }
+ else
+ {
+ // make sure no other error occurred
+ User::LeaveIfError(err);
+ }
+
+ /*Read the Numeric Value*/
+ TInt passKeyValue;
+
+ passKeyValue = pckg().NumericalValue();
+
+ /*Now I need to update a P&S key which will have the Pass key Value*/
+ err = RProperty::Set(KUidSystemCategory, KUidSspPassKey, passKeyValue);
+
+ if (err == KErrNotFound)
+ {
+ /* p+s key not defined by the test
+ * May be autonotifiers are not called for testing purpose (i.e. just running epoc in startupmode 4)
+ * so we should not panic here and hence do nothing
+ */
+ }
+ else
+ {
+ // make sure no other error occurred
+ User::LeaveIfError(err);
+ }
+
+ iMessage = RMessage2(aMessage);
+
+ 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)
+ {
+ //If error is defined then complete the notifiers with an error
+ iMessage.Complete(notifierError);
+ }
+ else
+ {
+ //Do nothing. We do not have to complete this msg here as stack will cancel it when it gets a
+ //simple pairing complete event.
+ }
+ }
+
+TPtrC8 CSSPPassKeyAutoNotifier::UpdateL(const TDesC8& /*aBuffer*/)
+ {
+ return KNullDesC8();
+ }
+
+void CSSPPassKeyAutoNotifier::UpdateL(const TDesC8& aBuffer, TInt /*aReplySlot*/, const RMessagePtr2& aMessage)
+ {
+ TBTNotifierUpdateParamsPckg2 pckgRaw;
+ pckgRaw.Copy(aBuffer.Left(pckgRaw.MaxLength()));
+
+ RMsgQueue<THCIPasskeyEntryNotificationType> keyPressNotificationQueue;
+ _LIT(KKeypressNotificationQueue, "KeypressNotificationQueue");
+
+ TInt err;
+
+ err = keyPressNotificationQueue.OpenGlobal(KKeypressNotificationQueue);
+ if(err == KErrNotFound)
+ {
+ err = keyPressNotificationQueue.CreateGlobal(KKeypressNotificationQueue,KMaxNumberOfKeyPressNotifications);
+ User::LeaveIfError(err);
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ /*Notify the test code for the passkey press*/
+ if (pckgRaw().Type() == TBTNotifierUpdateParams2::EPasskeyDisplay)
+ {
+ TBTPasskeyDisplayUpdateParamsPckg pckg;
+ pckg.Copy(aBuffer);
+
+ THCIPasskeyEntryNotificationType keypressNotification = pckg().KeypressNotification();
+
+ keyPressNotificationQueue.SendBlocking(keypressNotification);
+
+ switch (keypressNotification)
+ {
+ case EPasskeyEntryStarted:
+ case EPasskeyDigitEntered:
+ case EPasskeyDigitDeleted:
+ case EPasskeyCleared:
+ case EPasskeyEntryCompleted:
+ break;
+ }
+ }
+
+ 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)
+ {
+ aMessage.Complete(KErrNone);
+ }
+ else
+ {
+ /*If error is defined then complete the notifiers with an error*/
+ iMessage.Complete(notifierError);
+ aMessage.Complete(KErrNone);
+ }
+ }
+
+//
+// CBTUIAutoPinCodeNotifier
+//
+
+CBTUIAutoPinCodeNotifier* CBTUIAutoPinCodeNotifier::NewL()
+ {
+ CBTUIAutoPinCodeNotifier* self = new(ELeave) CBTUIAutoPinCodeNotifier();
+ return self;
+ }
+
+CBTUIAutoPinCodeNotifier::CBTUIAutoPinCodeNotifier()
+ {
+ }
+
+CBTUIAutoPinCodeNotifier::~CBTUIAutoPinCodeNotifier()
+ {
+ }
+
+void CBTUIAutoPinCodeNotifier::Release()
+ {
+ delete this;
+ }
+
+CBTUIAutoPinCodeNotifier::TNotifierInfo CBTUIAutoPinCodeNotifier::RegisterL()
+ {
+ iInfo.iUid=KBTPinCodeEntryNotifierUid;
+ iInfo.iChannel=KTechViewScreenOutputChannel;
+ iInfo.iPriority=ENotifierPriorityLow;
+ return iInfo;
+ }
+
+CBTUIAutoPinCodeNotifier::TNotifierInfo CBTUIAutoPinCodeNotifier::Info() const
+ {
+ return iInfo;
+ }
+
+TPtrC8 CBTUIAutoPinCodeNotifier::StartL(const TDesC8&)
+ {
+ User::Panic(KPanicCat, ESynchronousStartWithPinCodeEntry);
+ return KNullDesC8();
+ }
+
+void CBTUIAutoPinCodeNotifier::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)
+ {
+ UpdateLastNotifierType(ELegacyPinCodeNotifier);
+ iMessage = aMessage;
+ iReplySlot = aReplySlot;
+ // read properties
+ TBTPinCode pinCode;
+
+ TBTPinCodeEntryNotifierParamsPckg pckg;
+ if(aBuffer.Length() != sizeof(TBTPinCodeEntryNotifierParams))
+ {
+ User::Leave(KErrArgument);
+ }
+ pckg.Copy(aBuffer);
+ TUint passkeyMinLength;
+ passkeyMinLength = pckg().PinCodeMinLength();
+
+
+ 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();
+
+ /* Passkey length should not be less then the expected length.
+ * If it is smaller than complete the notifiers with an error
+ */
+ if(buf.Length() < passkeyMinLength )
+ {
+ PinInputComplete(pinCode, KErrArgument);
+ }
+ else
+ {
+ 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);
+ }
+ }
+ }
+
+
+void CBTUIAutoPinCodeNotifier::Cancel()
+ {
+ }
+
+void CBTUIAutoPinCodeNotifier::UpdateL(const TDesC8& /*aBuffer*/, TInt /*aReplySlot*/, const RMessagePtr2& aMessage)
+ {
+ aMessage.Complete(KErrNone);
+ }
+
+TPtrC8 CBTUIAutoPinCodeNotifier::UpdateL(const TDesC8&)
+ {
+ return KNullDesC8();
+ }
+
+void CBTUIAutoPinCodeNotifier::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);
+ }
+ }
+