/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include "T_BluetoothSynchronousLinkData.h"
#include "T_BTDevAddrData.h"
#include "T_BTSyncBandWidthData.h"
#include "T_BTUtil.h"
#include "T_TBTSockAddrChild.h"
/*@{*/
//Parameters
_LIT(KRSocketServ, "socketserv");
_LIT(KTBTDevAddr, "tbtdevaddr");
_LIT(KIntDevAddr, "integerdevaddr");
_LIT(KPacketType, "packettype");
_LIT(KSyncPacket, "syncpacket");
_LIT(KData, "data");
_LIT(KVoiceSetting, "voicesetting");
_LIT(KSyncBandwidth, "syncbandwidth");
_LIT(KLatency, "latency");
_LIT(KRetransmissionType, "retransmissiontype");
_LIT(KUseAlternateNotifier, "usealternatenotifier");
_LIT(KUid, "uid");
_LIT(KExpectNull, "expectnull");
_LIT(KExpected, "expected");
_LIT(KErrForSetupConnection, "errforsetupconnection");
_LIT(KErrForSend, "errforsend");
_LIT(KErrForReceive, "errforreceive");
_LIT(KErrForAcceptConnection, "errforacceptconnection");
_LIT(KErrForDisconnect, "errfordisconnect");
_LIT(KIncOutstanding, "incoutstanding");
//Commands
_LIT(KCmdNewL, "NewL");
_LIT(KCmdNewLC, "NewLC");
_LIT(KCmdSetupConnection, "SetupConnection");
_LIT(KCmdCancelSetup, "CancelSetup");
_LIT(KCmdDisconnect, "Disconnect");
_LIT(KCmdSend, "Send");
_LIT(KCmdCancelSend, "CancelSend");
_LIT(KCmdReceive, "Receive");
_LIT(KCmdCancelReceive, "CancelReceive");
_LIT(KCmdAcceptConnection, "AcceptConnection");
_LIT(KCmdCancelAccept, "CancelAccept");
_LIT(KCmdSetCoding, "SetCoding");
_LIT(KCmdCoding, "Coding");
_LIT(KCmdSetMaxBandwidth, "SetMaxBandwidth");
_LIT(KCmdBandwidth, "Bandwidth");
_LIT(KCmdSetMaxLatency, "SetMaxLatency");
_LIT(KCmdLatency, "Latency");
_LIT(KCmdSetRetransmissionEffort, "SetRetransmissionEffort");
_LIT(KCmdRetransmissionEffort, "RetransmissionEffort");
_LIT(KCmdRemoteName, "RemoteName");
_LIT(KCmdSetNotifier, "SetNotifier");
_LIT(KCmdDestructor, "~");
_LIT(KCmdMBSLN_ExtensionInterfaceL, "MBSLN_ExtensionInterfaceL");
// Logging
_LIT(KLogMissingParameters, "Missing parameters '%S' or '%S'");
_LIT(KLogMissingParameter, "Missing parameter '%S'");
/*@}*/
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CT_BluetoothSynchronousLinkData* CT_BluetoothSynchronousLinkData::NewL()
{
CT_BluetoothSynchronousLinkData* ret=new (ELeave) CT_BluetoothSynchronousLinkData();
CleanupStack::PushL(ret);
ret->ConstructL();
CleanupStack::Pop(ret);
return ret;
}
CT_BluetoothSynchronousLinkData::CT_BluetoothSynchronousLinkData()
: iData(NULL)
, iErrForSetupConnection(0)
, iErrForSend(0)
, iErrForReceive(0)
, iErrForAcceptConnection(0)
, iErrForDisconnect(0)
, ibtSyncPackets(NULL)
, iSetupIndex(0)
, iDisconnectionIndex(0)
, iAcceptIndex(0)
, iSendIndex(0)
, iReceiveIndex(0)
{
}
void CT_BluetoothSynchronousLinkData::ConstructL()
{
}
CT_BluetoothSynchronousLinkData::~CT_BluetoothSynchronousLinkData()
{
DestroyData();
}
// Service methods
TAny* CT_BluetoothSynchronousLinkData::GetObject()
{
return iData;
}
void CT_BluetoothSynchronousLinkData::SetObjectL(TAny* aObject)
{
//called when loading up persistent data
DestroyData();
iData = static_cast<CBluetoothSynchronousLink*>(aObject);
}
void CT_BluetoothSynchronousLinkData::DisownObjectL()
{
iData=NULL;
}
void CT_BluetoothSynchronousLinkData::DestroyData()
{
delete iData;
iData = NULL;
if ( ibtSyncPackets )
{
ibtSyncPackets = NULL;
}
}
inline TCleanupOperation CT_BluetoothSynchronousLinkData::CleanupOperation()
{
return CleanupOperation;
}
void CT_BluetoothSynchronousLinkData::CleanupOperation(TAny* aAny)
{
CBluetoothSynchronousLink* arg=static_cast<CBluetoothSynchronousLink*>(aAny);
delete arg;
}
void CT_BluetoothSynchronousLinkData::HandleSetupConnectionCompleteL(TInt aError)
{
INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleSetupConnectionCompleteL Status (%d)"), aError);
DecOutstanding();
if ( aError!=iErrForSetupConnection )
{
ERR_PRINTF2(_L("HandleSetupConnectionCompleteL Call failed: aError = %d"),aError);
SetAsyncError(iSetupIndex, aError);
}
else
{
INFO_PRINTF1(_L("HandleSetupConnectionCompleteL successful" ));
}
}
void CT_BluetoothSynchronousLinkData::HandleDisconnectionCompleteL(TInt aError)
{
INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleDisconnectionCompleteL Status (%d)"), aError);
DecOutstanding();
if ( aError!=iErrForDisconnect)
{
ERR_PRINTF2(_L("HandleDisconnectionCompleteL Call failed: aError = %d"),aError);
SetAsyncError(iDisconnectionIndex, aError);
}
else
{
INFO_PRINTF1(_L("HandleDisconnectionCompleteL successful" ));
}
}
void CT_BluetoothSynchronousLinkData::HandleAcceptConnectionCompleteL(TInt aError)
{
INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleAcceptConnectionCompleteL Status (%d)"), aError);
DecOutstanding();
if ( aError!=iErrForAcceptConnection)
{
ERR_PRINTF2(_L("HandleAcceptConnectionCompleteL Call failed: aError = %d"),aError);
SetAsyncError(iAcceptIndex, aError);
}
else
{
INFO_PRINTF1(_L("HandleAcceptConnectionCompleteL successful" ));
}
}
void CT_BluetoothSynchronousLinkData::HandleSendCompleteL(TInt aError)
{
INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleSendCompleteL Status (%d)"), aError);
DecOutstanding();
if ( aError!=iErrForSend )
{
ERR_PRINTF2(_L("HandleSendCompleteL Call failed: aError = %d"),aError);
SetAsyncError(iSendIndex, aError);
}
else
{
INFO_PRINTF1(_L("HandleSendCompleteL successful" ));
}
}
void CT_BluetoothSynchronousLinkData::HandleReceiveCompleteL(TInt aError)
{
INFO_PRINTF2(_L("MBluetoothSynchronousLinkNotifier::HandleReceiveCompleteL Status (%d)"), aError);
DecOutstanding();
if ( aError!=iErrForReceive )
{
ERR_PRINTF2(_L("HandleReceiveCompleteL Call failed: aError = %d"),aError);
SetAsyncError(iReceiveIndex, aError);
}
else
{
INFO_PRINTF1(_L("HandleReceiveCompleteL successful" ));
}
}
TBool CT_BluetoothSynchronousLinkData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
{
TBool ret = ETrue;
if ( aCommand==KCmdNewL )
{
DoCmdNewL(aSection);
}
else if ( aCommand==KCmdNewLC )
{
DoCmdNewLC(aSection);
}
else if ( aCommand==KCmdSetupConnection )
{
DoCmdSetupConnection(aSection, aAsyncErrorIndex);
}
else if ( aCommand==KCmdCancelSetup )
{
DoCmdCancelSetup();
}
else if ( aCommand==KCmdDisconnect )
{
DoCmdDisconnect(aSection, aAsyncErrorIndex);
}
else if ( aCommand==KCmdSend )
{
DoCmdSend(aSection, aAsyncErrorIndex);
}
else if ( aCommand==KCmdCancelSend )
{
DoCmdCancelSend();
}
else if ( aCommand==KCmdReceive )
{
DoCmdReceive(aSection, aAsyncErrorIndex);
}
else if ( aCommand==KCmdCancelReceive )
{
DoCmdCancelReceive();
}
else if ( aCommand==KCmdAcceptConnection )
{
DoCmdAcceptConnection(aSection, aAsyncErrorIndex);
}
else if ( aCommand==KCmdCancelAccept )
{
DoCmdCancelAccept();
}
else if ( aCommand==KCmdSetCoding )
{
DoCmdSetCoding(aSection);
}
else if ( aCommand==KCmdCoding )
{
DoCmdCoding(aSection);
}
else if ( aCommand==KCmdSetMaxBandwidth )
{
DoCmdSetMaxBandwidth(aSection);
}
else if ( aCommand==KCmdBandwidth )
{
DoCmdBandwidth();
}
else if ( aCommand==KCmdSetMaxLatency )
{
DoCmdSetMaxLatency(aSection);
}
else if ( aCommand==KCmdLatency )
{
DoCmdLatency(aSection);
}
else if ( aCommand==KCmdSetRetransmissionEffort )
{
DoCmdSetRetransmissionEffort(aSection);
}
else if ( aCommand==KCmdRetransmissionEffort )
{
DoCmdRetransmissionEffort(aSection);
}
else if ( aCommand==KCmdRemoteName )
{
DoCmdRemoteName(aSection);
}
else if ( aCommand==KCmdSetNotifier )
{
DoCmdSetNotifier(aSection);
}
else if ( aCommand==KCmdDestructor )
{
DoCmdDestructor();
}
else if ( aCommand==KCmdMBSLN_ExtensionInterfaceL )
{
DoCmdMBSLN_ExtensionInterfaceL(aSection);
}
else
{
ret=EFalse;
}
return ret;
}
/**
Test NewL()
*/
void CT_BluetoothSynchronousLinkData::DoCmdNewL(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink NewL Call"));
DestroyData();
TPtrC socketServName;
if(GetStringFromConfig(aSection, KRSocketServ(), socketServName))
{
RSocketServ* socketServ=static_cast<RSocketServ*>(GetDataObjectL(socketServName));
TRAPD(err, iData = CBluetoothSynchronousLink::NewL(*this, *socketServ));
if( err!=KErrNone )
{
INFO_PRINTF2(_L("CBluetoothSynchronousLink Standard Constructor NewL err=%d" ),err);
SetError(err);
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KRSocketServ());
SetBlockResult(EFail);
}
}
/**
Test NewLC()
*/
void CT_BluetoothSynchronousLinkData::DoCmdNewLC(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink NewLC Call"));
DestroyData();
TPtrC socketServName;
if(GetStringFromConfig(aSection, KRSocketServ(), socketServName))
{
RSocketServ* socketServ=static_cast<RSocketServ*>(GetDataObjectL(socketServName));
TRAPD(err, iData = CBluetoothSynchronousLink::NewLC(*this, *socketServ); CleanupStack::Pop(););
if( err!=KErrNone )
{
INFO_PRINTF2(_L("CBluetoothSynchronousLink Standard Constructor NewLC err=%d" ),err);
SetError(err);
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KRSocketServ());
SetBlockResult(EFail);
}
}
/**
Test SetupConnection()
*/
void CT_BluetoothSynchronousLinkData::DoCmdSetupConnection(const TDesC& aSection, const TInt aAsyncErrorIndex)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink SetupConnection Call"));
TBool foundTBTDevAddr = EFalse;
TPtrC tbtDevAddrName;
CT_BTDevAddrData* tbtDevAddrData = NULL;
if(GetStringFromConfig(aSection, KTBTDevAddr(), tbtDevAddrName))
{
foundTBTDevAddr = ETrue;
tbtDevAddrData = static_cast<CT_BTDevAddrData*>(GetDataWrapperL(tbtDevAddrName));
}
TBool foundIntDevAddr = EFalse;
TInt intBtDevAddr = 0;
if(GetIntFromConfig(aSection, KIntDevAddr(), intBtDevAddr))
{
foundIntDevAddr = ETrue;
}
if( !foundTBTDevAddr & !foundIntDevAddr )
{
ERR_PRINTF3(KLogMissingParameters, &KTBTDevAddr(), &KIntDevAddr());
SetBlockResult(EFail);
}
TInt err = 0;
//SetupConnection()2
TBool foundPackType = EFalse;
TPtrC packetTypeName;
TInt packetTypeValue;
if(GetStringFromConfig(aSection, KPacketType(), packetTypeName))
{
if ( CT_BTUtil::GetPacketTypeIntValue(packetTypeName, packetTypeValue) )
{
INFO_PRINTF2(_L("CBluetoothSynchronousLink SetupConnection: packetTypeValue = %d"), packetTypeValue);
foundPackType = ETrue;
if( foundTBTDevAddr )
{
const TBTDevAddr* btDevAddr = tbtDevAddrData->GetAddress();
err = iData->SetupConnection(*btDevAddr, packetTypeValue);
}
else
{
const TBTDevAddr intDevAddr(intBtDevAddr);
iBTDeveAddr = intDevAddr;
err = iData->SetupConnection(iBTDeveAddr, packetTypeValue);
}
}
else
{
ERR_PRINTF1(_L("Unknow input for PacketType"));
SetBlockResult(EFail);
}
}
//SetupConnection()3
TBool foundSyncPack = EFalse;
TPtrC syncPacketName;
if (GetStringFromConfig(aSection, KSyncPacket(), syncPacketName) )
{
TBTSyncPackets* tbtSyncPackets = static_cast<TBTSyncPackets*>(GetDataObjectL(syncPacketName));
foundSyncPack = ETrue;
if( foundTBTDevAddr )
{
const TBTDevAddr* btDevAddr = tbtDevAddrData->GetAddress();
err = iData->SetupConnection(*btDevAddr, *tbtSyncPackets);
}
else
{
const TBTDevAddr intDevAddr(intBtDevAddr);
iBTDeveAddr = intDevAddr;
err = iData->SetupConnection(iBTDeveAddr, *tbtSyncPackets);
}
}
//SetupConnection()1
if( !foundPackType & !foundSyncPack )
{
if( foundTBTDevAddr )
{
const TBTDevAddr* btDevAddr = tbtDevAddrData->GetAddress();
err = iData->SetupConnection(*btDevAddr);
}
else
{
const TBTDevAddr intDevAddr(intBtDevAddr);
iBTDeveAddr = intDevAddr;
err = iData->SetupConnection(iBTDeveAddr);
}
}
if(err != KErrNone)
{
ERR_PRINTF2(_L("CBluetoothSynchronousLink SetupConnection failed with error %d"), err);
SetError(err);
}
else
{
IncOutstanding();
iSetupIndex = aAsyncErrorIndex;
}
if( !GetIntFromConfig(aSection, KErrForSetupConnection(), iErrForSetupConnection))
{
ERR_PRINTF2(KLogMissingParameter, &KErrForSetupConnection());
SetBlockResult(EFail);
}
}
/**
Test CancelSetup()
*/
void CT_BluetoothSynchronousLinkData::DoCmdCancelSetup()
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink CancelSetup Call"));
iData->CancelSetup();
DecOutstanding();
}
/**
Test Disconnect()
*/
void CT_BluetoothSynchronousLinkData::DoCmdDisconnect(const TDesC& aSection, const TInt aAsyncErrorIndex)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink Disconnect Call"));
TInt err = iData->Disconnect();
if(err != KErrNone)
{
ERR_PRINTF2(_L("CBluetoothSynchronousLink Disconnect failed with error %d"), err);
SetError(err);
}
else
{
IncOutstanding();
iDisconnectionIndex = aAsyncErrorIndex;
}
if( !GetIntFromConfig(aSection, KErrForDisconnect(), iErrForDisconnect))
{
ERR_PRINTF2(KLogMissingParameter, &KErrForDisconnect());
SetBlockResult(EFail);
}
}
/**
Test Send()
*/
void CT_BluetoothSynchronousLinkData::DoCmdSend(const TDesC& aSection, const TInt aAsyncErrorIndex)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink Send Call"));
TPtrC dataToSend;
if(GetStringFromConfig(aSection, KData(), dataToSend))
{
TBuf8<KDataSize> dataToSend8(_L8(""));
dataToSend8.Copy(dataToSend);
TInt err = iData->Send(dataToSend8);
if(err != KErrNone)
{
ERR_PRINTF2(_L("CBluetoothSynchronousLink Send failed with error %d"), err);
SetError(err);
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KData());
SetBlockResult(EFail);
}
IncOutstanding();
iSendIndex = aAsyncErrorIndex;
if( !GetIntFromConfig(aSection, KErrForSend(), iErrForSend))
{
ERR_PRINTF2(KLogMissingParameter, &KErrForSend());
SetBlockResult(EFail);
}
}
/**
Test CancelSend()
*/
void CT_BluetoothSynchronousLinkData::DoCmdCancelSend()
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink CancelSend Call"));
iData->CancelSend();
DecOutstanding();
}
/**
Test Receive()
*/
void CT_BluetoothSynchronousLinkData::DoCmdReceive(const TDesC& aSection, const TInt aAsyncErrorIndex)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink Receive Call"));
TPtrC dataToReceive;
if(GetStringFromConfig(aSection, KData(), dataToReceive))
{
TBuf8<KDataSize> dataToReceive8(_L8(""));
dataToReceive8.Copy(dataToReceive);
TInt err = iData->Receive(dataToReceive8);
if(err != KErrNone)
{
ERR_PRINTF2(_L("CBluetoothSynchronousLink Receive failed with error %d"), err);
SetError(err);
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KData());
SetBlockResult(EFail);
}
IncOutstanding();
iReceiveIndex = aAsyncErrorIndex;
if( !GetIntFromConfig(aSection, KErrForReceive(), iErrForReceive))
{
ERR_PRINTF2(KLogMissingParameter, &KErrForReceive());
SetBlockResult(EFail);
}
}
/**
Test CancelReceive()
*/
void CT_BluetoothSynchronousLinkData::DoCmdCancelReceive()
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink CancelReceive Call"));
iData->CancelReceive();
DecOutstanding();
}
/**
Test AcceptConnection()
*/
void CT_BluetoothSynchronousLinkData::DoCmdAcceptConnection(const TDesC& aSection, const TInt aAsyncErrorIndex)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink AcceptConnection Call"));
TInt err = 0;
TPtrC syncPacketName;
if (GetStringFromConfig(aSection, KSyncPacket(), syncPacketName) )
{
ibtSyncPackets = static_cast<TBTSyncPackets*>(GetDataObjectL(syncPacketName));
err = iData->AcceptConnection(*ibtSyncPackets);
}
else
{
err = iData->AcceptConnection();
}
if(err != KErrNone)
{
ERR_PRINTF2(_L("CBluetoothSynchronousLink AcceptConnection failed with error %d"), err);
SetError(err);
}
else
{
TBool incoutstanding = ETrue;
// if in ini file, incoutstanding = false, this case is a unconnected case and will not expect a callback, so do not IncOutstanding().
if ( (GetBoolFromConfig(aSection, KIncOutstanding(), incoutstanding)) && (incoutstanding == EFalse) )
{
INFO_PRINTF1(_L("incoutstanding is false, do not IncOutstanding()"));
}
else
{
IncOutstanding();
iAcceptIndex = aAsyncErrorIndex;
}
}
if( !GetIntFromConfig(aSection, KErrForAcceptConnection(), iErrForAcceptConnection))
{
ERR_PRINTF2(KLogMissingParameter, &KErrForAcceptConnection());
SetBlockResult(EFail);
}
}
/**
Test CancelAccept()
*/
void CT_BluetoothSynchronousLinkData::DoCmdCancelAccept()
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink CancelAccept Call"));
iData->CancelAccept();
DecOutstanding();
}
/**
Test SetCoding()
*/
void CT_BluetoothSynchronousLinkData::DoCmdSetCoding(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink SetCoding Call"));
TInt voiceSetting;
if(GetIntFromConfig(aSection, KVoiceSetting(), voiceSetting))
{
iData->SetCoding(voiceSetting);
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KVoiceSetting());
SetBlockResult(EFail);
}
}
/**
Test Coding()
*/
void CT_BluetoothSynchronousLinkData::DoCmdCoding(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink Coding Call"));
TUint16 voiceSetting = iData->Coding();
INFO_PRINTF2(_L("CBluetoothSynchronousLink Coding result: actual = %d"), voiceSetting);
TInt expected;
if(GetIntFromConfig(aSection, KExpected(), expected))
{
if( expected != voiceSetting )
{
ERR_PRINTF1(_L("Coding not as expected!"));
SetBlockResult(EFail);
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KExpected());
SetBlockResult(EFail);
}
}
/**
Test SetMaxBandwidth()
*/
void CT_BluetoothSynchronousLinkData::DoCmdSetMaxBandwidth(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink SetMaxBandwidth Call"));
TPtrC bandwidthName;
if(GetStringFromConfig(aSection, KSyncBandwidth(), bandwidthName))
{
TBTSyncBandwidth* tbtSyncBandwidth = static_cast<TBTSyncBandwidth*>(GetDataObjectL(bandwidthName));
iData->SetMaxBandwidth(*tbtSyncBandwidth);
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KSyncBandwidth());
SetBlockResult(EFail);
}
}
/**
Test Bandwidth()
*/
void CT_BluetoothSynchronousLinkData::DoCmdBandwidth()
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink Bandwidth Call"));
TBTSyncBandwidth bandwidth = iData->Bandwidth();
INFO_PRINTF1(_L("CBluetoothSynchronousLink Bandwidth result"));
INFO_PRINTF2(_L("iTransmit = %d"), bandwidth.iTransmit);
INFO_PRINTF2(_L("iReceive = %d"), bandwidth.iReceive);
}
/**
Test SetMaxLatency()
*/
void CT_BluetoothSynchronousLinkData::DoCmdSetMaxLatency(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink SetMaxLatency Call"));
TInt latency = 0;
if(GetIntFromConfig(aSection, KLatency(), latency))
{
iData->SetMaxLatency((TUint16)latency);
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KLatency());
SetBlockResult(EFail);
}
}
/**
Test Latency()
*/
void CT_BluetoothSynchronousLinkData::DoCmdLatency(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink Latency Call"));
TUint16 latency = iData->Latency();
INFO_PRINTF2(_L("CBluetoothSynchronousLink Latency result: actual = %d"), latency);
TInt expected;
if(GetIntFromConfig(aSection, KExpected(), expected))
{
if( expected != latency )
{
ERR_PRINTF1(_L("Latency not as expected!"));
SetBlockResult(EFail);
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KExpected());
SetBlockResult(EFail);
}
}
/**
Test SetRetransmissionEffort()
*/
void CT_BluetoothSynchronousLinkData::DoCmdSetRetransmissionEffort(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink SetRetransmissionEffort Call"));
TBTeSCORetransmissionTypes retransmissionType;
if ( CT_BTUtil::ReadTBTeSCORetransmissionTypes(*this, retransmissionType, aSection, KRetransmissionType()) )
{
INFO_PRINTF2(_L("CBluetoothSynchronousLink SetRetransmissionEffort: retransmissionType = %d"), retransmissionType);
iData->SetRetransmissionEffort(retransmissionType);
}
else
{
ERR_PRINTF1(_L("Missing parameter, TBTeSCORetransmissionTypes"));
SetBlockResult(EFail);
}
}
/**
Test RetransmissionEffort()
*/
void CT_BluetoothSynchronousLinkData::DoCmdRetransmissionEffort(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink RetransmissionEffort Call"));
TUint8 retransmissionType = iData->RetransmissionEffort();
INFO_PRINTF2(_L("CBluetoothSynchronousLink RetransmissionEffort result: actual = %d"), retransmissionType);
TBTeSCORetransmissionTypes expected;
if ( CT_BTUtil::ReadTBTeSCORetransmissionTypes(*this, expected, aSection, KExpected()) )
{
if( expected != retransmissionType )
{
ERR_PRINTF1(_L("RetransmissionEffort not as expected!"));
SetBlockResult(EFail);
}
}
else
{
ERR_PRINTF1(_L("Missing parameter, TBTeSCORetransmissionTypes"));
SetBlockResult(EFail);
}
}
/**
Test RemoteName()
*/
void CT_BluetoothSynchronousLinkData::DoCmdRemoteName(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink RemoteName Call"));
T_TBTSockAddrChild addr;
iData->RemoteName(addr);
TBTDevAddr currentAddr = addr.BTAddr();
TBuf<KMaxSockAddrSize> tmpBuf;
currentAddr.GetReadable(tmpBuf);
INFO_PRINTF2(_L("RemoteName() = 0x%S"),&tmpBuf);
TPtrC myTBTDevAddrName;
if(GetStringFromConfig(aSection, KTBTDevAddr(), myTBTDevAddrName))
{
CT_BTDevAddrData* myTBTDevAddrData=static_cast<CT_BTDevAddrData*>(GetDataWrapperL(myTBTDevAddrName));
TBTDevAddr btDevAddr = *myTBTDevAddrData->GetAddress();
TBuf<KMaxSockAddrSize> tmpBuf2;
btDevAddr.GetReadable(tmpBuf2);
if (tmpBuf2 != tmpBuf)
{
ERR_PRINTF3(_L("Expected address (%S) != actual address (%S)"),&tmpBuf2,&tmpBuf);
SetBlockResult(EFail);
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KTBTDevAddr());
SetBlockResult(EFail);
}
}
/**
Test SetNotifier
*/
void CT_BluetoothSynchronousLinkData::DoCmdSetNotifier(const TDesC& aSection)
{
INFO_PRINTF1(_L("CBluetoothSynchronousLink SetNotifier Call"));
MBluetoothSynchronousLinkNotifier* theNotifier = this;
TBool useAlternate =EFalse;
if(GetBoolFromConfig(aSection, KUseAlternateNotifier(), useAlternate) )
{
if (useAlternate)
{
theNotifier=this;
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KUseAlternateNotifier());
SetBlockResult(EFail);
}
iData->SetNotifier(*theNotifier);
}
/**
Test Destructor
*/
void CT_BluetoothSynchronousLinkData::DoCmdDestructor()
{
DestroyData();
}
/**
Test MBSLN_ExtensionInterfaceL()
*/
void CT_BluetoothSynchronousLinkData::DoCmdMBSLN_ExtensionInterfaceL(const TDesC& aSection)
{
TInt tmp = 0;
void* theExtensionObjectPtr;
if(GetIntFromConfig(aSection, KUid(), tmp))
{
TUid uid=TUid::Uid(tmp);
TBool expectNull = EFalse;
if(GetBoolFromConfig(aSection, KExpectNull(), expectNull))
{
TRAPD(err, this->MBSLN_ExtensionInterfaceL(uid, theExtensionObjectPtr));
if( err!=KErrNone )
{
ERR_PRINTF2(_L("MBSLN_ExtensionInterfaceL err=%d"),err);
SetError(err);
}
if (expectNull)
{
//Fail if not NULL
if (theExtensionObjectPtr!=NULL)
{
ERR_PRINTF1(_L("Expected Null pointer but object found"));
SetBlockResult(EFail);
}
}
else
{
//Fail if NULL
if (theExtensionObjectPtr==NULL)
{
ERR_PRINTF1(_L("Expected object but found NULL"));
SetBlockResult(EFail);
}
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KExpectNull());
SetBlockResult(EFail);
}
}
else
{
ERR_PRINTF2(KLogMissingParameter, &KUid());
SetBlockResult(EFail);
}
}