--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dbgagents/trkagent/trkserver/trksrvsession.cpp Tue Mar 02 10:33:16 2010 +0530
@@ -0,0 +1,425 @@
+/*
+* 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);
+}
+