--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetooth/btexample/testui/BTTextNotifiers/inc/BTTextNotifiers.h	Fri Jan 15 08:13:17 2010 +0200
@@ -0,0 +1,913 @@
+// Copyright (c) 2000-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:
+//
+
+/**
+ @file
+ @internalComponent
+*/
+
+#ifndef BTTEXTNOTIFIERS_H
+#define BTTEXTNOTIFIERS_H
+
+#include <e32std.h>
+#include <e32base.h>
+#include <bt_sock.h>
+#include <btextnotifiers.h> // contains definitions of standard Bluetooth notifiers
+#include <btextnotifierspartner.h>
+#include <twintnotifier.h>
+#include <btdevice.h>
+#include <btmanclient.h> // contains definitions of standard Bluetooth secuirty notfiers (pre-SSP)
+#include <networking/panuiinterfaces.h> // for KBTPanDeviceSelectionNotifierUid
+
+const TUid KScreenOutputChannel ={0x00000666};
+
+/**
+The maximum number of devices to show on screen at once
+@internalComponent
+*/
+const TInt KMaxDeviceRows=12;
+
+typedef RPointerArray<CBTDevice> RBTDevices;
+
+enum TRegistryState
+/**
+The state of the registry lookup to get info about a device
+@internalComponent
+*/
+	{
+	EFinding,	//< finding device details in registry
+	EGetting,	//< getting PIN from console
+	};
+
+/**
+Class for containing console utility methods used by BTTextNotifiers.
+*/
+class BTTextNotifiersConsole
+	{
+public:
+	static CConsoleBase* AutoSizeNewL(const TDesC& aTitle, TSize aSize);
+	};
+	
+	
+	
+// -----------------
+// PIN Code Entry UI
+// -----------------
+
+/**
+Mixing for receiving notifications about PIN code entry from the UI.
+*/
+class MBTPinCodeEntryObserver
+	{
+public:
+	virtual void MbpceoPinInputComplete(const TBTPinCode& aPin, TInt aReason) = 0;	
+	};
+
+
+class CBTManPinNotifierEngine;
+
+/**
+Notifier to get a PIN for pairing - This is the legacy version (i.e. not SSP aware).
+@internalTechnology
+*/
+NONSHARABLE_CLASS(CBTManPinNotifier)
+	: public CBase
+	, public MNotifierBase2
+	, public MBTPinCodeEntryObserver
+	{
+public:
+	static CBTManPinNotifier* NewLC();
+	
+private: // from MNotifierBase2
+	void Release();
+	TNotifierInfo RegisterL();
+	TNotifierInfo Info() const;
+	TPtrC8 StartL(const TDesC8& aBuffer);
+	void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);
+	void Cancel();
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	
+private: // from MBTPinCodeEntryObserver
+	void MbpceoPinInputComplete(const TBTPinCode& aPin, TInt aReason);
+
+private:
+	CBTManPinNotifier();
+	void ConstructL();
+	~CBTManPinNotifier();
+	
+private:
+	TNotifierInfo iInfo;
+	RMessage2 iMessage;
+	TInt iReplySlot;
+	TBool iNeedToCompleteMessage;
+	CBTManPinNotifierEngine* iEngine;
+	};
+
+
+#ifndef __BT_TEXT_NOTIFIERS_NO_SSP__
+/**
+Notifier to get a PIN for pairing - This is the SSP aware version.
+@internalTechnology
+*/
+NONSHARABLE_CLASS(CBTUIPinCodeEntry)
+	: public CBase
+	, public MNotifierBase2
+	, public MBTPinCodeEntryObserver
+	{
+public:
+	static CBTUIPinCodeEntry* NewLC();
+	
+private: // from MNotifierBase2
+	void Release();
+	TNotifierInfo RegisterL();
+	TNotifierInfo Info() const;
+	TPtrC8 StartL(const TDesC8& aBuffer);
+	void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);
+	void Cancel();
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	
+private: // from MBTPinCodeEntryObserver
+	void MbpceoPinInputComplete(const TBTPinCode& aPin, TInt aReason);
+
+private:
+	CBTUIPinCodeEntry();
+	void ConstructL();
+	~CBTUIPinCodeEntry();
+	
+private:
+	TNotifierInfo iInfo;
+	RMessage2 iMessage;
+	TInt iReplySlot;
+	TBool iNeedToCompleteMessage;
+	CBTManPinNotifierEngine* iEngine;
+	};
+
+#endif // __BT_TEXT_NOTIFIERS_NO_SSP__
+
+
+class CHostResolverCacheProdder;
+class CBTGetPinFromConsole;
+
+NONSHARABLE_CLASS(CBTManPinNotifierEngine) : public CActive
+	{
+public:
+	static CBTManPinNotifierEngine* NewL(MBTPinCodeEntryObserver& aObserver);
+	~CBTManPinNotifierEngine();
+	
+	void StartLegacyPinEntryL(const TDesC8& aBuffer);
+	void StartPinEntryL(const TDesC8& aBuffer);
+	void Stop();
+	
+	TPtrC8 LegacyUpdateL(const TDesC8& aBuffer);
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	
+	void HostResolverCacheInfoReceived(const TNameEntry& aResult);
+	void PinInputComplete(const TBTPinCode& aPin, TInt aReason);
+
+private:
+	CBTManPinNotifierEngine(MBTPinCodeEntryObserver& aObserver);
+	void DoStartPinEntryL();
+	void StoreNameUpdateL(const TDesC8& aBuffer);
+	void PerformNameUpdateL(TInt aResult);
+	
+private: // from CActive
+	void RunL();
+	void DoCancel();
+	void ConstructL();
+	
+private:
+	MBTPinCodeEntryObserver& iObserver;	// the notifier to signal when we have a PIN
+	
+	CHostResolverCacheProdder* iHostResolverCacheProdder;
+	CBTDevice* iDevice;			// the device for which we're prompting for a PIN
+	CBTGetPinFromConsole* iGetPinFromConsole;	// responsible for getting the PIN from the user
+	RBTRegServ iRegistry;
+	RBTRegistry iRegistryView;
+	TBTRegistrySearch iRegistrySearch;
+	TRegistryState iRegistryState;
+	CBTRegistryResponse* iResponse;
+	
+	TBTDevAddr						iDeviceAddress;
+	TBTDeviceName					iDeviceName;
+	TUint							iPasskeyMinLength;
+	TBool							iLocallyInitiated;
+	TBool							iStrongKeyRequired;
+	TUint							iRecommendedPasskeyMinLength;
+	};
+
+NONSHARABLE_CLASS(CHostResolverCacheProdder): public CActive
+/** 
+Get CoD from HostResolver class
+@internalComponent
+*/
+	{
+public:
+	static CHostResolverCacheProdder* NewL(CBTManPinNotifierEngine* aParent);
+	static CHostResolverCacheProdder* NewLC(CBTManPinNotifierEngine* aParent);
+	~CHostResolverCacheProdder();
+	TInt Start(const TBTDevAddr& aBDAddr);
+	
+private:
+	CHostResolverCacheProdder(CBTManPinNotifierEngine* aParent);
+	void DoCancel(){iHostResolver.Cancel();};
+	void RunL();
+
+private:	
+ 	CBTManPinNotifierEngine* iParent;
+	RHostResolver iHostResolver;
+	TNameEntry iResult;
+	TInquirySockAddr iAddr;
+	};
+
+/**
+Display a console and get a PIN response
+@internalComponent
+*/
+NONSHARABLE_CLASS(CBTGetPinFromConsole) 
+	: public CActive
+	{
+public:
+	static CBTGetPinFromConsole* NewL(CBTManPinNotifierEngine* aParent, const CBTDevice& aDevice,
+									  TUint aPasskeyMinLength, TBool aInternallyInitiated, TBool aStringKeyRequired, 
+									  TUint aRecommendedPasskeyMinLength);
+	~CBTGetPinFromConsole();
+	
+	void GetPinL();
+	void DeviceNameRetrieved(const TPtrC aName, TInt aResult);
+	void CoDRetrieved(TBTDeviceClass& aCoD);
+	
+private: // from CActive
+	void RunL();
+	void DoCancel();
+
+#ifdef __BT_TEXT_NOTIFIERS_AUTO__
+	static TInt AutoNotifierCallBack(TAny *aConsolePin);
+#endif
+	
+protected:
+	CBTGetPinFromConsole(CBTManPinNotifierEngine* aPtr, TUint aPasskeyMinLength, TBool aInternallyInitiated, TBool aStrongKeyRequired, TUint aRecommendedPasskeyMinLength);
+	
+private:
+	void ConstructL(const CBTDevice& aDevice);
+	void IssueRequestL();
+	
+private:
+	const CBTDevice* iDevice;
+	CBTManPinNotifierEngine* iParent;	// the class to notify when we have a PIN code
+	CConsoleBase* iConsole;	// console for interaction with the user
+	TBTPinCode iPin;
+	TInt iInsert;
+	TUint	iPasskeyMinLength;
+	TBool	iInternallyInitiated;
+	TBool	iStrongKeyRequired;
+	TUint	iRecommendedPasskeyMinLength;
+	
+#ifdef __BT_TEXT_NOTIFIERS_AUTO__
+	CAsyncCallBack* iAutoNotifierCallback;
+#endif
+	};
+
+class CBTManAuthNotifierEngine;
+NONSHARABLE_CLASS(CBTManAuthNotifier): public CBase, public MNotifierBase2
+	{
+public:
+	static CBTManAuthNotifier* NewLC();
+	~CBTManAuthNotifier();
+	void Release();
+	TNotifierInfo RegisterL();
+	TNotifierInfo Info() const;
+	TPtrC8 StartL(const TDesC8& aBuffer);
+	void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);
+	void Cancel();
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	void AuthorisationComplete(TBool aDecision, TInt aReason);
+
+private:
+	void ConstructL();
+
+private:
+	TNotifierInfo iInfo;
+	CBTManAuthNotifierEngine* iEngine;
+	RMessage2 iMessage;
+	TInt iReplySlot;
+	TBool iNeedToCompleteMessage;
+	};
+	
+class CBTGetAuthFromConsole;
+NONSHARABLE_CLASS(CBTManAuthNotifierEngine) : public CActive
+/**
+The implementation of authorisation notifier plugin.
+@note Separate class to avoid CActive and MNotifyBase Cancel name clash.
+*/
+	{
+public:
+	static CBTManAuthNotifierEngine* NewL(CBTManAuthNotifier& aParent);
+	void StartAuthorisationL(const TDesC8& aBuffer);
+	void AuthorisationComplete(TBool aDecision, TInt aReason);
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	~CBTManAuthNotifierEngine();
+	void Stop();
+
+private:
+	CBTManAuthNotifierEngine(CBTManAuthNotifier& aParent);
+	void RunL();
+	void DoCancel();
+
+private:
+	CBTGetAuthFromConsole* iGetAuthFromConsole;
+	RBTRegServ iRegistry;
+	RBTRegistry	iRegistryView;
+	TBTRegistrySearch iRegistrySearch;
+	TRegistryState iRegistryState;
+	CBTRegistryResponse* iResponse;
+	CBTDevice* iDevice;
+	TBTAuthorisationParamsPckg iAuthPckg;
+	CBTManAuthNotifier&	iParent;
+	};
+
+NONSHARABLE_CLASS(CBTGetAuthFromConsole) : public CActive
+/**
+Display a console and get a Y/N response
+@internalComponent
+*/
+	{
+public:
+	static CBTGetAuthFromConsole* NewL(CBTManAuthNotifierEngine* aParent, const CBTDevice& aDevice, TUid aUid);
+	static CBTGetAuthFromConsole* NewLC(CBTManAuthNotifierEngine* aParent, const CBTDevice& aDevice, TUid aUid);
+	~CBTGetAuthFromConsole();
+	void AuthoriseL();
+	void RunL();
+	void DoCancel();
+	void DeviceNameRetrieved(const TDesC& aName, TInt aResult);
+	
+#ifdef __BT_TEXT_NOTIFIERS_AUTO__
+	static TInt AutoNotifierCallBack(TAny *aConsoleAuth);
+#endif
+
+protected:
+	CBTGetAuthFromConsole(CBTManAuthNotifierEngine* aParent);
+	
+private:
+	TInt GetDeviceName(const TBTDevAddr& aBDAddr, TDes& aName);
+	void ConstructL(const CBTDevice& aDevice, TUid aUid);
+	void IssueRequest();
+	
+private:
+	TUid iServiceUid;
+	const CBTDevice* iDevice;
+	CBTManAuthNotifierEngine* iParent;
+	CConsoleBase* iConsole;
+
+#ifdef __BT_TEXT_NOTIFIERS_AUTO__
+	CAsyncCallBack* iAutoNotifierCallback;
+#endif
+	};
+
+NONSHARABLE_CLASS(CBTManDeviceSelectionNotifier)
+	: public CBase
+	, public MNotifierBase2
+	{
+public:
+	enum TUserResult
+		{
+		EScanStateSelected,
+		EScanStateContinue,
+		EScanStateCancelled
+		};
+public:
+	static CBTManDeviceSelectionNotifier* NewLC();
+	~CBTManDeviceSelectionNotifier();
+	TKeyCode GetResponseL(TRefByValue<const TDesC> aPrompt, TInt aWidth, TInt aHeight);
+	void GetAddressL(TBTDevAddr& aBDAddr);
+	void GetNameL(TBTDeviceName& aName);
+	//void GetClassL(TBTDeviceClass& aClass);
+	void DisplayErrorMessageL();
+	
+private: // from MNotifierBase2
+	void Release();
+	TNotifierInfo RegisterL();
+	TNotifierInfo Info() const;
+	TPtrC8 StartL(const TDesC8& aBuffer);
+	void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);
+	void Cancel();
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	
+private:
+	CBTManDeviceSelectionNotifier();
+	void ConstructL();
+	TNotifierInfo iInfo;
+	TBTDevAddr iBDAddr;
+	TBTDeviceName iName;
+	TBTDeviceClass iClass;
+	};
+
+NONSHARABLE_CLASS(CBTManDeviceScanner): public CBase
+	{
+public:
+	enum TScanState
+		{
+		EScanStateUnfinished,
+		EScanStateCancelled,
+		EScanStateSelected
+		};
+public:
+	static CBTManDeviceScanner* NewL();
+	~CBTManDeviceScanner();
+	TBool GetByScanL(TBTDevAddr& aBDAddr, TBTDeviceName& aName, TBTDeviceClass& aClass);
+private:
+	CBTManDeviceScanner();
+	void ConstructL();
+
+	void NotifyErrorL(TRefByValue<const TDesC> aErrorNotification);
+	void ResetDeviceLists();
+	void EnsureConsoleExistsL();
+	void StartWaitMessageL();
+	void StopWaitMessage();
+	void AddDiscoveredDeviceL(RBTDevices& aDeviceArray, const TNameEntry& aNameEntry);
+//	void AddDiscoveredDeviceL(CBTDevInfoArray& aDevInfoArray, TNameEntry aNameEntry);
+	void SetupDeviceParams(RHostResolver aHr, TBTNamelessDevice& aDevInfo);
+	void SetupDeviceParams(const THostName& aName, TBTNamelessDevice& aDevInfo);
+	void PrintDiscoveredDevice(TUint aCount, CBTDevice& aDevice);
+	void RubOutWaitMessage();
+	void PrintDiscoveredDevice();
+	TBool DeviceNumberFromUserL(TBool allowMore);
+	void DisplayNoDeviceMessageL(TBool isMore);
+	void CheckUnfinishedL();
+
+private:
+	CConsoleBase*		iConsole;
+	CConsoleBase*		iWaitConsole;
+	TPtrC				iWaitMessage;
+	RBTDevices			iDevices;
+	RPointerArray<TNameEntry>		iNoNameDevices;
+//	CBTDevInfoArray* iDevsWithName;
+
+	TUint iPrintedCounter;
+	TUint iChosenDeviceIndex;
+	TUint iResultCountWithName;
+	TUint iResultCountNoName;
+	TBTDeviceResponseParams iDevPms;
+
+	TScanState iScanState;
+	};
+
+//
+// BT PAN profile device discovery notifier classes
+//
+
+class MBTPanDeviceSelectionNotify
+/**
+Notification interface from PAN device selection engine to the notifier
+@internalComponent
+*/
+	{
+public:
+	/**
+	Remote device(s) have been selected
+	*/
+	virtual void DeviceSelectionComplete(TBTDeviceList& aDevices) = 0;
+	virtual void DeviceSelectionError(TInt aError) = 0;
+	
+protected:
+	~MBTPanDeviceSelectionNotify() {};
+	};
+
+class CBTPanDeviceSelectionNotifierEngine;
+class CBTPanDeviceSelectionNotifier
+	: public CBase
+	, public MNotifierBase2
+	, private MBTPanDeviceSelectionNotify
+/**
+An example notifier for Bluetooth PAN profile device selection.  This allows the selection of 
+multiple devices.
+@internalTechnology
+*/
+	{
+public:
+	static CBTPanDeviceSelectionNotifier* NewLC();
+	~CBTPanDeviceSelectionNotifier();
+
+	// MNotifierBase2 methods
+	virtual void Release();
+	virtual TNotifierInfo RegisterL();
+	virtual TNotifierInfo Info() const;
+	virtual TPtrC8 StartL(const TDesC8& aBuffer);
+	virtual void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);
+	virtual void Cancel();
+	virtual TPtrC8 UpdateL(const TDesC8& aBuffer);
+
+	// MBTPanDeviceSelectionNotify methods
+	virtual void DeviceSelectionComplete(TBTDeviceList& aDevices);
+	virtual void DeviceSelectionError(TInt aError);
+
+private:
+	CBTPanDeviceSelectionNotifier();
+	void ConstructL();
+
+public:
+
+private:
+	TNotifierInfo iInfo;			//< Info about this notifier
+	RMessage2 iMessage;				//< Client message to signal when device selection is complete
+	TBool iMessageOutstanding;		//< Have we got a message outstanding that needs to be completed?
+	TInt iReplySlot;				//< The slot in the message that contains the reply buffer
+
+	CBTPanDeviceSelectionNotifierEngine* iEngine;	//< Engine to do the actual device scanning and selection
+	};
+
+class MBTPanDeviceDiscoveryNotify
+/**
+Notification interface for when new devices are discovered
+@internalComponent
+*/
+	{
+public:
+	/**
+	A new device has been found
+	@param aNewDevice Information about the new device
+	@note aNewDevice must be copied if you want to use it after this method completes
+	*/
+	virtual void NewDeviceFoundL(TNameRecord& aNewDevice) = 0;
+	
+	/**
+	The search for devices has completed
+	*/
+	virtual void DeviceSearchComplete(TInt aError) = 0;
+	
+protected:
+	~MBTPanDeviceDiscoveryNotify() {};
+	};
+
+class CBTPanDeviceSelectionNotifierDeviceDiscoverer;
+class CBTPanDeviceSelectionNotifierEngine : public CActive, private MBTPanDeviceDiscoveryNotify
+/**
+Engine to display discovered devices to the user and get them to select some
+@internalComponent
+*/
+	{
+public:
+	static CBTPanDeviceSelectionNotifierEngine* NewL(MBTPanDeviceSelectionNotify& aNotify);
+	~CBTPanDeviceSelectionNotifierEngine();
+	
+	void PromptForDevicesL(const TDesC8& aBuffer);
+	void Stop();
+	
+	// CActive methods
+	virtual void RunL();
+	virtual void DoCancel();
+
+	// MBTPanDeviceDiscoveryNotify methods
+	virtual void NewDeviceFoundL(TNameRecord& aNewDevice);
+	virtual void DeviceSearchComplete(TInt aError);
+
+private:
+	CBTPanDeviceSelectionNotifierEngine(MBTPanDeviceSelectionNotify& aNotify);
+	void ConstructL();
+	
+	void DisplayInstructions(TPtr& aDisplayBuf);
+	TInt DisplayDevice(TUint aDeviceNumber, TPtr& aDisplayBuf);
+	void Redraw();
+	void PackageSelectedDevicesAndCompleteNotifier();
+	void CompleteNotifierWithError(TInt aError);
+	void AbortEverything();
+	
+	TInt NumberOfDevicesSelected();
+
+public:
+
+private:
+	class TBTDeviceSelectionInfo
+		{
+	public:
+		TBool iSelected;
+		TNameRecord iNameRecord;
+		};
+		
+	RPointerArray<TBTDeviceSelectionInfo> iDevices;
+	
+	CConsoleBase* iConsole;
+	HBufC* iDisplayBuf;					//< Buffer into which to put text for display
+	TPtr iDisplayPtr;
+	TUint iCurrentlySelectedDevice;		//< The index of the device to which the cursor is currently pointing
+	TUint iPositionOfTopDeviceInList;	//< The index of the device which is at the top of the list currently being displayed to the user
+	TBool iDeviceSearchComplete;		//< Has the device search completed?
+	
+	TBool iAborting;					//< Flag to stop us going round in circles as AOs complete with KErrCancel and signal us
+	
+	CBTPanDeviceSelectionNotifierDeviceDiscoverer* iDeviceDiscoverer;
+	MBTPanDeviceSelectionNotify& iNotify;	//< the class to be notified when the devices have been selected
+	};
+	
+class CBTPanDeviceSelectionNotifierDeviceDiscoverer : public CActive
+/**
+Discovers remote devices and notifies the engine about them
+@internalComponent
+*/
+	{
+public:
+	static CBTPanDeviceSelectionNotifierDeviceDiscoverer* NewL(MBTPanDeviceDiscoveryNotify& iNotify);
+	~CBTPanDeviceSelectionNotifierDeviceDiscoverer();
+	
+	void StartDeviceDiscovery();
+	
+	// CActive methods
+	virtual void RunL();
+	virtual void DoCancel();
+
+private:
+	CBTPanDeviceSelectionNotifierDeviceDiscoverer(MBTPanDeviceDiscoveryNotify& iNotify);
+	void ConstructL();
+
+public:
+
+private:
+	RSocketServ iSockServ;					//< Socket server session
+	RHostResolver iHostResolver;			//< Host resolver to discover devices
+	TNameEntry iNameEntry;					//< Name entry into which to return results
+	TInquirySockAddr iInquiryAddr;			//< The inquiry address to use to discover devices
+
+	MBTPanDeviceDiscoveryNotify& iNotify;	//< The class to notify when a new device is found
+	};
+
+// forward declarations
+class CPbapAuthNotifierConsole;
+class CPbapAuthNotifierEngine;
+
+/**
+Console utility class
+@internalTechnology
+*/
+class PbapTextNotifiersConsole
+	{
+public:
+	static CConsoleBase* AutoSizeNewL(const TDesC& aTitle, TSize aSize);
+	};
+
+/**
+PBAP OBEX authentication notifier.
+Handles notification of a PBAP client challenge when attempting to connect to the server.
+@internalTechnology
+*/
+NONSHARABLE_CLASS(CPbapAuthNotifier): public CBase, public MNotifierBase2
+	{
+public:
+	static CPbapAuthNotifier* NewLC();
+	~CPbapAuthNotifier();
+
+	void PasswordInputComplete(const TDesC& aPassword, TInt aReason);
+
+public:
+	// from MNotifierBase2
+	void Release();
+	TNotifierInfo RegisterL();
+	TNotifierInfo Info() const;
+	TPtrC8 StartL(const TDesC8& aBuffer);
+	void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);
+	void Cancel();
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+
+private:
+	CPbapAuthNotifier();
+	void ConstructL();
+
+private:
+	TNotifierInfo iInfo;
+	RMessage2 iMessage;
+	TInt iReplySlot;
+	TBool iNeedToCompleteMessage;
+	CPbapAuthNotifierEngine* iEngine;
+	};
+
+NONSHARABLE_CLASS(CPbapAuthNotifierEngine) : public CActive
+	{
+public:
+	static CPbapAuthNotifierEngine* NewL(CPbapAuthNotifier& aParent);
+	~CPbapAuthNotifierEngine();
+
+	void StartPasswordEntryL(const TDesC8& aBuffer);
+	void Stop();
+	void PasswordInputComplete(const TDesC& aPassword, TInt aReason);
+
+private:
+	CPbapAuthNotifierEngine(CPbapAuthNotifier& aParent);
+	void ConstructL();
+
+	// from CActive
+	void RunL();
+	void DoCancel();
+
+private:
+	enum TRegistryState
+		{
+		EFinding,
+		EGetting
+		};
+private:
+	CPbapAuthNotifier& iParent;
+	CBTDevice* iDevice;
+	CPbapAuthNotifierConsole* iAuthConsole;
+	RBTRegServ iRegistry;
+	RBTRegistry iRegistryView;
+	TBTRegistrySearch iRegistrySearch;
+	TRegistryState iRegistryState;
+	CBTRegistryResponse* iResponse;
+	TPbapAuthNotifierParamsPckg iParamsPckg;
+	};
+
+/**
+Display a console and get a password response
+@internalComponent
+*/
+NONSHARABLE_CLASS(CPbapAuthNotifierConsole) : public CActive
+	{
+public:
+	static CPbapAuthNotifierConsole* NewL(CPbapAuthNotifierEngine* aParent, const CBTDevice& aDevice, const TDesC& aRealm, TBool aRealmTruncated);
+	~CPbapAuthNotifierConsole();
+
+	void GetPasswordL();
+
+#ifdef __PBAP_TEXT_NOTIFIERS_AUTO__
+	static TInt AutoNotifierCallBack(TAny *aConsolePin);
+#endif
+
+protected:
+	CPbapAuthNotifierConsole(CPbapAuthNotifierEngine* aParent, const TDesC& aRealm, TBool aRealmTruncated);
+
+private:
+	void ConstructL(const CBTDevice& aDevice);
+	void IssueRequestL();
+
+	// from CActive
+	void RunL();
+	void DoCancel();
+
+private:
+	CPbapAuthNotifierEngine* iParent;
+	const CBTDevice* iDevice;
+	TBufC<KPbapAuthRealmLength> iRealm;
+	TBool iRealmTruncated;
+	CConsoleBase* iConsole;
+	TBuf<KPbapAuthPasswordLength> iPassword;
+	
+#ifdef __PBAP_TEXT_NOTIFIERS_AUTO__
+	CAsyncCallBack* iAutoNotifierCallback;
+#endif
+	};
+
+
+#ifndef __BT_TEXT_NOTIFIERS_NO_SSP__
+
+class MBTGetNCResultFromConsoleObserver
+	{
+public:
+	virtual void NumericComparisonComplete(TBool aDecision, TInt aReason)=0;		
+	};
+	
+class CBTUINumericComparisonEngine;
+NONSHARABLE_CLASS(CBTUINumericComparison):	public CBase,
+											public MNotifierBase2,
+											public MBTGetNCResultFromConsoleObserver
+	{
+public:
+	static CBTUINumericComparison* NewLC();
+	~CBTUINumericComparison();
+	void Release();
+	TNotifierInfo RegisterL();
+	TNotifierInfo Info() const;
+	TPtrC8 StartL(const TDesC8& aBuffer);
+	void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);
+	void Cancel();
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	
+	// MBTGetNCResultFromConsoleObserver
+	void NumericComparisonComplete(TBool aDecision, TInt aReason);
+
+private:
+	void ConstructL();
+
+private:
+	TNotifierInfo iInfo;
+	CBTUINumericComparisonEngine* iEngine;
+	RMessage2 iMessage;
+	TInt iReplySlot;
+	TBTNumericComparisonParamsPckg		iNumericComparisonParamsPckg;
+	TBool iNeedToCompleteMessage;
+	};
+
+NONSHARABLE_CLASS(CBTUINumericComparisonEngine) : public CActive
+	{
+public:
+	static CBTUINumericComparisonEngine* NewL(MBTGetNCResultFromConsoleObserver& aObserver);
+	static CBTUINumericComparisonEngine* NewLC(MBTGetNCResultFromConsoleObserver& aObserver);
+	~CBTUINumericComparisonEngine();
+
+	void DoComparisonL(TBTNumericComparisonParams& aNumericComparisonParams);
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	void Stop();
+	void RunL();
+	void DoCancel();
+
+protected:
+	CBTUINumericComparisonEngine(MBTGetNCResultFromConsoleObserver& aObserver);
+	
+private:
+	void ConstructL();
+	void IssueRequest();
+	
+private:
+	MBTGetNCResultFromConsoleObserver& iObserver;
+	CConsoleBase* iConsole;
+	};
+
+
+// ----------------------
+// Passkey Entry UI (SSP)
+// ----------------------
+
+class MBTGetPasskeyResultFromConsoleObserver
+	{
+public:
+	virtual void PasskeyComplete(TInt aReason)=0;		
+	};
+
+
+class CBTUIPasskeyEntryEngine;
+
+NONSHARABLE_CLASS(CBTUIPasskeyEntry)
+	: public CBase
+	, public MNotifierBase2
+	, public MBTGetPasskeyResultFromConsoleObserver
+	{
+public:
+	static CBTUIPasskeyEntry* NewLC();
+	
+private: // from MNotifierBase2
+	void Release();
+	TNotifierInfo RegisterL();
+	TNotifierInfo Info() const;
+	TPtrC8 StartL(const TDesC8& aBuffer);
+	void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);
+	void Cancel();
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+		
+private: // from MBTGetPasskeyResultFromConsoleObserver
+	void PasskeyComplete(TInt aReason);
+
+private:
+	void ConstructL();
+	~CBTUIPasskeyEntry();
+
+private:
+	TNotifierInfo iInfo;
+	CBTUIPasskeyEntryEngine* iEngine;
+	RMessage2 iMessage;
+	TInt iReplySlot;
+	TBTPasskeyDisplayParamsPckg			iPasskeyDisplayParamsPckg;
+	TBTDevAddr iAddr;
+	TBTDeviceName iName;
+	TUint32 iNumericValue;
+	TBool iNeedToCompleteMessage;
+	};
+
+NONSHARABLE_CLASS(CBTUIPasskeyEntryEngine)
+	: public CActive
+	{
+public:
+	static CBTUIPasskeyEntryEngine* NewL(MBTGetPasskeyResultFromConsoleObserver& aObserver);
+	static CBTUIPasskeyEntryEngine* NewLC(MBTGetPasskeyResultFromConsoleObserver& aObserver);
+	~CBTUIPasskeyEntryEngine();
+
+	void DoPasskeyL(TBTPasskeyDisplayParams& aPasskeyParams);
+	TPtrC8 UpdateL(const TDesC8& aBuffer);
+	void Stop();
+	void RunL();
+	void DoCancel();
+
+private:
+	CBTUIPasskeyEntryEngine(MBTGetPasskeyResultFromConsoleObserver& aObserver);
+	void ConstructL();
+	void IssueRequest();
+	
+private:
+	MBTGetPasskeyResultFromConsoleObserver& iObserver;
+	CConsoleBase* iConsole;
+	};
+
+
+#endif // __BT_TEXT_NOTIFIERS_NO_SSP__
+
+
+
+#endif // BTTEXTNOTIFIERS_H