/*

* Copyright (c) 2007 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:  Implementation of CGbaServer

*

*/

#include <e32svr.h>

#include <e32math.h>

#include <s32file.h>

#include "GbaServer.h"

#include "GbaSession.h"

#include "GBALogger.h"

_LIT(KGBAStoreStandardDrive, "C:");

_LIT(KGbaIniFileName, "GbaConf.ini");

const TInt KPrivateFilepathLength = 20; 

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

// CGbaServer::CGbaServer()

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

//

CGbaServer::CGbaServer():CPolicyServer( EPriorityStandard, GBAPolicy, ESharableSessions )

    {

    // Implementation not required

    }

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

// CGbaServer::~CGbaServer()

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

//

CGbaServer::~CGbaServer()

    {

    GBA_TRACE_DEBUG(("CGbaServer::~CGbaServer"));

    }

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

// CGbaServer::NewL()

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

//

CGbaServer* CGbaServer::NewL()

    {

    CGbaServer* self = CGbaServer::NewLC();

    CleanupStack::Pop( self ) ;

    return self;

    }

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

// CGbaServer::NewLC()

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

//

CGbaServer* CGbaServer::NewLC()

    {

    CGbaServer* self = new (ELeave) CGbaServer();

    CleanupStack::PushL( self ) ;

    self->ConstructL() ;

    return self;

    }

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

// CGbaServer::ConstructL()

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

//

void CGbaServer::ConstructL()

    { 

    StartL( KGbaServerName ) ;

    iShutdown.ConstructL();

    if(!iShutdown.IsActive())

        {

        iShutdown.Start();

        }

    }

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

// CGbaServer::ConstructL()

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

//

CSession2* CGbaServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

    {

    GBA_TRACE_DEBUG(("Creating NewSessionL"));

    // check we're the right version

    if (!User::QueryVersionSupported(TVersion(KGbaServMajorVersionNumber,

                                              KGbaServMinorVersionNumber,

                                              KGbaServBuildVersionNumber),

                                              aVersion))

        {

        GBA_TRACE_DEBUG(("Version isn't supported"));

        User::Leave(KErrNotSupported);

        }

    CGbaServerSession* session = CGbaServerSession::NewL();

    return session;

    }

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

// CGbaServer::IncrementSessions()

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

//

void CGbaServer::IncrementSessions()

    {

    GBA_TRACE_DEBUG(("CGbaServer::IncrementSessions"));

    iSessionCount++;

    iShutdown.Cancel();

    }

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

// CGbaServer::DecrementSessions()

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

//

void CGbaServer::DecrementSessions()

    {

    GBA_TRACE_DEBUG(("CGbaServer::DecrementSessions"));

    if ( --iSessionCount == 0 )

        {

        if(!iShutdown.IsActive())

            {

            iShutdown.Start();

            }

        }

    GBA_TRACE_DEBUG(("CGbaServer::DecrementSessions END"));

    }

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

// CGbaServer::ReadOptionL()

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

//

TBool CGbaServer::ReadOptionL(const TUid& aOptionID, TDes8& aValue) const

    {

    GBA_TRACE_DEBUG(("ReadOptionL"));

    TInt pushCount = 0;

    TInt result = EFalse;

    RFs fs;

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

    CleanupClosePushL( fs );

    pushCount++; 

    TFindFile folder( fs );

    TFileName fullPath;

    MakePrivateFilenameL(fs, KGbaIniFileName, fullPath);

    TInt err = folder.FindByDir( fullPath, KNullDesC);

    if (  err != KErrNone )

        {

        CleanupStack::PopAndDestroy( pushCount );

        return result;

        }

    else

       {

       CDictionaryFileStore* pStore = CDictionaryFileStore::OpenLC( fs, fullPath , KGbaIniUid );   

       pushCount++;

       if ( pStore->IsPresentL( aOptionID ) )

          {          

          RDictionaryReadStream drs;

          CleanupClosePushL( drs );

          drs.OpenL(*pStore,aOptionID); 

          TInt length = drs.ReadInt32L();

          drs.ReadL(aValue,length); 

          CleanupStack::PopAndDestroy( &drs );

          result = ETrue;

          }

       }

     CleanupStack::PopAndDestroy( pushCount );

     return result;

    }

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

// CGbaServer::WriteOptionL()

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

//

void CGbaServer::WriteOptionL(const TUid& aOptionID, const TDesC8& aValue) const

    {

    GBA_TRACE_DEBUG(("WriteOptionL"));

    TInt pushCount = 0;

    RFs fs;

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

    CleanupClosePushL( fs );

    pushCount++;

    TFindFile folder( fs );

    TFileName fullPath;

    MakePrivateFilenameL(fs, KGbaIniFileName, fullPath);

    EnsurePathL(fs, fullPath );

    GBA_TRACE_DEBUG(fullPath); 

    TInt err = folder.FindByDir( fullPath, KNullDesC);

    if (  err == KErrNotFound || err == KErrNone )  

       {

       CDictionaryFileStore* pStore = CDictionaryFileStore::OpenLC( fs, fullPath, KGbaIniUid );   

       pushCount++;       

       RDictionaryWriteStream wrs;

       CleanupClosePushL( wrs );

       wrs.AssignL(*pStore,aOptionID);

       wrs.WriteInt32L(aValue.Length());

       wrs.WriteL(aValue);

       wrs.CommitL();

       pStore->CommitL();  

       CleanupStack::PopAndDestroy( &wrs );

       CleanupStack::PopAndDestroy( pushCount );     

       GBA_TRACE_DEBUG(aValue);

       }

    else

        {

        CleanupStack::PopAndDestroy( pushCount );    

        User::LeaveIfError( err );

        }

    }

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

// CGbaServer::MakePrivateFilenameL()

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

//

void CGbaServer::MakePrivateFilenameL(RFs& aFs, const TDesC& aLeafName, 

                                     TDes& aNameOut) const

    {

    aNameOut.Copy(KGBAStoreStandardDrive);

    // Get private path

    TBuf<KPrivateFilepathLength> privatePath;

    aFs.PrivatePath(privatePath);

    aNameOut.Append(privatePath);

    aNameOut.Append(aLeafName);

    }

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

// CGbaServer::EnsurePathL()

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

//      

void CGbaServer::EnsurePathL( RFs& aFs, const TDesC& aFile ) const

    {

    TInt err = aFs.MkDirAll(aFile);

    if (err != KErrNone && err != KErrAlreadyExists)

        {

        User::Leave(err);

        }

    } 

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

// CShutdown::CShutdown

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

//

inline CShutdown::CShutdown()

  :CTimer(-1)

    {

    CActiveScheduler::Add(this);

    }

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

// CShutdown::ConstructL

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

//

inline void CShutdown::ConstructL()

    {

    CTimer::ConstructL();

    }

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

// CShutdown::Start

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

//

inline void CShutdown::Start()

    {

    GBA_TRACE_DEBUG(("GbaServer: starting shutdown timeout"));

    After( EGbaServerShutdownDelay );

    }

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

// CShutdown::RunL

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

//

void CShutdown::RunL()

    {

    GBA_TRACE_DEBUG(("GbaServer: server timeout ... closing"));

    CActiveScheduler::Stop();

    }

// ======== LOCAL FUNCTIONS ========

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

// PanicClient()

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

//

void PanicClient( const RMessage2& aMessage, TInt aPanic )

    {

    aMessage.Panic( KGbaServer, aPanic );

    }

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

// PanicServer()

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

//

void PanicServer( TInt aPanic )

    {

    User::Panic( KGbaServer, aPanic );

    }

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

// RunServerL()

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

//

static void RunServerL()

    {

    // Construct active scheduler

    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;

    CleanupStack::PushL(activeScheduler) ;

    CActiveScheduler::Install(activeScheduler);

    // Construct our server

    CGbaServer* server = CGbaServer::NewLC();    

    RProcess::Rendezvous(KErrNone);

    // Start handling requests

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( server );

    CleanupStack::PopAndDestroy( activeScheduler );

    }

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

// E32Main:()

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

//

TInt E32Main()

    {

 __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TInt err = KErrNoMemory;

    if ( cleanup )

        { 

        TRAP(err, RunServerL());

        delete cleanup;

        }

__UHEAP_MARKEND;

    return err;

    }

//EOF