1 // Copyright (c) 2004-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 #include "BTTestHelpers.h"

    17 #include "BTTestConsole.h"

    18 

    19 _LIT(KNotDefined,				"-");

    20 

    21 _LIT(KConnIdle,					"Idle        ");

    22 _LIT(KConnListening,			"Listening   ");

    23 _LIT(KConnListeningAccept,		"Lstn[Accept]");

    24 _LIT(KConnAccepting,			"Accepting   ");

    25 _LIT(KConnConnecting,			"Connecting  ");

    26 _LIT(KConnConnected,			"Connected   ");

    27 _LIT(KConnDisconnected,			"Disconnected");

    28 _LIT(KConnServerDisconnected,	"Serv Disc   ");

    29 _LIT(KConnFailed,				"Failed      ");

    30 

    31 _LIT(KRoleMaster,				"M");

    32 _LIT(KRoleSlave,				"S");

    33 

    34 _LIT(KModeActive,				"Active");

    35 _LIT(KRoleHold,					"Hold  ");

    36 _LIT(KRoleSniff,				"Sniff ");

    37 _LIT(KRolePark,					"Park  ");

    38 _LIT(KRoleScatter,				"Scatr ");

    39 _LIT(KModeExplicitActive,		"ExpAct");

    40 

    41 _LIT(KDataNone,					" --- ");

    42 _LIT(KDataDialog1,				"Rx/Tx");

    43 _LIT(KDataDialog2,				"Tx/Rx");

    44 _LIT(KDataFailed,				"FAIL ");

    45 _LIT(KDataSend,					"Send ");

    46 _LIT(KDataRecv,					"Recv ");

    47 _LIT(KDataRecvAny,				"RecvA");

    48 _LIT(KDataSendReceive,			"BiDi ");

    49 _LIT(KDataSendOS,				"Tx OS");

    50 _LIT(KDataRecvOS,				"Rx OS");

    51 

    52 const TDesC& TConnProfile::StateName(TConnState aState)

    53 	{

    54 	switch(aState)

    55 		{

    56 		case EConnIdle:

    57 			return KConnIdle;

    58 			

    59 		case EConnListening:

    60 			return KConnListening;

    61 			

    62 		case EConnListeningAccept:

    63 			return KConnListeningAccept;

    64 			

    65 		case EConnAccepting:

    66 			return KConnAccepting;

    67 			

    68 		case EConnConnecting:

    69 			return KConnConnecting;

    70 			

    71 		case EConnConnected:

    72 			return KConnConnected;

    73 			

    74 		case EConnDisconnected:

    75 			return KConnDisconnected;

    76 			

    77 		case EConnServerDisconnected:

    78 			return KConnServerDisconnected;

    79 			

    80 		case EConnFailed:

    81 			return KConnFailed;

    82 			

    83 		default:

    84 			break;

    85 		};

    86 		

    87 	return KNullDesC;	

    88 	}

    89 

    90 const TDesC& TConnProfile::RoleName(TConnRole aState)

    91 	{

    92 	switch(aState)

    93 		{

    94 		case ENone:

    95 			return KNotDefined;

    96 			

    97 		case EMaster:

    98 			return KRoleMaster;

    99 			

   100 		case ESlave:

   101 			return KRoleSlave;

   102 			

   103 		default:

   104 			break;

   105 		};

   106 		

   107 	return KNullDesC;	

   108 	}

   109 

   110 const TDesC& TConnProfile::ModeName(TBTLinkMode aState)

   111 	{

   112 	switch(aState)

   113 		{

   114 		case EActiveMode:

   115 			return KModeActive;

   116 			

   117 		case EHoldMode:

   118 			return KRoleHold;

   119 

   120 		case ESniffMode:

   121 			return KRoleSniff;

   122 			

   123 		case EParkMode:

   124 			return KRolePark;

   125 

   126 		case EScatterMode:

   127 			return KRoleScatter;

   128 			

   129 		default:

   130 			break;

   131 		};

   132 		

   133 	return KNullDesC;	

   134 	}

   135 

   136 const TDesC& TConnProfile::ModeName(TConnProfile::TConnMode aState)

   137 	{

   138 	switch(aState)

   139 		{

   140 		case EActive:

   141 			return KModeActive;

   142 			

   143 		case EHold:

   144 			return KRoleHold;

   145 

   146 		case ESniff:

   147 			return KRoleSniff;

   148 			

   149 		case EPark:

   150 			return KRolePark;

   151 		

   152 		case EExplicitActive:

   153 			return KModeExplicitActive;

   154 

   155 		default:

   156 			break;

   157 		};

   158 		

   159 	return KNullDesC;	

   160 	}

   161 

   162 const TDesC& TConnProfile::DataStateName(TDataState aState)

   163 	{

   164 	switch(aState)

   165 		{

   166 		case EDataIdle:

   167 			return KDataNone;

   168 			

   169 		case EDataDialog1:

   170 			return KDataDialog1;

   171 			

   172 		case EDataDialog2:

   173 			return KDataDialog2;

   174 			

   175 		case EDataFailed:

   176 			return KDataFailed;

   177 			

   178 		case EDataSend:

   179 			return KDataSend;

   180 			

   181 		case EDataRecv:

   182 			return KDataRecv;

   183 

   184 		case EDataRecvAny:

   185 			return KDataRecvAny;

   186 			

   187 		case EDataSendOneShot:

   188 			return KDataSendOS;

   189 			

   190 		case EDataRecvOneShot:

   191 			return KDataRecvOS;

   192 

   193 		case EDataSendReceive:

   194 			return KDataSendReceive;

   195 			

   196 		default:

   197 			break;

   198 		};

   199 		

   200 	return KNullDesC;	

   201 	}

   202 

   203 

   204 CBTTestConnectionNotifier* CBTTestConnectionNotifier::NewL(CBTTestConnection & aParent)

   205 	{

   206 	CBTTestConnectionNotifier* self = NewLC(aParent);

   207 	CleanupStack::Pop(); // self

   208 	return self;

   209 	}

   210 

   211 CBTTestConnectionNotifier* CBTTestConnectionNotifier::NewLC(CBTTestConnection & aParent)

   212 	{

   213 	CBTTestConnectionNotifier* self = new (ELeave) CBTTestConnectionNotifier(aParent);

   214 	CleanupStack::PushL(self);

   215 	return self;

   216 	}

   217 

   218 CBTTestConnectionNotifier::~CBTTestConnectionNotifier()

   219 	{

   220 	}

   221 

   222 CBTTestConnectionNotifier::CBTTestConnectionNotifier(CBTTestConnection & aParent)

   223   : CActive(CActive::EPriorityStandard), iParent(aParent)

   224 	{

   225 	CActiveScheduler::Add(this);

   226 	}

   227 

   228 void CBTTestConnectionNotifier::CancelRequests()

   229 	{

   230 	Cancel();

   231 	}

   232 

   233 void CBTTestConnectionNotifier::DoCancel()

   234 	{

   235 	iParent.CancelBasebandNotifyRequest();

   236 	}

   237 

   238 void CBTTestConnectionNotifier::RequestNotifications(TUint32 aNotifications, RBTPhysicalLinkAdapter & aPhyAdapter)

   239 	{

   240 	iEvent = iNotification;

   241 	aPhyAdapter.NotifyNextBasebandChangeEvent(iEvent, iStatus, aNotifications);

   242 

   243 	SetActive();

   244 	}

   245 

   246 

   247 void CBTTestConnectionNotifier::RunL()

   248 	{

   249 	TBTBasebandEventNotification notification = iEvent();

   250 	iParent.OutputOneShotEventNotification(notification);

   251 	}

   252 

   253 

   254 //

   255 //				CBTTestConnection Class Methods					//

   256 //

   257 //

   258 //				Public functions								//

   259 //

   260 CBTTestConnection* CBTTestConnection::NewL(CBTTestConsole* aConsole, RSocketServ& aSocketServer)

   261 	{

   262 	CBTTestConnection* self = NewLC(aConsole, aSocketServer);

   263 	self->ConstructL();

   264 	CleanupStack::Pop(); // self

   265 	return self;

   266 	}

   267 

   268 CBTTestConnection* CBTTestConnection::NewLC(CBTTestConsole * aConsole, RSocketServ & aSocketServer)

   269 	{

   270 	CBTTestConnection* self = new (ELeave) CBTTestConnection(aConsole, aSocketServer);

   271 	CleanupStack::PushL(self);

   272 	return self;

   273 	}

   274 

   275 CBTTestConnection::CBTTestConnection(CBTTestConsole * aConsole, RSocketServ & aSocketServer)

   276 : iParent(aConsole),

   277   iSocketServer(aSocketServer),

   278   iNotifier(*this),

   279   iSyncLinkHandler(*this),

   280   iPhyLinkAdapter(),

   281   iEventNotificationQueue(_FOFF(TBTQueuedBasebandEventNotification, iLink)),

   282   iCurrentIOCTL(EDontCare),

   283   iTailDigit(-1),

   284   iTotalRecvByte(0),

   285   iAutoSniff(EFalse)

   286 	{

   287 	}

   288 

   289 void CBTTestConnection::ConstructL()

   290 	{

   291 	iCustomSendRecvBuffer.CreateL(0);

   292 	}

   293 

   294 CBTTestConnection::~CBTTestConnection()

   295 	{

   296 	delete iBTSocket;

   297 	delete iBTPhyLinks;

   298 	delete iBTSyncLink;

   299 	iNotifier.CancelRequests();

   300 	iPhyLinkAdapter.Close();

   301 	delete iMetrics;

   302 	delete iMetricsConsole;

   303 	ClearEventStore();

   304 	}

   305 

   306 TInt CBTTestConnection::ConfigureLink(TBool aUseIoctl)

   307 	{

   308 	iConfigPkg() = (iParent->L2CapAPIConfig());

   309 	TInt rerr;

   310 	if(aUseIoctl)

   311 		{

   312 		rerr = iBTSocket->Ioctl(KL2CAPUpdateChannelConfigIoctl, &iConfigPkg, KSolBtL2CAP); 

   313 		}

   314 	else

   315 		{

   316 		rerr = iBTSocket->SetOpt(KL2CAPUpdateChannelConfig, KSolBtL2CAP, iConfigPkg);

   317 		}

   318 		

   319 	return rerr;

   320 	}

   321 

   322 TInt CBTTestConnection::CreateListeningSocket(TUint16 aPort, TDesC16 const& aProtocolName, TBTServiceSecurity & aSecurity, TBool aUseDefaultConfig)

   323 	{

   324 	TInt rerr = KErrNone;

   325 	

   326 	TProtocolDesc iProtocolInfo;

   327 

   328 	User::LeaveIfError(iSocketServer.FindProtocol(aProtocolName, iProtocolInfo));  //Qualified

   329 	TRAP(rerr, iBTSocket = CBluetoothSocket::NewL(*this, iSocketServer, iProtocolInfo.iSockType,iProtocolInfo.iProtocol));

   330 

   331 	if(rerr == KErrNone)

   332 		{

   333 		iPeerSocketAddr.SetBTAddr(TBTDevAddr(0));

   334 		iPeerSocketAddr.SetPort(aPort);

   335 		iPeerSocketAddr.SetSecurity(aSecurity);

   336 

   337 		rerr = iBTSocket->Bind(iPeerSocketAddr);

   338 		if(rerr == KErrNone)

   339 			{

   340 			rerr = iBTSocket->Listen(5);

   341 			if(rerr == KErrNone)

   342 				{

   343 #ifdef _DEBUG

   344 				TInt value = 0;

   345 				TInt err = iBTSocket->GetOpt(KL2CAPVersion1_2, KSolBtL2CAP, value);

   346 #else

   347 				// For non debug build this condition can not be tested.  Assume L2CAP is v1.2

   348 				TInt err = KErrNone;

   349 #endif

   350 				if(!aUseDefaultConfig && err == KErrNone)

   351 					{

   352 					TL2CapConfigPkg pkg(iParent->L2CapAPIConfig());

   353 					rerr = iBTSocket->SetOpt(KL2CAPUpdateChannelConfig, KSolBtL2CAP, pkg);

   354 					}

   355 				}

   356 			}

   357 		}

   358 	iProfile.iState = (rerr == KErrNone) ? TConnProfile::EConnListening :

   359 	                                       TConnProfile::EConnFailed;

   360 	iProfile.iErrorCode = rerr;	

   361 

   362 	return rerr;		

   363 	}

   364 

   365 TInt CBTTestConnection::Accept(CBluetoothSocket& aListeningSocket)

   366 	{

   367 	TInt rerr = KErrNone;

   368 	TRAP(rerr, iBTSocket = CBluetoothSocket::NewL(*this, iSocketServer));

   369 	if(rerr == KErrNone)

   370 		{

   371 		rerr = aListeningSocket.Accept(*iBTSocket);

   372 		}

   373 

   374 	iProfile.iState = (rerr == KErrNone) ? TConnProfile::EConnAccepting :

   375 	                                       TConnProfile::EConnFailed;

   376 	iProfile.iErrorCode = rerr;

   377 

   378 	return rerr;

   379 	}

   380 

   381 TInt CBTTestConnection::ConnectToPeer(TBTDevAddr &aAddr, TUint16 aPort, TDesC16 const& aProtocolName, TBTServiceSecurity & aSecurity, TBool aUseDefaultConfig)

   382 	{

   383 	TInt rerr = KErrNone;

   384 	

   385 	TProtocolDesc iProtocolInfo;

   386 

   387 	rerr = iSocketServer.FindProtocol(aProtocolName, iProtocolInfo);

   388 	if(rerr == KErrNone)

   389 		{

   390 		TRAP(rerr, iBTSocket = CBluetoothSocket::NewL(*this, iSocketServer, iProtocolInfo.iSockType,

   391 			                                                                 iProtocolInfo.iProtocol));

   392 		if(rerr == KErrNone)

   393 			{

   394 			iPeerSocketAddr.SetBTAddr(aAddr);

   395 			iPeerSocketAddr.SetPort(aPort);

   396 			iPeerSocketAddr.SetSecurity(aSecurity);

   397 

   398 #ifdef _DEBUG

   399 			TInt value = 0;

   400 			TInt err = iBTSocket->GetOpt(KL2CAPVersion1_2, KSolBtL2CAP, value);

   401 #else

   402 			// For non debug build this condition can not be tested.  Assume L2CAP is v1.2

   403 			TInt err = KErrNone;

   404 #endif

   405 			if(!aUseDefaultConfig && err == KErrNone)

   406 				{

   407 				TL2CapConfigPkg pkg(iParent->L2CapAPIConfig());

   408 				rerr = iBTSocket->SetOpt(KL2CAPUpdateChannelConfig, KSolBtL2CAP, pkg);

   409 				}

   410 			}

   411 		}

   412 	if(rerr == KErrNone)

   413 		{

   414 		rerr = iBTSocket->Connect(iPeerSocketAddr);

   415 		}

   416 

   417 	iProfile.iState = (rerr == KErrNone) ? TConnProfile::EConnConnecting :

   418 	                                       TConnProfile::EConnFailed;

   419 	iProfile.iErrorCode = rerr;		

   420 

   421 	return rerr;

   422 	}

   423 	

   424 TInt CBTTestConnection::SendMTUIoctl(TBool aIsIncomingMTU, TUint16 aNewValue)

   425 	{

   426 	i16bitIoctlBuffer() = aNewValue;

   427 	return iBTSocket->Ioctl((aIsIncomingMTU ? KL2CAPIncomingMTUIoctl : KL2CAPOutgoingMTUIoctl), &i16bitIoctlBuffer, KSolBtL2CAP);

   428 	}

   429 

   430 TInt CBTTestConnection::SendPretendIncomingSduQFullIoctl(TBool aPretendIncomingSduQFull)

   431 	{

   432 	iBoolIoctlBuffer() = aPretendIncomingSduQFull;

   433 	return iBTSocket->Ioctl(KL2CAPPretendIncomingSduQFull, &iBoolIoctlBuffer, KSolBtL2CAP);

   434 	}

   435 

   436 TInt CBTTestConnection::GetChannelMode(TL2CapChannelMode& aMode)

   437 	{

   438 	return iBTSocket->GetOpt(KL2CAPNegotiatedChannelMode, KSolBtL2CAP, reinterpret_cast<TInt&>(aMode));

   439 	}

   440 

   441 TInt CBTTestConnection::GetLocalPSM(TL2CAPPort& aPsm)

   442 	{

   443 	TPckg<TL2CAPPort> buf(aPsm);

   444 	return iBTSocket->GetOpt(KL2CAPLocalPSM, KSolBtL2CAP, buf);

   445 	}

   446 

   447 TInt CBTTestConnection::RecvOneShotData()

   448 	{

   449 	TInt rerr = KErrNone;

   450 	if(iProfile.iIsStreamProtocol)

   451 		{

   452 		rerr = iBTSocket->RecvOneOrMore(iRecvBuffer, 0, iRecvBufferLength);

   453 		}

   454 	else

   455 		{

   456 		rerr = iBTSocket->Read(iRecvBuffer);

   457 		}

   458 	return rerr;

   459 	}

   460 	

   461 TInt CBTTestConnection::SendOneShotData(TUint16 aDataSize)

   462 	{

   463 	TInt rerr = KErrNone;

   464 	//fill the data with 0123456789012... sequences

   465 	iCustomSendRecvBuffer.Zero();	

   466 	iCustomSendRecvBuffer.ReAlloc(aDataSize);

   467 	for(TInt i =0 ;i<aDataSize;i++)

   468 		{

   469 		iCustomSendRecvBuffer.Append(i%10);

   470 		}

   471 	rerr = iBTSocket->Write(iCustomSendRecvBuffer);

   472 	return rerr;

   473 	}

   474 	

   475 TInt CBTTestConnection::RecvContinuationData(TUint16 aDataSize)

   476 	{

   477 	TInt rerr =0;

   478 	

   479 	iCustomSendRecvBuffer.Zero();	

   480 	rerr = iCustomSendRecvBuffer.ReAlloc(aDataSize);

   481 	if(rerr == KErrNone)

   482 		{

   483 		/*

   484 		In function Recv(iCustomSendRecvBuffer, KSockReadContinuation, iRecvBufferLength);

   485 		iCustomSendRecvBuffer: 	A descriptor for the information being sent to the remote Bluetooth device. 

   486 		KSockReadContinuation:	Bluetooth information flags. When it's set to KSockReadContinuation, 

   487 								Read from datagram in a stream-like fashion(not discarding tails,continuation).

   488 		iRecvBufferLength:		A length indicating how much data is left in the buffer.

   489 		*/

   490 		rerr = iBTSocket->Recv(iCustomSendRecvBuffer, KSockReadContinuation, iRecvBufferLength);

   491 		}

   492 	return rerr;

   493 	}

   494 

   495 TInt CBTTestConnection::SetLocalModemStatus(TUint8 aModemStatus)

   496 	{

   497 	TPckgBuf<TUint8> pkg(aModemStatus);

   498 	iParent->test.Printf(_L("\nSetLocalModemStatus: %x"), aModemStatus);

   499 	return iBTSocket->SetOpt(KRFCOMMLocalModemStatus, KSolBtRFCOMM, pkg);

   500 	}

   501 	

   502 TInt CBTTestConnection::RequestRFCommConfChgInd()

   503 	{

   504 	// Cancel any outstanding IOCTLs

   505 	__ASSERT_ALWAYS(iBTSocket, Panic(EBTConsoleNoSocketForSocketBasedConnection));

   506 	iBTSocket->CancelIoctl();

   507 	

   508 	TInt rerr = iBTSocket->Ioctl(KRFCOMMConfigChangeIndicationIoctl, NULL, KSolBtRFCOMM); 

   509 	if(rerr == KErrNone)

   510 		{

   511 		iCurrentIOCTL = ERFCOMMConfigInd;

   512 		}

   513 	return rerr;	

   514 	}

   515 

   516 TInt CBTTestConnection::ConnectUsingBAP(TBTDevAddr &aAddr)

   517 	{

   518 	TInt rerr = KErrNone;

   519 	iProfile.iIsSocketBased = EFalse;

   520 	TRAP(rerr, iBTPhyLinks = CBluetoothPhysicalLinks::NewL(*this, iSocketServer));

   521 	if(rerr == KErrNone)

   522 		{

   523 		iProfile.iRemoteBTAddr.SetBTAddr(aAddr);

   524 		rerr = iBTPhyLinks->CreateConnection(aAddr);

   525 		}

   526 		

   527 	return rerr;	

   528 	}

   529 

   530 void CBTTestConnection::UpdateProfileAcceptComplete()

   531 	{

   532 	TInt rerr = KErrNone;

   533 	

   534 	iBTSocket->RemoteName(iProfile.iRemoteBTAddr);

   535 	iProfile.iState = TConnProfile::EConnConnected;

   536 	TBTDevAddr addr = iProfile.iRemoteBTAddr.BTAddr();

   537 

   538 	TInt rValue = 0;

   539 	rerr = iBTSocket->GetOpt(KL2CAPOutboundMTUForBestPerformance, KSolBtL2CAP, rValue);

   540 	if(rerr == KErrNone)

   541 		{

   542 		iProfile.iSendingMTUSize = rValue;

   543 

   544 		rerr = iBTSocket->GetOpt(KL2CAPInboundMTU, KSolBtL2CAP, rValue);

   545 		if(rerr == KErrNone)

   546 			{

   547 			iProfile.iRecvMTUSize = rValue;

   548 			

   549 			iParent->CreatePhyRecord(addr);

   550 			RequestNotification(0xffffffff);

   551 			}

   552 		}

   553 

   554 	iProfile.iErrorCode = rerr;	

   555 	}

   556 

   557 

   558 void CBTTestConnection::AcceptComplete(TInt result)

   559 	{

   560 	if(result)

   561 		{

   562 		iParent->test.Printf(_L("\nAccept Completed with error: %d"), result);

   563 		iProfile.iErrorCode = result;	

   564 		if(iProfile.iAccepterIx >= 0 && iParent->GetConn(iProfile.iAccepterIx))

   565 			{

   566 			(iParent->GetConn(iProfile.iAccepterIx))->iProfile.iState = TConnProfile::EConnFailed;

   567 			(iParent->GetConn(iProfile.iAccepterIx))->iProfile.iErrorCode = result;

   568 			}

   569 		}

   570 	else

   571 		{

   572 		if(iProfile.iAccepterIx >= 0 && iParent->GetConn(iProfile.iAccepterIx))

   573 			{

   574 			(iParent->GetConn(iProfile.iAccepterIx))->UpdateProfileAcceptComplete();

   575 			(iParent->GetConn(iProfile.iAccepterIx))->iProfile.iIsStreamProtocol = iProfile.iIsStreamProtocol;

   576 			}

   577 		}

   578 	iProfile.iState = TConnProfile::EConnListening;

   579 	iParent->Draw();

   580 	}

   581 

   582 void CBTTestConnection::ConnectComplete(TInt result)

   583 	{

   584 	TInt rerr = KErrNone;

   585 	

   586 	if(result)

   587 		{

   588 		iParent->test.Printf(_L("\nConnect Completed with error: %d"), result);

   589 		iProfile.iState = TConnProfile::EConnFailed;

   590 		iProfile.iErrorCode = result;	

   591 		}

   592 	else

   593 		{

   594 		iProfile.iState = TConnProfile::EConnConnected;

   595 		iBTSocket->RemoteName(iProfile.iRemoteBTAddr);

   596 		TBTDevAddr addr = iProfile.iRemoteBTAddr.BTAddr();

   597 

   598 		TInt rValue = 0;

   599 		rerr = iBTSocket->GetOpt(KL2CAPOutboundMTUForBestPerformance, KSolBtL2CAP, rValue);

   600 		if(rerr == KErrNone)

   601 			{

   602 			iProfile.iSendingMTUSize = rValue;

   603 

   604 			rerr = iBTSocket->GetOpt(KL2CAPInboundMTU, KSolBtL2CAP, rValue);

   605 			if(rerr == KErrNone)

   606 				{

   607 				iProfile.iRecvMTUSize = rValue;

   608 				TRAP_IGNORE(iMetrics = CBluetoothPhysicalLinkMetrics::NewL(*this, iSocketServer, addr));

   609 				iParent->CreatePhyRecord(addr);

   610 				RequestNotification(0xffffffff);

   611 				}

   612 			}

   613 		iProfile.iErrorCode = rerr;	

   614 		}

   615 	iParent->Draw();

   616 	}

   617 

   618 TInt CBTTestConnection::SetupPhysAdapter()

   619 	{

   620 	TBTDevAddr addr = iProfile.iRemoteBTAddr.BTAddr();

   621 	iParent->CreatePhyRecord(addr);

   622 	TInt rerr = iPhyLinkAdapter.Open(iSocketServer, addr);

   623 	if(rerr == KErrNone)

   624 		{

   625 		iNotifier.CancelRequests();

   626 		iNotifier.RequestNotifications(0xffffffff, iPhyLinkAdapter);

   627 		}

   628 	return rerr;

   629 	}

   630 

   631 void CBTTestConnection::ConnectBAPComplete(TInt result)

   632 	{

   633 	if(result)

   634 		{

   635 		iParent->test.Printf(_L("\nConnect BAP Completed with error: %d"), result);

   636 		iProfile.iState = TConnProfile::EConnFailed;

   637 		iProfile.iErrorCode = result;

   638 		}

   639 	else

   640 		{

   641 		iProfile.iState = TConnProfile::EConnConnected;

   642 		TBTDevAddr addr = iProfile.iRemoteBTAddr.BTAddr();

   643 		

   644 		TInt rerr = SetupPhysAdapter();

   645 		if(rerr == KErrNone)

   646 			{

   647 			TRAP_IGNORE(iMetrics = CBluetoothPhysicalLinkMetrics::NewL(*this, iSocketServer, addr));

   648 			}

   649 		else

   650 			{

   651 			iProfile.iErrorCode = rerr;	

   652 			}

   653 		}

   654 	iParent->Draw();

   655 	}

   656 

   657 TInt CBTTestConnection::SendEchoRequest(TInt aPayloadSize)

   658 	{

   659 	TInt rerr = KErrNone;

   660 	if(iProfile.iIsSocketBased)

   661 		{

   662 		if (aPayloadSize == 0)

   663 			{

   664 			rerr = iBTSocket->Ioctl(KL2CAPEchoRequestIoctl, NULL, KSolBtL2CAP);

   665 			}

   666 		else

   667 			{

   668 			iEchoDataBuffer.Fill(0x28, aPayloadSize);

   669 			iEchoDataBuffer.SetLength(aPayloadSize);	

   670 			rerr = iBTSocket->Ioctl(KL2CAPEchoRequestIoctl, &iEchoDataBuffer, KSolBtL2CAP);

   671 			}

   672 		}

   673 	return rerr;

   674 	}

   675 

   676 void CBTTestConnection::CancelAccept()

   677 	{

   678 	if(iProfile.iAccepterIx >= 0 && iParent->GetConn(iProfile.iAccepterIx))

   679 		{

   680 		(iParent->GetConn(iProfile.iAccepterIx))->iProfile.iState = TConnProfile::EConnFailed;

   681 		}

   682 	iBTSocket->CancelAccept();

   683 	iProfile.iState = TConnProfile::EConnListening;

   684 	}

   685 

   686 void CBTTestConnection::CancelConnect()

   687 	{

   688 	if(iProfile.iIsSocketBased)

   689 		{

   690 		iBTSocket->CancelConnect();

   691 		}

   692 	else

   693 		{

   694 		iBTPhyLinks->CancelCreateConnection();

   695 		}

   696 	}

   697 

   698 TInt CBTTestConnection::ShutdownSocket(RSocket::TShutdown aShutdownType)

   699 	{

   700 	TInt rerr = KErrNone;

   701 	if(iProfile.iIsSocketBased)

   702 		{

   703 		__ASSERT_ALWAYS(iBTSocket, Panic(EBTConsoleNoSocketForSocketBasedConnection));

   704 		rerr = iBTSocket->Shutdown(aShutdownType);

   705 		iProfile.iState = (rerr == KErrNone) ? TConnProfile::EConnDisconnected :

   706 		                                       TConnProfile::EConnFailed;

   707 		iProfile.iErrorCode = rerr;		

   708 		}

   709 	else

   710 		{

   711 		Panic(EBTConsoleShutdownCalledOnNonCBluetoothSocket);

   712 		}

   713 	

   714 	return rerr;	

   715 	}

   716 	

   717 TInt CBTTestConnection::IncreaseRTXTimer(TUint aTime)

   718 	{

   719 	TInt rerr = KErrNone;

   720 	if(iProfile.iIsSocketBased)

   721 		{

   722 		__ASSERT_ALWAYS(iBTSocket, Panic(EBTConsoleNoSocketForSocketBasedConnection));

   723 		rerr = iBTSocket->SetOpt(KL2CAPRTXTimer, KSolBtL2CAP, aTime);

   724 		iProfile.iErrorCode = rerr;		

   725 		}

   726 	else

   727 		{

   728 		Panic(EBTConsoleShutdownCalledOnNonCBluetoothSocket);

   729 		}

   730 	

   731 	return rerr;	

   732 	}

   733 

   734 TInt CBTTestConnection::DisconnectLink()

   735 	{

   736 	TInt rerr = KErrNone;

   737 	if(!iProfile.iIsSocketBased)

   738 		{

   739 		if(iProfile.iIsSCO)

   740 			{

   741 			rerr = iBTSyncLink->Disconnect();			

   742 			}

   743 		else

   744 			{

   745 			rerr = iBTPhyLinks->Disconnect(iProfile.iRemoteBTAddr.BTAddr());

   746 			}

   747 

   748 		iProfile.iState = (rerr == KErrNone) ? TConnProfile::EConnDisconnected :

   749 		                                       TConnProfile::EConnFailed;

   750 		iProfile.iErrorCode = rerr;		

   751 		}

   752 	else

   753 		{

   754 		Panic(EBTConsoleDisconnectCalledOnCBluetoothSocket);

   755 		}

   756 	

   757 	return rerr;	

   758 	}

   759 

   760 void CBTTestConnection::RequestNotification(TUint32 aNotification)

   761 	{

   762 	TInt rerr = KErrNone;

   763 	if(iProfile.iIsSocketBased)

   764 		{

   765 		rerr = KErrNotFound;

   766 		if(iBTSocket)

   767 			{

   768 			rerr = iBTSocket->ActivateBasebandEventNotifier(aNotification);

   769 			}

   770 		}

   771 

   772 	if(rerr != KErrNone)

   773 		{

   774 		iParent->test.Printf(_L("Request Notification [%d], Error: %d\n"), aNotification, rerr);

   775 		}

   776 	}

   777 

   778 void CBTTestConnection::OutputOneShotEventNotification(TBTBasebandEventNotification & aNotification)

   779 	{

   780 	iNotifier.RequestNotifications(0xffffffff, iPhyLinkAdapter);

   781 	OutputEventNotification(aNotification);

   782 	}

   783 	

   784 void CBTTestConnection::OutputEventNotification(TBTBasebandEventNotification & aNotification)

   785 	{

   786 	TConnProfile * profile = iParent->FindPhyRecord(iProfile.iRemoteBTAddr.BTAddr());

   787 	if(!profile)

   788 		{

   789 		return;

   790 		}

   791 

   792 	// Store the event.

   793 	StoreEvent(aNotification);

   794 

   795 	// Find associated PHY.

   796 	if(ENotifyMaster & aNotification.EventType())

   797 		{

   798 		profile->iRole = TConnProfile::EMaster;

   799 		}

   800 	if(ENotifySlave & aNotification.EventType())

   801 		{

   802 		profile->iRole = TConnProfile::ESlave;

   803 		}

   804 

   805 	if(ENotifyActiveMode & aNotification.EventType())

   806 		{

   807 		profile->iMode2 = TConnProfile::EActive;

   808 

   809 		if(iParent->iLPMRequestsIfActive == EFalse )

   810 			{

   811 			RemoveLPMRequest();	

   812 			}

   813 		}

   814 

   815 	if(ENotifySniffMode & aNotification.EventType())

   816 		{

   817 		profile->iMode2 = TConnProfile::ESniff;

   818 		}

   819 	if(ENotifyParkMode & aNotification.EventType())

   820 		{

   821 		profile->iMode2 = TConnProfile::EPark;

   822 		}

   823 	if(ENotifyHoldMode & aNotification.EventType())

   824 		{

   825 		profile->iMode2 = TConnProfile::EHold;

   826 		}

   827 

   828 	if(ENotifyMaxSlots1 & aNotification.EventType())

   829 		{

   830 		profile->iMaxSlots = 1;

   831 		}

   832 	if(ENotifyMaxSlots3 & aNotification.EventType())

   833 		{

   834 		profile->iMaxSlots = 3;

   835 		}

   836 	if(ENotifyMaxSlots5 & aNotification.EventType())

   837 		{

   838 		profile->iMaxSlots = 5;

   839 		}

   840 

   841 	TUint16 packetTypes = 0;

   842 	TBool packetEvent = EFalse;

   843 

   844 	if(ENotifyPacketsDM1 & aNotification.EventType())

   845 		{

   846 		packetTypes |= EPacketsDM1;

   847 		packetEvent = ETrue;

   848 		}

   849 	if(ENotifyPacketsDM3 & aNotification.EventType())

   850 		{

   851 		packetTypes |= EPacketsDM3;

   852 		packetEvent = ETrue;

   853 		}

   854 	if(ENotifyPacketsDM5 & aNotification.EventType())

   855 		{

   856 		packetTypes |= EPacketsDM5;

   857 		packetEvent = ETrue;

   858 		}

   859 	if(ENotifyPacketsDH1 & aNotification.EventType())

   860 		{

   861 		packetTypes |= EPacketsDH1;

   862 		packetEvent = ETrue;

   863 		}

   864 	if(ENotifyPacketsDH3 & aNotification.EventType())

   865 		{

   866 		packetTypes |= EPacketsDH3;

   867 		packetEvent = ETrue;

   868 		}

   869 	if(ENotifyPacketsDH5 & aNotification.EventType())

   870 		{

   871 		packetTypes |= EPacketsDH5;

   872 		packetEvent = ETrue;

   873 		}

   874 	if(packetEvent)

   875 		{

   876 		profile->iPackets = packetTypes;

   877 		}

   878 /*

   879 	if(EPacketsTypeHV1 & aNotification.EventType())

   880 		{

   881 		iParent->test.Printf(_L("SCO HV1 packet type now supported."));

   882 		}

   883 	if(EPacketsTypeHV2 & aNotification.EventType())

   884 		{

   885 		iParent->test.Printf(_L("SCO HV2 packet type now supported."));

   886 		}

   887 	if(EPacketsTypeHV3 & aNotification.EventType())

   888 		{

   889 		iParent->test.Printf(_L("SCO HV3 packet type now supported."));

   890 		}

   891 

   892 	if(ENotifyAuthenticationComplete & aNotification.EventType())

   893 		{

   894 		iParent->test.Printf(_L("Authentification complete."));

   895 		}

   896 */

   897 	if(ENotifyEncryptionChangeOn & aNotification.EventType())

   898 		{

   899 		profile->iEncryption = ETrue;

   900 		}

   901 	if(ENotifyEncryptionChangeOff & aNotification.EventType())

   902 		{

   903 		profile->iEncryption = EFalse;

   904 		}

   905 

   906 	if(ENotifyPhysicalLinkUp & aNotification.EventType())

   907 		{

   908 		profile->iState = TConnProfile::EConnConnected;

   909 		}

   910 	if(ENotifyPhysicalLinkDown & aNotification.EventType())

   911 		{

   912 		profile->iState = TConnProfile::EConnDisconnected;

   913 		}

   914 	if(ENotifyPhysicalLinkError & aNotification.EventType())

   915 		{

   916 		profile->iState = TConnProfile::EConnFailed;

   917 		}

   918 	iParent->Draw();

   919 	}

   920 

   921 void CBTTestConnection::CancelBasebandNotifyRequest()

   922 	{

   923 	iPhyLinkAdapter.CancelNextBasebandChangeEventNotifier();

   924 	}

   925 

   926 

   927 TInt CBTTestConnection::ChangeSupportedPacketTypes(TUint16 aPacketTypes)

   928 	{

   929 	TInt rerr;

   930 

   931 	if(iProfile.iIsSocketBased)

   932 		{

   933 		rerr = KErrNotFound;

   934 		if(iBTSocket)

   935 			{

   936 			rerr = iBTSocket->RequestChangeSupportedPacketTypes(aPacketTypes);

   937 			}

   938 		}

   939 	else

   940 		{

   941 		rerr = iPhyLinkAdapter.RequestChangeSupportedPacketTypes(aPacketTypes);

   942 		}

   943 

   944 	iParent->test.Printf(_L("Change Supported Packet Request [%d], Error: %d\n"), aPacketTypes, rerr);

   945 	return rerr;

   946 	}

   947 

   948 

   949 TInt CBTTestConnection::RoleChangeAllowed(TBool aAllowed)

   950 	{

   951 	TInt rerr;

   952 	if(aAllowed)

   953 		{

   954 		iParent->test.Printf(_L("Accept role change requests"));

   955 		if(iProfile.iIsSocketBased)

   956 			{

   957 			rerr = KErrNotFound;

   958 			if(iBTSocket)

   959 				{

   960 				rerr = iBTSocket->AllowRoleSwitch();

   961 				}

   962 			}

   963 		else

   964 			{

   965 			rerr = iPhyLinkAdapter.AllowRoleSwitch();

   966 			}

   967 		}

   968 	else

   969 		{

   970 		iParent->test.Printf(_L("Prevent role change requests"));

   971 		if(iProfile.iIsSocketBased)

   972 			{

   973 			rerr = KErrNotFound;

   974 			if(iBTSocket)

   975 				{

   976 				rerr = iBTSocket->PreventRoleSwitch();

   977 				}

   978 			}

   979 		else

   980 			{

   981 			rerr = iPhyLinkAdapter.PreventRoleSwitch();

   982 			}

   983 		}

   984 	iParent->test.Printf(_L("Role Change Allowed Request, Error: %d\n"), rerr);

   985 	return rerr;

   986 	}

   987 

   988 

   989 TInt CBTTestConnection::RequestRoleChange(TBTBasebandRole aRole)

   990 	{

   991 	TInt rerr;

   992 	if(aRole == EMaster)

   993 		{

   994 		iParent->test.Printf(_L("Request Role Change to Master\n"));

   995 		if(iProfile.iIsSocketBased)

   996 			{

   997 			rerr = KErrNotFound;

   998 			if(iBTSocket)

   999 				{

  1000 				rerr = iBTSocket->RequestMasterRole();

  1001 				}

  1002 			}

  1003 		else

  1004 			{

  1005 			rerr = iPhyLinkAdapter.RequestMasterRole();

  1006 			}

  1007 		}	

  1008 	else

  1009 		{

  1010 		iParent->test.Printf(_L("Request Role Change to Slave\n"));

  1011 		if(iProfile.iIsSocketBased)

  1012 			{

  1013 			rerr = KErrNotFound;

  1014 			if(iBTSocket)

  1015 				{

  1016 				rerr = iBTSocket->RequestSlaveRole();

  1017 				}

  1018 			}

  1019 		else

  1020 			{

  1021 			rerr = iPhyLinkAdapter.RequestSlaveRole();

  1022 			}

  1023 		}

  1024 	iParent->test.Printf(_L("Role Change Request, Error: %d\n"), rerr);

  1025 	return rerr;

  1026 	}

  1027  	

  1028 TInt CBTTestConnection::RequestAuthentication()

  1029  	{

  1030  	TInt rerr;

  1031  	iParent->test.Printf(_L("Requesting Authentication\n"));

  1032  	if(iProfile.iIsSocketBased)

  1033  		{

  1034  		rerr = KErrNotFound;

  1035  		iParent->test.Printf(_L("Can't request authentication on a socket based connection\n"));

  1036  		}

  1037  	else

  1038  		{

  1039  		rerr = iPhyLinkAdapter.Authenticate();

  1040  		}

  1041  	iParent->test.Printf(_L("Authentication Request, Error: %d\n"), rerr);

  1042  	return rerr;

  1043  	}

  1044 

  1045 void CBTTestConnection::StartACLData()

  1046 	{

  1047 	iTime.HomeTime();

  1048 	iDataDialogCount = 0;

  1049 	ContinueDialog();

  1050 	}

  1051 	

  1052 void CBTTestConnection::StopACLData()

  1053 	{

  1054 	iBTSocket->CancelSend();

  1055 	iBTSocket->CancelRecv();

  1056 	}

  1057 

  1058 

  1059 TBool CBTTestConnection::SendComplete(TInt aIndex, TInt aStatus)

  1060 	{

  1061 	if(aStatus != KErrNone)

  1062 		{

  1063 		iParent->test.Printf(_L("\nSend[%d] Completed with Error: %d.\n"), aIndex, aStatus);

  1064 		return EFalse;

  1065 		}

  1066 	return ETrue;

  1067 	}

  1068 

  1069 TBool CBTTestConnection::RecvComplete(TInt aIndex, TInt aStatus, TInt aDataErr)

  1070 	{

  1071 	TBool rCode = ETrue;

  1072 	if(aStatus != KErrNone)

  1073 		{

  1074 		iParent->test.Printf(_L("\nRevc[%d] Completed with Error: %d.\n"), aIndex, aStatus);

  1075 		rCode = EFalse;

  1076 		}

  1077 	else

  1078 		{

  1079 		if(aDataErr == KErrCompletion)

  1080 			{

  1081 			iDataDialogCount++;

  1082 			}

  1083 		else

  1084 			{

  1085 			if(aDataErr != KErrNone)

  1086 				{

  1087 				iParent->test.Printf(_L("\nRevc[%d] Completed. Data Error.\n"), aIndex);

  1088 				rCode = EFalse;

  1089 				}

  1090 			}

  1091 		}

  1092 	return rCode;

  1093 	}

  1094 

  1095 

  1096 TInt CBTTestConnection::RequestLPM(TConnProfile::TConnMode aLPM)

  1097 	{

  1098 	TInt rerr = KErrNone;

  1099 

  1100 	switch(aLPM)

  1101 		{

  1102 		case TConnProfile::EActive:

  1103 			if(iProfile.iIsSocketBased)

  1104 				{

  1105 				__ASSERT_DEBUG(iBTSocket, Panic(EBTConsoleNoSocketForSocketBasedConnection));

  1106 				rerr = iBTSocket->CancelLowPowerModeRequester();

  1107 				}

  1108 			else

  1109 				{

  1110 				rerr = iPhyLinkAdapter.CancelLowPowerModeRequester();

  1111 				}

  1112 			break;

  1113 

  1114 		case TConnProfile::ESniff:

  1115 			if(iProfile.iIsSocketBased)

  1116 				{

  1117 				__ASSERT_DEBUG(iBTSocket, Panic(EBTConsoleNoSocketForSocketBasedConnection));

  1118 				rerr = iBTSocket->ActivateSniffRequester();

  1119 				}

  1120 			else

  1121 				{

  1122 				rerr = iPhyLinkAdapter.ActivateSniffRequester();

  1123 				}

  1124 			break;

  1125 

  1126 		case TConnProfile::EPark:

  1127 			if(iProfile.iIsSocketBased)

  1128 				{

  1129 				__ASSERT_DEBUG(iBTSocket, Panic(EBTConsoleNoSocketForSocketBasedConnection));

  1130 				rerr = iBTSocket->ActivateParkRequester();

  1131 				}

  1132 			else

  1133 				{

  1134 				rerr = iPhyLinkAdapter.ActivateParkRequester();

  1135 				}