int main()
{
int retval =ESuccess;
wstring des;
__UHEAP_MARK;
RBuf8 buf;
buf.Create(10);
buf.Copy((TUint8 *)"Hello", 5);
buf.CleanupClosePushL();
//int size =15;
retval = Rbuf8ToWstring(buf, des );
int rbuf_len = buf.Length();
int string_len = des.length();
if (retval ==ESuccess && rbuf_len == string_len && rbuf_len == 5 && string_len == 5)
{
printf("test rbuf8towstring boundary2 Passed\n");
}
else
{
assert_failed = true;
printf("test rbuf8towstring boundary2 Failed\n");
}
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("test_rbuf8towstring_boundary2");
return 0;
}
int main()
{
__UHEAP_MARK;
int retval =ESuccess;
wchar_t* mywcharstring = NULL;
RBuf8 myRBuf;
myRBuf.CreateL(10);
myRBuf.CleanupClosePushL();
retval = WcharToRbuf8 (mywcharstring, myRBuf);
if (retval == EInvalidPointer)
{
printf("wchartorbuf8 negative1 Passed\n");
}
else
{
assert_failed = true;
printf("wchartorbuf8 negative1 Failed\n");
}
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("test_wchartorbuf8_negative1");
return 0;
}
int main()
{
__UHEAP_MARK;
RBuf8 myrbuf;
TBufC8<5> myTBufC (_L8("hello"));
myrbuf.Create(myTBufC);
myrbuf.CleanupClosePushL();
char *des= new char[5];
int retval=ESuccess;
int size=5;
retval= Rbuf8ToChar(myrbuf,des,size);
if(retval ==ESuccess)
{
printf("Test_rbuf8tochar_minsize passed\n");
}
else
{
assert_failed = true;
printf("Test_rbuf8tochar_minsize FAILURE\n");
}
delete[] des;
des=NULL;
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("Test_rbuf8tochar_minsize");
return 0;
}
void CSifTransportServer::ConstructL(const TDesC& aServerName, TInt aShutdownPeriodUs)
/**
Second-phase construction initializes the superclass and
starts the server.
*/
{
// Define a key (KSifOperationKey) which would be used to notify the client of any new operations.
TInt ret = RProperty::Define(KUidSystemCategory, KSifOperationKey, RProperty::EByteArray, KSecurityPolicyWDD, KSecurityPolicyNone,(sizeof(TInt) * KMaxNumberOfOperations));
if (ret != KErrAlreadyExists && ret != KErrNone)
{
User::Leave(ret);
}
if(ret == KErrNone)
{
// Create a empty CSifOperationKey object and publish it.
CSifOperationKey* nullKey = CSifOperationKey::NewL();
CleanupStack::PushL(nullKey);
RBuf8 nullKeyBuffer;
nullKeyBuffer.CleanupClosePushL();
ExternalizeRefObjectL(*nullKey, nullKeyBuffer);
User::LeaveIfError(RProperty::Set(KUidSystemCategory, KSifOperationKey, nullKeyBuffer));
CleanupStack::PopAndDestroy(2, nullKey);
}
CScsServer::ConstructL(aShutdownPeriodUs);
StartL(aServerName);
}
// ---------------------------------------------------------------------------
// Data request from CatalogsPCConnectivityPlugin
// First ask the size from server, then give correct size CBufFlat
// ---------------------------------------------------------------------------
//
void RCatalogsPCConnectivityClient::GetDataL(
TDataType& aMimeType, CBufFlat& aData )
{
TPckgBuf<TInt> pckgSize;
TPckgBuf<TDataType> pckgMIME;
User::LeaveIfError( SendReceive(
ECatalogsPCConnectivityGetSize,
TIpcArgs( &pckgMIME, &pckgSize ) ) );
TInt size = pckgSize();
aMimeType = pckgMIME();
RBuf8 desData;
desData.CreateL( size );
desData.CleanupClosePushL();
User::LeaveIfError( SendReceive(
ECatalogsPCConnectivityGetData,
TIpcArgs( &desData ) ) );
aData.Reset();
aData.ExpandL( 0, size );
aData.Write( 0, desData, size );
CleanupStack::Pop(); //desData
desData.Close();
}
int main()
{
__UHEAP_MARK;
RBuf8 myrbuf;
TBufC8<20> myTBufC (_L8(""));
myrbuf.Create(myTBufC);
myrbuf.CleanupClosePushL();
wchar_t * des= new wchar_t [20];
int size=20;
int retval =ESuccess;
retval= Rbuf8ToWchar(myrbuf,des,size);
if(retval == EDescriptorNoData)
{
printf("Test_rbuf8towchar_nodata passed\n");
}
else
{
assert_failed = true;
printf("Test_rbuf8towchar_nodata FAILURE\n");
}
delete[] des;
des = NULL;
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("test_rbuf8towchar_nodata");
return 0;
}
int main()
{
__UHEAP_MARK;
int retval =ESuccess;
char* mycharstring = "Hello Char String";
int char_length= strlen(mycharstring);
RBuf8 myRBuf;
myRBuf.CreateL(30);
myRBuf.CleanupClosePushL();
retval = CharToRbuf8 (mycharstring, myRBuf);
int buf_len = myRBuf.Length();
if (retval ==ESuccess &&\
char_length == buf_len &&\
strncmp("Hello Char String",(char*)myRBuf.Ptr() , 17) ==0 )
{
printf("CharToRbuf8 content check Passed\n");
}
else
{
assert_failed = true;
printf("CharToRbuf8 content check Failed\n");
}
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("test_chartorbuf8_content_check");
return 0;
}
// ---------------------------------------------------------------------------
// Data package from CatalogsPCConnectivityPlugin
// ---------------------------------------------------------------------------
//
void RCatalogsPCConnectivityClient::PutDataL(
const TDataType& aMimeType, const CBufFlat& aData )
{
TInt size = aData.Size();
RBuf8 desData;
desData.CreateL( size );
desData.CleanupClosePushL();
aData.Read( 0, desData, size );
TPckgBuf<TDataType> pckgMIME( aMimeType );
User::LeaveIfError( SendReceive(
ECatalogsPCConnectivityPutData,
TIpcArgs( &pckgMIME, &desData, size ) ) );
CleanupStack::Pop(); //desData
desData.Close();
}
QNdefMessage QNFCNdefUtility::CNdefMsg2QNdefMsgL( const CNdefMessage& msg )
{
BEGIN
QNdefMessage result;
LOG("CNdefMessage size is "<<msg.SizeL());
HBufC8* newBuf = HBufC8::NewL(msg.SizeL());
RBuf8 buf;
buf.Assign(newBuf);
buf.CleanupClosePushL();
LOG("export msg to raw data");
msg.ExportRawDataL(buf,0);
LOG("import raw data to msg");
QByteArray qtArray;
qtArray.append(reinterpret_cast<const char*>(newBuf->Ptr()),newBuf->Size());
result = QNdefMessage::fromByteArray(qtArray);
CleanupStack::PopAndDestroy(&buf);
END
return result;
}
/** Adds a child part to this part and set the content to the same content stored in the input file handle
/param aProperties the headers of the newly added part
/param aFile file handle that contains the content.
/note This method leaves with KErrNotSupported if it is NOT multi-part, i.e. this part
already has content.
*/
EXPORT_C CMsgStoreMessagePart* CMsgStoreMessagePart::AddChildPartL( const CMsgStorePropertyContainer& aProperties,
RFile& aFile )
{
RBuf8 serializedProperties;
serializedProperties.CleanupClosePushL();
aProperties.SerializeL( serializedProperties );
TInt partId = iContext.iSession.CreateContainerL( Id(),
KMsgStoreInvalidId, //do not check grand parent id
iMailBoxId,
EMsgStorePartBits,
serializedProperties,
ETrue,
aFile );
CMsgStoreMessagePart* part = CMsgStoreMessagePart::NewL( iContext, partId, Id(), iMailBoxId, serializedProperties );
CleanupStack::PopAndDestroy( &serializedProperties );
return part;
}
void CDnsUpdateOption::ToStringL(RBuf8& aBuf8) const
/**
* Writes DNS update option data to a string suitable for sending out
* on to the network
*
* @internalTechnology
*
*/
{
RBuf8 encodedDomainName;
encodedDomainName.CleanupClosePushL();
TDomainNameArray domainNames;
CleanupClosePushL(domainNames);
domainNames.AppendL(iDomainName);
CDomainNameCodec* domainNameEncoder = new(ELeave) CDomainNameCodec();
CleanupStack::PushL(domainNameEncoder);
domainNameEncoder->EncodeL(domainNames, encodedDomainName);
CleanupStack::PopAndDestroy(domainNameEncoder);
CleanupStack::PopAndDestroy(&domainNames); // closes the RBuf8
aBuf8.Zero();
aBuf8.ReAllocL( 3 + encodedDomainName.Length() );
aBuf8.Append((TChar)(iFlags.Value()));
aBuf8.Append((TChar)iRCode1);
aBuf8.Append((TChar)iRCode2);
aBuf8.Append(encodedDomainName);
CleanupStack::PopAndDestroy(&encodedDomainName); // closes the array
}
int main()
{
__UHEAP_MARK;
int retval =ESuccess;
wchar_t* mywcharstring = L"Hello Widechar String";
RBuf8 myRBuf;
myRBuf.CreateL(50);
myRBuf.CleanupClosePushL();
retval = WcharToRbuf8(mywcharstring, myRBuf);
if (retval ==ESuccess)
{
printf("wchartorbuf8 positive1 Passed\n");
}
else
{
assert_failed = true;
printf("wchartorbuf81 Failed\n");
}
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("test_wchartorbuf8_positive1");
return 0;
}
TVerdict CBigSendRecvRtp::doTestStepL()
/**
* @return - TVerdict code
*/
{
SetTestStepResult(EFail);
if(KErrNone == InitSocketsL())
{
iIpAddrDest1.SetPort(9000);
RBuf8 sendBuf;
sendBuf.CreateMax(KBufferSize1);
sendBuf.CleanupClosePushL();
RBuf8 recvBuf;
recvBuf.CreateMax(KBufferSize1);
recvBuf.CleanupClosePushL();
/* Fill the buffer with given character upto its length */
sendBuf.Fill('Q');
TRequestStatus status;
/* do a Send of the data */
iRtpSocket.SendTo(sendBuf, iIpAddrDest1, NULL, status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
/* Now do a Receive */
recvBuf.FillZ();
iRtpSocket.RecvFrom(recvBuf,iIpAddrDest1,NULL,status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
/* Obtain a TPtr of the data excluding the RTP header */
TPtr8 sendBufPtr = sendBuf.MidTPtr(KRtpHeaderSize);
TPtr8 recvBufPtr = recvBuf.MidTPtr(KRtpHeaderSize);
/* Check if the data received is the same as the data sent */
TInt ret = sendBufPtr.Compare(recvBufPtr);
if(ret == 0)
{
/* Increase the buffer size and fill it up with given data */
sendBuf.ReAlloc(KBufferSize2);
recvBuf.ReAlloc(KBufferSize2);
sendBuf.Fill('Q', KBufferSize2);
/* Send the larger data */
iRtpSocket.SendTo(sendBuf, iIpAddrDest1, NULL, status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
/* Now do a Receive */
recvBuf.FillZ(KBufferSize2);
iRtpSocket.RecvFrom(recvBuf,iIpAddrDest1,NULL,status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
/* Get pointer to data and compare both of them */
TPtr8 sendBufPtr = sendBuf.MidTPtr(KRtpHeaderSize);
TPtr8 recvBufPtr = recvBuf.MidTPtr(KRtpHeaderSize);
TInt ret = sendBufPtr.Compare(recvBufPtr);
if(ret == 0)
{
SetTestStepResult(EPass);
}
}
CleanupStack::PopAndDestroy(2);
}
return TestStepResult();
}
// ---------------------------------------------------------------------------
// CRoHandlerDMgrWrapper::DoSaveRoapTriggerL
// ---------------------------------------------------------------------------
//
void CRoHandlerDMgrWrapper::DoSaveRoapTriggerL( TMeterState aNextState )
{
// Check success of download
DRMDEBUG2(
RoHdlrDMgrWrDebugLiterals::KFormatDoDlHdlRoapTrigL(),
&RoHdlrDMgrWrDebugLiterals::KStrDlFinished() );
try
{
// Fetch download created in DoDownloadRoapTriggerL
QString downloadUrl((QChar*)iTriggerUrl->Des().Ptr(),iTriggerUrl->Length());
//uncomment
iDownload = NULL; //iDlMgr->findDownload( downloadUrl );
}
catch(const std::exception& exception)
{
qt_symbian_exception2LeaveL(exception);
}
// Delete trigger URL so that it is possible to check
// whether or not meteringResponse has PrUrl.
delete iTriggerUrl;
iTriggerUrl = NULL;
RFile roapTrigger;
if ( !iDownloadSuccess )
{
if ( iConnectionError )
{
User::Leave( KErrCouldNotConnect );
}
else
{
User::Leave( KErrGeneral );
}
}
User::LeaveIfError( roapTrigger.Open( iFs, *iFileName, EFileShareReadersOrWriters ) );
CleanupClosePushL( roapTrigger );
// Get filehandle of ROAP trigger
const TInt KReadBufSize = 512;
RBuf8 readBuf;
readBuf.CleanupClosePushL();
readBuf.CreateL( KReadBufSize );
// Read file to buffer
TInt triggerFileSize( 0 );
User::LeaveIfError( roapTrigger.Size( triggerFileSize ) );
if ( iTriggerBuf )
{
delete iTriggerBuf;
iTriggerBuf = NULL;
}
iTriggerBuf = HBufC8::NewL( triggerFileSize );
User::LeaveIfError( roapTrigger.Read( readBuf, KReadBufSize ) );
iTriggerBuf->Des().Copy( readBuf );
while ( readBuf.Length() == KReadBufSize )
{
User::LeaveIfError( roapTrigger.Read( readBuf, KReadBufSize ) );
iTriggerBuf->Des().Append( readBuf );
}
// And let ROAP handle it...
CleanupStack::PopAndDestroy( &readBuf );
CleanupStack::PopAndDestroy( &roapTrigger );
iFs.Delete( *iFileName );
delete iFileName;
iFileName=NULL;
Continue( aNextState, KErrNone );
}
// second-phase constructor
void CServerCrashDataSource::ConstructL()
{
LOG_MSG("->CServerCrashDataSource::ConstructL()\n" );
// Get the debug func block and make appropriate changes to our structures
TInt err;
TUint32 bufsize = 0;
LOG_MSG( " -> iSecSess->GetDebugFunctionalityBufSize( &bufsize )\n" );
err = iSecSess.GetDebugFunctionalityBufSize( &bufsize );
if( (err != KErrNone) || (0 == bufsize) )
{
// No debug functionality block, cannot do much without that.
LOG_MSG2("CServerCrashDataSource::ConstructL() - unable to get debug functionality block! err:%d\n", err);
User::Leave( KErrNotSupported );
}
RBuf8 DFBlock;
DFBlock.CreateL(bufsize);
DFBlock.CleanupClosePushL();
LOG_MSG2( " -> HBufC8::NewLC( bufsize=%d )\n", bufsize );
LOG_MSG("CServerCrashDataSource::ConstrucL -> GetDebugFunctionality()\n" );
err = iSecSess.GetDebugFunctionality(DFBlock);
if( KErrNone != err )
{
LOG_MSG( "CServerCrashDataSource::ConstructL() : ERROR !* : Could not retrieve debug functionality block\n" );
User::Leave( KErrNotSupported );
}
LOG_MSG( " -> GetDebugHeader( EDF_TagHdrId_RegistersCore )\n" );
TTagHeader * hdr = GetDebugHeader( ETagHeaderIdRegistersCore, DFBlock );
if( hdr == NULL )
{
LOG_MSG( "Could not retrieve ETagHeaderIdRegistersCore register debug block\n" );
}
else if( 0 == hdr->iNumTags )
{
LOG_MSG( "Zero tags found for ETagHeaderIdRegistersCore register debug block\n" );
}
else
{
iRegisterList.ReserveL( (TInt)hdr->iNumTags );
// Skip the header to get to the tags
TUint8 * ptr = ((TUint8 *) hdr) + sizeof( TTagHeader );
TTag * tag = (TTag *) ptr;
TRegisterData regData;
TRegisterData * reg = ®Data;
// Process all the register tags
for( TInt regIdx = 0; regIdx < hdr->iNumTags; regIdx ++ )
{
reg->iRegClass = 0; // Core = 0
reg->iId = tag->iTagId; //
reg->iSubId = 0; //
reg->iSize = 2; // Should all be 32 bits == 2.
reg->iAvailable = ETrue;
reg->iValue64 = 0;
iRegisterList.Append( *reg );
tag++;
}
}
hdr = GetDebugHeader( ETagHeaderIdMemory, DFBlock );
if( hdr == NULL )
{
LOG_MSG( "Could not retrieve ETagHeaderIdMemory. Cannot read memory\n" );
iMaxMemReadSize = 0;
}
else if( 0 == hdr->iNumTags )
{
LOG_MSG( "Zero tags found for ETagHeaderIdMemory register debug block\n" );
iMaxMemReadSize = 0;
}
else
{
TTag* tag = GetTag( hdr, EMemoryMaxBlockSize );
if( tag )
{
//LOG_MSG2( " EMemoryMaxBlockSize =0x%X\n", tag->iValue );
iMaxMemReadSize = tag->iValue;
}
}
iLastThreadListSize = 1;
iLastProcListSize = 1;
iLastRegListSize = 1;
CleanupStack::PopAndDestroy(&DFBlock);
}
void CServerCrashDataSource::SetRegValuesL( const TUint64 aThreadId, RRegisterList &aRegisterList )
{
LOG_MSG2("->CServerCrashDataSource::SetRegValuesL(aThreadId=%Lu)\n", aThreadId);
TInt numberOfRegisters = aRegisterList.Count();
RBuf8 ids;
ids.CreateL( numberOfRegisters * sizeof(TFunctionalityRegister) );
ids.CleanupClosePushL();
TInt totalByteSize = 0; // Keeps track of the number of bytes that we are requesting
for( TInt i=0; i < numberOfRegisters; i++ )
{
TRegisterInfo reg = (TRegisterInfo)( aRegisterList[i].iId );
// iSize = (0 == 1 byte); (3 == 8 bytes)
TInt byteSize = (aRegisterList[i].iSize) << 1;
totalByteSize += byteSize;
ids.Append( reinterpret_cast<const TUint8*>(®), sizeof(TRegisterInfo) );
}
RBuf8 registerValues;
registerValues.CreateL( totalByteSize );
registerValues.CleanupClosePushL();
RBuf8 registerFlags;
registerFlags.CreateL( numberOfRegisters );
registerFlags.CleanupClosePushL();
LOG_MSG("CServerCrashDataSource::SetRegValuesL - reading registers\n");
User::LeaveIfError(iSecSess.ReadRegisters( aThreadId, ids, registerValues, registerFlags ));
// Now copy the values back to the array and mark the availability from the flags
TUint8* valuePtr = (TUint8*) registerValues.Ptr();
for( TInt i=0; i < numberOfRegisters; i++ )
{
TRegisterData & reg = aRegisterList[i];
switch( reg.iSize )
{
case 0:
reg.iValue8 = *((TUint8 *)valuePtr);
valuePtr += 1;
break;
case 1:
reg.iValue16 = *((TUint16 *)valuePtr);
valuePtr += 2;
break;
case 2:
reg.iValue32 = *((TUint32 *)valuePtr);
valuePtr += 4;
break;
case 3:
reg.iValue64 = *((TUint64 *)valuePtr);
valuePtr += 8;
break;
}
if( EValid == registerFlags[i] )
{
reg.iAvailable = ETrue;
}
else
{
reg.iAvailable = EFalse;
}
}
CleanupStack::PopAndDestroy(®isterFlags);
CleanupStack::PopAndDestroy(®isterValues);
CleanupStack::PopAndDestroy(&ids);
}
void ScrShotsGenUtils::DumpJsFileL(CScrShotsSettings* scrShotsSettings)
{
CGetImei* getImei = CGetImei::NewL();
CleanupStack::PushL(getImei);
RBuf8 formatBuf;
formatBuf.Create(256);
formatBuf.CleanupClosePushL();
TFileName infoFile;
User::LeaveIfError(CEikonEnv::Static()->FsSession().PrivatePath(infoFile));
infoFile.Append( KDeviceJSFile );
TParsePtrC parse((CEikonEnv::Static()->EikAppUi()->Application())->AppFullName());
infoFile.Insert(0, KCDriveWithColon);
RFs fsConn;
User::LeaveIfError(fsConn.Connect());
CleanupClosePushL(fsConn);
RFile jsFile;
if(BaflUtils::FileExists(fsConn, infoFile)){
BaflUtils::DeleteFile(fsConn, infoFile);
}
//now create the file
User::LeaveIfError(jsFile.Create(fsConn, infoFile, EFileWrite));
CleanupClosePushL(jsFile);
// User::LeaveIfError(jsFile.Write(KFunctionBlockStart));
RBuf8 values;
values.Create(256);
for(int i = 0; i < KDeviceParamsCount ; i++){
formatBuf.Zero();
TInt sizeOfItem = User::StringLength((TText8 *)DeviceParams [i]);
TPtr8 item((unsigned char*)DeviceParams [i],sizeOfItem ,sizeOfItem );
switch(i){
//device_model
case 0:{
CDeviceTypeInformation* devInfo = SysUtil::GetDeviceTypeInfoL();
CleanupStack::PushL(devInfo);
TPtrC manufName, modelCode, modelName;
devInfo->GetManufacturerName(manufName);
devInfo->GetModelCode(modelCode);
devInfo->GetModelName(modelName);
RBuf8 manufName8, modelName8, modelCode8;
manufName8.Create(128); modelName8.Create(128); modelCode8.Create(128);
manufName8.CleanupClosePushL(); modelName8.CleanupClosePushL(); modelCode8.CleanupClosePushL();
manufName8.Copy(manufName);
modelName8.Copy(modelName);
modelCode8.Copy(modelCode);
values.Format(KModelNameFormatString, &manufName8, &modelName8, &modelCode8);
CleanupStack::PopAndDestroy(4);
break;
}
//firmware_version
case 1:{
RBuf swVersion;
swVersion.Create(128);
SysUtil::GetSWVersion(swVersion);
values.Copy(swVersion);
TInt pos = 0;
while((pos = values.Find(_L8("\n"))) != KErrNotFound){
//values.Delete(pos,1);
values.Replace(pos,1,_L8("_"));
}
swVersion.Close();
break;
}
//ram_info
case 2:{
TInt totalram= 0;
HAL::Get(HALData::EMemoryRAM, totalram);
totalram /= 1024;
values.Num(totalram);
break;
}
//uptime
case 3:{
TTimeIntervalMicroSeconds32 iTickPeriod;
UserHal::TickPeriod(iTickPeriod);
TUint tickCount = User::TickCount();
TUint noOfTicksPerSecond = (1000 * 1000) / iTickPeriod.Int();
TInt noOfSecsSinceStartUp = tickCount / noOfTicksPerSecond;//noOfMicroSecsSinceStartup / (1000 * 1000);
values.Num(noOfSecsSinceStartUp);
break;
}
//scrshot count
case 4:{
values.Num(scrShotsSettings->TotalScrShotCount());
break;
}
//symbian version
case 5:{
TVersion epocver = User::Version();
values.Copy(epocver.Name());
break;
}
//series 60 version
case 6:{
VersionInfo::TPlatformVersion platformVersion;
VersionInfo::GetVersion(platformVersion);
TInt aMajor = platformVersion.iMajorVersion;
TInt aMinor = platformVersion.iMinorVersion;
values.Format(_L8("%d.%d"),aMajor, aMinor);
break;
}
//country code
case 7:{
TLocale loc;
int code = loc.CountryCode();
values.Num(code);
break;
}
//imei hash
case 8:{
TBuf8<256> inputimei;
TBuf8<256> outimeihash;
if(getImei->IsImeiFetched()){
getImei->GetImei(inputimei);
GetWhirlPoolHash(outimeihash,inputimei);
values.Copy(outimeihash);
}
}
break;
}
formatBuf.Format(KStringVariableDeclaration,
&item,
&values);
TRACE_ON(RDebug::Printf((const char*)formatBuf.PtrZ()));
jsFile.Write(formatBuf);
}
values.Close();
CleanupStack::PopAndDestroy(4);
//TODO: This code should be commented in final release build
#if BRAHMA_DEBUG
//code to copy the js file just created to the c:\ so that it can be analyzed
_LIT(KTargetFileName, "c:\\device_info.js");
BaflUtils::CopyFile(CEikonEnv::Static()->FsSession(),infoFile, KTargetFileName);
#endif
}
