/*

* Copyright (c) 2009 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 "trksrvsession.h"

// System includes

//User Includes

#include "trkdebugmgrcallbacks.h"

#include "trksrvcmdcodes.h"

// Type definitions

// Constants

const TInt KTrkServerTransferBufferExpandSize = 100;

const TInt KSlot0 = 0;

const TInt KSlot2 = 2;

// Enumerations

// Classes referenced

// Static functions

// Checks for a null'd handle before attempting complete. 

// If handle is null'd then don't complete as this will panic server.

//

void SafeComplete(const RMessagePtr2& aMessage, TInt aCompletionCode)

{

    if(!aMessage.IsNull())

    {

        aMessage.Complete(aCompletionCode);

    }

}

//

// CTrkSrvSession (source)

//

//

// CTrkSrvSession::CTrkSrvSession()

//

// Constructor

//

CTrkSrvSession::CTrkSrvSession(CTrkDebugManager* aTrkDebugMgr) : iTrkDebugMgr(aTrkDebugMgr)

{

}

//

// CTrkSrvSession::~CTrkSrvSession()

//

// Destructor

//

CTrkSrvSession::~CTrkSrvSession()

{

	HandleServerDestruction();

	delete iTransferBuffer;

}

//

// CTrkSrvSession::ConstructL()

//

// Creates an instance of CTrkSrvSession.

//

void CTrkSrvSession::ConstructL()

{

	iTransferBuffer = CBufFlat::NewL(KTrkServerTransferBufferExpandSize);

	iTrkDebugMgr->SetDebugMgrCallback(this);

}

//

// CTrkSrvServer::NewL()

//

// Static self construction

//

CTrkSrvSession* CTrkSrvSession::NewL(CTrkDebugManager* aTrkDebugMgr)

{

	CTrkSrvSession* self = new(ELeave) CTrkSrvSession(aTrkDebugMgr);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

}

//

// CTrkSrvSession::HandleServerDestruction()

//

// Called by the server's destructor. We need to be told that the server is

// being destroyed.

//

void CTrkSrvSession::HandleServerDestruction()

{

}

//

// CTrkSrvSession::ServiceL()

//

// Services requests from a client.

// Called by the IPC framework whenever a client sends a request to the server.

//

void CTrkSrvSession::ServiceL(const RMessage2& aMessage)

{

	const TInt cmd = aMessage.Function();

	switch (cmd)

	{

		case ETrkSrvGetVersion:

			CmdGetVersionL(aMessage);

			break;

		case ETrkSrvCmdConnect:

			CmdConnectL(aMessage);

			break;

		case ETrkSrvCmdDisConnect:

			CmdDisConnectL(aMessage);

			break;

		case ETrkSrvCmdGetCurrentConnData:

		    CmdGetCurrentConnDataL(aMessage);

		    break;

		case ETrkSrvCmdSetCurrentConnData:

		    CmdSetCurrentConnDataL(aMessage);

		    break;

		case ETrkSrvCmdGetDebugConnStatus:

			CmdGetDebugConnStatusL(aMessage);

			break;

		case ETrkSrvDebugConnStatus:

			ConnStatusNotifyL(aMessage);

			break;

		case ETrkSrvDebugConnStatusCancel:

		    ConnStatusNotifyCancel(aMessage);

		    break;

		case ETrkSrvCmdGetDebuggingStatus:

			CmdGetDebugStatusL(aMessage);

			break;

		case ETrkSrvDebuggingStatus:

			DebugStatusNotifyL(aMessage);				

			break;

		case ETrkSrvDebuggingStatusCancel:

		    DebugStatusNotifyCancel(aMessage);

		    break;

		case ETrkGetPlugAndPlayType:

		    GetPlugAndPlayTypeL(aMessage);

		    break;

		case ETrkSetPlugAndPlayType:

		    SetPlugAndPlayTypeL(aMessage);

		    break;

		case ETrkSrvCmdCodeShutDownServer:

		    CmdShutDownServer(aMessage);

			break;

		default:

		    aMessage.Panic(KServerIntiatedSessionPanic, ETrkServerInitiatedClientPanicInvalidOperation);

			break;

	}

}

//

// CTrkSrvSession::CmdGetVersionL()

//

// Gets the TRK version information

//

void CTrkSrvSession::CmdGetVersionL(const RMessage2& aMessage)

{

	TTRKVersion version;

	iTrkDebugMgr->GetVersion(version);

	TPckgC<TTRKVersion> package(version);

	TRAPD(err, aMessage.WriteL(KSlot0, package));

	if (err != KErrNone)

	{

        aMessage.Panic(_L("TrkServer"), 2);

	}

	aMessage.Complete(KErrNone);

}

//

// CTrkSrvSession::CmdConnectL()

//

void CTrkSrvSession::CmdConnectL(const RMessage2& aMessage)

{

	TRAPD(err,iTrkDebugMgr->ConnectToDebuggerL());

	if (err != KErrNone)

	{

        aMessage.Panic(_L("TrkServer"), 3);

	}

	aMessage.Complete(KErrNone);

}

//

// CTrkSrvSession::CmdDisconnectL()

//

void CTrkSrvSession::CmdDisConnectL(const RMessage2& aMessage)

{

	iTrkDebugMgr->DisConnect();	

	aMessage.Complete(KErrNone);

}

//

// CTrkSrvSession::CmdGetConnStatusL()

//

void CTrkSrvSession::CmdGetCurrentConnDataL(const RMessage2& aMessage)

{

    TTrkConnData connData;  

    iTrkDebugMgr->GetCurrentConnData(connData);

    TPckgC<TTrkConnData> package(connData);      

    TRAPD(err, aMessage.WriteL(KSlot0, package));    

    if (err != KErrNone)

    {

        aMessage.Panic(_L("TrkServer"), 2);

    }

    aMessage.Complete(KErrNone);

}

//

// CTrkSrvSession::CmdGetConnStatusL()

//

void CTrkSrvSession::CmdSetCurrentConnDataL(const RMessage2& aMessage)

{   

    TTrkConnData connData;

    TPckg<TTrkConnData> package(connData);

    TRAPD(err, aMessage.ReadL(KSlot0, package));

    if (err != KErrNone)

    {

        aMessage.Panic(_L("TrkServer"), 2);

    }

    TPckgBuf<TBool> connected(iTrkDebugMgr->IsConnected());

    TBuf<KMaxPath> connStatus;

    iTrkDebugMgr->SetCurrentConnData(connData);       

    aMessage.Complete(KErrNone);

}

//

// CTrkSrvSession::CmdGetConnStatusL()

//

void CTrkSrvSession::CmdGetDebugConnStatusL(const RMessage2& aMessage)

{	

    TPckgBuf<TTrkConnStatus> package(iTrkDebugMgr->GetConnectionStatus());

    TBuf<KMaxPath> connMsg;

	iTrkDebugMgr->GetConnectionMsg(connMsg);

	TRAPD(err, aMessage.WriteL(KSlot0, package));

	TRAPD(err1, aMessage.WriteL(KSlot2, connMsg));

	if (err || err1)

	{

        aMessage.Panic(_L("TrkServer"), 2);

	 }

	aMessage.Complete(KErrNone);   

}

//

// CTrkSrvSession::ConnStatusNotifyL()

//

void CTrkSrvSession::ConnStatusNotifyL(const RMessage2& aMessage)

{

    if (!iPendingConnState)

    {

        iBlockedConnState = aMessage;       

        iPendingConnState = ETrue;

    }

    else

    {

        aMessage.Complete(KErrAlreadyExists);

    }

}

//

//CTrkSrvSession::ConnStatusNotifyCancel()

//

void CTrkSrvSession::ConnStatusNotifyCancel(const RMessage2& aMessage)

{

    if (iPendingConnState && iBlockedConnState.Handle())

    {

       SafeComplete(iBlockedConnState, KErrCancel);

       iPendingConnState = EFalse;        

    }

    SafeComplete(aMessage, KErrNone);

    iTrkDebugMgr->SetDebugMgrCallback(NULL);

}

//

// CTrkSrvSession::CmdGetDebugStatusL()

//

void CTrkSrvSession::CmdGetDebugStatusL(const RMessage2& aMessage)

{

    TPckgBuf<TBool> debugging(iTrkDebugMgr->IsDebugging());        

    TRAPD(err, aMessage.WriteL(KSlot0, debugging));

    if (err != KErrNone)

    {

        aMessage.Panic(_L("TrkServer"), 2);

    }

    aMessage.Complete(KErrNone);

}

//

// CTrkSrvSession::DebugStatusNotifyL()

//

void CTrkSrvSession::DebugStatusNotifyL(const RMessage2& aMessage)

{	

    if (!iPendingDebugState)

    {

        iBlockedDebugState = aMessage;       

        iPendingDebugState = ETrue;

    }

    else

    {

        aMessage.Complete(KErrAlreadyExists);

    }

}

//

// CTrkSrvSession::DebugStatusNotifyCancel()

//

void CTrkSrvSession::DebugStatusNotifyCancel(const RMessage2& aMessage)

{

    if (iPendingDebugState && iBlockedDebugState.Handle())

    {

       SafeComplete(iBlockedDebugState, KErrCancel);

       iPendingDebugState = EFalse;        

    }

    SafeComplete(aMessage, KErrNone);

}

//

// CTrkSrvSession::CmdShutDownServer()

//

// Stops the active scheduler. This way, server process will run to completion.

//

void CTrkSrvSession::CmdShutDownServer(const RMessage2& aMessage)

{

    CActiveScheduler::Stop();

    aMessage.Complete(KErrNone);

}

//

// CTrkSrvSession::DebugConnStatusChanged()

//

// It is called when the debug connection status has been found changed

//

void CTrkSrvSession::DebugConnStatusChanged(TTrkConnStatus& aConnStatus)

{

    if (iPendingConnState && iBlockedConnState.Handle())

    {

        TPckg<TTrkConnStatus> package(aConnStatus);

        //write the file data into the client descriptor

        TRAPD(err, iBlockedConnState.WriteL(KSlot0, package));                      

        if (err != KErrNone)

        {

            iBlockedConnState.Panic(_L("TrkServer"), 2);

        }

        SafeComplete(iBlockedConnState, err);    

    }

    iPendingConnState = EFalse;

}

//

// CTrkSrvSession::DebugConnStatusChanged()

//

// Called when the debugging status is changed

//

void CTrkSrvSession::DebuggingStatusChanged(TBool& aDebugging)

{

    if (iPendingDebugState && iBlockedDebugState.Handle())

    {

        TPckg<TBool> package(aDebugging);

        //write the file data into the client descriptor

        TRAPD(err, iBlockedDebugState.WriteL(KSlot0, package));                      

        if (err != KErrNone)

        {

            iBlockedDebugState.Panic(_L("TrkServer"), 2);

        }

        SafeComplete(iBlockedDebugState, err);    

    }

    iPendingDebugState = EFalse;

}

//

// CTrkSrvSession::GetPlugAndPlayType()

//

// To know whether plug and play is set or not

//

void CTrkSrvSession::GetPlugAndPlayTypeL(const RMessage2& aMessage)

{

    TPckg<TBool> plugandPlay(iTrkDebugMgr->GetPlugAndPlayOption());

    TRAPD(err, aMessage.WriteL(KSlot0, plugandPlay));

    if (err!= KErrNone)

    {

        aMessage.Panic(_L("TrkServer"), 2);

    }

    aMessage.Complete(KErrNone);  

}

//

// CTrkSrvSession::SetPlugAndPlayType()

//

// To set the plug and play 

//

void CTrkSrvSession::SetPlugAndPlayTypeL(const RMessage2& aMessage)

{   

    TBool plugandPlay;

    TPckg<TBool> package(plugandPlay);

    TRAPD(err, aMessage.ReadL(KSlot0, package));

    if (err!= KErrNone)

    {

        aMessage.Panic(_L("TrkServer"), 2);

    }

    iTrkDebugMgr->SetPlugAndPlayOption(plugandPlay);

    aMessage.Complete(KErrNone);

}