1 // Copyright (c) 2008-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 #ifndef _BTACCESSREQUESTERSTATEMACHINE_H

    17 #define _BTACCESSREQUESTERSTATEMACHINE_H

    18 

    19 #include "secman.h"

    20 

    21 class CBTAccessRequester;

    22 class CBTAccessRequesterTransition;

    23 class TBTSecEvent;

    24 class CBTBaseStateAction;

    25 

    26 

    27 enum TBTAccessRequesterState

    28 	{

    29 	EBTUninitialised,

    30 	EBTReady,

    31 	EBTWaiting,

    32 	EBTPhysicalLinkUp,

    33 	EBTAuthenticationRequested,

    34 	EBTRequestAuthentication,

    35 	EBTAuthenticationComplete,

    36 	EBTEncryptionChangePending,

    37 	EBTEncryptionChangeComplete,

    38 	EBTAuthorisationRequested,

    39 	EBTRequestAuthorisation,

    40 	EBTAuthorisationComplete,

    41 	EBTIOCapsResponse,

    42 	EBTIOCapsRequested,

    43 	EBTUserConfirmation,

    44 	EBTPasskeyEntry,

    45 	EBTRemoteOOBDataRequest,

    46 	EBTSimplePairingPending,

    47 	EBTPrefetchZombie,

    48 

    49 	// --- End of states ---

    50 	EBTMaximumStateNumber,

    51 	EBTUnknownState, //< Special state value

    52 	EBTNopState, //< Special state value

    53 	};

    54 

    55 

    56 NONSHARABLE_CLASS(CBTAccessRequesterStateFactory)

    57 	: public CBase

    58 	{

    59 public:

    60 	static CBTAccessRequesterStateFactory* NewL();

    61 	static CBTAccessRequesterStateFactory* NewLC();

    62 	~CBTAccessRequesterStateFactory();

    63 

    64 	void ExecuteAction(TBTAccessRequesterState aState, CBTAccessRequester& aRequester, TBTSecEvent& aEvent);

    65 

    66 	TInt ProcessRequesterState(TBTAccessRequesterState aState, CBTAccessRequester& aRequester, TBTSecEvent& aEvent);

    67 

    68 private:

    69 	CBTAccessRequesterStateFactory();

    70 	void ConstructL();

    71 	void ConstructStateMachineL();

    72 	void AddTransitionL(CBTAccessRequesterTransition* aTransition);

    73 	CBTBaseStateAction* GetStateL(TBTAccessRequesterState aState);

    74 

    75 

    76 private:

    77 	RPointerArray<CBTBaseStateAction> iStateActions;

    78 	};

    79 

    80 

    81 

    82 _LIT(KBTFlyStateStateMachine, "BT FlyStateMachine");

    83 enum TBTFlyStateMachinePanic

    84 	{

    85 	EBTFlyUnknowState,

    86 	EBTFlyMismatchState,

    87 	EBTFlyMismatchExecuteActionState,

    88 	EBTFlyUnknowNextState,

    89 	};

    90 

    91 

    92 /*********************** SECOND GENERATION CODE ************/

    93 

    94 /**

    95 NONSHARABLE_CLASS(CBTBaseStateAction

    96 */

    97 NONSHARABLE_CLASS(CBTBaseStateAction) : public CBase

    98 	{

    99 

   100 public:

   101 	static CBTBaseStateAction* NewL(TBTAccessRequesterState aState);

   102 	static CBTBaseStateAction* NewLC(TBTAccessRequesterState aState);

   103 	~CBTBaseStateAction();

   104 

   105 	virtual void ExecuteAction(CBTAccessRequester& aRequester, TBTSecEvent& aEvent);

   106 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   107 

   108 protected:

   109 	CBTBaseStateAction(TBTAccessRequesterState aState);

   110 

   111 

   112 protected:

   113 	TBTAccessRequesterState iState;

   114 	};

   115 

   116 

   117 

   118 NONSHARABLE_CLASS(CBTUninitialisedState) : public CBTBaseStateAction

   119 	{

   120 

   121 public:

   122 	static CBTUninitialisedState* NewL(TBTAccessRequesterState aState);

   123 	static CBTUninitialisedState* NewLC(TBTAccessRequesterState aState);

   124 	~CBTUninitialisedState();

   125 

   126 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   127 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   128 

   129 protected:

   130 	CBTUninitialisedState(TBTAccessRequesterState aState)

   131 	: CBTBaseStateAction(aState)

   132 	{}

   133 

   134 	};

   135 

   136 NONSHARABLE_CLASS(CBTWaitingState) : public CBTBaseStateAction

   137 	{

   138 

   139 public:

   140 	static CBTWaitingState* NewL(TBTAccessRequesterState aState);

   141 	static CBTWaitingState* NewLC(TBTAccessRequesterState aState);

   142 	~CBTWaitingState();

   143 

   144 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   145 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   146 

   147 protected:

   148 	CBTWaitingState(TBTAccessRequesterState aState)

   149 	: CBTBaseStateAction(aState)

   150 	{}

   151 

   152 	};

   153 

   154 

   155 /**

   156 NONSHARABLE_CLASS(CBTReadyState

   157 */

   158 NONSHARABLE_CLASS(CBTReadyState) : public CBTBaseStateAction

   159 	{

   160 

   161 public:

   162 	static CBTReadyState* NewL(TBTAccessRequesterState aState);

   163 	static CBTReadyState* NewLC(TBTAccessRequesterState aState);

   164 	~CBTReadyState();

   165 

   166 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   167 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   168 

   169 protected:

   170 	CBTReadyState(TBTAccessRequesterState aState)

   171 	: CBTBaseStateAction(aState)

   172 	{}

   173 

   174 	};

   175 

   176 

   177 /**

   178 NONSHARABLE_CLASS(CBTPhysicalLinkUpState

   179 */

   180 NONSHARABLE_CLASS(CBTPhysicalLinkUpState) : public CBTBaseStateAction

   181 	{

   182 

   183 public:

   184 	static CBTPhysicalLinkUpState* NewL(TBTAccessRequesterState aState);

   185 	static CBTPhysicalLinkUpState* NewLC(TBTAccessRequesterState aState);

   186 	~CBTPhysicalLinkUpState();

   187 

   188 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   189 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   190 

   191 protected:

   192 	CBTPhysicalLinkUpState(TBTAccessRequesterState aState)

   193 	: CBTBaseStateAction(aState)

   194 	{}

   195 

   196 	};

   197 

   198 

   199 /**

   200 NONSHARABLE_CLASS(CBTAuthenticationRequestedState

   201 */

   202 NONSHARABLE_CLASS(CBTAuthenticationRequestedState) : public CBTBaseStateAction

   203 	{

   204 

   205 public:

   206 	static CBTAuthenticationRequestedState* NewL(TBTAccessRequesterState aState);

   207 	static CBTAuthenticationRequestedState* NewLC(TBTAccessRequesterState aState);

   208 	~CBTAuthenticationRequestedState();

   209 

   210 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   211 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   212 

   213 protected:

   214 	CBTAuthenticationRequestedState(TBTAccessRequesterState aState)

   215 	: CBTBaseStateAction(aState)

   216 	{}

   217 

   218 	};

   219 

   220 

   221 /**

   222 NONSHARABLE_CLASS(CBTRequestAuthenticationState

   223 */

   224 NONSHARABLE_CLASS(CBTRequestAuthenticationState) : public CBTBaseStateAction

   225 	{

   226 

   227 public:

   228 	static CBTRequestAuthenticationState* NewL(TBTAccessRequesterState aState);

   229 	static CBTRequestAuthenticationState* NewLC(TBTAccessRequesterState aState);

   230 	~CBTRequestAuthenticationState();

   231 

   232 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   233 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   234 

   235 protected:

   236 	CBTRequestAuthenticationState(TBTAccessRequesterState aState)

   237 	: CBTBaseStateAction(aState)

   238 	{}

   239 

   240 	};

   241 

   242 

   243 /**

   244 NONSHARABLE_CLASS(CBTAuthenticationCompleteState

   245 */

   246 NONSHARABLE_CLASS(CBTAuthenticationCompleteState) : public CBTBaseStateAction

   247 	{

   248 

   249 public:

   250 	static CBTAuthenticationCompleteState* NewL(TBTAccessRequesterState aState);

   251 	static CBTAuthenticationCompleteState* NewLC(TBTAccessRequesterState aState);

   252 	~CBTAuthenticationCompleteState();

   253 

   254 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   255 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   256 

   257 protected:

   258 	CBTAuthenticationCompleteState(TBTAccessRequesterState aState)

   259 	: CBTBaseStateAction(aState)

   260 	{}

   261 

   262 	};

   263 

   264 

   265 

   266 /**

   267 NONSHARABLE_CLASS(CBTEncryptionChangePendingState

   268 */

   269 NONSHARABLE_CLASS(CBTEncryptionChangePendingState) : public CBTBaseStateAction

   270 	{

   271 

   272 public:

   273 	static CBTEncryptionChangePendingState* NewL(TBTAccessRequesterState aState);

   274 	static CBTEncryptionChangePendingState* NewLC(TBTAccessRequesterState aState);

   275 	~CBTEncryptionChangePendingState();

   276 

   277 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   278 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   279 

   280 protected:

   281 	CBTEncryptionChangePendingState(TBTAccessRequesterState aState)

   282 	: CBTBaseStateAction(aState)

   283 	{}

   284 

   285 	};

   286 

   287 

   288 /**

   289 NONSHARABLE_CLASS(CBTEncryptionChangeCompleteState

   290 */

   291 NONSHARABLE_CLASS(CBTEncryptionChangeCompleteState) : public CBTBaseStateAction

   292 	{

   293 

   294 public:

   295 	static CBTEncryptionChangeCompleteState* NewL(TBTAccessRequesterState aState);

   296 	static CBTEncryptionChangeCompleteState* NewLC(TBTAccessRequesterState aState);

   297 	~CBTEncryptionChangeCompleteState();

   298 

   299 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   300 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   301 

   302 protected:

   303 	CBTEncryptionChangeCompleteState(TBTAccessRequesterState aState)

   304 	: CBTBaseStateAction(aState)

   305 	{}

   306 

   307 	};

   308 

   309 

   310 /**

   311 NONSHARABLE_CLASS(CBTAuthorisationRequestedState

   312 */

   313 NONSHARABLE_CLASS(CBTAuthorisationRequestedState) : public CBTBaseStateAction

   314 	{

   315 

   316 public:

   317 	static CBTAuthorisationRequestedState* NewL(TBTAccessRequesterState aState);

   318 	static CBTAuthorisationRequestedState* NewLC(TBTAccessRequesterState aState);

   319 	~CBTAuthorisationRequestedState();

   320 

   321 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   322 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   323 

   324 protected:

   325 	CBTAuthorisationRequestedState(TBTAccessRequesterState aState)

   326 	: CBTBaseStateAction(aState)

   327 	{}

   328 

   329 	};

   330 

   331 

   332 /**

   333 NONSHARABLE_CLASS(CBTRequestAuthorisationState

   334 */

   335 NONSHARABLE_CLASS(CBTRequestAuthorisationState) : public CBTBaseStateAction

   336 	{

   337 

   338 public:

   339 	static CBTRequestAuthorisationState* NewL(TBTAccessRequesterState aState);

   340 	static CBTRequestAuthorisationState* NewLC(TBTAccessRequesterState aState);

   341 	~CBTRequestAuthorisationState();

   342 

   343 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   344 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   345 

   346 protected:

   347 	CBTRequestAuthorisationState(TBTAccessRequesterState aState)

   348 	: CBTBaseStateAction(aState)

   349 	{}

   350 

   351 	};

   352 

   353 

   354 /**

   355 NONSHARABLE_CLASS(CBTAuthorisationCompleteState

   356 */

   357 NONSHARABLE_CLASS(CBTAuthorisationCompleteState) : public CBTBaseStateAction

   358 	{

   359 

   360 public:

   361 	static CBTAuthorisationCompleteState* NewL(TBTAccessRequesterState aState);

   362 	static CBTAuthorisationCompleteState* NewLC(TBTAccessRequesterState aState);

   363 	~CBTAuthorisationCompleteState();

   364 

   365 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   366 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   367 

   368 protected:

   369 	CBTAuthorisationCompleteState(TBTAccessRequesterState aState)

   370 	: CBTBaseStateAction(aState)

   371 	{}

   372 

   373 	};

   374 

   375 

   376 /**

   377 NONSHARABLE_CLASS(CBTIOCapsResponseState

   378 */

   379 NONSHARABLE_CLASS(CBTIOCapsResponseState) : public CBTBaseStateAction

   380 	{

   381 

   382 public:

   383 	static CBTIOCapsResponseState* NewL(TBTAccessRequesterState aState);

   384 	static CBTIOCapsResponseState* NewLC(TBTAccessRequesterState aState);

   385 	~CBTIOCapsResponseState();

   386 

   387 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   388 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   389 

   390 protected:

   391 	CBTIOCapsResponseState(TBTAccessRequesterState aState)

   392 	: CBTBaseStateAction(aState)

   393 	{}

   394 

   395 	};

   396 

   397 

   398 /**

   399 NONSHARABLE_CLASS(CBTIOCapsRequestedState

   400 */

   401 NONSHARABLE_CLASS(CBTIOCapsRequestedState) : public CBTBaseStateAction

   402 	{

   403 

   404 public:

   405 	static CBTIOCapsRequestedState* NewL(TBTAccessRequesterState aState);

   406 	static CBTIOCapsRequestedState* NewLC(TBTAccessRequesterState aState);

   407 	~CBTIOCapsRequestedState();

   408 

   409 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   410 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   411 

   412 protected:

   413 	CBTIOCapsRequestedState(TBTAccessRequesterState aState)

   414 	: CBTBaseStateAction(aState)

   415 	{}

   416 

   417 	};

   418 

   419 

   420 /**

   421 NONSHARABLE_CLASS(CBTUserConfirmationState

   422 */

   423 NONSHARABLE_CLASS(CBTUserConfirmationState) : public CBTBaseStateAction

   424 	{

   425 

   426 public:

   427 	static CBTUserConfirmationState* NewL(TBTAccessRequesterState aState);

   428 	static CBTUserConfirmationState* NewLC(TBTAccessRequesterState aState);

   429 	~CBTUserConfirmationState();

   430 

   431 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   432 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   433 

   434 protected:

   435 	CBTUserConfirmationState(TBTAccessRequesterState aState)

   436 	: CBTBaseStateAction(aState)

   437 	{}

   438 

   439 	};

   440 

   441 

   442 /**

   443 NONSHARABLE_CLASS(CBTPasskeyEntryState

   444 */

   445 NONSHARABLE_CLASS(CBTPasskeyEntryState) : public CBTBaseStateAction

   446 	{

   447 

   448 public:

   449 	static CBTPasskeyEntryState* NewL(TBTAccessRequesterState aState);

   450 	static CBTPasskeyEntryState* NewLC(TBTAccessRequesterState aState);

   451 	~CBTPasskeyEntryState();

   452 

   453 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   454 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   455 

   456 protected:

   457 	CBTPasskeyEntryState(TBTAccessRequesterState aState)

   458 	: CBTBaseStateAction(aState)

   459 	{}

   460 

   461 	};

   462 

   463 

   464 /**

   465 NONSHARABLE_CLASS(CBTRemoteOOBDataRequestState

   466 */

   467 NONSHARABLE_CLASS(CBTRemoteOOBDataRequestState) : public CBTBaseStateAction

   468 	{

   469 

   470 public:

   471 	static CBTRemoteOOBDataRequestState* NewL(TBTAccessRequesterState aState);

   472 	static CBTRemoteOOBDataRequestState* NewLC(TBTAccessRequesterState aState);

   473 	~CBTRemoteOOBDataRequestState();

   474 

   475 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   476 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   477 

   478 protected:

   479 	CBTRemoteOOBDataRequestState(TBTAccessRequesterState aState)

   480 	: CBTBaseStateAction(aState)

   481 	{}

   482 

   483 	};

   484 

   485 

   486 /**

   487 NONSHARABLE_CLASS(CBTSimplePairingPendingState

   488 */

   489 NONSHARABLE_CLASS(CBTSimplePairingPendingState) : public CBTBaseStateAction

   490 	{

   491 

   492 public:

   493 	static CBTSimplePairingPendingState* NewL(TBTAccessRequesterState aState);

   494 	static CBTSimplePairingPendingState* NewLC(TBTAccessRequesterState aState);

   495 	~CBTSimplePairingPendingState();

   496 

   497 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   498 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   499 

   500 protected:

   501 	CBTSimplePairingPendingState(TBTAccessRequesterState aState)

   502 	: CBTBaseStateAction(aState)

   503 	{}

   504 

   505 	};

   506 

   507 

   508 NONSHARABLE_CLASS(CBTPrefetchZombieState) : public CBTBaseStateAction

   509 	{

   510 

   511 public:

   512 	static CBTPrefetchZombieState* NewL(TBTAccessRequesterState aState);

   513 	static CBTPrefetchZombieState* NewLC(TBTAccessRequesterState aState);

   514 	~CBTPrefetchZombieState();

   515 

   516 	virtual void ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent);

   517 	virtual TBTAccessRequesterState GetNextState(TInt aEventId);

   518 

   519 protected:

   520 	CBTPrefetchZombieState(TBTAccessRequesterState aState)

   521 	: CBTBaseStateAction(aState)

   522 	{}

   523 

   524 	};

   525 

   526 

   527 

   528 #endif //_BTACCESSREQUESTERSTATEMACHINE_H