diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/multimodetsy/test/Te_LoopBack/Te_LoopBackSCHAT.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/multimodetsy/test/Te_LoopBack/Te_LoopBackSCHAT.CPP Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,415 @@ +// Copyright (c) 1997-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: +// This file implements the management of strings for matching between the chat buffer (also +// called the history buffer) and the chat strings. The chat buffer is a single buffer that +// contains information that has been written to the test harness from the tsy. The chat +// strings are the expected strings specified in the scripting language (in the RxEvents). +// The expected or chat strings must match the strings received from the TSY. +// This file also includes the logic to support the use of buffer markers to be associated with +// the history buffer and the Chat strings. Essentially, these buffer markers delimit the +// range of addresses in the history buffer where data associated with a particular command +// could be found. The buffer marker structure only contains one address and uses the current +// last character address as it's other delimeter. +// +// + +/** + @file +*/ + +#include "Te_LoopBackATSTD.H" +#include "Te_LoopBackSCHAT.H" +#include "Te_LoopBackSLOGGER.H" + +CCommChatString* CCommChatString::NewL(const TDesC8& aDes, TBool aIsFolded) +/** + * 2 Phase Constructor + * + * This method creates a CCommChatString instance. After newing the necessary, it + * pushes the chat string pointer onto the stack. Then it calls it's second stage + * constructor (in this case the CreateL method), passing the parameters passed to + * this method. + * + * @param aDes references the descriptor that contains the string. + * @param aIsFolded a boolean that indicates the "foldedness" of this string. + * + * @leave This function will leave if the system is out of memory or unable + * to allocate the amount of memory requested. + * + * @return A pointer to the newly created CCommChatString + */ + { + CCommChatString* cs = new (ELeave) CCommChatString; + CleanupStack::PushL(cs); + cs->CreateL(aDes, aIsFolded); + CleanupStack::Pop(); + return cs; + } + +CCommChatString::CCommChatString() +/** + * This method is the standard constructor for the class CCommChatString. + */ + { + __DECLARE_NAME(_S("CCommChatString")); + } + +CCommChatString::~CCommChatString() +/** + * This method is the standard destructor. It frees the memory allocated in the CreateL + * method during construction. + * + * @return None. + */ + { + User::Free(iString); + } + +void CCommChatString::CreateL(const TDesC8& aDes, TBool aIsFolded) +/** + * Second Phase of Constructor + * + * This method is used as the second phase of the constructor for the CComChatString + * class. It allocates heap memory as specified by the passed in descriptor's length. + * Then, the string located in the descriptor is copied into the newly allocated memory. + * The member data iLastChar is initialized to point to the last byte copied. The member + * data iIsFolded is initialized to the passed parameter. + * + * @param aDes The descriptor containing the string data specified by the caller. + * @param aIsFolded A boolean indicating whether or not the string is folded. + * + * @leave Leaves via User::AllocL if memory can not be allocated. + */ + { + iIsFolded = aIsFolded; + iString = (TText8*) User::AllocL(aDes.Length()); + iLastChar = (iString+aDes.Length())-1; + Mem::Copy(iString, (TUint8*)aDes.Ptr(), aDes.Length()); + } + +// +// CCommChatter +// +CCommChatter::CCommChatter(MCommChatNotify* aNotify, TInt aPriority) + : CTimer(aPriority), iNotify(aNotify) +/** + * The constructor for the CCommChatter class. It adds the active object to the active + * scheduler of the current thread and initializes member data elements. + * + * @param aNotify A pointer to the mixin class object associated with this object. This + * information is stored in the iNotify member. + * @param aPriority The priority which is assigned to the timer this class derives from CTimer. + */ + { + __DECLARE_NAME(_S("CCommChatter")); + CActiveScheduler::Add(this); + iList.SetOffset(_FOFF(CCommChatString,iLink)); + iMarkWrapCnt=0; + } + +CCommChatter::~CCommChatter() +/** + * The standard destructor associated with the CCommChatter class. This method uses the + * DeleteAllAndStop method to free resources saved in the CCommChatter object. Then it frees + * the buffer created with CCommChatter. + * + * @return None + */ + { + DeleteAllAndStop(); + User::Free(iBuffer); + } + +void CCommChatter::CreateL(TInt aBufSize) +/** + * This method is really the second stage constructor for the CCommChatter class, though it is + * not called by the typical CCommChatter::NewL() method. The CCommChatter class is typically + * created by another method (in the regression test case harness it is created in the + * CATIO::ConstructL() method), then this method is called. This method allocates a buffer and + * constructs the timer derived from CTimer in this class. The member data iBuffer, iBufferEnd, + * and iMarkWrapCnt are initialized. + * + * @param aBufSize The size of the buffer to be created with this object. + * + * @leave This method can Leave via User::AllocL if memory is not available. + */ + { + CTimer::ConstructL(); + iBuffer = (TText8*)User::AllocL(aBufSize); + iBufferEnd = (iBuffer+aBufSize)-1; + ClearHistory(); + iMarkWrapCnt=0; + } + +void CCommChatter::ClearHistory() +// +// Empty history +// +/** + * This method resets the history of the CCommChatter buffer in the object. It simply clears + * the iCount and initializes the iLastChar member to iBuffer (the beginning of the buffer). + * + * @return None. + */ + { + iLastChar = iBuffer; + iCount = 0; + } + +void CCommChatter::AddCharL(TText8 aChar) +// +// Add a character to the history buffer +// Scan all strings to find any matches that may +// be completed. +// +/** + * This method adds a single character to the history buffer and then scans all stored + * strings to find any matches that may have been completed because this character has + * been added. The function deals with folded characters during the search. Note that + * the routine first checks to see if the last character in the stored string matches + * the input character. This reduces the number of invocations of the string match + * functions. + * + * @param aChar The character to add to the buffer. + * @leave This method can leave via the ChatStringMatchL call. + */ + { + // Add char to buffer + if (++iLastChar>iBufferEnd) + { + iLastChar = iBuffer; + iMarkWrapCnt++; + } + *iLastChar = aChar; + ++iCount; + + TText8 fchar = (TText8)User::Fold(aChar); + + // Scan for matching last character + CCommChatString* cs; + TDblQueIter iter(iList); + + while (cs = iter++, cs!=NULL) + { + if (cs->IsFolded() + ? (User::Fold(cs->LastChar())==fchar && MatchF(cs)) + : (cs->LastChar()==aChar && Match(cs))) + { + iNotify->ChatStringMatchL(cs); + cs = iter; // In case user removed cs; + } + } + } + +TBool CCommChatter::Match(const CCommChatString* aString) const +// +// Match a chat sgring against the history buffer +// (Case sensitive) +// +/** + * This method matchs a chat string against the history buffer in a case sensitive (unfolded) + * manner. First the length of the two strings is compared. Then the actual content of the + * strings is compared. + * + * @param aString A constant pointer to the chat string. + * + * @return ETrue if strings match, EFalse if they do not. + */ + { + const TText8* s = aString->Ptr(); + const TText8* sp = aString->EndPtr(); + const TText8* bp = iLastChar; + + if (iCountLength()) + return EFalse; + + while (*bp==*sp && sp>=s) + { + --sp; + if (--bpPtr(); + const TText8* sp = aString->EndPtr(); + const TText8* bp = iLastChar; + if (iCountLength()) + return EFalse; + + while (User::Fold(*bp)==User::Fold(*sp) && sp>=s) + { + --sp; + if (--bpiBufferEnd) + { + aBufferMarker.iMarkWrap=iMarkWrapCnt+1; + aBufferMarker.iMarkChar=iBuffer; + } + else + aBufferMarker.iMarkWrap=iMarkWrapCnt; + } + +TPtrC8 CCommChatter::GetChatBufferLC(TInputBufferMark& aBufferMarker) +/** + * This method deals with extracting data from the Chat or History Buffer and returning it + * to the caller. The data that is extracted from the buffer marker to the current last + * character in the buffer. This method creates a new HBufC8 object and returns a pointer + * to that descriptor. This method deals properly with a wrapped history buffer. + * + * @param aBufferMarker is a reference to a buffer marker structure that has been + * previously initialized. This buffer marker structure limits the range of the + * history buffer which must be copied/examined to find the relevant data. + * @leave Leaves if error processing buffer between the mark and the current + * last character. + * @return TPtrC8 pointer to a newly created HBufC8 which contains the iRxBuffer + * contents between the marker and the current last character. Data that + * is of interest to this completion has been copied from the general + * receive buffer to this buffer. + */ + { + TText8* markChar=aBufferMarker.iMarkChar; + if(iMarkWrapCnt==aBufferMarker.iMarkWrap) + { + __ASSERT_ALWAYS(iLastChar>markChar,User::Leave(KErrGeneral)); // Internal Error + HBufC8* buffer=HBufC8::NewLC(iLastChar-markChar+1); + TPtr8 ptr(buffer->Des()); + ptr.Copy(markChar,iLastChar-markChar+1); + return ptr; + } + else + { + if((iLastChar>markChar)||(iMarkWrapCnt>aBufferMarker.iMarkWrap+1)) + User::Leave(KErrGeneral); // Data Lost + HBufC8* buffer=HBufC8::NewLC(KChatBufferSize-(markChar-iLastChar)+1); + TPtr8 ptr(buffer->Des()); + ptr.Copy(TPtrC8(markChar,iBufferEnd-markChar+1)); + ptr.Append(TPtrC8(iBuffer,iLastChar-iBuffer+1)); + return ptr; + } + } + +void CCommChatter::RunL() +/** + * This is the RunL associated with the CTimer inherited by the CCommChatter class. This + * RunL simply processess a timeout. + * + * @return None + */ + { + iNotify->ChatTimeout(); + } + +CCommChatString* CCommChatter::AddString(const TDesC8& aString) +/** + * This method adds a string to the stored chat strings. It creates a new chat string object + * and adds it to the list of outstanding chat strings. + * + * @param aString This is a constant TDesC8 reference that is used to create the new string. + * @return A pointer to the newly created CCommChatString object. + */ + { + CCommChatString* chatString=NULL; + TRAP_IGNORE(chatString=CCommChatString::NewL(aString,ETrue)); // trap but ignore leaves + iList.AddLast(*chatString); + return chatString; + } + +void CCommChatter::RemoveString(CCommChatString* aString) +/** + * This method removes a string from the stored chat strings. It dequeues the string from the + * list of stored chat strings but does not delete the object. + * + * @param aString A pointer to a CCommChatString + * @return None + */ { + aString->iLink.Deque(); + } + +void CCommChatter::DeleteAllAndStop() +/** + * This method stops the outstanding CTimer and removes all of the outstanding chat strings + * from the chat string list and deletes them. + * + * @return None. + */ + { + StopTimer(); + CCommChatString* cs; + while (!iList.IsEmpty()) + { + cs = iList.First(); + RemoveString(cs); + delete cs; + } + } + +void CCommChatter::StartTimer(const TTimeIntervalMicroSeconds32 aTimeout) +/** + * This method starts the timer associated with the CCommChatter class. This timer + * triggers after a specific interval of time. This is a one shot timer. + * + * @param aTimeout The interval in micro-seconds before the timer should trigger. + * @return None + */ + { + if (IsActive()) + Cancel(); + After(aTimeout); + } + +void CCommChatter::StopTimer() +/** + * This method simply stops the outstanding timer for the CCommChatter class. This timer + * is implemented via an active object by the CTimer class. + * + * @return None + */ + { + Cancel(); + }