/*
* Copyright (c) 2006-2006 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:  Memory Scan Client
*
*/



// SYSTEM INCLUDES
#include <e32svr.h>
#include <s32mem.h> // RBufReadStream

// USER INCLUDES
#include "memscanclient.h"
#include "memscanutils.h" // traces


// Standard server startup code
// 
static TInt StartServer()
	{
	TRACES( RDebug::Print(_L("MemScanClient: Starting server...")) );
  
	RProcess server;
	TInt r=server.Create(KMemScanServImg,KNullDesC);

	if (r!=KErrNone)
		{
		TRACES( RDebug::Print(_L("MemScanClient: server start failed %d"),r) );
		return r;
		}
	TRequestStatus stat;
	server.Rendezvous(stat);
	if (stat!=KRequestPending)
		server.Kill(0);		// abort startup
	else
		server.Resume();	// logon OK - start the server
	TRACES( RDebug::Print(_L("MemScanClient: Started")) );
	User::WaitForRequest(stat);		// wait for start or death
	// we can't use the 'exit reason' if the server panicked as this
	// is the panic 'reason' and may be '0' which cannot be distinguished
	// from KErrNone
	r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();
	server.Close();
	return r;
	}

EXPORT_C RMemScanClient::RMemScanClient()
: iScanEventPackagePointer( NULL, 0, 0 )
    {
    }
    

// This is the standard retry pattern for server connection
EXPORT_C TInt RMemScanClient::Connect()
	{
	TVersion version(KMemScanServMajor, KMemScanServMinor, KMemScanServBuild);
	TInt retry=2;
	for (;;)
		{
		TInt r=CreateSession(KMemScanServName, version, 1);
		if (r!=KErrNotFound && r!=KErrServerTerminated)
			return r;
		if (--retry==0)
			return r;
		r=StartServer();
		if (r!=KErrNone && r!=KErrAlreadyExists)
			return r;
		}
	}
	
EXPORT_C void RMemScanClient::Close()
	{
	RSessionBase::Close();  //basecall
	}


// ***************************************************************************
// Client Server functions
// ***************************************************************************


// ---------------------------------------------------------------------------
// RMemScanClient::DataGroupsL()
//
// ---------------------------------------------------------------------------
EXPORT_C CDesCArray* RMemScanClient::DataGroupsL() const
    {
    // Ask server to externalize the data group array to buffer
    // and to provide size of buffer 
    TPckgBuf<TInt> bufferSize;
    User::LeaveIfError(SendReceive( EMemScanPrepareDataGroups, TIpcArgs(&bufferSize) ));
    
    // Create a buffer of sufficient size in order to fetch the
	// buffer from the server
	CBufBase* buffer = CBufFlat::NewL( bufferSize() ); //buffer granularity
	CleanupStack::PushL( buffer );
	buffer->ResizeL( bufferSize() ); //buffer size

	// Now fetch the transfer buffer from the server
	TPtr8 pBuffer(buffer->Ptr(0));
	User::LeaveIfError(SendReceive( EMemScanGetDataGroups, TIpcArgs(&pBuffer) ));
    
    // *** Start internalizing the buffer ***
    
    RBufReadStream stream(*buffer);
    CleanupClosePushL(stream);
	
	// Read the number of data groups from the beginning of the stream
	const TInt count = stream.ReadInt32L();
	
    // Create the array for the data group names with appropriate granularity
	CDesCArray* dataGroupNameArray = new (ELeave) CDesCArrayFlat(count);
    CleanupStack::PushL( dataGroupNameArray );
    
	
	// Read each group name to array
    for(TInt i=0; i<count; i++)
        {
        // Read number of bytes in varying length descriptor
        const TInt length = stream.ReadInt32L();
        // Read datagroup name
        HBufC* group = HBufC::NewLC( stream, length );
        dataGroupNameArray->AppendL( *group );
        CleanupStack::PopAndDestroy( group );
        }
    
    // *** Internalizing done ***    
    
    CleanupStack::Pop( dataGroupNameArray );
    CleanupStack::PopAndDestroy( &stream );   
    CleanupStack::PopAndDestroy( buffer );

     
    return dataGroupNameArray;
    }       


// ---------------------------------------------------------------------------
// RMemScanClient::ScanResultL()
//
// ---------------------------------------------------------------------------
EXPORT_C CArrayFix<TInt64>* RMemScanClient::ScanResultL() const
	{
    // Ask server to externalize the scan result array to buffer
    // and to provide size of buffer
	TPckgBuf<TInt> bufferSize;
	User::LeaveIfError(SendReceive(EMemScanPrepareScanResults, TIpcArgs( &bufferSize )));
	
	// Create a buffer of sufficient size in order to fetch the
	// buffer from the server
	CBufBase* buffer = CBufFlat::NewL( bufferSize() ); //buffer granularity
	CleanupStack::PushL( buffer );
	buffer->ResizeL( bufferSize() ); //buffer size

	// Now fetch the transfer buffer from the server
	TPtr8 pBuffer(buffer->Ptr(0));
	TIpcArgs args(&pBuffer);
	User::LeaveIfError(SendReceive( EMemScanGetScanResults, args ));
	
	// *** Start internalizing the buffer ***
	
    RBufReadStream stream(*buffer);
    CleanupClosePushL(stream);
    
	// Read the number of results from the beginning of the stream
	const TInt count = stream.ReadInt32L();
	
    // Create the result array with such granularity
    // that reallocations do not happen
    CArrayFix<TInt64>* resultArray = new (ELeave) CArrayFixFlat<TInt64>(count);
    CleanupStack::PushL(resultArray);
	
	
    // Read scan results for each data group and write them to result array
    for(TInt i=0; i<count; i++)
        {    
        TInt64 result;
        stream >> result;
        resultArray->AppendL(result);
        }
        
    // *** Internalizing done ***        
    
    CleanupStack::Pop( resultArray );
    CleanupStack::PopAndDestroy( &stream );
    CleanupStack::PopAndDestroy( buffer );
	
	
	return resultArray;
	}

// ---------------------------------------------------------------------------
// RMemScanClient::Scan()
//
// ---------------------------------------------------------------------------
EXPORT_C TInt RMemScanClient::Scan(TDriveNumber aDrive)
	{
	TInt err = SendReceive( EMemScanStartScan, TIpcArgs( aDrive ) );
	return err;
	}


// ---------------------------------------------------------------------------
// RMemScanClient::RequestScanEvents()
//
// ---------------------------------------------------------------------------
EXPORT_C void RMemScanClient::RequestScanEvents( TInt& aError, TRequestStatus& aRequestStatus )
    {
	iScanEventPackagePointer.Set( (TUint8*) &aError, sizeof(TInt), sizeof(TInt) );

	TIpcArgs args( &iScanEventPackagePointer );
	SendReceive( EMemScanRequestScanEvents, args, aRequestStatus );
    }


// ---------------------------------------------------------------------------
// RMemScanClient::RequestScanEventsCancel()
//
// ---------------------------------------------------------------------------
EXPORT_C void RMemScanClient::RequestScanEventsCancel()
    {
    // There is nothing client can do if cancelling went wrong, 
    // so we don't return any error
	SendReceive( EMemScanRequestScanEventsCancel );
    }
	

// ---------------------------------------------------------------------------
// RMemScanClient::ScanInProgress()
//
// ---------------------------------------------------------------------------	
EXPORT_C TBool RMemScanClient::ScanInProgress() const
    {
    TBool result = EFalse;
    TInt err = SendReceive(EMemScanInProgress);
	if( err < 0 )
	    {
	    result = EFalse;
	    }
	else
	    {
	    result = static_cast<TBool> (err);
	    }
	return result;
    }


// End of File