/*
* Copyright (c) 2010 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:
*
*/

#include "stubsrv.h"
#include "stubsrvsession.h"
#include "stubsrvapiexecutor.h"
#include "apibehavior.h"
#include "stubsrvsecuritypolicy.h"

CStubSrv::CStubSrv(TInt aPriority)
  	:CPolicyServer(aPriority, KStubSrvPolicy)
    {
    }

CStubSrv* CStubSrv::NewLC()
    {
    CStubSrv* self = new (ELeave) CStubSrv(EPriorityNormal);
    CleanupStack::PushL(self);
    self->StartL(KStubSrvName);
    self->ConstructL();
    return self;
    }

CStubSrv::~CStubSrv()
    {
    iBehQueue.ResetAndDestroy();
    iBehQueue.Close();
    iSessions.Close();
    delete iTimer;
    }

const TInt KShutdownDelay = 1000000;

void CStubSrv::StartShutdownTimerIfNoSessions()
	{
	if (iSessions.Count() == 0 && !iTimer->IsActive())
		{
		iTimer->Start(KShutdownDelay, 0, TCallBack(CStubSrv::TimerFired, this));
		}
	}

TInt CStubSrv::ClientOpened(CStubSrvSess& aSession)
	{
	return iSessions.Append(&aSession);
	}

void CStubSrv::ClientClosed(CStubSrvSess& aSession)
	{
	const TUint sessCount = iSessions.Count();
	for ( TUint ii = 0 ; ii < sessCount ; ++ii )
		{
		if ( iSessions[ii] == &aSession )
			{
			iSessions.Remove(ii);
			break;
			}
		}
	StartShutdownTimerIfNoSessions();
	}

void CStubSrv::EnqueueL(const RMessage2& aMessage)
    {
    TApiBehaviorPckgBuf buf;
    aMessage.ReadL(0, buf);
    TInt duration = aMessage.Int1();
    
    TInt sesss = iSessions.Count();
    for (TInt i = 0; i < sesss; i++)
        {
        TInt err = iSessions[i]->ConsumeApiBehavior(buf(), duration);
        if (err == KErrNone)
            {
            return;
            }
        }
    TApiQueueItem* item = new (ELeave) TApiQueueItem();
    item->iBeh = buf();
    item->iExeDuration = duration;
    item->iTransactionId = 0;  
    CleanupStack::PushL(item);
    iBehQueue.AppendL(item);
    CleanupStack::Pop(item);
    }

void CStubSrv::DeleteQueues(const RMessage2& aMessage)
    {
    TUint lib = aMessage.Int0();
    TUint api = aMessage.Int1();
    TInt count = iBehQueue.Count();
    for (TInt i = count - 1; i >= 0; i--)
        {
        if (iBehQueue[i]->iBeh.MatchId(lib, api))
            {
            delete iBehQueue[i];
            iBehQueue.Remove(i);
            }
        }
    }

TInt CStubSrv::Dequeue(TApiBehavior& aBeh, TInt& aExeDuration, TInt aTransactionId)
	{
    TInt count = iBehQueue.Count();
    for (TInt i = 0; i < count; i++)
        {
        if (iBehQueue[i]->iBeh.MatchId(aBeh.iLib, aBeh.iApi) &&
            aTransactionId == iBehQueue[i]->iTransactionId)
            {
            aBeh = iBehQueue[i]->iBeh;
            aExeDuration = iBehQueue[i]->iExeDuration;
            delete iBehQueue[i];
            iBehQueue.Remove(i);
            return KErrNone;
            }
        }
    return KErrNotFound;	
	}

void CStubSrv::GetApiCompleteCodeL(const RMessage2& aMessage)
    {
    TUint lib = aMessage.Int0();
    TUint api = aMessage.Int1();
    TInt count = iBehQueue.Count();
    for (TInt i = 0; i < count; i++)
        {
        if (iBehQueue[i]->iBeh.MatchId(lib, api))
            {
            iBehQueue[i]->iTransactionId = iTransctionUnique++;
            TPckgBuf<TInt> buf(iBehQueue[i]->iTransactionId);
            aMessage.WriteL(2, buf);
            aMessage.Complete(iBehQueue[i]->iBeh.iCompleteCode);
            return;
            }
        }
    aMessage.Complete(0);
    }

void CStubSrv::ConstructL()
    {
    iTimer = CPeriodic::NewL(CActive::EPriorityStandard);
    }

CSession2* CStubSrv::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const
    {
	TVersion v(KStubSrvMajorVersionNumber, KStubSrvMinorVersionNumber, KStubSrvBuildNumber);
	if ( !User::QueryVersionSupported(v, aVersion) )
		User::Leave(KErrNotSupported);
    CStubSrvSess* session = CStubSrvSess::NewL(const_cast<CStubSrv&>(*this));
    const_cast<CStubSrv*>(this)->CancelShutdownTimer();
    return session;
    }

void CStubSrv::CancelShutdownTimer()
    {
    iTimer->Cancel();
    }

TInt CStubSrv::TimerFired(TAny* /*aThis*/)
	{
	CActiveScheduler::Stop();
	return KErrNone;
	}
    
static void RunServerL()
	{
    static_cast<void>(User::LeaveIfError(User::RenameThread(KStubSrvName)));	
	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);
    CStubSrv::NewLC();
	RProcess::Rendezvous(KErrNone);
	CActiveScheduler::Start();
	CleanupStack::PopAndDestroy(2, scheduler);
	}

GLDEF_C TInt E32Main()
    {
	TInt ret = KErrNoMemory;
	__UHEAP_MARK;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	if (cleanup)
		{
		TRAP(ret, RunServerL());
		delete cleanup;
		}
	__UHEAP_MARKEND;
	return ret;    
    }