/*
* 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 );
    }