#include <w32std.h>

#include <APGTASK.H>

#include <APGWGNAM.H>  

#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>

#include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>

#include <memspy/engine/memspyenginehelperserver.h>

#include <memspy/engine/memspyenginehelperecom.h>

#include <memspy/engine/memspyprocessdata.h>

#include <memspy/engine/memspythreaddata.h>

#include <memspy/engine/memspykernelobjectdata.h>

#include <memspy/engine/memspythreadinfoitemdata.h>

#include <memspy/engine/memspymemorytrackingcycledata.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyenginehelperactiveobject.h>

#include <memspy/engine/memspyserverdata.h>

#include <memspysession.h>

#include <memspy/engine/memspyecomdata.h>

inline CShutdown::CShutdown() :CTimer(-1)

    {

    CActiveScheduler::Add(this);

    }

inline void CShutdown::ConstructL()

    {

    CTimer::ConstructL();

    }

inline void CShutdown::Start()

    {

    After(KMyShutdownDelay);

    }

void CShutdown::RunL()

    //

    // Initiate server exit when the timer expires

    //

    {

    CActiveScheduler::Stop();

    }

    iShutdown.ConstructL();

    // ensure that the server still exits even if the 1st client fails to connect

    iShutdown.Start();

void CMemSpyEngineServer::AddSession(TBool aCliRequest)

    {

    if (aCliRequest)

        {

        iCliConnected = ETrue;

        }

    else

        {

        ++iSessionCount;

        }

    iShutdown.Cancel();

    }

void CMemSpyEngineServer::DropSession(TBool aCliRequest)

    {

    if (!aCliRequest)

        {

        --iSessionCount;

        }

    if (iSessionCount == 0 && !iCliConnected)

        {

        iShutdown.Start();

        }

    }

    Server().DropSession(iIsCliRequest);

    const TUid KCliUid3 = { 0x2002129D };

    iIsCliRequest = aMessage.SecureId() == TSecureId(KCliUid3);

void CMemSpyEngineSession::CreateL()

    {   

    Server().AddSession(iIsCliRequest);

    }

    if ((aMessage.Function() & KMemSpyOpFlagsAsyncOperation) == 0 || error != KErrNone)

    	{

		aMessage.Complete( error );

    	}

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

// DoServiceL( const RMessage2& aMessage )

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

//

void CMemSpyEngineSession::DoServiceL( const RMessage2& aMessage )

	{

	TInt function = aMessage.Function() & KMemSpyOpFlagsTypeMask;

	if (function >= EMemSpyClientServerOpMarkerUiFirst && 

		function < EMemSpyClientServerOpMarkerUiLast)

		DoUiServiceL(aMessage);

	else

		DoCmdServiceL(aMessage);

	}

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

// DoUiServiceL( const RMessage2& aMessage )

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

//

void CMemSpyEngineSession::DoUiServiceL( const RMessage2& aMessage )

    {

	switch (aMessage.Function() & KMemSpyOpFlagsTypeMask)

		{

	    case EMemSpyClientServerOpGetOutputSink:

	        {

	        TMemSpySinkType sink = iEngine.SinkType();

	        TPckgBuf<TMemSpySinkType> type( sink );

	        aMessage.WriteL( 0, type );

	        break;

	        }

		case EMemSpyClientServerOpGetProcessCount:

			{

			aMessage.WriteL(0, TPckgBuf<TInt>(iEngine.Container().Count()));

			break;

			}

		case EMemSpyClientServerOpGetProcesses:

			{

			CMemSpyEngineObjectContainer& list = iEngine.Container();

			TPckgBuf<TInt> a0;

			aMessage.ReadL(0, a0);

			TInt realCount = Min(a0(), list.Count());

			for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyProcessData))

				{

				CMemSpyProcess& process = iEngine.Container().At(i);

				TMemSpyProcessData data;

				data.iIsDead = process.IsDead();

				data.iId = process.Id();

				data.iName.Copy(process.Name().Left(KMaxFullName));

				data.iThreadCount = process.Count();

				data.iPriority = process.Priority();

				data.iExitType = process.ExitType();

				data.iExitReason = process.ExitReason();

				data.iExitCategory = process.ExitCategory();

				data.iSID = process.SID();

				TPckgBuf<TMemSpyProcessData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				}

			a0 = list.Count();

			aMessage.WriteL(0, a0);

			break;

			}

		case EMemSpyClienServerOpGetProcessIdByName:

			{

			TFullName processName;

			aMessage.ReadL(0, processName);

			TBool found(EFalse);

			for (TInt i=0; i<iEngine.Container().Count(); i++)

				{

				CMemSpyProcess& process = iEngine.Container().At(i);

				if (process.Name().FindF(processName) >= 0)

					{

					found = ETrue;

					TPckgBuf<TProcessId> procId(process.Id());

					aMessage.WriteL(1, procId);

					}

				}

			if (!found)

				{

				User::Leave(KErrNotFound);

				}

			break;

			}

		case EMemSpyClientServerOpProcessSystemPermanentOrCritical:

			{

			TBool ret = EFalse;

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			if  ( process.IsSystemPermanent() || process.IsSystemCritical() )

				{

				ret = ETrue;

				}

			TPckgBuf<TBool> retBuf( ret );

			aMessage.WriteL( 1, retBuf );

			break;

			}

		case EMemSpyClientServerOpEndProcess:

			{

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			TPckgBuf<TMemSpyEndType> type;

			aMessage.ReadL( 1, type );

			CMemSpyEngineObjectContainer& container = iEngine.Container();			

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			switch ( type() )

				{

				case ETerminate:

					{

					process.TerminateL();

					break;

					}

				case EPanic:

					{

					process.PanicL();

					break;

					}

				case EKill:

					{

					process.KillL();

					break;

					}

				}																

			break;

			}

		case EMemSpyClientServerOpSwitchToProcess:

			{/*

			TInt wgCount;

			RWsSession wsSession;

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

			CleanupClosePushL( wsSession );

			User::LeaveIfError( wgCount = wsSession.NumWindowGroups() );

			RArray<RWsSession::TWindowGroupChainInfo> wgArray;

			CleanupClosePushL( wgArray );

			User::LeaveIfError( wsSession.WindowGroupList( &wgArray ) );

			TApaTask task( wsSession );

			TBool brought( EFalse );

			TInt wgId( KErrNotFound );

			TThreadId threadId;

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			// loop trough threads in a process

			for ( TInt i = 0; i < process.MdcaCount(); i++ )

				{

				TInt wgCountLocal = wgCount;

				// loop trough all window groups and see if a thread id matches

				while( !brought && wgCountLocal-- )

					{

					wgId = wgArray[wgCountLocal].iId;

					User::LeaveIfError( wsSession.GetWindowGroupClientThreadId( wgId, threadId ) );

					if ( threadId == process.At( i ).Id() )

						{

						CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, wgId );

						task.SetWgId( wgId );

						if ( !wgName->Hidden() && task.Exists() )

							{

							task.BringToForeground();

							brought = ETrue;                        

							}

						CleanupStack::PopAndDestroy( wgName );

						}

					}

				}

			TPckgBuf<TBool> ret( brought );

			aMessage.WriteL( 1, ret );

			break;*/

			}

		case EMemSpyClientServerOpGetThreadCount:

			{

			TPckgBuf<TProcessId> pid;

			aMessage.ReadL(1, pid);

			CMemSpyProcess& process = iEngine.Container().ProcessByIdL(pid());

			aMessage.WriteL(0, TPckgBuf<TInt>(process.Count()));

			break;

			}

		case EMemSpyClientServerOpGetThreads:

			{

			TPckgBuf<TProcessId> pid;

			aMessage.ReadL(2, pid);

			CMemSpyProcess& list = iEngine.Container().ProcessByIdL(pid());

			TPckgBuf<TInt> a0;

			aMessage.ReadL(0, a0);

			TInt realCount = Min(a0(), list.Count());

			for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyThreadData))

				{

				CMemSpyThread& thread = list.At(i);

				TMemSpyThreadData data;

				data.iId = thread.Id();

				data.iName.Copy(thread.Name().Left(KMaxFullName));

				data.iThreadPriority = thread.Priority();

				TPckgBuf<TMemSpyThreadData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				}

			a0 = list.Count();

			aMessage.WriteL(0, a0);

			break;

			}

		case EMemSpyClientServerOpSetThreadPriority:

			{

			TPckgBuf<TThreadId> tid;

			TPckgBuf<TInt> priority;

			aMessage.ReadL(0, tid);

			aMessage.ReadL(1, priority);

			CMemSpyProcess* process = NULL;

			CMemSpyThread* thread = NULL; 

			User::LeaveIfError(iEngine.Container().ProcessAndThreadByThreadId(tid(), process, thread));

			if (thread)

				{				

				thread->SetPriorityL(static_cast<TThreadPriority>(priority()));

				}					

			break;

			}

		case EMemSpyClientServerOpThreadSystemPermanentOrCritical:

			{

			TPckgBuf<TThreadId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();            

			CMemSpyProcess* process = NULL;

			CMemSpyThread* thread = NULL;