/*

* 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:   CXcapCacheServer

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32math.h>

#include <flogger.h>

#include <centralrepository.h>

#include <XdmEngineDomainCRKeys.h>

#include "XcapCacheIndex.h"

#include "XcapCacheServer.h"

#include "XcapCacheSession.h"

#include "XcapCacheIndexAdmin.h"

#include "XcapCacheServerMain.h"

GLDEF_C void PanicServer( TXcapCacheServerPanic aPanic )

    {

    _LIT( KCacheServerPanic, "XcapCacheServer");

    User::Panic( KCacheServerPanic, aPanic );

    }

// ----------------------------------------------------------

// CXcapCacheServer::New

// 

// ----------------------------------------------------------

//

CServer2* CXcapCacheServer::NewLC()

    {

    CXcapCacheServer* self = new CXcapCacheServer( EPriorityHigh );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ----------------------------------------------------------

// CXcapCacheServer::New

// 

// ----------------------------------------------------------

//

void CXcapCacheServer::ConstructL()

    {

    ReadMaxCacheSizeL();

    User::LeaveIfError( iFileSession.Connect() );

    StartL( KXcapCacheServerLib );

    iShutdownTimer.ConstructL();

    iShutdownTimer.Start();

    }

// ----------------------------------------------------------

// CXcapCacheServer::NewSessionL

// 

// ----------------------------------------------------------

//

CSession2* CXcapCacheServer::NewSessionL( const TVersion& aVersion,

        								  const RMessage2& /*aMessage*/ ) const

    {

    // Check version number of API against our known version number.

    TVersion thisVersion( KCacheServerMajorVersionNumber,

                          KCacheServerMinorVersionNumber,

                          KCacheServerBuildVersionNumber );

    if( !User::QueryVersionSupported( thisVersion, aVersion ) ) 

        User::Leave( KErrNotSupported );

    return CXcapCacheSession::NewL( ( CXcapCacheServer* )this );

    }

// ----------------------------------------------------------

// CXcapCacheServer::CXcapCacheServer

// 

// ----------------------------------------------------------

//

CXcapCacheServer::~CXcapCacheServer()

    {

    iFileSession.Close();

    }

// ----------------------------------------------------------

// CXcapCacheServer::ReadMaxCacheSizeL

// 

// ----------------------------------------------------------

//

void CXcapCacheServer::ReadMaxCacheSizeL()

    {

    #ifdef _DEBUG

        CXcapCacheServer::WriteToLog( _L8( "CXcapCacheServer::ReadMaxCacheSizeL()" ) );

    #endif

    CRepository* repository = CRepository::NewL( KCRUIDXDMEngineXcapLocal );

    CleanupStack::PushL( repository );

    TInt error = repository->Get( KXDMXcapCacheSize, iMaxCacheSize );

    //If something went wrong, just use 30 KB as a default value

    if( error != KErrNone )

        {

        #ifdef _DEBUG

            CXcapCacheServer::WriteToLog( _L8( "Reading from CenRep failed: %d => Default to 30 KB" ), error );

        #endif

        iMaxCacheSize = 30000;

        }

    else

        {

        #ifdef _DEBUG

            CXcapCacheServer::WriteToLog( _L8( "  Max cache size is %d KB" ), iMaxCacheSize );

        #endif  

        iMaxCacheSize = iMaxCacheSize * 1000;

        }

    CleanupStack::PopAndDestroy();  //repository

    }

// ----------------------------------------------------------

// CXcapCacheServer::CXcapCacheServer

// 

// ----------------------------------------------------------

//

CXcapCacheServer::CXcapCacheServer( TInt aPriority ) : CServer2( aPriority )

    {

    }

// ----------------------------------------------------------

// CXcapCacheServer::AddSession

//

// ----------------------------------------------------------

//

void CXcapCacheServer::AddSession()

    {

    #ifdef _DEBUG

        CXcapCacheServer::WriteToLog( _L8( "CXcapCacheServer::AddSession()" ) );

    #endif

	++iSessionCount;

	iShutdownTimer.Cancel();

    }

// ----------------------------------------------------------

// CXcapCacheServer::DropSession

// 

// ----------------------------------------------------------

//

void CXcapCacheServer::DropSession()

    {

    #ifdef _DEBUG

        CXcapCacheServer::WriteToLog( _L8( "CXcapCacheServer::DropSession()" ) );

    #endif

	if( --iSessionCount == 0 )

		CActiveScheduler::Stop();

    }

// ----------------------------------------------------------

// CXcapCacheServer::ConvertDesc

// 

// ----------------------------------------------------------

//

TInt CXcapCacheServer::ConvertDesc( const TDesC8& aNumberDesc )

    {

    TInt ret = 0;

    TLex8 lex( aNumberDesc );

    TInt error = lex.Val( ret );

    return error == KErrNone ? ret : error;

    }

// ---------------------------------------------------------

// CXcapCacheServer::DateL

// 

// ---------------------------------------------------------

//

HBufC* CXcapCacheServer::DateL()

    {

    TTime time;

    TBuf<KDateMaxSize> dateBuffer;

    dateBuffer.SetLength( 0 );

    time.HomeTime();

    time.FormatL( dateBuffer, KCacheDateFormat );

    HBufC* heapDate = dateBuffer.AllocL();

    return heapDate;

    }

// ---------------------------------------------------------

// CXcapCacheServer::DateTimeL

// 

// ---------------------------------------------------------

//

HBufC* CXcapCacheServer::DateTimeL()

    {

    TTime time;

    TBuf<KDateMaxSize> dateBuffer;

    time.HomeTime();

    time.FormatL( dateBuffer, KDateFormatFileName );

    TBuf<KDateMaxSize> timeBuffer;

    time.HomeTime();

    time.FormatL( timeBuffer, KTimeFormatFileName );

    TBuf<KDateTimeMaxSize> buffer;

    buffer.SetLength( 0 );

    buffer.Copy( dateBuffer );

    buffer.Append( timeBuffer );

    HBufC* ret = HBufC::NewL( buffer.Length() );

    ret->Des().Copy( buffer );

    return ret;

    }

// ---------------------------------------------------------

// CXcapCacheServer::DateTimeL

// 

// ---------------------------------------------------------

//

HBufC* CXcapCacheServer::DateTimeL( const TTime& aTime )

    {

    TBuf<KDateTimeMaxSize> dateTimeBuffer;

    aTime.FormatL( dateTimeBuffer, KDateTimeFormat );

    HBufC* heapDateTime = dateTimeBuffer.AllocL();

    return heapDateTime;

    }

// ----------------------------------------------------------

// CXcapCacheServer::MaxCacheSize

// 

// ----------------------------------------------------------

//

TInt CXcapCacheServer::MaxCacheSize() const

    {

    return iMaxCacheSize;

    }

// ---------------------------------------------------------

// CXcapCacheServer::CacheSize

// 

// ---------------------------------------------------------

//

TInt CXcapCacheServer::CacheSize( TInt& aEntryCount )

    {

    #ifdef _DEBUG

	    CXcapCacheServer::WriteToLog( _L8( "CXcapCacheServer::CacheSize()" ) );

	#endif

    TInt total = 0;

    TInt entryCount = 0;

    CDir* directory = NULL;

    User::LeaveIfError( iFileSession.GetDir( KCacheServerRoot, KEntryAttNormal,

                                             ESortNone, directory ) );

    CleanupStack::PushL( directory );

    entryCount = directory->Count();

    for( TInt i = 0;i < entryCount;i++ )

        total = total + ( *directory )[i].iSize;

    #ifdef _DEBUG

	    CXcapCacheServer::WriteToLog( _L8( " Entries:    %d " ), entryCount );

	    CXcapCacheServer::WriteToLog( _L8( " Total size: %d bytes" ), total );

	#endif

	CleanupStack::PopAndDestroy();

	aEntryCount = entryCount;

	return total;

    }

// ---------------------------------------------------------

// CXcapCacheServer::RandomStringL

// 

// ---------------------------------------------------------

//

HBufC* CXcapCacheServer::RandomStringL()

    {

    const TInt charCount( sizeof( KRandomStringCharArray ) / sizeof( TInt ) );

    TBuf<KRandStringLength> buffer;

    buffer.Zero();

    for( TInt i = 0; i < KRandStringLength;i++ )

        {

        TInt index = Math::Random() % charCount;

        buffer.Append( ( TChar )KRandomStringCharArray[index] );

        }

    HBufC* randomHeapBuffer = buffer.AllocL();

    return randomHeapBuffer;

    }

// ---------------------------------------------------------

// CXcapCacheServer::TimeL

// 

// ---------------------------------------------------------

//

HBufC* CXcapCacheServer::TimeL()

    {

    TTime time;

    TBuf<KDateMaxSize> timeBuffer;

    timeBuffer.SetLength( 0 );

    time.HomeTime();

    time.FormatL( timeBuffer, KCacheTimeFormat );

    HBufC* heapTime = timeBuffer.AllocL();

    return heapTime;

    }

// ---------------------------------------------------------

// CXcapCacheServer::DescriptorCast

//

// ---------------------------------------------------------

//

TPtr8 CXcapCacheServer::DescriptorCast( const TDesC8& aConstData )

	{

    TInt length = aConstData.Length();

    TPtr8 constCast( CONST_CAST( TUint8*, aConstData.Ptr() ), length, length );

    constCast.TrimAll();

    return constCast;

	}

// ----------------------------------------------------

// CXcapCacheServer::FileSession

// 

// ----------------------------------------------------

//

RFs& CXcapCacheServer::FileSession()

    {

    return FsSession;

    }

// ----------------------------------------------------

// CXcapCacheServer::FileSession

// 

// ----------------------------------------------------

//

CXcapCacheIndex* CXcapCacheServer::Index()

    {

    return CacheIndex;

    }

// ----------------------------------------------------

// CXcapCacheServer::FileSession

// 

// ----------------------------------------------------

//

CXcapCacheIndexAdmin* CXcapCacheServer::IndexAdmin()

    {

    return CacheIndexAdmin;

    }

// ----------------------------------------------------

// CXcapCacheServer::StartThreadL

// 

// ----------------------------------------------------

//

EXPORT_C TInt CXcapCacheServer::StartThreadL()

    {

    User::LeaveIfError( User::RenameThread( KXcapCacheServerName ) );

    CActiveScheduler* scheduler = new ( ELeave ) CActiveScheduler;

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    User::LeaveIfError( FsSession.Connect() );

    CleanupClosePushL( FsSession );

    CXcapCacheServer::NewLC();

    CacheIndex = CXcapCacheIndex::NewL();

    CleanupStack::PushL( CacheIndex );

    CacheIndexAdmin = CXcapCacheIndexAdmin::NewL();

    CleanupStack::PushL( CacheIndexAdmin );

    RProcess::Rendezvous( KErrNone );

    #ifdef _DEBUG

        CXcapCacheServer::WriteToLog( _L8( "XcapCacheServer fully running" ) );

    #endif

    CActiveScheduler::Start();

    #ifdef _DEBUG

        CXcapCacheServer::WriteToLog( _L8( "XcapCacheServer closing..." ) );

    #endif

    CleanupStack::PopAndDestroy( 5 );  //CacheIndexAdmin, CacheIndex, server, FsSession, scheduler

    return KErrNone;

    }

// ----------------------------------------------------

// CXcapCacheServer::WriteToLog

// 

// ----------------------------------------------------

//

EXPORT_C void CXcapCacheServer::WriteToLog( TRefByValue<const TDesC8> aFmt,... )

    {

    VA_LIST list;

    VA_START( list, aFmt );

    TBuf8<KServerLogBufferMaxSize> buf;

    buf.FormatList( aFmt, list );

    RFileLogger::Write( KCacheServerLogDir, KCacheServerLogFile, EFileLoggingModeAppend, buf );

    RDebug::RawPrint( buf );

    }