diff -r 000000000000 -r 3553901f7fa8 smsprotocols/smsstack/smsprot/Test/TE_SMSINTER/actrecv.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/smsprotocols/smsstack/smsprot/Test/TE_SMSINTER/actrecv.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,826 @@ +// Copyright (c) 1999-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 +#include +#include + +#include "TE_smsinterbase.h" + +const TInt KActiveReceiverSocketGranularity = 8; +const TInt KActiveSocketPriority = CActive::EPriorityIdle; + +class CStopIfKeyPressed; + +class MStopTest + { +public: + virtual void StopTests() = 0; + }; + +// +// +// CActiveSocket +// +// + +class CActiveSocket : public CActive + { +public: + enum { EPriority = KActiveSocketPriority }; +public: + static CActiveSocket* NewL(const TTestCase& aTest, RSocketServ& aSocketServer, RFs& aFs); + ~CActiveSocket(); + void ReceiveMessage(TRequestStatus* aStatus); + void SetIndex(TInt aIndex); + void TestResultL(); + TBool TestComplete(); + TPtrC Message(); +private: + virtual void DoCancel(); + virtual void RunL(); + CActiveSocket(RSocketServ& aSocketServer); +private: + void InitRSocketL(); +private: + TRequestStatus* iActiveReceiverStatus; + RSocket iSocket; + TTestCase iTestCase; + CSmsMessage* iSmsMessage; + TInt iActiveReceiverIndex; + TPckgBuf iSelectBuf; + RSocketServ& iSocketServer; + }; + +// +// +// CActiveSenderImp +// +// + +class CActiveSenderImp : public CActiveSender, MStopTest + { +public: + static CActiveSenderImp* NewL(RSocketServ& aSocketServer, + RFs& aFs, + const TDesC& aTelephoneNumber, + const TDesC& aServiceCenterNumber); + virtual void StartSendingL(); + virtual void StopIfKeyPressedL(); + ~CActiveSenderImp(); +public: + void StopTests(); +private: + void InitRSocketL(); + void SendSmsMessageL(); +private: + virtual void DoCancel(); + virtual void RunL(); +private: + CActiveSenderImp(RSocketServ& aSocketServer, RFs& aFs); + CStopIfKeyPressed* iStopTest; + RSocket iSocket; + CSmsMessage* iSmsMessage; + TPckgBuf iIntBuf; + TInt iCount; + }; + +// +// +// CActiveReceiverImp +// +// + +class CActiveReceiverImp : public CActiveReceiver, MStopTest + { +public: + static CActiveReceiverImp* NewL(RSocketServ& aSocketServer, RFs& aFs); + virtual void AddTestL(const TTestCase& aTest); + virtual void StartTestsL(); + virtual void StopIfKeyPressedL(); + ~CActiveReceiverImp(); +public: + void StopTests(); +private: + virtual void DoCancel(); + virtual void RunL(); +private: + CActiveReceiverImp(RSocketServ& aSocketServer, RFs& aFs); + CArrayPtr* iSockArray; + TInt iResultCount; + CStopIfKeyPressed* iStopTest; + }; + +// +// +// CStopIfKeyPressed +// +// + +class CStopIfKeyPressed : public CActive + { +public: + enum { EPriority = KStopIfKeyPressedPriority }; +public: + static CStopIfKeyPressed* NewL(MStopTest* aReceiver); + virtual void RunL(); + virtual void DoCancel(); +public: + void StopIfKeyPressed(); +private: + CStopIfKeyPressed(); + MStopTest* iReceiver; + }; + +CStopIfKeyPressed* CStopIfKeyPressed::NewL(MStopTest* aReceiver) +// +// Factory +// + { + + CStopIfKeyPressed* stopTest = new(ELeave) CStopIfKeyPressed; + stopTest->iReceiver = aReceiver; + CActiveScheduler::Add(stopTest); + return stopTest; + } + +void CStopIfKeyPressed::StopIfKeyPressed() +// +// Activate +// + { + + if (IsActive()) + return; +// CConsoleBase* console = gTest.Console(); +// console->Read(iStatus); +// SetActive(); + } + +CStopIfKeyPressed::CStopIfKeyPressed() +// +// Constructor +// +: CActive(EPriority) + {} + +void CStopIfKeyPressed::RunL() +// +// Called if a key has been pressed +// + { + + iReceiver->StopTests(); + CActiveScheduler::Stop(); + } + +void CStopIfKeyPressed::DoCancel() +// +// Cancel has been called +// + { + +// CConsoleBase* console = gTest.Console(); +// console->ReadCancel(); + } + +// +// +// CActiveSocket +// +// + +CActiveSocket* CActiveSocket::NewL(const TTestCase& aTest, RSocketServ& aSocketServer, RFs& aFs) +// +// Factory +// + { + + CActiveSocket* socket = new(ELeave) CActiveSocket(aSocketServer); + CleanupStack::PushL(socket); + socket->iTestCase=aTest; + socket->InitRSocketL(); + + CSmsBuffer* buffer=NULL; + buffer=CSmsBuffer::NewL(); + socket->iSmsMessage=CSmsMessage::NewL(aFs, CSmsPDU::ESmsSubmit,buffer); + CleanupStack::Pop(); + + CActiveScheduler::Add(socket); + return socket; + } + +CActiveSocket::CActiveSocket(RSocketServ& aSocketServer) +// +// Constructor +// +: CActive(EPriority), + iSocketServer(aSocketServer) + {} + +CActiveSocket::~CActiveSocket() +// +// Destructor +// + { + + delete iSmsMessage; + iSocket.Close(); + } + +void CActiveSocket::TestResultL() +// +// Test the sms message contains the expected data +// + { + + CSmsBufferBase& smsBuffer=iSmsMessage->Buffer(); + TInt bufLen=smsBuffer.Length(); + HBufC* textBuf=HBufC::NewL(bufLen); + TPtr textPtr(textBuf->Des()); + smsBuffer.Extract(textPtr,0,bufLen); + +// if (iTestCase.iTestForever) +// gTest.Printf(_L("RECEIVED: Msg %S\n"),&textPtr); +// else if (iTestCase.iMatchType==ESmsAddrStatusReport) +// gTest.Printf(_L("SUCCESS: Status report received for %S\n"),&iTestCase.iMsg); +// else +// { +// TBool ret = (textPtr==iTestCase.iMsg); +// if (ret>0) +// gTest.Printf(_L("SUCCESS: Msg %S received\n"),&iTestCase.iMsg); +// else +// gTest.Printf(_L("SUCCESS: Msg %S not received\n"),&iTestCase.iMsg); +// } + + delete textBuf; + } + + +void CActiveSocket::SetIndex(TInt aIndex) +// +// Set the index ofthe socket within the receiver's iSockArray +// + { + + iActiveReceiverIndex = aIndex; + } + +TPtrC CActiveSocket::Message() +// +// Return the testcase message +// + { + + return iTestCase.iMsg; + } + +void CActiveSocket::InitRSocketL() +// +// Initialise the active socket's connection with the socket server +// + { + + TInt ret=iSocket.Open(iSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol); + User::LeaveIfError(ret); + TSmsAddr smsAddr; + smsAddr.SetSmsAddrFamily(iTestCase.iMatchType); + + switch(iTestCase.iMatchType) + { + case ESmsAddrMatchText: + { + TBuf8<128> match; + match.Copy(iTestCase.iMatch); + smsAddr.SetTextMatch(match); + break; + } + case ESmsAddrMatchIEI: + smsAddr.SetIdentifierMatch(iTestCase.iIdentifierMatch); + break; + case ESmsAddrMessageIndication: + break; + default: + break; + }; + + ret=iSocket.Bind(smsAddr); + User::LeaveIfError(ret); + } + +void CActiveSocket::ReceiveMessage(TRequestStatus* aStatus) +// +// Receive a message +// + { + + iActiveReceiverStatus = aStatus; + iSelectBuf()=KSockSelectRead; + iSocket.Ioctl(KIOctlSelect,iStatus,&iSelectBuf,KSOLSocket); + SetActive(); + } + +void CActiveSocket::DoCancel() +// +// Cancel the select +// + { + + iSocket.CancelAll(); + } + +void CActiveSocket::RunL() +// +// Got something to read +// + { + + if (iStatus<0) + { + User::RequestComplete(iActiveReceiverStatus,iStatus.Int()); + return; + } + + RSmsSocketReadStream readstream(iSocket); + TRAPD(ret,readstream >> *iSmsMessage); + User::LeaveIfError(ret); + + TPckgBuf sbuf; + TRequestStatus status; + iSocket.Ioctl(KIoctlReadMessageSucceeded,status,&sbuf, KSolSmsProv); + User::WaitForRequest(status); + + User::RequestComplete(iActiveReceiverStatus,iActiveReceiverIndex); + } + +TBool CActiveSocket::TestComplete() +// +// Socket has finished performing all tests +// + { + + if (iTestCase.iTestForever) + return EFalse; + return ETrue; + } + +// +// +// CActiveReceiverImp +// +// + +CActiveReceiverImp* CActiveReceiverImp::NewL(RSocketServ& aSocketServer, RFs& aFs) +// +// Factory +// + { + + CActiveReceiverImp* actRecv = new(ELeave) CActiveReceiverImp(aSocketServer, aFs); + CleanupStack::PushL(actRecv); + actRecv->iSockArray=new(ELeave) CArrayPtrSeg(KActiveReceiverSocketGranularity); + actRecv->iStatus=KRequestPending; + CleanupStack::Pop(); + CActiveScheduler::Add(actRecv); + return actRecv; + } + +CActiveReceiverImp::CActiveReceiverImp(RSocketServ& aSocketServer, RFs& aFs) +// +// Constructor +// +:CActiveReceiver(aSocketServer, aFs) + {} + +CActiveReceiverImp::~CActiveReceiverImp() +// +// Destructor +// + { + + if (iSockArray) + { + StopTests(); + iSockArray->ResetAndDestroy(); + } + delete iStopTest; + delete iSockArray; + } + +void CActiveReceiverImp::AddTestL(const TTestCase& aTest) +// +// Add a test case to the receiver +// + { + + CActiveSocket* socket = CActiveSocket::NewL(aTest, iSocketServer, iFs); + CleanupStack::PushL(socket); + iSockArray->AppendL(socket); + socket->SetIndex(iSockArray->Count()-1); + socket->ReceiveMessage(&iStatus); + CleanupStack::Pop(); + + if (aTest.iMatchType==ESmsAddrStatusReport) + { + // Add a test to match the original message as well as the status report + TTestCase srrIdMatch(aTest.iMsg,aTest.iMsg.Left(TSmsAddr::EMaxTextMatchLength)); + AddTestL(srrIdMatch); + } + } + +void CActiveReceiverImp::StartTestsL() +// +// Kick off the tests +// + { + + SetActive(); + CActiveScheduler::Start(); + } + +void CActiveReceiverImp::StopTests() +// +// Cancel all active sockets +// + { + + for (TInt i=0;iCount();i++) + (*iSockArray)[i]->Cancel(); + if (iStopTest) + iStopTest->Cancel(); + Cancel(); + } + +void CActiveReceiverImp::StopIfKeyPressedL() +// +// Stop the active scheduler if a key is pressed +// + { + + if (!iStopTest) + iStopTest=CStopIfKeyPressed::NewL(this); + iStopTest->StopIfKeyPressed(); + } + +void CActiveReceiverImp::DoCancel() + { + + TRequestStatus* status = &iStatus; + User::RequestComplete(status,KErrCancel); + } + +void CActiveReceiverImp::RunL() +// +// An active socket has received a message +// + { + + TInt index = iStatus.Int(); + CActiveSocket* socket = (*iSockArray)[index]; + socket->TestResultL(); + + if (socket->TestComplete()) + iResultCount++; + else + socket->ReceiveMessage(&iStatus); + + if (iResultCount == iSockArray->Count()) + { + StopTests(); + CActiveScheduler::Stop(); + return; + } + + SetActive(); + iStatus=KRequestPending; + } + +// +// +// TTestCase +// +// + +TTestCase::TTestCase() +// +// Constructor +// + { + + CommonInit(); + } + +TTestCase::TTestCase(const TDesC& aMsg, const TDesC& aMatch) +// +// Constructor +// +: iMatchType(ESmsAddrMatchText), iMsg(aMsg), iMatch(aMatch) + { + + CommonInit(); + } + +void TTestCase::CommonInit() +// +// Reset member variables +// + { + + iTestSmsClass = EFalse; + iTestValidityPeriod = EFalse; + iTestForever=EFalse; + iTestIndicators=EFalse; + } + +TTestCase::TTestCase(const TDesC& aMsg, CSmsInformationElement::TSmsInformationElementIdentifier aIdentifier) +// +// Constructor +// +: iMatchType(ESmsAddrMatchIEI), iMsg(aMsg), iIdentifierMatch(aIdentifier) + { + + CommonInit(); + } + +TTestCase::TTestCase(const TDesC& aMsg, TSmsFirstOctet::TSmsStatusReportRequest /*aSRR*/) +// +// Match on status report - ignore actual value of aSRR +// +: iMatchType(ESmsAddrStatusReport), iMsg(aMsg) + { + + CommonInit(); + } + +TTestCase::TTestCase(const TDesC& aMsg, TSmsDataCodingScheme::TSmsIndicationType aIndicationType, + TSmsDataCodingScheme::TSmsDCSBits7To4 aBits7To4, + TSmsDataCodingScheme::TSmsIndicationState aIndicationState) +// +// Match on a type of message indication +// +: iMatchType(ESmsAddrMessageIndication), iMsg(aMsg), iIndicationType(aIndicationType), + iBits7To4(aBits7To4), iIndicationState(aIndicationState) + { + + __ASSERT_ALWAYS(iBits7To4==TSmsDataCodingScheme::ESmsDCSMessageWaitingIndicationDiscardMessage + || iBits7To4==TSmsDataCodingScheme::ESmsDCSMessageWaitingIndication7Bit + || iBits7To4==TSmsDataCodingScheme::ESmsDCSMessageWaitingIndicationUCS2, + User::Panic(_L("TestCase"), KErrNotSupported)); + + CommonInit(); + iTestIndicators=ETrue; + + } + +TTestCase::TTestCase(const TDesC& aMsg) +// +// Constructor +// +: iMatchType(ESmsAddrRecvAny), iMsg(aMsg) + { + + CommonInit(); + } + +const TTestCase& TTestCase::operator=(const TTestCase& aTest) +// +// Assignment operator +// + { + + iMatchType = aTest.iMatchType; + iMsg.Set(aTest.iMsg); + iMatch.Set(aTest.iMatch); + iIdentifierMatch = aTest.iIdentifierMatch; + iTestForever = aTest.iTestForever; + return *this; + } + +void TTestCase::SetSmsClass(TSmsDataCodingScheme::TSmsClass aClass) +// +// Set Sms Class +// + { + + iTestSmsClass = ETrue; + iSmsClass = aClass; + } + +void TTestCase::SetValidityPeriod(const TTimeIntervalMinutes& aTimeInterval) +// +// Set the validity period +// + { + + iTestValidityPeriod = ETrue; + iValidityPeriod = aTimeInterval; + } + +void TTestCase::SetRecvForever() +// +// Recv all messages forever +// + { + + iTestForever = ETrue; + iMatchType = ESmsAddrRecvAny; + } + + +// +// +// CActiveReceiver +// +// + +CActiveReceiver* CActiveReceiver::NewL(RSocketServ& aSocketServer, RFs& aFs) + { return CActiveReceiverImp::NewL(aSocketServer, aFs); } +CActiveReceiver::CActiveReceiver(RSocketServ& aSocketServer, RFs& aFs) +: CActive(EPriority), + iSocketServer(aSocketServer), + iFs(aFs) + {} +void CActiveReceiver::AddTestL(const TTestCase& /*aTest*/) + {} +void CActiveReceiver::StartTestsL() + {} +void CActiveReceiver::StopIfKeyPressedL() + {} + +// +// +// CActiveSender +// +// + +CActiveSender* CActiveSender::NewL(RSocketServ& aSocketServer, + RFs& aFs, + const TDesC& aTelephoneNumber, + const TDesC& aServiceCenterNumber) + { return CActiveSenderImp::NewL(aSocketServer, aFs, aTelephoneNumber, aServiceCenterNumber); } +CActiveSender::CActiveSender(RSocketServ& aSocketServer, RFs& aFs) +: CActive(EPriority), + iSocketServer(aSocketServer), + iFs(aFs) + {} +void CActiveSender::StartSendingL() + {} +void CActiveSender::StopIfKeyPressedL() + {} + + +// +// +// CActiveSenderImp +// +// + +CActiveSenderImp* CActiveSenderImp::NewL(RSocketServ& aSocketServer, + RFs& aFs, + const TDesC& aTelephoneNumber, + const TDesC& aServiceCenterNumber) +// +// Factory +// + { + + CActiveSenderImp* actSend = new(ELeave) CActiveSenderImp(aSocketServer, aFs); + CleanupStack::PushL(actSend); + actSend->iStatus=KRequestPending; + actSend->InitRSocketL(); + + CSmsBuffer* buffer=NULL; + buffer=CSmsBuffer::NewL(); + actSend->iSmsMessage=CSmsMessage::NewL(aFs, CSmsPDU::ESmsSubmit,buffer); + + TSmsUserDataSettings smsSettings; + smsSettings.SetAlphabet(TSmsDataCodingScheme::ESmsAlphabet7Bit); + smsSettings.SetTextCompressed(EFalse); + actSend->iSmsMessage->SetUserDataSettingsL(smsSettings); + + actSend->iSmsMessage->SetToFromAddressL(aTelephoneNumber); + actSend->iSmsMessage->SmsPDU().SetServiceCenterAddressL(aServiceCenterNumber); + buffer->InsertL(0,_L("Test Message")); + + CleanupStack::Pop(); // actSend + CActiveScheduler::Add(actSend); + return actSend; + } + +CActiveSenderImp::CActiveSenderImp(RSocketServ& aSocketServer, RFs& aFs) +// +// Constructor +// +:CActiveSender(aSocketServer, aFs) + {} + +CActiveSenderImp::~CActiveSenderImp() +// +// Destructor +// + { + + Cancel(); + delete iStopTest; + delete iSmsMessage; + iSocket.Close(); + } + +void CActiveSenderImp::StartSendingL() +// +// Kick off the tests +// + { + + SendSmsMessageL(); + CActiveScheduler::Start(); + } + +void CActiveSenderImp::StopTests() +// +// Prepare for active scheduler stop +// + { + + Cancel(); + } + +void CActiveSenderImp::StopIfKeyPressedL() +// +// Stop the active scheduler if a key is pressed +// + { + + if (!iStopTest) + iStopTest=CStopIfKeyPressed::NewL(this); + iStopTest->StopIfKeyPressed(); + } + +void CActiveSenderImp::DoCancel() +// +// Cancel the current send +// + { + + iSocket.CancelSend(); + } + +void CActiveSenderImp::SendSmsMessageL() +// +// Send an SMS message and wait for complete +// + { + + RSmsSocketWriteStream writestream(iSocket); + iSmsMessage->SmsPDU().SetClass(ETrue, TSmsDataCodingScheme::ESmsClass2); + TRAPD(ret,writestream << *iSmsMessage); + User::LeaveIfError(ret); + TRAP(ret,writestream.CommitL()); + User::LeaveIfError(ret); + + iSocket.Ioctl(KIoctlSendSmsMessage,iStatus,&iIntBuf, KSolSmsProv); + SetActive(); + } + +void CActiveSenderImp::RunL() +// +// An active socket has received a message +// + { + + if (iStatus.Int()!=KErrNone) + { + //gTest.Printf(_L("Error: Send completed with %d\n"),iStatus.Int()); + iStopTest->DoCancel(); + return; + } + iCount++; + //gTest.Printf(_L("Sent %d messages\n"),iCount); + SendSmsMessageL(); + } + +void CActiveSenderImp::InitRSocketL() +// +// Initialise the sender's socket +// + { + + TInt ret=iSocket.Open(iSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol); + User::LeaveIfError(ret); + TSmsAddr smsAddr; + smsAddr.SetSmsAddrFamily(ESmsAddrSendOnly); + ret=iSocket.Bind(smsAddr); + User::LeaveIfError(ret); + }