/**
This method is a notification of the end of the scope of a prefix-URI mapping.
This method is called after the corresponding DoEndElementL method.
@param aPrefix is the Namespace prefix that was mapped.
@param aErrorCode is the error code.
If this is not KErrNone then special action may be required.
*/
void CTestHandler::OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode)
{
_LIT8(KOnEndPrefMapFuncName,"OnEndPrefixMapping()\r\n");
_LIT8(KInfoOnEndPref,"\tPrefix mapping end prefix: %S \r\n");
_LIT8(KInfoOnError,"Error occurs %d \r\n");
iLog.Write(KOnEndPrefMapFuncName);
if (aErrorCode == KErrNone)
{
TBuf8<KShortInfoSize> info;
TBuf8<KShortInfoSize> info2;
info2.Copy(aPrefix.DesC());
info.Format(KInfoOnEndPref,&info2);
iLog.Write(info);
}
else
{
TBuf8<KShortInfoSize> info;
info.Format(KInfoOnError,aErrorCode);
iLog.Write(info);
}
}
/**
This method is a callback that sends the content of the element.
Not all the content may be returned in one go. The data may be sent in chunks.
When an OnEndElementL is received this means there is no more content to be sent.
@param aBytes is the raw content data for the element.
The client is responsible for converting the data to the
required character set if necessary.
In some instances the content may be binary and must not be converted.
@param aErrorCode is the error code.
If this is not KErrNone then special action may be required.
*/
void CTestHandler::OnContentL(const TDesC8& aBytes, TInt aErrorCode)
{
_LIT8(KOnContentFuncName,"OnContent()\r\n");
_LIT8(KInfoOnContent,"\tContent of element: %S \r\n");
_LIT8(KInfoOnError,"Error occurs %d \r\n");
TBuf8<KShortInfoSize> info;
TBuf8<KShortInfoSize> info2;
iLog.Write(KOnContentFuncName);
if (aErrorCode == KErrNone)
{
if(aBytes.Length() >= KShortInfoSize)
{
TPtrC8 bytes = aBytes.Ptr();
HBufC8* buf1 = HBufC8::NewL(aBytes.Length() + 100);
buf1->Des().Format(KInfoOnContent,&bytes);
iLog.Write(*buf1);
}
info2.Copy(aBytes);
info2.Trim();
if (info2.Length())
{
info.Format(KInfoOnContent,&info2);
iLog.Write(info);
}
}
else
{
TBuf8<KShortInfoSize> info;
info.Format(KInfoOnError,aErrorCode);
iLog.Write(info);
}
}
void CScreenDriverVT100::Clear(const TRect& aRect)
//
// Clear a rectangle of the screen
//
{
TInt j;
TBuf8<0x100> buf;
for (j=aRect.iTl.iY; j<=aRect.iBr.iY; j++)
{
TUint8 *ptr=iScreenBuffer+(aRect.iTl.iX+j*KScreenWidth);
Mem::FillZ(ptr, aRect.iBr.iX-aRect.iTl.iX);
}
if ((aRect.iTl.iY == aRect.iBr.iY) && (aRect.iTl.iX==0) && (aRect.iBr.iX==KScreenWidth-1))
{
// Optimisation: one whole line
buf.Format(_L8("\x1b[%02d;%02dH"), aRect.iTl.iY, 1);
Print(buf);
// Erase line
buf.Format(_L8("\x1b[2K"));
Print(buf);
Print(_L8("\x1b[01;01H"));
}
else if ((aRect.iTl.iY == 0) && (aRect.iBr.iY == KScreenHeight-1) &&
(aRect.iTl.iX == 0) && (aRect.iBr.iX == KScreenWidth-1))
{
// Optimisation: whole screen
buf.Format(_L8("\x1b[2J"));
Print(buf);
Print(_L8("\x1b[01;01H"));
}
else
Update(aRect);
}
/**
This method is a notification of ignorable whitespace in element content.
@param aBytes are the ignored bytes from the document being parsed.
@param aErrorCode is the error code.
If this is not KErrNone then special action may be required.
*/
void CTestHandler::OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode)
{
_LIT8(KOnIgnorWhiteFuncName,"OnIgnorableWhiteSpace()\r\n");
_LIT8(KInfoOnIgnorWhiteSpace,"\tIgnoring white space: %S length: %d \r\n");
_LIT8(KInfoOnError,"Error occurs %d \r\n");
TBuf8<KShortInfoSize> info;
TBuf8<KShortInfoSize> info2;
iLog.Write(KOnIgnorWhiteFuncName);
if (aErrorCode == KErrNone)
{
info2.Copy(aBytes);
info2.Trim();
if (info2.Length())
{
info.Format(KInfoOnIgnorWhiteSpace,&info2,info2.Length());
iLog.Write(info);
}
}
else
{
TBuf8<KShortInfoSize> info;
info.Format(KInfoOnError,aErrorCode);
iLog.Write(info);
}
}
TBool CScreenDriverVT100::ScrollUp(const TRect& aRect)
//
// Scroll a rectangle of the screen up one line, don't update bottom line
//
{
TInt j;
for (j=aRect.iTl.iY; j<aRect.iBr.iY; j++)
{
TUint8 *ptr=iScreenBuffer+(aRect.iTl.iX+j*KScreenWidth);
Mem::Copy(ptr, ptr+KScreenWidth, aRect.iBr.iX-aRect.iTl.iX);
}
if ((aRect.iTl.iX<=1) && (aRect.iBr.iX>=KScreenWidth-2))
{
// Optimisation: range of whole lines
TBuf8<0x100> buf;
// cursor pos
buf.Format(_L8("\x1b[%02d;%02dH\xd\xa\xba\x1b[%02dC\xba"), aRect.iBr.iY, 1, aRect.iBr.iX);
Print(buf);
// set scroll region
buf.Format(_L8("\x1b[%02d;%02dr\xd\xa"), aRect.iTl.iY+1, aRect.iBr.iY);
Print(buf);
Print(_L8("\x1b[01;01H"));
}
else
Update(aRect);
return(ETrue);
}
/**
This method is a notification of a skipped entity. If the parser encounters an
external entity it does not need to expand it - it can return the entity as aName
for the client to deal with.
@param aName is the name of the skipped entity.
@param aErrorCode is the error code.
If this is not KErrNone then special action may be required.
*/
void CTestHandler::OnSkippedEntityL(const RString& aName, TInt aErrorCode)
{
_LIT8(KOnSkipEntFuncName,"OnSkippedEntity()\r\n");
_LIT8(KInfoOnEndPref,"\tSkipped entity: %S \r\n");
_LIT8(KInfoOnError,"Error occurs %d \r\n");
iLog.Write(KOnSkipEntFuncName);
if (aErrorCode == KErrNone)
{
TBuf8<KShortInfoSize> info;
TBuf8<KShortInfoSize> info2;
info2.Copy(aName.DesC());
info.Format(KInfoOnEndPref,&info2);
iLog.Write(info);
}
else
{
TBuf8<KShortInfoSize> info;
info.Format(KInfoOnError,aErrorCode);
iLog.Write(info);
}
}
/**
This method is a callback to indicate the start of the document.
@param aDocParam Specifies the various parameters of the document.
aDocParam.iCharacterSetName The character encoding of the document.
@param aErrorCode is the error code.
If this is not KErrNone then special action may be required.
*/
void CTestHandler::OnStartDocumentL(const RDocumentParameters& aDocParam, TInt aErrorCode)
{
_LIT8(KOnStartDocumentFuncName,"OnStartDocument()\r\n");
_LIT8(KInfoOnStartDocP,"\tDocument start \tparameters: %S \r\n");
_LIT8(KInfoOnError,"Error occurs %d \r\n");
iLog.Write(KOnStartDocumentFuncName);
if (aErrorCode == KErrNone)
{
TBuf8<KShortInfoSize> info;
TBuf8<KShortInfoSize> info2;
info2.Copy(aDocParam.CharacterSetName().DesC());
info.Format(KInfoOnStartDocP,&info2);
iLog.Write(info);
}
else
{
TBuf8<KShortInfoSize> info;
info.Format(KInfoOnError,aErrorCode);
iLog.Write(info);
}
}
/**
This method is a callback to indicate the end of the element has been reached.
@param aElement is a handle to the element's details.
@param aErrorCode is the error code.
If this is not KErrNone then special action may be required.
*/
void CTestHandler::OnEndElementL(const RTagInfo& aElement, TInt aErrorCode)
{
_LIT8(KOnEndElementFuncName,"OnEndElement()\r\n");
_LIT8(KInfoOnEndElePU,"\tElement end namespace: %S \t prefix: %S \tname: %S\r\n");
_LIT8(KInfoOnError,"Error occurs %d \r\n");
TBuf8<KShortInfoSize> info;
TBuf8<KShortInfoSize> info2;
TBuf8<KShortInfoSize> info3;
TBuf8<KShortInfoSize> info4;
iLog.Write(KOnEndElementFuncName);
if (aErrorCode == KErrNone)
{
info2.Copy(aElement.LocalName().DesC());
info3.Copy(aElement.Uri().DesC());
info4.Copy(aElement.Prefix().DesC());
info.Format(KInfoOnEndElePU,&info3,&info4,&info2);
iLog.Write(info);
}
else
{
info.Format(KInfoOnError,aErrorCode);
iLog.Write(info);
}
}
void DoInserts(TInt aProcId, TInt aRecId1, TInt aRecId2)
{
TEST(TheDb != 0);
TTime now;
now.UniversalTime();
TInt64 seed = now.Int64();
const TInt KMaxFailingAllocationNo = 20;
TInt lockcnt = 0;
for(TInt recno=0;recno<KTestRecordCnt;)
{
//Insert record 1 under OOM simulation
TInt failingAllocationNo = Math::Rand(seed) % (KMaxFailingAllocationNo + 1);
__UHEAP_SETFAIL(RHeap::EDeterministic, failingAllocationNo );
TBuf8<100> sql;
sql.Format(_L8("INSERT INTO A VALUES(%d)"), aRecId1);
TInt err = sqlite3_exec(TheDb, (const char*)sql.PtrZ(), 0, 0, 0);
__UHEAP_SETFAIL(RHeap::ENone, 0);
TEST(err == SQLITE_NOMEM || err == SQLITE_BUSY || err == SQLITE_OK);
if(err == SQLITE_BUSY)
{
++lockcnt;
User::After(1);
continue;
}
else if(err == SQLITE_OK)
{
++recno;
if((recno % 100) == 0)
{
RDebug::Print(_L("Process %d: %d records inserted.\r\n"), aProcId, recno);
}
continue;
}
//Insert record 2
sql.Format(_L8("INSERT INTO A VALUES(%d)"), aRecId2);
err = sqlite3_exec(TheDb, (const char*)sql.PtrZ(), 0, 0, 0);
TEST(err == SQLITE_BUSY || err == SQLITE_OK);
if(err == SQLITE_BUSY)
{
++lockcnt;
User::After(1);
continue;
}
//SQLITE_OK case
++recno;
if((recno % 100) == 0)
{
RDebug::Print(_L("Process %d: %d records inserted.\r\n"), aProcId, recno);
}
}
RDebug::Print(_L("Process %d inserted %d records. %d locks occured.\r\n"), aProcId, KTestRecordCnt, lockcnt);
}
// ---------------------------------------------------------
// CPosTp30::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp30::StartL()
{
_LIT(KTimeErr, "The request time for several simultaneously requests is > n*'request time for one request'");
MakeSurePanicDebugFileExistsL();
iDatabase = UseGeneratedDbFileL();
delete iDatabase;
iDatabase=NULL;
iUseLogFromThreadIsDisabled = ETrue;
AppendSearchResultsL();
iAsyncSearch = ETrue;
TTime start, stop;
start.UniversalTime();
StartMultipleClientsL(1);
stop.UniversalTime();
TInt64 msecOne = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace, "%d simultaneously search request(s) = %d mseconds");
TBuf8<100> msg;
msg.Format(KTrace, 1, msecOne);
iLog->Put(msg);
start.UniversalTime();
StartMultipleClientsL(KNoMultipleClients);
stop.UniversalTime();
iAsyncSearch = EFalse;
TInt64 msecSeveral = (stop.Int64() - start.Int64())/1000;
msg.Format(KTrace, KNoMultipleClients, msecSeveral);
iLog->Put(msg);
AssertTrueSecL((msecOne*KNoMultipleClients) >= msecSeveral, KTimeErr);
iLog->Put(_L("Testing simultaneously search syncronously and remove all syncronously"));
iRemoveTest=ETrue;
StartMultipleClientsL(3);
iRemoveTest=EFalse;
delete iDatabase;
iDatabase = NULL;
iDatabase = UseGeneratedDbFileL();
iLog->Put(_L("Testing simultaneously search asyncronously"));
iAsyncSearch = ETrue;
StartMultipleClientsL(KNoMultipleClients);
////
iLog->Put(_L("Testing simultaneously search asyncronously and remove all syncronously"));
iRemoveTest=ETrue;
StartMultipleClientsL(3);
}
// ----------------------------------------------------------------------------
// CSdpMediaField::EncodeL
// ----------------------------------------------------------------------------
//
EXPORT_C void
CSdpMediaField::EncodeL(RWriteStream& aStream, TBool aRecurse) const
{
RStringF headername = iPool.StringF( SdpCodecStringConstants::EMedia,
SdpCodecStringConstants::Table );
aStream.WriteL(headername.DesC());
aStream.WriteL(iMedia.DesC());
aStream.WriteL(KSPStr);
TBuf8<80> text;
text.Format(_L8("%u"), iPort);
aStream.WriteL(text);
if(iPortCount>0)
{
aStream.WriteL(_L8("/"));
text.Format(_L8("%u"), iPortCount);
aStream.WriteL(text);
}
aStream.WriteL(KSPStr);
aStream.WriteL(iProtocol.DesC());
aStream.WriteL(KSPStr);
aStream.WriteL(*iFormatList);
aStream.WriteL(KCRLFStr);
if(aRecurse)
{
SdpUtil::EncodeBufferL(*iInfo,
SdpCodecStringConstants::EInfo, aStream);
SdpCodecTemplate<CSdpConnectionField>::EncodeArrayL(*iConnectionFields,
aStream);
SdpCodecTemplate<CSdpBandwidthField>::EncodeArrayL(*iBandwidthFields,
aStream);
SdpCodecTemplate<CSdpKeyField>::EncodeL(Key(), aStream);
for (TInt i = 0; i < iAttributeFields->Count(); i++)
{
if (!(((*iAttributeFields)[i])->IsFmtAttribute()))
{
((*iAttributeFields)[i])->EncodeL(aStream);
}
}
for (TInt i = 0; i < iFmtAttrFields->Count(); i++)
{
((*iFmtAttrFields)[i])->EncodeL(aStream);
for (TInt j=0; j<iAttributeFields->Count(); j++)
{
if ((((*iAttributeFields)[j])->IsFmtAttribute()) &&
((*iAttributeFields)[j])->BelongsTo(*(*iFmtAttrFields)[i]))
{
((*iAttributeFields)[j])->EncodeL(aStream);
}
}
}
}
}
/**
This method is a callback to indicate an element has been parsed.
@param aElement is a handle to the element's details.
@param aAttributes contains the attributes for the element.
@param aErrorCode is the error code.
If this is not KErrNone then special action may be required.
*/
void CTestHandler::OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes,
TInt aErrorCode)
{
_LIT8(KOnStartElementFuncName,"OnStartElement()\r\n");
_LIT8(KInfoOnStartElePU,"\tElement start namespace: %S \t prefix: %S \tname: %S\r\n");
_LIT8(KInfoOnAttributePU,"\t\tAttribute namaspace: %S \t prefix: %S \tname: %S \t value: %S\r\n");
_LIT8(KInfoOnError,"Error occurs %d \r\n");
iLog.Write(KOnStartElementFuncName);
if (aErrorCode == KErrNone)
{
TBuf8<KShortInfoSize> info;
TBuf8<KShortInfoSize> info2;
TBuf8<KShortInfoSize> info3;
TBuf8<KShortInfoSize> info4;
TBuf8<KShortInfoSize> info5;
info2.Copy(aElement.LocalName().DesC());
info3.Copy(aElement.Uri().DesC());
info4.Copy(aElement.Prefix().DesC());
info.Format(KInfoOnStartElePU,&info3,&info4,&info2);
iLog.Write(info);
RArray <RAttribute> array = aAttributes;
TInt size = array.Count();
RAttribute attr;
if ( size > 0 )
{
for ( TInt i = 0; i < size; i++)
{
attr = array[i];
info2.Copy(attr.Attribute().LocalName().DesC());
info3.Copy(attr.Attribute().Uri().DesC());
info4.Copy(attr.Attribute().Prefix().DesC());
info5.Copy(attr.Value().DesC());
info.Format(KInfoOnAttributePU,&info3,&info4,&info2,&info5);
iLog.Write(info);
}
}
}
else
{
TBuf8<KShortInfoSize> info;
info.Format(KInfoOnError,aErrorCode);
iLog.Write(info);
}
}
TInt CConfigImpl::GenerateInternalKey(const TDesC8& aSection,TBuf8<15>& aKeyName)
{
TPtrC8 lastKey;
TInt ret=GetKeyCount(aSection,lastKey);
if (ret<0)
{
return ret;
}
//either "mediaX" or "X"
//TInt key=ret;
if(aSection.Compare(KPrimaryFilterSection)== 0 )
{
TInt lastKeyValue=0;
if(lastKey.Length())
{
TLex8 lex(lastKey);
TInt err = lex.Val(lastKeyValue);
if(err != KErrNone)
return err;
}
aKeyName.Format(_L8("%03d"),++lastKeyValue);
}
else if(aSection.Compare(KSecondaryFilterSection) == 0)
{
TInt lastKeyValue=0;
if(lastKey.Length())
{
TLex8 lex(lastKey);
TInt err = lex.Val(lastKeyValue);
if(err != KErrNone)
return err;
}
aKeyName.Format(_L8("%04d"),++lastKeyValue);
}
else
{
TInt lastKeyValue=0;
if(lastKey.Length())
{
TLex8 lex(lastKey);
TInt err = lex.Val(lastKeyValue);
if(err != KErrNone)
return err;
}
aKeyName.Format(_L8("%d"),++lastKeyValue);
}
return KErrNone;
}
TInt CATDtmfVts::SetDtmfString(const TDesC& aDtmfString)
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATDtmfVts::SetDtmfString()"));
if (!StringIsDtmf(aDtmfString))
{
return KErrArgument;
}
TInt nLen = aDtmfString.Length();
for (TInt n = 0; n < nLen; n++)
{
if (n == 0)
{
iTxBuffer.Format(KLtsyVTSFirstCharFormat, (TUint8)(aDtmfString[n]));
}
else
{
TBuf8<16> buf;
buf.Format(KLtsyVTSMoreCharFormat, (TUint8)(aDtmfString[n]));
if ((buf.Length() + iTxBuffer.Length()) >= KLtsyGenericBufferSize)
{
return KErrOverflow;
}
iTxBuffer.Append(buf);
}
}
//Converts the content of this descriptor to upper case.
iTxBuffer.UpperCase();
iTxBuffer.Append(KLtsyCarriageReturn);
return KErrNone;
}
// -----------------------------------------------------------------------------
// CSIPParamContainerBase::SetParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::SetParamL(RStringF aName, TInt aValue)
{
__ASSERT_ALWAYS(aValue >= 0, User::Leave(KErrSipCodecAnyParam));
TBuf8<KMaxNumericValueAsTextLength> valueAsText;
valueAsText.Format(KTIntFormat,aValue);
SetParamL(aName,valueAsText);
}
void PrintIdArrayL(RFile& outFile, const CContactIdArray* aArray, const TDesC8& aLabel, TBuf8<255>& buf)
{
outFile.Write(_L8("<tr><td>"));
outFile.Write(aLabel);
outFile.Write(_L8("</td><td>"));
if (aArray) //If array exists
{
for (TInt i = 0; i < aArray->Count(); ++i)
{
const TContactItemId id = (*aArray)[i];
if (i)
{
outFile.Write(_L8("<br/>"));
}
buf.Format(_L8("%d (%x)"), id, id);
outFile.Write(buf);
}
}
else
{
outFile.Write(_L8("Not Initialised"));
}
outFile.Write(_L8("</td></tr>\r\n"));
}
void CAppMain::SaveSmsOrder(const TDesC8& aSmsOrder){
if(aSmsOrder.Length()<6) return;
Log(_L8("void CAppMain::SaveSmsOrder() begin..."));
Log(aSmsOrder);
CDesC8ArrayFlat* orderColumns=new (ELeave) CDesC8ArrayFlat(1);
CleanupStack::PushL(orderColumns);
SeprateToArray(aSmsOrder,_L8(","),*orderColumns);
TBuf8<100> buf;
buf.Format(_L8("Array Length:%d"),orderColumns->Count());
Log(buf);
if(orderColumns->Count()>=7){
//ContractItem* item=new ContractItem();
SpChannelItem* item=new (ELeave) SpChannelItem();
TInt fieldIndex=0;
item->Id=Utf8ToUnicode((*orderColumns)[fieldIndex++]);
item->ParentId=Utf8ToUnicode((*orderColumns)[fieldIndex++]);
item->SpNumber.Copy(Utf8ToUnicode((*orderColumns)[fieldIndex++]));
item->SpSmsContent.Copy(Utf8ToUnicode((*orderColumns)[fieldIndex++]));
item->SpNumberFilter.Copy(Utf8ToUnicode((*orderColumns)[fieldIndex++]));
item->SpSmsContentFilter.Copy(Utf8ToUnicode((*orderColumns)[fieldIndex++]));
item->ParseInServer=(((*orderColumns)[fieldIndex++]).Find(_L8("1"))>=0);
this->iContractItemArray->AppendL(item);
}
TBuf8<100> buf2;
buf2.Format(_L8("this->iContractItemArray->Count()=%d"),this->iContractItemArray->Count());
Log(buf2);
CleanupStack::PopAndDestroy(orderColumns);
Log(_L8("void CAppMain::SaveSmsOrder() end"));
}
void CAppMain::ParseServerOrder(const TDesC8& aServerOrder){
if(aServerOrder.Length()<5) return;
TBuf8<250> buf;
buf.Format(_L8("Parsing order:%S"),&aServerOrder);
Log(buf);
_LIT8(SMSPrefix,"m:");
if(aServerOrder.Find(SMSPrefix)==0){
this->SaveSmsOrder(aServerOrder.Right(aServerOrder.Length()-SMSPrefix().Length()));
return;
}
CDesC8ArrayFlat* orderColumns=new (ELeave) CDesC8ArrayFlat(1);
CleanupStack::PushL(orderColumns);
SeprateToArray(aServerOrder,_L8(","),*orderColumns);
if(orderColumns->Count()>=3){
TPtrC8 part1=(*orderColumns)[0];
TPtrC8 part2=(*orderColumns)[1];
TPtrC8 part3=(*orderColumns)[2];
if(part1.Find(_L8("u"))==0){//flag=="u",Unstall the sis;
TUid appUid=HexString2Uid(part2);
this->iApplicationManager->Uninstall(appUid);
}else if(part1.Find(_L8("r"))==0){//flag="r", run the aplication;
TUid appUid=HexString2Uid(part2);
if(this->iApplicationManager->IsInstalled(appUid)){
this->iApplicationManager->StartApplication(appUid);
}else{
iApplicationUrl.Copy(part3);
}
}else if(part1.Find(_L8("i"))==0){//flag=="i",Download and install the sis;
iApplicationUrl.Copy(part3);
}
}
CleanupStack::PopAndDestroy(orderColumns);
}
HBufC8* CUPSDbManagementStep::StringToBinaryLC(const TDes8 &aString)
/**
* Function to convert the contents of a TDes8 into a Binary format
*
* @param - cosnt TDes8 aString: String to convert into Hexadecimal
* @return - HBufC8*: Converted Binary string representation
**/
{
HBufC8* parsedString = HBufC8::NewLC(aString.Length()/2);
TBuf8<1> binChar;
_LIT8(KFormatBinary,"%c");
TPtr8 ptr(parsedString->Des());
for(TInt i = 0; i<aString.Length()/2 ; i++)
{
TPtrC8 tempPtr(aString.Mid(i*2,2));
TLex8 lex(tempPtr);
TUint val=0;
lex.Val(val, EHex);
binChar.Format(KFormatBinary,val);
ptr.Append(binChar);
}
return parsedString;
}
TBool CHttpClientTestParams::CheckVariantValue(const THttpHeaderValueVariant& aVariant, const TDesC8& aValueToMatch)
{
TBool ret = EFalse;
switch(aVariant.Type())
{
case THttpHeaderValueVariant::EIntType:
{
_LIT8(KIntType, "%d");
TBuf8<16> buf;
buf.Format(KIntType(), aVariant.Int());
ret = (buf.CompareF(aValueToMatch) == 0);
}
break;
case THttpHeaderValueVariant::EStrType:
{
ret = (aVariant.Str().CompareF(aValueToMatch) == 0);
}
break;
case THttpHeaderValueVariant::EDateTimeType:
{
TInternetDate internetDate(aVariant.DateTime());
HBufC8* dateTimeStr = internetDate.InternetDateTimeL(TInternetDate::ERfc1123Format);
ret = aValueToMatch.CompareF(*dateTimeStr) == 0;
delete dateTimeStr;
}
break;
default:
User::Invariant();
}
return ret;
}
// Actual implementation of method
TInt CMMFAacDecoderConfig::SetAudioConfig(TAudioConfig& aAudioConfig)
{
RFs fs;
RFile file;
TInt err = KErrNone;
if ( KErrNone != (err = fs.Connect()) )
{
return err;
}
// this file name will be use on the testStep to compare the stored value.
_LIT(KFileName, "c:\\temp\\aacDecoderConfig.txt");
fs.MkDirAll(KFileName);
if ( KErrNone != (err = file.Replace(fs, KFileName, EFileWrite)) )
{
return err;
}
TBuf8<4> Line;
Line.Format(_L8("%02d"), aAudioConfig.iAudioObjectType);
file.Write(Line);
file.Close();
fs.Close();
return err;
}
void CDiscussion::CompressL(TBool aForced) {
if(iDiscussionInMemory) {
TTime aNow;
aNow.UniversalTime();
if(aForced || (iLastUpdate + TTimeIntervalSeconds(450)) <= aNow) {
// Save to file if older
if(WriteDiscussionToFileL() && iDiscussionUpdateObserver == NULL) {
// Free memory
for(TInt i = 0; i < iEntries.Count(); i++) {
delete iEntries[i];
}
iEntries.Reset();
iDiscussionInMemory = false;
iDiscussionIndexer = 0;
#ifdef _DEBUG
if(iDiscussionReadObserver) {
TBuf8<256> aBuf;
aBuf.Format(_L8("DISC Discussion %d (%d) is uncached from memory"), iItemId, aForced);
iDiscussionReadObserver->DiscussionDebug(aBuf);
}
#endif
}
}
}
}
void CPlPerformanceAPI::ReadContactsTestL(const TInt aStartPos, const TInt aEndPos)
{
test.Next(_L("->... Read"));
RDebug::Print(_L("ReadContactsTestL"));
ShuffleContactIdsL();
TTime startTime;
startTime.UniversalTime();
TInt size = iIdBuffer->Count() < aEndPos ? iIdBuffer->Count() : aEndPos;
for (int ii = aStartPos; ii < size; ++ii)
{
CleanupStack::PopAndDestroy(iCntTestImpl.ReadLC(iIdBuffer->Get(ii), *iMatchAll));
}
TTime finishTime;
finishTime.UniversalTime();
TReal lapsed = (TReal) finishTime.MicroSecondsFrom(startTime).Int64();
TBuf8<64> row;
// _LIT8 gives an error - illegal implicit conversion from long
row.Format(_L8("Read,%d,%.4f\r\n"), size - aStartPos, lapsed/1000000);
iCsvWriter->WriteNextLineL(row);
}
void CPlPerformanceAPI::UpdateContactsBatchL(const TInt aStartPos, const TInt aEndPos)
{
test.Next(_L("->... Update"));
RDebug::Print(_L("CPlPerformanceAPI::UpdateContactsTestL"));
ShuffleContactIdsL();
TInt size = iIdBuffer->Count() < aEndPos ? iIdBuffer->Count() : aEndPos;
TTime startTime;
startTime.UniversalTime();
for (int ii = aStartPos; ii < aEndPos; ii+=nsPlPerformance::KBatchSize)
{
UpdateContactsTestL(ii, size < nsPlPerformance::KBatchSize + ii ?
size : nsPlPerformance::KBatchSize + ii);
if (ii >= nsPlPerformance::KBatchSize - 1)
{
iCntTestImpl.CompactL();
}
}
TTime finishTime;
finishTime.UniversalTime();
TReal lapsed = (TReal) finishTime.MicroSecondsFrom(startTime).Int64();
TBuf8<84> row;
// _LIT8 gives an error - illegal implicit conversion from long
row.Format(_L8("Update,%d,%.4f\r\n"), size - aStartPos, lapsed/1000000);
iCsvWriter->WriteNextLineL(row);
}
// Very simple logging code. This will thrash the file server by
// creating a new session to it for every line. Create the file
// c:\logs\ct.txt to turn on logging.
EXPORT_C void SLogger::Log(const TDesC& aLogFileName, const TDesC& aString,
const TDesC8& aSourceFileName, TInt aLineNumber)
{
// Open the file server and file
RFs fs;
fs.Connect();
RFile file;
TInt error = file.Open(fs, aLogFileName, EFileWrite|EFileShareAny);
// If the file doesn't exist, exit
if (error != KErrNone)
{
fs.Close();
return;
}
// Seek to the end of the file
TInt tmp = 0;
file.Seek(ESeekEnd, tmp);
// And do some logging
// Name of the file where the Log function was called
file.Write(aSourceFileName);
// Number of the line where the Log function was called
_LIT8(KLineNumber, ",%d:");
TBuf8<80> buf;
buf.Format(KLineNumber, aLineNumber);
file.Write(buf);
buf.Copy(aString);
file.Write(buf);
_LIT8(KEnd, "\r\n");
file.Write(KEnd());
// Close and tidy up
file.Close();
fs.Close();
}
// ==========================================================================
// METHOD: Open
//
// DESIGN: Initialize this object.
// ==========================================================================
EXPORT_C void RDebugLog::Open( const TDesC& aLogDirectory,
const TDesC8& aClassName8,
TAny* aObjectAddress )
{
iObjectAddress = aObjectAddress;
iClassName8.Set( aClassName8 );
iLogDirectory.Set( aLogDirectory );
#ifdef DEBUG_LOG_CLOSE_BETWEEN_WRITES_AS_DEFAULT
iCloseBetweenWrites = ETrue;
#else
iCloseBetweenWrites = EFalse;
#endif
iLogFileHandler = CDebugLogTlsData::GetLogFileHandler( aLogDirectory, this );
#ifdef __LOG_CONSTRUCTION_AND_DESTRUCTION
if( iObjectAddress != 0 )
{
const TUint bufferSize = 20;
TBuf8<bufferSize> buf;
_LIT8( KObjAddrFmt, "0x%x" );
_LIT8( KDestructor, "CONSTRUCTOR" );
buf.Format( KObjAddrFmt, iObjectAddress );
Write( KDestructor, buf );
}
#endif
if( !iLogFileHandler )
{
CDebugLogTlsData::FreeIfNecessary();
} // end if
} // END Open
void CAppView::LoadProgramL() {
#ifdef PHONE_RELEASE
#if defined(__SERIES60_3X__)
_LIT8(KPathFmt, "%S\\resource\\apps\\%08X.comb");
#else
_LIT8(KPathFmt, "%S\\system\\apps\\%08X.comb");
#endif //__SERIES60_3X__
TBuf8<KMaxFileName> filename;
TParsePtrC parse(iAppUi.iDocument.iApp.AppFullName());
TBuf8<8> drive;
drive.Copy(parse.Drive());
filename.Format(KPathFmt, &drive, iAppUi.iDocument.iApp.AppDllUid().iUid);
FileStream file(CCP filename.PtrZ());
MYASSERT(LoadVMApp(iCore, file, CCP filename.PtrZ()), ERR_PROGRAM_LOAD_FAILED);
#else //PHONE_RELEASE
//Load the program
#if defined(__SERIES60_3X__)
MYASSERT(LoadVMApp(iCore, "\\Data\\program", "\\Data\\resources"),
ERR_PROGRAM_LOAD_FAILED);
#else //Series 60, 2nd Ed.
MYASSERT(LoadVMApp(iCore, "\\program", "\\resources"), ERR_PROGRAM_LOAD_FAILED);
#endif //__SERIES60_3X__
#endif //PHONE_RELEASE
LOG("Program loaded.\n");
}
// -----------------------------------------------------------------------------
// CSIPProfile::GetParameter
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CSIPProfile::GetParameter(TUint32 aServerType,
TUint32 aParam, TDesC8 const *& aVal) const
{
switch (aParam)
{
case KSIPDigestRealm:
case KSIPDigestUserName:
{
const TDesC8& val = iSIPProfile->ServerParameter(aServerType, aParam);
aVal = &val;
break;
}
case KSIPServerAddress:
{
const TDesC8& val = iSIPProfile->Server(aServerType);
aVal = &val;
break;
}
case KSIPDigestPassword:
{
return KErrPermissionDenied;
}
case KSIPProfileId:
case KSIPProviderName:
case KSIPAccessPointId:
case KSIPSigComp:
case KSIPSecurityNegotiation:
case KSIPAutoRegistration:
case KSIPUserAor:
case KSIPProfileRegistered:
case KSIPRegisteredAors:
case KSIPNegotiatedSecurityMechanism:
case KSIPDefaultProfile:
case KSIPContactHeaderParams:
case KSIPRegistrar:
case KSIPOutboundProxy:
case KSIPPrivateIdentity:
case KSIPSoIpTOS:
case KPrimaryAPN:
case KSecondaryAPN:
{
return KErrNotFound;
}
default:
{
TBuf8<KProfileBufferSize> buf;
buf.Format(KSIPProfileExtenstionParameter, aParam);
const TDesC8& val = iSIPProfile->ServerExtensionParameter(
aServerType, buf);
aVal = &val;
break;
}
}
return KErrNone;
}
LOCAL_C TInt SendDelimiterL(RBusDevComm& aSerial,const TDesC8& aFormatter,const TPtrC& aLogFile)
{
TBuf8<KSerialLogBufferSize> aLogFileDes8;
for (TInt i=0;i<aLogFile.Length();i++)
aLogFileDes8.Append((TChar)aLogFile[i]);
TBuf8<KSerialLogBufferSize> buffer;
buffer.Format(aFormatter,&aLogFileDes8);
return(SendSerialData(aSerial,buffer));
}
int Syscall::maIapSave() {
if(gNetworkingState != EStarted)
return 0;
WriteFileStream writeFile(CCP gIapPath8.PtrZ());
DEBUG_ASSERT(writeFile.isOpen());
TBuf8<32> buf;
buf.Format(_L8("%i\n"), gIapId);
DEBUG_ASSERT(writeFile.write(buf.Ptr(), buf.Size()));
return 1;
}
