void CEmTubePlaylistEntry::ImportL( RFileReadStream& aStream )
{
TInt l = aStream.ReadInt32L();
if( l )
{
iLocation = HBufC::NewL( l );
TPtr pLocation( iLocation->Des() );
aStream.ReadL( pLocation, l );
}
else
{
iLocation = KNullDesC().AllocL();
}
l = aStream.ReadInt32L();
if( l )
{
iName = HBufC::NewL( l );
TPtr pName( iName->Des() );
aStream.ReadL( pName, l );
}
else
{
iName = KNullDesC().AllocL();
}
iPlayCount = aStream.ReadInt32L();
iType = (TEmTubePlaylistEntryType)aStream.ReadInt32L();
TReal t = aStream.ReadReal64L();
iTime = TTime( Int64( t ) );
}
/**
Reads the input config file created by sysstart_apparc_setup.bat and returns the
test case number (Defined in sysstart_apparc_run.bat)
@return TInt - the test case number
*/
TInt CSysStartApparcTestCase::ReadConfigFileL()
{
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFileReadStream reader;
User::LeaveIfError(reader.Open(fs, KApparcConfigFile, EFileRead));
CleanupClosePushL(reader);
TChar delimChar('=');
TBuf8<255> aDes;
reader.ReadL(aDes, delimChar);
//Read in a two character representation of a number and convert to an integer
TChar result1(reader.ReadInt8L());
TChar result0(reader.ReadInt8L());
TInt aTestCase = result1.GetNumericValue()*10 + result0.GetNumericValue();
// clean-up
CleanupStack::PopAndDestroy(2, &fs);
return aTestCase;
}
// ---------------------------------------------------------------------------
// Restore the file from given directory and given index
// ---------------------------------------------------------------------------
//
EXPORT_C CXIMPApiEventBase* CXIMPTestFileTool::PluginRestoreLC(
TInt aObjIndex )
{
HBufC* fileName = GetFileNameLC(
KFileToolPluginDirBase,
aObjIndex );
// try to instantiate it
RFileReadStream in;
CleanupClosePushL( in );
in.Open( iFs, *fileName, EFileStream );
TInt len = in.ReadUint32L();
HBufC8* buffer = HBufC8::NewLC( len );
TPtr8 ptr = buffer->Des();
in.ReadL( ptr );
// instantiate the object
TInt32 dummy = 0;
CXIMPApiEventBase* object = XIMPEventCodec::UnPackL( *buffer, dummy );
CleanupStack::PopAndDestroy( 2 ); // buffer, in
// delete the just read object
iFs.Delete( *fileName );
CleanupStack::PopAndDestroy( fileName );
CleanupStack::PushL( object );
return object;
}
void CEmTubePlaylist::ConstructL( RFileReadStream& aStream )
{
TInt l = aStream.ReadInt32L();
if( l )
{
iName = HBufC::NewL( l );
TPtr pName( iName->Des() );
aStream.ReadL( pName, l );
}
else
{
iName = KNullDesC().AllocL();
}
iType = (TEmTubePlaylistType)aStream.ReadInt32L();
iFlags = aStream.ReadInt32L();
TInt count = aStream.ReadInt32L();
for(TInt i=0;i<count;i++)
{
CEmTubePlaylistEntry* e = CEmTubePlaylistEntry::NewLC();
e->ImportL( aStream );
iEntries.AppendL( e );
CleanupStack::Pop( e );
}
}
// -----------------------------------------------------------------------------
// RDRMRightsClient::URIFileToArrayL
// Converts the given file into an array.
// -----------------------------------------------------------------------------
//
void RDRMRightsClient::URIFileToArrayL( RFs& aFs,
const TDesC& aFile,
RPointerArray< HBufC8 >& aList )
{
DRMLOG( _L( "RDRMRightsClient::URIFileToArrayL" ) );
RFileReadStream stream;
TUint16 size = 0;
TPtr8 data( NULL, 0, 0 );
User::LeaveIfError( stream.Open( aFs, aFile, EFileRead | EFileStream ) );
CleanupClosePushL( stream );
size = stream.ReadUint16L();
while( size > 0 )
{
HBufC8* tmp = HBufC8::NewLC( size );
data.Set( tmp->Des() );
stream.ReadL( data, size );
User::LeaveIfError( aList.Append( tmp ) );
CleanupStack::Pop(); // tmp
size = stream.ReadUint16L();
}
// All read, return.
CleanupStack::PopAndDestroy(); // stream
}
// ----------------------------------------------------------------------------
// CAudioStreamEngine::LoadAudioFileL()
//
// loads the audio data from a file into the buffer
// ----------------------------------------------------------------------------
void CAudioStreamEngine::LoadAudioFileL()
{
RFileReadStream audiofile;
// open file
TFileName fileName;
fileName.Copy(iAudioFilePath);
fileName.Append(iAudioFile);
TInt err = audiofile.Open(iFs, fileName, EFileRead|EFileStream);
iStreamBuffer->Des().FillZ(iFrameCount * iFrameSize); // Empty the stream buffer
if (err==KErrNone)
{
// file opened ok, proceed reading
if (iUseAMR)
{
// Read the AMR header (the first 6 bytes). We don't need to save/use the header,
// since while playback we already know it's an AMR-NB encoded stream.
TBuf8<KAMRHeaderLength> temp;
audiofile.ReadL(temp, KAMRHeaderLength);
}
TUint idx=0;
while (idx < iFrameCount)
{
TRAPD(fstatus, audiofile.ReadL(GetFrame(idx), iFrameSize));
if (fstatus!=KErrNone)
break;
idx++;
}
iStreamStart=0;
iStreamEnd=idx-1;
ShowMessage(_L("CAudioStreamEngine::LoadAudioFileL() Loading complete!"), ETrue);
iBufferOK = ETrue;
}
else
{
// failed to open file
ShowMessage(_L("CAudioStreamEngine::LoadAudioFileL() Error loading audio sample!"), ETrue);
iBufferOK = EFalse;
}
audiofile.Close();
}
TBool CSyntaxTest::LoadResultsL()
{
RFile resultsFile;
TFileName fullPath;
TInt err, fileSize;
HBufC8 *fileInfo;
fullPath.Append(iPath);
fullPath.Append(KResultsFile);
err = resultsFile.Open(iFs, fullPath, EFileRead);
if (err != KErrNone)
{
iConsole.Printf(_L("Error opening results file : "));
iConsole.Printf(fullPath);
iConsole.Printf(_L("\n"));
return(EFalse);
}
CleanupClosePushL(resultsFile);
resultsFile.Size(fileSize);
CleanupStack::PopAndDestroy(); // resultsFile
fileInfo = HBufC8::NewLC(fileSize);
TPtr8 fileInfoPtr(fileInfo->Des());
fileInfoPtr.SetLength(fileSize);
RFileReadStream fileStream;
User::LeaveIfError(fileStream.Open(iFs, fullPath, EFileStream));
CleanupClosePushL(fileStream);
fileStream.ReadL(fileInfoPtr, fileSize);
TLex8 theLex(fileInfoPtr);
CSyntaxResult *syntaxResult = NULL;
do
{
syntaxResult = CSyntaxResult::NewLC();
syntaxResult->SetFilename(theLex.NextToken());
syntaxResult->SetResult(theLex.NextToken());
iExpectedResults->Append(syntaxResult);
CleanupStack::Pop(); // syntaxResult
}
while(!theLex.Eos());
CleanupStack::PopAndDestroy(2); // fileinfo & fileStream
return(ETrue);
};
void CAppfwkAmaStarterTestStepCancel::TestCase1L()
{
// Launch the appropriate AMAStarter(s) via CAmaStart::StartL()
TRequestStatus myRequestStatus;
CAmaStart* amaStart = CAmaStart::NewL();
CleanupStack::PushL(amaStart);
amaStart->Start(TUid::Uid(0x10000017), myRequestStatus);
TEST(myRequestStatus == KRequestPending);
User::After(100000); // Wait for a tenth of a second to give the starter a chance to start something - if the cancel is issued without waiting, nothing is started.
amaStart->CancelStart();
User::WaitForRequest(myRequestStatus);
TEST(myRequestStatus == KErrCancel);
INFO_PRINTF3(_L("CAmaStart->Start(TUid::Uid(0x10000017), &myRequestStatus) finished with request status '%d' (expected '%d')"), myRequestStatus.Int(), KErrCancel);
//Check that the last item in the DSC didn't run
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFileReadStream rs;
TInt ret = rs.Open(fs, KLogFileName, EFileShareExclusive|EFileRead);
if (KErrNone != ret)
{
ERR_PRINTF2(_L("Could not open log file. Leave code: '%d'"), ret);
User::LeaveIfError(ret);
}
rs.PushL();
const TInt KMaxCommandLength = 256;
TBuf<KMaxCommandLength> commandLine;
rs.ReadL(commandLine,1);
TEST(commandLine.Compare(_L("9")) != 0);
INFO_PRINTF2(_L("Checking log result: Expected not '9', Actual '%s'"), &commandLine);
CleanupStack::PopAndDestroy(); //rs
ret = fs.Delete(KLogFileName);
if (KErrNone != ret)
{
ERR_PRINTF2(_L("Could not delete log file. Leave code: '%d'"), ret);
User::LeaveIfError(ret);
}
// clean-up
CleanupStack::PopAndDestroy(2,amaStart); // fs, amaStart
}
EXPORT_C TInt TEFparser::ReadFileLC(RFs& aFs,
const TDesC& aScriptFilepath,
TPtrC& aScriptFileContents )
{
RFile scriptFile;
TInt err = scriptFile.Open(aFs, aScriptFilepath, EFileStream | EFileRead | EFileShareAny);
if (err != KErrNone)
{
return KErrNotFound;
}
// gets size of ini file
TInt size;
scriptFile.Size(size);
scriptFile.Close();
// reads ini into iTestInput
HBufC* scriptFileH16 = HBufC::NewLC(size);
HBufC8* scriptFileH = HBufC8::NewLC(size);
//RBuf scriptFileR;
TPtr8 pInput = scriptFileH->Des();
TPtr pInput16 = scriptFileH16->Des();
pInput.SetLength(size);
RFileReadStream stream;
User::LeaveIfError(stream.Open(aFs, aScriptFilepath, EFileStream | EFileRead | EFileShareReadersOnly));
CleanupClosePushL(stream);
stream.ReadL(pInput,size);
// stream.ReadL(pInput, size);
pInput16.Copy(pInput);
//scriptFileR.Assign(scriptFileH16);
aScriptFileContents.Set(*scriptFileH16);
CleanupStack::PopAndDestroy(2); // stream, testInput
return KErrNone;
}
HBufC8* CValidateTest::ReadFileLC(const TDesC& aFilename)
{
RFile file;
User::LeaveIfError(file.Open(iFs, aFilename, EFileRead));
CleanupClosePushL(file);
TInt size;
file.Size(size);
CleanupStack::PopAndDestroy(1);//fileClose
HBufC8* res = HBufC8::NewLC(size);
TPtr8 p(res->Des());
p.SetLength(size);
RFileReadStream stream;
User::LeaveIfError(stream.Open(iFs, aFilename, EFileStream));
CleanupClosePushL(stream);
stream.ReadL(p, size);
CleanupStack::PopAndDestroy();//streamClose...bleurgh
return res;
}
EXPORT_C TInt CSenLogger::CreateL(TInt aChannel, TInt aLevel, const TDesC& aLogDir, const TDesC& aLogFileName, TFileLoggingMode aMode)
{
TInt index(KErrNotFound);
CSenLogger* pSenLogger = NULL;
TWsTls* tls = (TWsTls*)Dll::Tls();
if( !tls )
{
tls = new (ELeave) TWsTls();
tls->iLogger = NULL;
tls->iProxy = NULL;
Dll::SetTls( tls );
}
pSenLogger = tls->iLogger;
if ( !pSenLogger )
{
pSenLogger = new (ELeave) CSenLogger();
if ( pSenLogger )
{
tls->iLogger = pSenLogger;
pSenLogger->iCount = 0;
//reading the configuration file for the logging levels!!!
/*the file has the following format (IN ANSI)
* ==============================================================================
* LogChannel LogLevel
1000 0
2000 1
.
.
.
.
.
....
18000 2
this means first you need to write the channel followed by the corresponding logging level after a space
the file has to be located under C:\Config.txt
* ==============================================================================*/
TInt res;
RFs fs;
res=fs.Connect();
if(res==KErrNone)
{
RFileReadStream readStream;
res=readStream.Open(fs, KPath, EFileRead|EFileStreamText);
if(res == KErrNone)
{
TInt error;
TInt retVal;
do
{
TBuf8<128> readLineBuf;
TRAP(error, readStream.ReadL(readLineBuf, (TChar)'\n'));
if(error == KErrNone)
{
TInt32 length(0);
length = readLineBuf.Length() ;
TInt *key = new (ELeave) TInt;
TLex8 lexBuf(readLineBuf);
retVal = lexBuf.Val(*key);
if(retVal!=0)
{
delete key;
continue;
}
else
{
TInt *value = new (ELeave) TInt;
lexBuf.SkipSpace();
retVal=lexBuf.Val(*value);
if(retVal==0)
{
retVal = pSenLogger->iMap.Append(key,value);
if(retVal != KErrNone)
{
delete key;
delete value;
}
}
else
{
delete key;
delete value;
}
}
}
}while(error == KErrNone);
readStream.Close();
}
fs.Close();
}
}
else
{
return KErrGeneral;
}
}
else
{
index = pSenLogger->ChannelIndex(aChannel);
}
if (index == KErrNotFound)
{
TInt channelIndex;
TLog* pTLog = new (ELeave) TLog;
CleanupStack::PushL(pTLog);
pTLog->iChannel=aChannel;
channelIndex=pSenLogger->iMap.Find(aChannel);
if(channelIndex==KErrNotFound)
{
pTLog->iLevel=aLevel;
}
else
{
pTLog->iLevel=*(pSenLogger->iMap.ValueAt(channelIndex));
}
pTLog->iCount=1;
pTLog->iLog.Connect();
pTLog->iLog.CreateLog(aLogDir, aLogFileName, aMode);
pTLog->iLog.Write(_L("SenTLSLogger - Log file opened"));
#ifdef EKA
pSenLogger->iLogs.AppendL(pTLog);
#else
User::LeaveIfError(pSenLogger->iLogs.Append(pTLog));
#endif
CleanupStack::Pop(pTLog);
}
else
{
pSenLogger->iLogs[index]->iCount++;
}
pSenLogger->iCount++;
return KErrNone;
}
void CVideoEntry::ImportL( RFileReadStream &aStream )
{
delete iBitmap;
iBitmap = NULL;
delete iScaledBitmap;
iScaledBitmap = NULL;
delete iMediaTitle;
iMediaTitle = NULL;
delete iUrl;
iUrl = NULL;
delete iThumbnailUrl;
iThumbnailUrl = NULL;
delete iThumbnailFile;
iThumbnailFile = NULL;
delete iVideoId;
iVideoId = NULL;
delete iAuthorName;
iAuthorName = NULL;
delete iAuthorUrl;
iAuthorUrl = NULL;
delete iRelatedUrl;
iRelatedUrl = NULL;
delete iAuthorVideosUrl;
iAuthorVideosUrl = NULL;
TInt len;
len = aStream.ReadInt16L();
if( len )
{
iMediaTitle = HBufC::NewL( len );
TPtr tmp(iMediaTitle->Des());
aStream.ReadL(tmp, len);
}
else
{
iMediaTitle = KNullDesC().AllocL();
}
len = aStream.ReadInt16L();
if( len )
{
iUrl = HBufC::NewL( len );
TPtr tmp(iUrl->Des());
aStream.ReadL(tmp, len);
}
else
{
iUrl = KNullDesC().AllocL();
}
len = aStream.ReadInt16L();
if( len )
{
iThumbnailUrl = HBufC::NewL( len );
TPtr tmp(iThumbnailUrl->Des());
aStream.ReadL(tmp, len);
}
else
{
iThumbnailUrl = KNullDesC().AllocL();
}
len = aStream.ReadInt16L();
if( len )
{
iThumbnailFile = HBufC::NewL( len );
TPtr tmp(iThumbnailFile->Des());
aStream.ReadL(tmp, len);
}
else
{
iThumbnailFile = KNullDesC().AllocL();
}
len = aStream.ReadInt16L();
if( len )
{
iVideoId = HBufC::NewL( len );
TPtr tmp(iVideoId->Des());
aStream.ReadL(tmp, len);
}
else
{
iVideoId = KNullDesC().AllocL();
}
len = aStream.ReadInt16L();
if( len )
{
iAuthorName = HBufC::NewL( len );
TPtr tmp(iAuthorName->Des());
aStream.ReadL(tmp, len);
}
else
{
iAuthorName = KNullDesC().AllocL();
}
len = aStream.ReadInt16L();
if( len )
{
iAuthorUrl = HBufC::NewL( len );
TPtr tmp(iAuthorUrl->Des());
aStream.ReadL(tmp, len);
}
else
{
iAuthorUrl = KNullDesC().AllocL();
}
len = aStream.ReadInt16L();
if( len )
{
iRelatedUrl = HBufC::NewL( len );
TPtr tmp(iRelatedUrl->Des());
aStream.ReadL(tmp, len);
}
else
{
iRelatedUrl = KNullDesC().AllocL();
}
len = aStream.ReadInt16L();
if( len )
{
iAuthorVideosUrl = HBufC::NewL( len );
TPtr tmp(iAuthorVideosUrl->Des());
aStream.ReadL(tmp, len);
}
else
{
iAuthorVideosUrl = KNullDesC().AllocL();
}
iThumbnailHeight = aStream.ReadInt32L();
iThumbnailWidth = aStream.ReadInt32L();
iDuration = aStream.ReadInt32L();
iAverageRating = aStream.ReadReal32L();
iViewCount = aStream.ReadInt32L();
}
// ----------------------------------------------------------------------------
// WidgetPreferences::PreferenceL
// Get preference for a key
//
//
// ----------------------------------------------------------------------------
TInt WidgetPreferences::preferenceL( const TDesC& akey, HBufC*& avalue)
{
TInt rSuccess = KErrNotFound;
TInt size = 0;
if ( !m_basepath || (m_basepath->Length() <= 0) )
return rSuccess;
if ( akey.Length() <= KMaxKeyValueSize ) {
HBufC* k = HBufC::NewLC( akey.Length() + KMaxIntLength + 1 );
k->Des().Format( KKeyFormat, m_widgetid, &akey );
PrefElement* pref = m_preferences->Find( *k );
if ( !pref ) {
CleanupStack::PopAndDestroy( k );
return rSuccess;
}
size = pref->valueSize();
if ( size > KMaxKeyValueSize ) {
// return contents from temp file whose name is stored
// in the m_value member of m_preferences
RFs fs;
if ( fs.Connect() == KErrNone ) {
CleanupClosePushL( fs );
HBufC* filePath = HBufC::NewLC( pref->value().Length() );
TPtr fName( filePath->Des() );
fName.Append( pref->value() );
RFileReadStream readStream;
if ( readStream.Open( fs, *filePath, EFileRead ) == KErrNone ) {
CleanupClosePushL( readStream );
TInt len( readStream.ReadInt32L() );
if ( len > 0 ) {
HBufC* v = HBufC::NewLC( len );
TPtr ptrvalue = v->Des();
readStream.ReadL( ptrvalue, len );
avalue = v; // ownership xfered
CleanupStack::Pop( v );
rSuccess = KErrNone;
}
CleanupStack::PopAndDestroy();//readStream
}
CleanupStack::PopAndDestroy( 2 ); //filePath,fs
}
}
else if ( size >= 0 ) {
avalue = pref->value().AllocL();
rSuccess = KErrNone;
}
CleanupStack::PopAndDestroy( k );
}
return rSuccess;
}
