/*
* Copyright (c) 2005 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: CXcapCacheIndex
*
*/
// INCLUDE FILES
#include "ServerDefines.h"
#include "XcapCacheIndex.h"
#include "XcapCacheServer.h"
#include "XcapCacheIndexEntry.h"
// ----------------------------------------------------------
// CXcapCacheIndex::CXcapCacheIndex
//
// ----------------------------------------------------------
//
CXcapCacheIndex::CXcapCacheIndex()
{
}
// ----------------------------------------------------------
// CXcapCacheIndex::NewL
//
// ----------------------------------------------------------
//
CXcapCacheIndex* CXcapCacheIndex::NewL()
{
CXcapCacheIndex* self = new( ELeave ) CXcapCacheIndex();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
// ----------------------------------------------------------
// CXcapCacheIndex::ConstructL
//
// ----------------------------------------------------------
//
void CXcapCacheIndex::ConstructL()
{
TInt length = 0;
RFile index = InitialiseIndexL();
CleanupClosePushL( index );
User::LeaveIfError( index.Size( length ) );
if( length > 0 )
{
HBufC8* data = HBufC8::NewLC( length );
TPtr8 pointer( data->Des() );
User::LeaveIfError( index.Read( pointer ) );
ReadEntriesL( pointer );
CleanupStack::PopAndDestroy(); //data
}
CleanupStack::PopAndDestroy(); //index
}
// ----------------------------------------------------------
// CXcapCacheIndex::InitialiseIndexL
//
// ----------------------------------------------------------
//
RFile CXcapCacheIndex::InitialiseIndexL()
{
RFile ret;
TUid process = RProcess().Identity();
#ifdef _DEBUG
CXcapCacheServer::WriteToLog( _L8( "CXcapCacheIndex::InitialiseIndexL() - Process: %x" ), process ) ;
#endif
TInt error = ret.Open( CXcapCacheServer::FileSession(), KCacheServerIndex,
EFileShareExclusive | EFileRead | EFileWrite );
if( error != KErrNone )
{
if( error == KErrPathNotFound )
User::LeaveIfError( CXcapCacheServer::FileSession().MkDirAll( KCacheServerRoot ) );
User::LeaveIfError( ret.Create( CXcapCacheServer::FileSession(), KCacheServerIndex,
EFileShareExclusive | EFileRead | EFileWrite ) );
}
return ret;
}
// ----------------------------------------------------------
// CXcapCacheIndex::~CXcapCacheIndex
//
// ----------------------------------------------------------
//
CXcapCacheIndex::~CXcapCacheIndex()
{
iEntryList.ResetAndDestroy();
iEntryList.Close();
}
// ----------------------------------------------------------
// CXcapCacheIndex::ConstructL
//
// ----------------------------------------------------------
//
TInt CXcapCacheIndex::UpdateIndexL( const CXcapCacheIndexEntry* aEntry )
{
if( aEntry != NULL )
{
User::LeaveIfError( iEntryList.Append( aEntry ) );
return iEntryList.Find( aEntry );
}
else return KErrNotFound;
}
// ----------------------------------------------------------
// CXcapCacheIndex::Entry
//
// ----------------------------------------------------------
//
CXcapCacheIndexEntry* CXcapCacheIndex::Entry( TInt aIndex ) const
{
TInt count = iEntryList.Count();
CXcapCacheIndexEntry* entry = NULL;
if( count > 0 && aIndex >= 0 && aIndex < count )
entry = iEntryList[aIndex];
return entry;
}
// ----------------------------------------------------------
// CXcapCacheIndex::EntryCount
//
// ----------------------------------------------------------
//
TInt CXcapCacheIndex::EntryCount() const
{
return iEntryList.Count();
}
// ----------------------------------------------------------
// CXcapCacheIndex::Compare
//
// ----------------------------------------------------------
//
TInt CXcapCacheIndex::Compare( const CXcapCacheIndexEntry& aFirst,
const CXcapCacheIndexEntry& aSecond )
{
if( aFirst.LastModified() == aSecond.LastModified() )
return 0;
else if( aFirst.LastModified() > aSecond.LastModified() )
return 1;
else return -1;
}
// ----------------------------------------------------------
// CXcapCacheIndex::SortEntries
//
// ----------------------------------------------------------
//
void CXcapCacheIndex::SortEntriesL()
{
TLinearOrder<CXcapCacheIndexEntry> order( CXcapCacheIndex::Compare );
iEntryList.Sort( order );
#ifdef _DEBUG
TPtrC8 entryDesc;
TInt count = iEntryList.Count();
CXcapCacheServer::WriteToLog( _L8( "CXcapCacheIndex::SortEntriesL()" ) );
CXcapCacheServer::WriteToLog( _L8( "------------------------------------------" ) );
CXcapCacheServer::WriteToLog( _L8( " Sorted list:" ) );
for( TInt i = 0;i < count;i++ )
{
HBufC* buffer = NULL;
buffer = CXcapCacheServer::DateTimeL( iEntryList[i]->LastModified() );
TBuf8<KDateTimeMaxSize> printBuffer( _L8( " " ) );
printBuffer.AppendFormat( _L8( "%d: " ), i );
printBuffer.Append( *buffer );
CXcapCacheServer::WriteToLog( printBuffer );
}
CXcapCacheServer::WriteToLog( _L8( "------------------------------------------" ) );
#endif
}
// ----------------------------------------------------------
// CXcapCacheIndex::RemoveEntry
//
// ----------------------------------------------------------
//
void CXcapCacheIndex::RemoveEntry( TInt aIndex )
{
TInt count = iEntryList.Count();
if( count > 0 && aIndex >= 0 && aIndex < count )
{
CXcapCacheIndexEntry* entry = iEntryList[aIndex];
iEntryList.Remove( aIndex );
delete entry;
entry = NULL;
}
}
// ----------------------------------------------------------
// CXcapCacheIndex::ReadEntriesL
//
// ----------------------------------------------------------
//
void CXcapCacheIndex::ReadEntriesL( TPtr8& aIndexData )
{
TBool finished = EFalse;
while( !finished && aIndexData.Length() > 0 )
{
//If we find that there is still more data, but no \r\n
//to denote the end of an entry, simply quit. The data
//format has most probably been corrupted at some point.
TInt entryIndex = aIndexData.FindF( KIndexFileEndOfLine );
if( entryIndex > 0 )
{
TPtr8 entryData = CXcapCacheServer::DescriptorCast(
aIndexData.Left( entryIndex ) );
CXcapCacheIndexEntry* entry = CXcapCacheIndexEntry::NewL( entryData );
CleanupStack::PushL( entry );
User::LeaveIfError( iEntryList.Append( entry ) );
CleanupStack::Pop();
aIndexData.Delete( 0, entryIndex + 2 );
}
else finished = ETrue;
}
}
// ----------------------------------------------------------
// CXcapCacheIndex::ConstructL
//
// ----------------------------------------------------------
//
void CXcapCacheIndex::StoreCacheDataL()
{
RFile index;
TInt count = iEntryList.Count();
if( count > 0 )
{
User::LeaveIfError( index.Replace( CXcapCacheServer::FileSession(),
KCacheServerIndex, EFileWrite ) );
CleanupClosePushL( index );
for( TInt i = 0;i < count;i++ )
{
CXcapCacheIndexEntry* entry = iEntryList[i];
HBufC8* entryData = entry->PrintLC();
if( entryData )
{
User::LeaveIfError( index.Write( entryData->Des() ) );
CleanupStack::PopAndDestroy(); //entryData
}
}
CleanupStack::PopAndDestroy(); //index
}
else
{
CFileMan* manager = CFileMan::NewL( CXcapCacheServer::FileSession() );
manager->Delete( KCacheServerIndex );
delete manager;
manager = NULL;
}
}