/*

* Copyright (c) 2007 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:  Class definition of CDiagResultsDbSession

*

*/

#include "diagresultsdatabasecommon.h"

#include "diagresultsdbsession.h"

#include "diagresultsdbserver.h"

#include "diagresultsdbtestrecordsubsession.h"

#include "diagresultsdatabasetestrecordinfo.h"

#include "diagresultsdbtestrecordhandle.h"

#include "diagresultsdbtestrecord.h"

#include "diagresultsdatabaseitem.h"

#include "diagresultsdbrecordinfoarraypacked.h"

#include "diagresultsdbcrdc.h"

#include "diagresultsdbrecordengineparam.h"

//System includes

#include <s32mem.h>

const TInt KArrayGranuality = 50;

const TInt KResultsDatabaseBufferLength=0x700;

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

// constructor - must pass client to CSession

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

// 

CDiagResultsDbSession::CDiagResultsDbSession(CDiagResultsDbServer * aServer): 

       iServer(aServer), iSubsessionContainer( NULL ), iSubsessionIndex(NULL), 

       iLastResultCommand( 0 ),

       iStore(NULL), iBufferedLastResults(NULL), iBufferedSingleResult(NULL),

       iHasWrittenData(EFalse)

	{

	aServer->IncreaseSessionCount();

	}

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

// NewL.

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

// 

CDiagResultsDbSession* CDiagResultsDbSession::NewL(CDiagResultsDbServer * aServer)

	{

	CDiagResultsDbSession* pSession= new (ELeave) CDiagResultsDbSession( aServer );

	CleanupStack::PushL( pSession );

	pSession->ConstructL();

	CleanupStack::Pop();

	return pSession;

	}

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

// ConstructL.

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

// 

void CDiagResultsDbSession::ConstructL()

	{

	iSubsessionContainer = iServer->NewContainerL();

	iSubsessionIndex = CObjectIx::NewL();

	// buffer for IPC. Objects are transmitted in this buffer.

	// Size of the buffer has to be selected carefully.

	// It should be 'large enough' but not too large.

	// If you see too many overflows, increase the size.

	iBuffer = CBufFlat::NewL(KArrayGranuality);

	iBuffer->ResizeL(KResultsDatabaseBufferLength);

	}

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

// Destructor.

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

// 	

CDiagResultsDbSession::~CDiagResultsDbSession()

	{

    if ( iBuffer )

        {

        iBuffer->Reset();

        delete iBuffer;

        iBuffer = NULL;

        }

	// NOTE!

	// The deletion order is important here. You must

	// delete object indexes first, because this zeros the

	// number of references to any CObject type objects. Trying 

	// to delete object container first, you get panic

	// E32USER-CBase 33: an attempt is made to delete the CObject 

	// when the reference count is not zero.

	delete iSubsessionIndex;

    if ( iSubsessionContainer )

        {

        iServer->RemoveContainer( iSubsessionContainer );

        }

	delete iStore;

    if ( iServer )

        {

        iServer->DecreaseSessionCount();

        }

	if ( iBufferedLastResults )

	    {

	    iBufferedLastResults->ResetAndDestroy();

	    iBufferedLastResults->Close();

	    delete iBufferedLastResults;

	    iBufferedLastResults = 0;

	    }

    if ( iBufferedSingleResult )

        {

        delete iBufferedSingleResult;

        iBufferedSingleResult = NULL;

        }

	}

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

// Service client requests.

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

// 

void CDiagResultsDbSession::ServiceL(const RMessage2& aMessage)

	{

	LOGME("CDiagResultsDbSession::ServiceL");

	TBool async = EFalse;

	TRAPD( err, async = DispatchMessageL( aMessage ) );

	LOGME1("CDiagResultsDbSession::ServiceL %d",err);

	if ( !async ) 

	    {

	    aMessage.Complete( err );

	    }

	}

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

// service a client request; test the opcode and then do appropriate servicing

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

//     

TBool CDiagResultsDbSession::DispatchMessageL(const RMessage2 &aMessage)

	{

	LOGME("CDiagResultsDbSession::DispatchMessageL");

	iMsg = aMessage;

	TInt function = aMessage.Function();

	LOGME1("CDiagResultsDbSession::DispatchMessageL - %d",function);

	TInt handle(0);

	CObject* subsession = NULL;

	switch( function )

        {

	case DiagResultsDbCommon::EConnect:

	    {

	    LOGME("CDiagResultsDbSession::EConnect");

	    TPckgBuf<TUid> uidpckg;

	    aMessage.Read(0, uidpckg);

        iDbUid = uidpckg();

        iStore = CDiagResultsDbStore::NewL( iDbUid );

		return EFalse;

	    }

    case DiagResultsDbCommon::EClose:

        {        

        LOGME("CDiagResultsDbSession::EClose");

        aMessage.Complete (KErrNone);

        return ETrue;

        }

    case DiagResultsDbCommon::EGetRecordCount:

        {        

        LOGME("CDiagResultsDbSession::EGetRecordCount");

        RArray<TUid> uids;

        CleanupClosePushL ( uids );

        iStore->RecordUidsL( uids );

        TPckgBuf<TUint> pckg( uids.Count() );

        aMessage.Write(0, pckg);

        CleanupStack::PopAndDestroy( &uids );

        return EFalse;

        }

	case DiagResultsDbCommon::EConnectSubsession:

			LOGME("CDiagResultsDbSession::EConnectSubsession");

	    ConnectSubsessionL( aMessage );

		return EFalse;			

	case DiagResultsDbCommon::ESubsessionCreateNewRecord:

			LOGME("CDiagResultsDbSession::ESubsessionCreateNewRecord");

	    CreateNewRecordL( aMessage );

	    HasWritten();

		return EFalse;

	case DiagResultsDbCommon::ECloseSubsession:

		LOGME("CDiagResultsDbSession::ECloseSubsession");

		CloseSubsessionL();

		return EFalse;

    case DiagResultsDbCommon::EGetLastRecord:  

    		LOGME("CDiagResultsDbSession::EGetLastRecord");

        GetLastRecordL( aMessage );

        return EFalse;

    case DiagResultsDbCommon::EGetLastNotCompletedRecord:

    		LOGME("CDiagResultsDbSession::EGetLastNotCompletedRecord");

        GetLastNotCompletedRecordL( aMessage );

        return EFalse;

    case DiagResultsDbCommon::EGetRecordList: //record uids 

    		LOGME("CDiagResultsDbSession::EGetRecordList");

        GetRecordListL( aMessage );

        return EFalse;

    case DiagResultsDbCommon::EGetRecordInfoList:

    		LOGME("CDiagResultsDbSession::EGetRecordInfoList");

        GetRecordInfoListL( aMessage );

        return EFalse;

    case DiagResultsDbCommon::EInitiateGetLastResults:  //Async

        {     

        LOGME("CDiagResultsDbSession::EInitiateGetLastResults");

        ReadBufferL( aMessage, 0, iBuffer );

        iLastResultsMsg = iMsg;

        iLastResultCommand = DiagResultsDbCommon::EInitiateGetLastResults;	

        if ( iBufferedLastResults )

	        {

	        iBufferedLastResults->ResetAndDestroy();

	        iBufferedLastResults->Close();

	        delete iBufferedLastResults;

	        iBufferedLastResults = 0;

	        }

        iStore->ExistingRecordsAsyncL( *this );

        return ETrue;

        }

    case DiagResultsDbCommon::EInitiateGetSingleLastResult: //Async

        {           

        LOGME("CDiagResultsDbSession::EInitiateGetSingleLastResult");     

        iLastSingleResultsMsg = iMsg;

        iLastResultCommand = DiagResultsDbCommon::EInitiateGetSingleLastResult;	

        if ( iBufferedSingleResult )

            {

            delete iBufferedSingleResult;

            iBufferedSingleResult = NULL;

            }

        iStore->ExistingRecordsAsyncL( *this );

        return ETrue;  

        }

    case DiagResultsDbCommon::EGetLastResults:    

    		LOGME("CDiagResultsDbSession::EGetLastResults");     

        GetLastResultsL( aMessage );

        return EFalse;

    case DiagResultsDbCommon::EGetSingleLastResult: 

    		LOGME("CDiagResultsDbSession::EGetSingleLastResult");        

        GetSingleLastResultL( aMessage );

        return EFalse;    

    case DiagResultsDbCommon::ECancelInitiateGetLastResults:

        {

        LOGME("CDiagResultsDbSession::ECancelInitiateGetLastResults");        

        CancelLastResultsL( aMessage );

        return EFalse;

        }

	// Sub-session requests. See CDiagResultsDbTestRecordSubsession.

    case DiagResultsDbCommon::ESubsessionGetTestRecordId:

    case DiagResultsDbCommon::ESubsessionTestCompleted:

    case DiagResultsDbCommon::ESubsessionIsTestCompleted:

    case DiagResultsDbCommon::ESubsessionGetRecordInfo:

    case DiagResultsDbCommon::ESubsessionGetTestUids:

    case DiagResultsDbCommon::ESubsessionSuspend:

    case DiagResultsDbCommon::ESubsessionIsSuspended:

    case DiagResultsDbCommon::ESubsessionLogTestResult:

    case DiagResultsDbCommon::ESubsessionGetTestResult:

    case DiagResultsDbCommon::ESubsessionGetTestResults:

    case DiagResultsDbCommon::ESubsessionGetEngineParam:

    case DiagResultsDbCommon::ESubsessionGetStatus:

    case DiagResultsDbCommon::ESubsessionCancelLogTestResult:

    LOGME("CDiagResultsDbSession::ESubsessionCancelLogTestResult");        

		handle = aMessage.Int3();

		subsession = iSubsessionIndex->At( handle );

		return static_cast<CDiagResultsDbTestRecordSubsession*>(subsession)

		                                    ->DispatchMessageL( aMessage );

	default:

		aMessage.Panic( _L("DiagSrv panic: unknown command"), 

		                    DiagResultsDbCommon::EBadRequest );

		return EFalse;

		}

	}

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

// Get function.

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

// 

TBool CDiagResultsDbSession::SessionHasWritten() const

    {

    return iHasWrittenData;

    }

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

// Connect to a subsession. Test record represents the connected subsession.

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

//     

void CDiagResultsDbSession::ConnectSubsessionL( const RMessage2 &aMessage )    

    {

    TPckgBuf<TUid> uidpckg;

	aMessage.Read(0, uidpckg);

    TUid recordUid = uidpckg(); 

    TPckgBuf<TBool> readOnlyPckg;

	aMessage.Read(1, readOnlyPckg);

    TBool readonly = readOnlyPckg();

	CDiagResultsDbTestRecordHandle* handle = iStore->OpenExistingHandleL( 

	                                           recordUid );

    if ( readonly ) 

        {

        // keep the record as it is.

        }

    else

        {

        if ( handle->RecordInfo().iCompleted )

            {

            delete handle;

            handle = 0;

            User::Leave( KErrAlreadyExists );

            }

        handle->RecordInfo().iRecordStatus = 

                TDiagResultsDatabaseTestRecordInfo::EOpen;

        }

    CreateSubsessionL( handle, readonly );

    }

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

// Create a new record. This does not write data into the db file.

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

//     

void CDiagResultsDbSession::CreateNewRecordL ( const RMessage2 &aMessage )

    {

    ReadBufferL( aMessage, 1, iBuffer );

    RBufReadStream stream( *iBuffer );

    CleanupClosePushL ( stream );

    CDiagResultsDbRecordEngineParam* params = 

                            CDiagResultsDbRecordEngineParam::NewL ( stream );

    CleanupStack::PushL( params );                         

    CDiagResultsDbTestRecordHandle* handle = iStore->CreateNewRecordL( params );

    handle->RecordInfo().iRecordStatus = 

                                TDiagResultsDatabaseTestRecordInfo::EOpen;

    CleanupStack::Pop(); //params    

    CleanupStack::PopAndDestroy( &stream );

	CreateSubsessionL(handle, EFalse);

	TPckgBuf<TUid> recorduidpckg( handle->RecordInfo().iRecordId );

	aMessage.Write(0, recorduidpckg );

    }

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

// Return the database file uid.

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

//      

TUid CDiagResultsDbSession::DbUid() const

    {

    return iDbUid;

    }

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

// Create a new subsession.

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

//     

void CDiagResultsDbSession::CreateSubsessionL( 

                            CDiagResultsDbTestRecordHandle* aTestRecordHandle,

                            TBool aReadonly )

	{

    TInt handle(0);

    CObject* subsession = NULL;

	// Create sub-session object

	subsession = CDiagResultsDbTestRecordSubsession::NewL( this, 

	                                                    aTestRecordHandle,

	                                                    aReadonly );

    CleanupStack::PushL( subsession );

    iSubsessionContainer->AddL( subsession );

    CleanupStack::Pop();

	// Create sub-session handle

	TRAPD( err, handle = iSubsessionIndex->AddL( subsession ) );

	// Remember to remove session object from object container

	if( err != KErrNone )

		{

		iSubsessionContainer->Remove( subsession ); 

		User::Leave( DiagResultsDbCommon::ESvrCreateSubsession );

		}

    // Package to pass information to the client

    TPckgC<TInt> handlePckg(handle);

    // Send handle to the client

    TRAP( err, iMsg.WriteL( 3, handlePckg ) );

	if( err != KErrNone )

		{

		iSubsessionIndex->Remove(handle);

		User::Leave( DiagResultsDbCommon::ESvrCreateSubsession );

		}

	return;

	}

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

// Close existing subsession.

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

// 

void CDiagResultsDbSession::CloseSubsessionL()

	{

	TInt handle = iMsg.Int3();

	iSubsessionIndex->Remove(handle);

	}

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

// Return store that is responsible for handling the database file.

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

// 	

CDiagResultsDbStore& CDiagResultsDbSession::Store()

    {

    return *iStore;

    }

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

// Service function. Searches for newest test results. 

//    Related functions: 

//    ExistingRecordsAsyncL (initiates async fetch of test records)

//    CancelLastResultsL (cancel async fetch)

//    ExistingRecordsL (retrieves test records)

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

// 

void CDiagResultsDbSession::GetLastResultsL( const RMessage2 &aMessage )

    {

    if ( iBufferedLastResults == NULL )

        {

        User::Leave ( KErrNotFound );

        }

    ReadBufferL( aMessage, 0, iBuffer );

    RBufWriteStream stream ( *iBuffer );

    CleanupClosePushL( stream );

    stream.WriteInt16L( iBufferedLastResults->Count() );

    for ( TInt i = 0; i < iBufferedLastResults->Count(); ++i )

        {    

        CDiagResultsDatabaseItem* item = (*iBufferedLastResults)[i];

        if ( item == NULL )

            {

            stream.WriteUint8L(0); 

            }

        else 

            {

            stream.WriteUint8L(1);

            (*iBufferedLastResults)[i]->ExternalizeL( stream );

            }

        }

    if ( iBuffer->Ptr(0).Length() > aMessage.GetDesMaxLength(0) )

        {

        User::Leave( KErrOverflow );

        }

    stream.CommitL();

    CleanupStack::PopAndDestroy( &stream );

    aMessage.Write( 0, iBuffer->Ptr(0) ); //write to client's address space 

    iBufferedLastResults->ResetAndDestroy();

    iBufferedLastResults->Close();

    delete iBufferedLastResults;

    iBufferedLastResults = NULL;   

    }

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

// Service function. Get single test result (the newest).

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

//   

void CDiagResultsDbSession::GetSingleLastResultL( const RMessage2 &aMessage )

    {

    ReadBufferL( aMessage, 0, iBuffer );

    RBufWriteStream stream ( *iBuffer );

    CleanupClosePushL( stream );

    if ( iBufferedSingleResult )

        {

        stream.WriteInt8L( 1 );

        iBufferedSingleResult->ExternalizeL( stream );