/*
* 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 "memspysession.h"
#include <memspy/api/memspyapiprocess.h>
#include <memspy/api/memspyapikernelobject.h>
#include <memspy/api/memspyapikernelobjectitem.h>
//KernelObjects
#include <memspy/driver/memspydriverenumerationsshared.h>
// IMPLEMENTATION

EXPORT_C RMemSpySession::RMemSpySession()
    {
    }


EXPORT_C TInt RMemSpySession::Connect()
    {
	TInt error(KErrNone);
	
	for (TInt i=0; i<2; i++) // Two retries max
		{
		TInt error = CreateSession(KMemSpyServer2, TVersion(KMemSpyVersion, 0, 0));
		
		if (error != KErrNotFound && error != KErrServerTerminated)
			return error;
		
		error = StartServer();
		
		if (error != KErrNone && error != KErrAlreadyExists)
			return error;
		}
	
	return error;	
    }

TInt RMemSpySession::StartServer()
	{
	RProcess server;
	_LIT(KCommand, "start");
	const TUid KServerUid3 = {0xE5883BC2};
	TInt error = server.Create(KMemSpyServer2, KCommand);//, KServerUid3);
	
	if (error != KErrNone)
		return error;
	
	TRequestStatus startStatus, stopStatus;
	server.Logon(stopStatus);
	if (stopStatus != KRequestPending)
		{
		User::WaitForRequest(stopStatus);
		server.Kill(0);
		server.Close();
		return stopStatus.Int();
		}
	
	server.Rendezvous(startStatus);
	server.Resume();
	User::WaitForRequest(startStatus, stopStatus);
	if (startStatus == KRequestPending)
		{
		// not started yet, i.e. stopStatus was signaled
		server.Close();
		return stopStatus.Int();
		}
	
	// Rendezvous was called - the server is ready
	
	// We first need to cancel Logon
	server.LogonCancel(stopStatus);
	// We don't need this anymore
	server.Close();
	// Wait for LogonCancel to complete
	User::WaitForRequest(stopStatus);

	// Everything went OK
	return KErrNone;
	}

//inline void RMemSpySession::Close()
//    {
//    RSessionBase::Close();
//    }
//
//inline TMemSpySinkType RMemSpySession::GetSinkType()
//	{
//	TPckgBuf<TMemSpySinkType> OutBuf;
//	TIpcArgs args( &OutBuf );
//	SendReceive( EGetSinkType, args );
//	return OutBuf();
//	}
//
//inline void RMemSpySession::OutputKernelObjects()
//	{
//	SendReceive( EOutputKernelObjects );
//	}
//
//inline void RMemSpySession::OutputToDebug()
//	{
//	SendReceive( EOutputToDebug );
//	}
//
//inline void RMemSpySession::OutputToFile()
//	{
//	SendReceive( EOutputToFile );
//	}
//
//inline void RMemSpySession::SetServerTimeOutStatus( TUint32 aValue, TBool aEnabled )
//	{
//	TPckgBuf<TUint32> In1(aValue);
//	TPckgBuf<TBool> In2(aEnabled);
//	TIpcArgs args( &In1, &In2 );
//	SendReceive( ESetServerTimeOutStatus, args );	
//	}

//inline void RMemSpySession::OutputProcessInfo( TMemSpyProcess aProcess )
//	{
//	TProcessId iId = aProcess.iId;
//	TPckgBuf<TProcessId> In( iId );
//	TIpcArgs args( &In );
//	SendReceive( EOutputProcessInfo, args );
//	}

////Processes operations
//inline TInt RMemSpySession::ProcessesCount()
//	{
//	TPckgBuf<TInt> Out;
//	TIpcArgs args( &Out );
//	SendReceive( EProcessesCount, args );
//	return Out();
//	}
//
//inline TMemSpyProcess RMemSpySession::GetProcessByIndex( TInt aIndex )
//	{
//	TPckgBuf<TInt> In( aIndex );
//	TPckgBuf<TMemSpyProcess> Out;
//	TIpcArgs args( &In, &Out );
//	SendReceive( EProcessByIndex, args );
//	return Out();
//	}
//
//inline TInt RMemSpySession::ProcessIndexById( TProcessId aId )
//	{
//	TPckgBuf<TProcessId> In( aId );
//	TPckgBuf<TInt> Out;
//	TIpcArgs args( &In, &Out );
//	SendReceive( EProcessIndexById, args );
//	return Out();
//	}
//
//inline TBool RMemSpySession::ProcessIsDead( TMemSpyProcess aProcess )
//	{
//	TProcessId iId = aProcess.iId;
//	TPckgBuf<TProcessId> In( iId );
//	TPckgBuf<TBool> Out;
//	TIpcArgs args( &In, &Out );
//	SendReceive( EProcessIsDead, args );
//	return Out();
//	}

EXPORT_C void RMemSpySession::GetProcessesL(RArray<CMemSpyApiProcess*> &aProcesses, TSortType aSortType)
	{
	TPckgBuf<TInt> count;
	User::LeaveIfError(SendReceive(EGetProcessCount, TIpcArgs(&count)));
	
	TInt requestedCount = count();
	HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyProcessData));
	TPtr8 bufferPtr(buffer->Des());
	
	User::LeaveIfError(SendReceive(EGetProcesses, TIpcArgs(&count, &bufferPtr)));
	aProcesses.Reset();
	
	TInt receivedCount = Min(count(), requestedCount);
	for(TInt i=0, offset = 0; i<requestedCount; i++, offset+=sizeof(TMemSpyProcessData))
		{
		TPckgBuf<TMemSpyProcessData> data;
		data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyProcessData));
		aProcesses.AppendL(CMemSpyApiProcess::NewLC(data()));
		}
	CleanupStack::Pop(aProcesses.Count());
	CleanupStack::PopAndDestroy(buffer);
	}

EXPORT_C TInt RMemSpySession::ProcessSystemPermanentOrCritical( TProcessId aId, TBool aValue )
	{
	TPckgBuf<TProcessId> arg1( aId );
	TPckgBuf<TBool> arg2( aValue );
	TIpcArgs args( &arg1, &arg2 );
		
	TInt error = SendReceive( EProcessSystemPermanentOrCritical, args );
	
	return error;
	}

EXPORT_C TInt RMemSpySession::EndProcess( TProcessId aId, TEndType aType )
	{
	TPckgBuf<TProcessId> arg1( aId );
	TPckgBuf<TEndType> arg2( aType );
	TIpcArgs args( &arg1, &arg2 );
	
	TInt error = SendReceive( EEndProcess, args );
	
	return error;
	}

EXPORT_C TInt RMemSpySession::SwitchToProcess( TProcessId aId, TBool aBrought )
	{
	TPckgBuf<TProcessId> arg1( aId );
	TPckgBuf<TBool> arg2( aBrought );
	TIpcArgs args( &arg1, &arg2 );
	
	TInt error = SendReceive( ESwitchToProcess, args );
	
	return error;	
	}

EXPORT_C void RMemSpySession::GetThreadsL(TProcessId aProcessId, RArray<CMemSpyApiThread*> &aThreads, TSortType aSortType)
	{
	TPckgBuf<TInt> count;
	TPckgBuf<TProcessId> pid(aProcessId);
	User::LeaveIfError(SendReceive(EGetThreadCount, TIpcArgs(&count, &pid)));
	
	TInt requestedCount = count();
	HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyThreadData));
	TPtr8 bufferPtr(buffer->Des());
	
	User::LeaveIfError(SendReceive(EGetThreads, TIpcArgs(&count, &bufferPtr, &pid)));
	aThreads.Reset();
	
	TInt receivedCount = Min(count(), requestedCount);
	for(TInt i=0, offset = 0; i<requestedCount; i++, offset+=sizeof(TMemSpyThreadData))
		{
		TPckgBuf<TMemSpyThreadData> data;
		data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyThreadData));
		aThreads.AppendL(CMemSpyApiThread::NewLC(data()));
		}
	CleanupStack::Pop(aThreads.Count());
	CleanupStack::PopAndDestroy(buffer);
	}

EXPORT_C void RMemSpySession::SetThreadPriorityL(TThreadId aId, TInt aPriority)
	{
	TPckgBuf<TThreadId> arg1( aId );
	TPckgBuf<TInt> arg2( aPriority );
	
	User::LeaveIfError(SendReceive( ESetThreadPriority, TIpcArgs(&arg1, &arg2)));
	}

EXPORT_C TInt RMemSpySession::ThreadSystemPermanentOrCritical( TThreadId aId, TBool aValue )
	{
	TPckgBuf<TThreadId> arg1( aId );
	TPckgBuf<TBool> arg2( aValue );
	TIpcArgs args( &arg1, &arg2 );
	
	TInt error = SendReceive( EThreadSystemPermanentOrCritical, args );
	
	return error;
	}

EXPORT_C TInt RMemSpySession::EndThread( TThreadId aId, TEndType aType )
	{
	TPckgBuf<TThreadId> arg1( aId );
	TPckgBuf<TEndType> arg2( aType );
	TIpcArgs args( &arg1, &arg2 );
	
	TInt error = SendReceive( EEndThread, args );
	
	return error;
	}

EXPORT_C TInt RMemSpySession::SwitchToThread( TThreadId aId, TBool aBrought )
	{
	
	}
/*
EXPORT_C TInt RMemSpySession::TerminateThread( TThreadId aId )
	{
	TPckgBuf<TThreadId> arg( aId );
	TIpcArgs args( &arg );
	
	TInt error = SendReceive( ETerminateThread, args );
	
	return error;
	}
*/

//inline void RMemSpySession::SortProcessesBy( TSortType aType )
//	{
//	TPckgBuf<TSortType> In( aType );
//	TIpcArgs args( &In );
//	SendReceive( ESortProcessesBy, args );
//	}

//inline void RMemSpySession::OpenCloseCurrentProcess( TProcessId aId, TBool  aOpen )
//	{
//	TPckgBuf<TProcessId> In1( aId );
//	TPckgBuf<TBool> In2( aOpen );
//	TIpcArgs args( &In1, &In2 );
//	SendReceive( EOpenCloseCurrentProcess, args );
//	}

//Kernel Objects specific operations
EXPORT_C TInt RMemSpySession::GetKernelObjects( RArray<CMemSpyApiKernelObject*> &aKernelObjects )
	{		
	TPckgBuf<TInt> count;
	TInt error = SendReceive( EGetKernelObjectTypeCount, TIpcArgs(&count) );
	
	if( error == KErrNone )
		{			
		TInt requestedCount = count();
		HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyKernelObjectData));
		TPtr8 bufferPtr(buffer->Des());
			
		TPckgBuf<TInt> count(requestedCount);
		TIpcArgs args( &count, &bufferPtr );
		TInt error = SendReceive( EGetKernelObjects, args );
			
		for(TInt i=0, offset = 0; i<requestedCount; i++, offset+=sizeof(TMemSpyKernelObjectData))
			{
			TPckgBuf<TMemSpyKernelObjectData> data;
			data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyKernelObjectData));
			aKernelObjects.AppendL(CMemSpyApiKernelObject::NewL(data()));
			}
				
		CleanupStack::PopAndDestroy(buffer);						
		}	
	return KErrNone;		
	}

EXPORT_C TInt RMemSpySession::GetKernelObjectItems( RArray<CMemSpyApiKernelObjectItem*> &aKernelObjectItems, TMemSpyDriverContainerType aForContainer )
	{
	TPckgBuf<TInt> count;
	TPckgBuf<TMemSpyDriverContainerType> type(aForContainer);
	TInt error = SendReceive( EGetKernelObjectItemsCount, TIpcArgs(&count, &type) );
		
	if (error == KErrNone)
		{
		TInt requestedCount = count();
		HBufC8* buffer = HBufC8::NewLC(requestedCount * sizeof(TMemSpyDriverHandleInfoGeneric));
		TPtr8 bufferPtr(buffer->Des());
		
		TPckgBuf<TInt> count(requestedCount);
		TIpcArgs args( &count, &type, &bufferPtr );
		TInt error = SendReceive( EGetKernelObjectItems, args );
		
		for(TInt i=0, offset = 0; i<requestedCount; i++, offset+=sizeof(TMemSpyDriverHandleInfoGeneric))
			{
			TPckgBuf<TMemSpyDriverHandleInfoGeneric> data;
			data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyDriverHandleInfoGeneric));
			aKernelObjectItems.AppendL( CMemSpyApiKernelObjectItem::NewL( data() ) );
			}
						
		CleanupStack::PopAndDestroy(buffer);				
		}
	return KErrNone;
	}

//Heap specific operations
EXPORT_C CMemSpyApiHeap* RMemSpySession::GetHeap()
	{
	CMemSpyApiHeap* aHeap;
	TInt error = KErrNone;
	
	HBufC8* buffer = HBufC8::NewLC( sizeof(TMemSpyHeapData) );
	TPtr8 bufferPtr(buffer->Des());
	TIpcArgs args( &bufferPtr );
	
	error = SendReceive( EGetHeap, args );
	
	if( error == KErrNone )
		{
		TPckgBuf<TMemSpyHeapData> data;
		data.Copy(bufferPtr.Ptr(), sizeof(TMemSpyHeapData));		
		aHeap = CMemSpyApiHeap::NewL( data() );
		}
	CleanupStack::PopAndDestroy(buffer);
		
	return aHeap;
	}