1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @internalComponent

    19  @test

    20 */

    21 

    22 

    23 #ifndef BTUINOTIFIERS_H

    24 #define BTUINOTIFIERS_H

    25 

    26 #include <e32std.h>

    27 #include <e32base.h>

    28 #include <e32property.h>

    29 #include <eiknotapi.h>

    30 #include <btdevice.h>

    31 #include <btmanclient.h>

    32 

    33 /**

    34 UID of Publish & Subscribe variable category to control auto notifiers

    35 

    36 UID of the automatic authorisation RNotifier plugin - unused

    37 @publishedPartner

    38 @released

    39 */

    40 const TUid KUidAutoNotifierCat = { 0x1020DBC4}; // unused

    41 

    42 /**

    43 UID range for Publish & Subscribe variables to control auto notifiers

    44 

    45 @internalTechnology

    46 */

    47 const TUint KUidBluetoothTestPubSubKeyBase = 0x1027235E; //	Range of 10 values registered

    48 const TUint KUidBluetoothTestPubSubKeyBase2 = 0x10286508; // Range of 50 values registered

    49 /**

    50 UID for auto notifiers - Pin Code

    51 

    52 @internalTechnology

    53 */

    54 const TUint KUidAutoPropertyPinCode = (KUidBluetoothTestPubSubKeyBase +0); 

    55 

    56 /**

    57 UID for auto notifiers - Authorise Accept

    58 

    59 @internalTechnology

    60 */

    61 const TUint KUidAutoPropertyAuthoriseAccept = (KUidBluetoothTestPubSubKeyBase +1);

    62 

    63 /**

    64 UID for Pbap auto notifiers - Password

    65 

    66 @internalTechnology

    67 */

    68 const TUint KUidPbapAutoNotifierPassword = (KUidBluetoothTestPubSubKeyBase + 2); 

    69 

    70 /**

    71 UID for Pbap auto notifiers - Executed Status

    72 

    73 @internalTechnology

    74 */

    75 const TUint KUidPbapAutoNotifierExecuted = (KUidBluetoothTestPubSubKeyBase + 3);

    76 

    77 /**

    78 UID for PAN NAP Auth auto notifiers - Result (i.e., accept as NAP, GN or disallow)

    79 

    80 @internalTechnology

    81 */

    82 const TUint KUidPanNapAutoNotifierResult = (KUidBluetoothTestPubSubKeyBase + 4); 

    83 

    84 /**

    85 UID for PAN NAP Auth auto notifiers - Executed Status

    86 

    87 @internalTechnology

    88 */

    89 const TUint KUidPanNapAutoNotifierExecuted = (KUidBluetoothTestPubSubKeyBase + 5);

    90 

    91 /**

    92 Pin input completed - Status

    93 

    94 @internalTechnology

    95 */

    96 const TUint KUidAuthenticationExecuted = (KUidBluetoothTestPubSubKeyBase + 6);

    97 

    98 /**

    99 Authorisation completed - Status

   100 

   101 */

   102 const TUint KUidAuthorisationExecuted = (KUidBluetoothTestPubSubKeyBase + 7);

   103 

   104 

   105 /**

   106 Numeric value from the controller

   107 

   108 */

   109 const TUint KUidSspNumericValue = (KUidBluetoothTestPubSubKeyBase + 8);

   110 

   111 /**

   112 Passkey value

   113 */

   114 const TUint KUidSspPassKey = (KUidBluetoothTestPubSubKeyBase + 9);

   115 

   116 /**

   117  * P&S key for identifying the type of notifier that has run.

   118  */

   119 const TUint KUidLastNotifierTypeRun = (KUidBluetoothTestPubSubKeyBase2 + 1);

   120 

   121 /** 

   122  * P&S key to hold the information whether the autonotifier should pass the authorization or not

   123  * By default it will pass. 

   124  */

   125 const TUint KUidSspAuthorisation = (KUidBluetoothTestPubSubKeyBase2 + 2);

   126 

   127 /** 

   128  * P&S key to hold the error which should be issued from the notifiers. Currently it is mainly used

   129  * for canceling the Notifiers.

   130  * Offset 3 and 4 are used by PLM and LSTO tests so I am using offset 5

   131  */

   132 const TUint KUidErrorNotifiers = (KUidBluetoothTestPubSubKeyBase2 + 5);

   133 

   134 /** 

   135  * P&S key to hold the information about who initiated the authetication. 

   136  */

   137 const TUint KUidLocallyInitiated = (KUidBluetoothTestPubSubKeyBase2 + 6);

   138 

   139 

   140 

   141 _LIT(KPanicCat, "BTAutoNotifiers");

   142 enum TPanicCode

   143 	{

   144 	ESynchronousStartWithNumericComparison,

   145 	ESynchronousStartWithPasskeyDisplay,

   146 	ESynchronousStartWithPinCodeEntry,

   147 	};

   148 

   149 

   150 enum TAutoNotifierType

   151 	{

   152 	ENone,

   153 	ESspPassKeyNotifier,

   154 	ESspNumericComparisonNotifier,

   155 	ELegacyPinCodeNotifier,

   156 	};

   157 

   158 class CBTUIAutoPasskeyNotifier:  public MEikSrvNotifierBase2

   159 	{

   160 public:

   161 	/*

   162 	 * Contructs a CBTUIPasskeyNotifier object.

   163 	 * @return CBTUIPasskeyNotifier which is the actual object.

   164 	 */

   165 	static CBTUIAutoPasskeyNotifier* NewL();

   166 	/*

   167 	 * Destructor

   168 	 */

   169 	virtual ~CBTUIAutoPasskeyNotifier();

   170 

   171 	//from MEikSrvNotifierBase2

   172 	/**

   173 	 * Called when all resources allocated by notifiers shoudl be freed.

   174 	 * @see MEikSrvNotifierBase2::Release()

   175 	 */

   176 	void Release();

   177 	/**

   178 	 * Called when a notifier is first loaded to allow any initial construction that is required.

   179 	 * @see MEikSrvNotifierBase2::RegisterL()

   180 	 */

   181 	TNotifierInfo RegisterL();

   182 	/**

   183 	 * Return the priority a notifier takes and the channels it acts on.  The return value may be varied 

   184 	 * at run-time.

   185 	 * @see MEikSrvNotifierBase2::Info()

   186 	 */

   187 	TNotifierInfo Info() const;

   188 	/**

   189 	 * Start the notifier with data aBuffer and return an initial response.

   190 	 * @see MEikSrvNotifierBase2::StartL(const TDesC8& aBuffer) 

   191 	 */

   192 	TPtrC8 StartL( const TDesC8& aBuffer );

   193 	/**

   194 	 * Start the notifier with data aBuffer.  aMessage should be completed when the notifier is deactivated.

   195 	 * May be called multiple times if more than one client starts the notifier.  The notifier is immediately

   196 	 * responsible for completing aMessage.

   197 	 * @see MEikSrvNotifierBase2::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

   198 	 */

   199 	void StartL( const TDesC8& aBuffer, TInt aReplySlot,  const RMessagePtr2& aMessage );

   200 	/**

   201 	 * Update a currently active notifier with data aBuffer.

   202 	 * This is called as a result of a client-side call to the asynchronous 

   203 	 * function RNotifier::UpdateNotifierAndGetResponse(). 

   204 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   205 	 */

   206 	void UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   207 	/**

   208 	 * Update a currently active notifier with data aBuffer.

   209 	 * This is called as a result of a client-side call to the synchronous function RNotifier::UpdateNotifier().

   210 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer)

   211 	 */

   212 	TPtrC8 UpdateL(const TDesC8& aBuffer);

   213 	/**

   214 	 * The notifier has been deactivated so resources can be freed and outstanding messages completed.

   215 	 * @see MEikSrvNotifierBase2::Cancel()

   216 	 */

   217 	void Cancel();	//implemented by CActive!!

   218 

   219 private:

   220 	/*

   221 	 * Constructor

   222 	 */

   223 	CBTUIAutoPasskeyNotifier();

   224 	/*

   225 	 * Reads and loads the resource file.

   226 	 */

   227 	void ConstructL();

   228 	/*

   229 	 * Calls SetActive() and starts the active object.

   230 	 */ 

   231 

   232 private:

   233 	

   234 	/**

   235 	* RMessagePtr2

   236 	*/

   237 	RMessagePtr2			iMessage;

   238 	

   239 	/**

   240 	* Return value from iMessage

   241 	*/

   242 	TInt iReplySlot;

   243 

   244 	/**

   245 	* Notifier info

   246 	*/

   247 	TNotifierInfo		iInfo;

   248 

   249 	void PinInputComplete(const TBTPinCode& aPin, TInt aReason);

   250 	

   251 	};

   252 

   253 

   254 class CBTUIAutoAuthNotifier:  public MEikSrvNotifierBase2

   255 	{

   256 public:

   257 	/*

   258 	 * Contructs a CBTUIPasskeyNotifier object.

   259 	 * @return CBTUIPasskeyNotifier which is the actual object.

   260 	 */

   261 	static CBTUIAutoAuthNotifier* NewL();

   262 	/*

   263 	 * Destructor

   264 	 */

   265 	virtual ~CBTUIAutoAuthNotifier();

   266 

   267 	//from MEikSrvNotifierBase2

   268 	/**

   269 	 * Called when all resources allocated by notifiers shoudl be freed.

   270 	 * @see MEikSrvNotifierBase2::Release()

   271 	 */

   272 	void Release();

   273 	/**

   274 	 * Called when a notifier is first loaded to allow any initial construction that is required.

   275 	 * @see MEikSrvNotifierBase2::RegisterL()

   276 	 */

   277 	TNotifierInfo RegisterL();

   278 	/**

   279 	 * Return the priority a notifier takes and the channels it acts on.  The return value may be varied 

   280 	 * at run-time.

   281 	 * @see MEikSrvNotifierBase2::Info()

   282 	 */

   283 	TNotifierInfo Info() const;

   284 	/**

   285 	 * Start the notifier with data aBuffer and return an initial response.

   286 	 * @see MEikSrvNotifierBase2::StartL(const TDesC8& aBuffer) 

   287 	 */

   288 	TPtrC8 StartL( const TDesC8& aBuffer );

   289 	/**

   290 	 * Start the notifier with data aBuffer.  aMessage should be completed when the notifier is deactivated.

   291 	 * May be called multiple times if more than one client starts the notifier.  The notifier is immediately

   292 	 * responsible for completing aMessage.

   293 	 * @see MEikSrvNotifierBase2::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

   294 	 */

   295 	void StartL( const TDesC8& aBuffer, TInt aReplySlot,  const RMessagePtr2& aMessage );

   296 	/**

   297 	 * Update a currently active notifier with data aBuffer.

   298 	 * This is called as a result of a client-side call to the asynchronous 

   299 	 * function RNotifier::UpdateNotifierAndGetResponse(). 

   300 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   301 	 */

   302 	void UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   303 	/**

   304 	 * Update a currently active notifier with data aBuffer.

   305 	 * This is called as a result of a client-side call to the synchronous function RNotifier::UpdateNotifier().

   306 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer)

   307 	 */

   308 	TPtrC8 UpdateL(const TDesC8& aBuffer);

   309 	/**

   310 	 * The notifier has been deactivated so resources can be freed and outstanding messages completed.

   311 	 * @see MEikSrvNotifierBase2::Cancel()

   312 	 */

   313 	void Cancel();	//implemented by CActive!!

   314 

   315 private:

   316 	/*

   317 	 * Constructor

   318 	 */

   319 	CBTUIAutoAuthNotifier();

   320 	/*

   321 	 * Reads and loads the resource file.

   322 	 */

   323 	void ConstructL();

   324 	/*

   325 	 * Calls SetActive() and starts the active object.

   326 	 */ 

   327 

   328 private:

   329 	

   330 	/**

   331 	* RMessagePtr2

   332 	*/

   333 	RMessagePtr2			iMessage;

   334 	

   335 	/**

   336 	* Return value from iMessage

   337 	*/

   338 	TInt iReplySlot;

   339 

   340 	/**

   341 	* Notifier info

   342 	*/

   343 	TNotifierInfo		iInfo;

   344 

   345 	void AuthorisationComplete(TInt aAuthorised);

   346 	

   347 	};

   348 

   349 

   350 class CPbapUIAutoAuthNotifier:  public MEikSrvNotifierBase2

   351 	{

   352 public:

   353 	/*

   354 	 * Contructs a CPbapUIAutoAuthNotifier object.

   355 	 * @return CPbapUIAutoAuthNotifier which is the actual object.

   356 	 */

   357 	static CPbapUIAutoAuthNotifier* NewL();

   358 	/*

   359 	 * Destructor

   360 	 */

   361 	virtual ~CPbapUIAutoAuthNotifier();

   362 

   363 	//from MEikSrvNotifierBase2

   364 	/**

   365 	 * Called when all resources allocated by notifiers shoudl be freed.

   366 	 * @see MEikSrvNotifierBase2::Release()

   367 	 */

   368 	void Release();

   369 	/**

   370 	 * Called when a notifier is first loaded to allow any initial construction that is required.

   371 	 * @see MEikSrvNotifierBase2::RegisterL()

   372 	 */

   373 	TNotifierInfo RegisterL();

   374 	/**

   375 	 * Return the priority a notifier takes and the channels it acts on.  The return value may be varied 

   376 	 * at run-time.

   377 	 * @see MEikSrvNotifierBase2::Info()

   378 	 */

   379 	TNotifierInfo Info() const;

   380 	/**

   381 	 * Start the notifier with data aBuffer and return an initial response.

   382 	 * @see MEikSrvNotifierBase2::StartL(const TDesC8& aBuffer) 

   383 	 */

   384 	TPtrC8 StartL( const TDesC8& aBuffer );

   385 	/**

   386 	 * Start the notifier with data aBuffer.  aMessage should be completed when the notifier is deactivated.

   387 	 * May be called multiple times if more than one client starts the notifier.  The notifier is immediately

   388 	 * responsible for completing aMessage.

   389 	 * @see MEikSrvNotifierBase2::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

   390 	 */

   391 	void StartL( const TDesC8& aBuffer, TInt aReplySlot,  const RMessagePtr2& aMessage );

   392 	/**

   393 	 * Update a currently active notifier with data aBuffer.

   394 	 * This is called as a result of a client-side call to the asynchronous 

   395 	 * function RNotifier::UpdateNotifierAndGetResponse(). 

   396 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   397 	 */

   398 	void UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   399 	/**

   400 	 * Update a currently active notifier with data aBuffer.

   401 	 * This is called as a result of a client-side call to the synchronous function RNotifier::UpdateNotifier().

   402 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer)

   403 	 */

   404 	TPtrC8 UpdateL(const TDesC8& aBuffer);

   405 	/**

   406 	 * The notifier has been deactivated so resources can be freed and outstanding messages completed.

   407 	 * @see MEikSrvNotifierBase2::Cancel()

   408 	 */

   409 	void Cancel();	//implemented by CActive!!

   410 

   411 private:

   412 	/*

   413 	 * Constructor

   414 	 */

   415 	CPbapUIAutoAuthNotifier();

   416 

   417 private:	

   418 	/**

   419 	* RMessagePtr2

   420 	*/

   421 	RMessagePtr2			iMessage;

   422 	

   423 	/**

   424 	* Return value from iMessage

   425 	*/

   426 	TInt iReplySlot;

   427 

   428 	/**

   429 	* Notifier info

   430 	*/

   431 	TNotifierInfo iInfo;

   432 

   433 	RProperty iProperty;

   434 	

   435 	void PasswordInputComplete(const TDesC& aPassword, TInt aReason);	

   436 	};

   437 

   438 

   439 class CPanNapAuthAutoNotifier:  public MEikSrvNotifierBase2

   440 	{

   441 public:

   442 	/*

   443 	 * Contructs a CPanNapAuthAutoNotifier object.

   444 	 * @return CPanNapAuthAutoNotifier which is the actual object.

   445 	 */

   446 	static CPanNapAuthAutoNotifier* NewL();

   447 	/*

   448 	 * Destructor

   449 	 */

   450 	virtual ~CPanNapAuthAutoNotifier();

   451 

   452 	//from MEikSrvNotifierBase2

   453 	/**

   454 	 * Called when all resources allocated by notifiers shoudl be freed.

   455 	 * @see MEikSrvNotifierBase2::Release()

   456 	 */

   457 	void Release();

   458 	/**

   459 	 * Called when a notifier is first loaded to allow any initial construction that is required.

   460 	 * @see MEikSrvNotifierBase2::RegisterL()

   461 	 */

   462 	TNotifierInfo RegisterL();

   463 	/**

   464 	 * Return the priority a notifier takes and the channels it acts on.  The return value may be varied 

   465 	 * at run-time.

   466 	 * @see MEikSrvNotifierBase2::Info()

   467 	 */

   468 	TNotifierInfo Info() const;

   469 	/**

   470 	 * Start the notifier with data aBuffer and return an initial response.

   471 	 * @see MEikSrvNotifierBase2::StartL(const TDesC8& aBuffer) 

   472 	 */

   473 	TPtrC8 StartL( const TDesC8& aBuffer );

   474 	/**

   475 	 * Start the notifier with data aBuffer.  aMessage should be completed when the notifier is deactivated.

   476 	 * May be called multiple times if more than one client starts the notifier.  The notifier is immediately

   477 	 * responsible for completing aMessage.

   478 	 * @see MEikSrvNotifierBase2::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

   479 	 */

   480 	void StartL( const TDesC8& aBuffer, TInt aReplySlot,  const RMessagePtr2& aMessage );

   481 	/**

   482 	 * Update a currently active notifier with data aBuffer.

   483 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer)

   484 	 */

   485 	TPtrC8 UpdateL(const TDesC8& aBuffer);

   486 	/**

   487 	 * The notifier has been deactivated so resources can be freed and outstanding messages completed.

   488 	 * @see MEikSrvNotifierBase2::Cancel()

   489 	 */

   490 	void Cancel();	//implemented by CActive!!

   491 

   492 private:

   493 	/*

   494 	 * Constructor

   495 	 */

   496 	CPanNapAuthAutoNotifier();

   497 

   498 private:	

   499 	/**

   500 	* RMessagePtr2

   501 	*/

   502 	RMessagePtr2			iMessage;

   503 	

   504 	/**

   505 	* Return value from iMessage

   506 	*/

   507 	TInt iReplySlot;

   508 

   509 	/**

   510 	* Notifier info

   511 	*/

   512 	TNotifierInfo iInfo;

   513 

   514 	RProperty iProperty;

   515 	

   516 	void PanNapNotifierComplete(TNapConnectionResult aResult, TInt aReason);	

   517 	};

   518 

   519 	

   520 	

   521 

   522 // ========================================

   523 // |                                      |

   524 // | Secure Simple Pairing Auto Notifiers |

   525 // v                                      v

   526 //	

   527 	

   528 NONSHARABLE_CLASS(CSSPNumericComparisionAutoNotifier)

   529 	: public CBase

   530 	, public MEikSrvNotifierBase2

   531 	{

   532 public:

   533 	static CSSPNumericComparisionAutoNotifier* NewL();

   534 

   535 private: // from MEikSrvNotifierBase2

   536 	void Release();

   537 	TNotifierInfo RegisterL();

   538 	TNotifierInfo Info() const;

   539 	TPtrC8 StartL( const TDesC8& aBuffer );

   540 	void StartL( const TDesC8& aBuffer, TInt aReplySlot,  const RMessagePtr2& aMessage );

   541 	/**

   542 	 * Update a currently active notifier with data aBuffer.

   543 	 * This is called as a result of a client-side call to the asynchronous 

   544 	 * function RNotifier::UpdateNotifierAndGetResponse(). 

   545 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   546 	 */

   547 	void UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   548 	/**

   549 	 * Update a currently active notifier with data aBuffer.

   550 	 * This is called as a result of a client-side call to the synchronous function RNotifier::UpdateNotifier().

   551 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer)

   552 	 */

   553 	TPtrC8 UpdateL(const TDesC8& aBuffer);

   554 	

   555 	void Cancel();

   556 

   557 private:

   558 	CSSPNumericComparisionAutoNotifier();

   559 	~CSSPNumericComparisionAutoNotifier();

   560 	

   561 	void SSPNumericComparisonComplete(TInt aReason);	

   562 

   563 private:	

   564 	RMessagePtr2	iMessage;

   565 	TInt			iReplySlot;

   566 	TNotifierInfo	iInfo;

   567 	};

   568 	

   569 	

   570 

   571 NONSHARABLE_CLASS(CSSPPassKeyAutoNotifier)

   572 	: public CBase

   573 	, public MEikSrvNotifierBase2

   574 	{

   575 public:

   576 	static CSSPPassKeyAutoNotifier* NewL();

   577 

   578 private: // from MEikSrvNotifierBase2

   579 	void Release();

   580 	TNotifierInfo RegisterL();

   581 	TNotifierInfo Info() const;

   582 	TPtrC8 StartL( const TDesC8& aBuffer );

   583 	void StartL( const TDesC8& aBuffer, TInt aReplySlot,  const RMessagePtr2& aMessage );	

   584 	/**

   585 	 * Update a currently active notifier with data aBuffer.

   586 	 * This is called as a result of a client-side call to the asynchronous 

   587 	 * function RNotifier::UpdateNotifierAndGetResponse(). 

   588 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   589 	 */

   590 	void UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   591 	/**

   592 	 * Update a currently active notifier with data aBuffer.

   593 	 * This is called as a result of a client-side call to the synchronous function RNotifier::UpdateNotifier().

   594 	 * @see MEikSrvNotifierBase2::UpdateL(const TDesC8& aBuffer)

   595 	 */

   596 	TPtrC8 UpdateL(const TDesC8& aBuffer);

   597 	void Cancel();

   598 

   599 private:

   600 	CSSPPassKeyAutoNotifier();

   601 	~CSSPPassKeyAutoNotifier();

   602 	

   603 private:	

   604 	RMessagePtr2	iMessage;

   605 	TInt			iReplySlot;

   606 	TNotifierInfo	iInfo;

   607 	TBool iNeedToCompleteMessage;

   608 	};

   609 

   610 

   611 

   612 NONSHARABLE_CLASS(CBTUIAutoPinCodeNotifier)

   613 	: public CBase

   614 	, public MEikSrvNotifierBase2

   615 	{

   616 public:

   617 	static CBTUIAutoPinCodeNotifier* NewL();

   618 

   619 private: //from MEikSrvNotifierBase2

   620 	void Release();

   621 	TNotifierInfo RegisterL();

   622 	TNotifierInfo Info() const;

   623 	TPtrC8 StartL( const TDesC8& aBuffer );

   624 	void StartL( const TDesC8& aBuffer, TInt aReplySlot,  const RMessagePtr2& aMessage );

   625 	void UpdateL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage);

   626 	TPtrC8 UpdateL(const TDesC8& aBuffer);

   627 	void Cancel();

   628 

   629 private:

   630 	CBTUIAutoPinCodeNotifier();

   631 	~CBTUIAutoPinCodeNotifier();

   632 	

   633 	void PinInputComplete(const TBTPinCode& aPin, TInt aReason);

   634 

   635 private:

   636 	RMessagePtr2	iMessage;

   637 	TInt			iReplySlot;

   638 	TNotifierInfo	iInfo;

   639 	};

   640 	

   641 #endif //BTUINOTIFIERS_H

   642