/*

* 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 RDiagResultsDatabase

*

*/

// USER INCLUDE FILES

#include "diagresultsdatabase.h"

#include "diagresultsdatabaseitem.h"

#include "diagresultsdbrecordinfoarraypacked.h"

#include "diagresultsdatabasetestrecordinfo.h"

#include "diagresultsdbprivatecrkeys.h"

#include "diagresultsdbrecordengineparam.h"

#include "diagresultsdatabasecommon.h"

//#include <diagframeworkdebug.h>

// SYSTEM INCLUDE FILES

#include <s32mem.h> 

#include <centralrepository.h> 

const TInt KResultsDatabaseBufferLength = 0x700;

const TInt KResultsDatabaseSubsessionBufferLength = 0x250;

const TInt KResultsDatabaseGranuality = 50;

// ======== MEMBER FUNCTIONS ========

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

// Constructor.

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

//

EXPORT_C RDiagResultsDatabase::RDiagResultsDatabase(): 

         iBuffer(NULL), iOpen(EFalse)

       , iPtr( NULL, 0 )

    {

    }

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

// Destructor.

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

//

EXPORT_C RDiagResultsDatabase::~RDiagResultsDatabase()

    {

    if ( iBuffer )

        {

        iBuffer->Reset();

        delete iBuffer;

        iBuffer = NULL;    

        }

    }

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

// Create connection to the results DB server

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

//

EXPORT_C TInt RDiagResultsDatabase::Connect( TUid aAppUid )

    {

    LOGME("RDiagResultsDatabase::Connect");

	TRAPD( err, DoConnectL( aAppUid));

	return err;

    }

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

// Start server, create flat buffer and send request.

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

//

void RDiagResultsDatabase::DoConnectL (TUid aAppUid)

    {

    LOGME("RDiagResultsDatabase::DoConnectL");

    if (iBuffer==NULL)

		{

		iBuffer = CBufFlat::NewL(KResultsDatabaseGranuality);

		iBuffer->ResizeL(KResultsDatabaseBufferLength);

		if (iBuffer==NULL)

			User::Leave( KErrNoMemory );

		}

    TInt r = DiagResultsDbCommon::StartServer();

    LOGME1("RDiagResultsDatabase::StartServer %d",r);

	if( r==KErrNone )

	    // Use default message slots

		r = CreateSession( KDiagResultsDatabaseServerName, Version() );

	LOGME1("RDiagResultsDatabase::Createsession %d",r); 

	if ( r != KErrNone )

	    {

	    User::Leave (r);

	    }

	iOpen = ETrue;

    TPckgBuf<TUid> uid( aAppUid );

    TInt srret = SendReceive (DiagResultsDbCommon::EConnect,TIpcArgs(&uid) );

    LOGME1("Rsession sendreceive %d",srret);

    if (srret != KErrNone)

	User::Leave( srret );

    }

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

// Close connection with the server.

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

//

EXPORT_C TInt RDiagResultsDatabase::Close()

    {

    LOGME("RDiagResultsDatabase::Close");

    if ( iOpen )

        {

        TInt err = SendReceive( DiagResultsDbCommon::EClose );

        RHandleBase::Close();

        iOpen = EFalse;

        delete iBuffer;

        iBuffer = NULL;

        return err;    

        }

    else 

        {

        iOpen = EFalse;

        return KErrNone;

        }

    }

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

// Returns the version of this server.

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

//

EXPORT_C TVersion RDiagResultsDatabase::Version() const

    {

    return( TVersion( KDiagResultsDatabaseServerMajor, 

                      KDiagResultsDatabaseServerMinor,

		              KDiagResultsDatabaseServerBuild ) );

    }

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

// Returns test record count.

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

//

EXPORT_C TInt RDiagResultsDatabase::GetRecordCount( TUint& aCount ) const

    {

	TPckgBuf<TUint> pckg;

	TInt error = SendReceive( DiagResultsDbCommon::EGetRecordCount, TIpcArgs(&pckg) );

	aCount = pckg();

	return error;

    }

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

// Fetch maximum number of test records from the central repository.

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

//

EXPORT_C TInt RDiagResultsDatabase::GetDatabaseMaximumSize( TInt& aMaxSize )

    {

    TRAPD( err, DoGetDatabaseMaximumSizeL( aMaxSize ) );

    return err;

    }

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

// Fetch maximum number of test records from the central repository.

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

//

void RDiagResultsDatabase::DoGetDatabaseMaximumSizeL( TInt& aMaxSize )

    {

    CRepository* cr = CRepository::NewLC( KCRUidDiagnosticsResults );

    User::LeaveIfError( cr->Get( KDiagDatabaseMaxRecordCount, aMaxSize ) );

    CleanupStack::PopAndDestroy( cr );

    }

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

// Get available record uids.

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

//

EXPORT_C TInt RDiagResultsDatabase::GetRecordUids( 

            CArrayFixFlat<TUid>& aSortedRecordUidArray ) const

    {

    TRAPD( err, DoGetRecordUidsL( aSortedRecordUidArray ));

    return err;

    }

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

// Resize buffer and then start query. Overflow means that the buffer was not

// large enough.

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

//    

void RDiagResultsDatabase::DoGetRecordUidsL( 

                           CArrayFixFlat<TUid>& aSortedRecordUidArray ) const

    {

    iBuffer->Delete( 0, iBuffer->Size() );

    iBuffer->ResizeL( KResultsDatabaseBufferLength );

    TPtr8 ptr ( iBuffer->Ptr(0) );

    //Now ask server to serialize object into this buffer

    TInt ret = SendReceive( DiagResultsDbCommon::EGetRecordList, 

                            TIpcArgs(&ptr) );

    while ( ret == KErrOverflow )

        {

        iBuffer->ResizeL( iBuffer->Size() + KResultsDatabaseBufferLength );

        ptr.Set( iBuffer->Ptr(0) );

        ret = SendReceive( DiagResultsDbCommon::EGetRecordList, 

                           TIpcArgs(&ptr) );

        }

    if ( ret != KErrNone )

        {

        User::Leave (ret);

        }

    RBufReadStream readStream ( *iBuffer );   

    CleanupClosePushL( readStream ) ;

    TInt count = readStream.ReadInt16L();

    for ( TInt i = 0; i < count; ++i )

        {

        aSortedRecordUidArray.AppendL ( TUid::Uid( readStream.ReadInt32L()) );

        }

   CleanupStack::PopAndDestroy( &readStream );

    }    

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

// Returns last completed record.

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

//

EXPORT_C TInt RDiagResultsDatabase::GetLastRecord( TUid& aRecordUid ) const

    {

    TPckgBuf<TUid> pckg;

	TInt err = SendReceive( DiagResultsDbCommon::EGetLastRecord, 

	                        TIpcArgs(&pckg) );

	aRecordUid = pckg();

	return err;

    }

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

// Get last incomplete record. It could suspended or application crashed

// when running the test.

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

//       

EXPORT_C TInt RDiagResultsDatabase::GetLastNotCompletedRecord ( 

                                                    TUid& aRecordUid ) const

    {

    TPckgBuf<TUid> pckg;

    TInt err = SendReceive( DiagResultsDbCommon::EGetLastNotCompletedRecord, 

	                        TIpcArgs(&pckg) );

	aRecordUid = pckg();

	return err;

    }

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

// Get all test record overviews.

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

//

EXPORT_C TInt RDiagResultsDatabase::GetAllRecordInfos ( 

            CArrayFixFlat<TDiagResultsDatabaseTestRecordInfo>& aInfoArray) 

    {

    TRAPD( err, DoGetAllRecordInfosL( aInfoArray ));

    return err;

    }

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

// Send client request to the server. If overflow, then resize buffer and

// try again. 

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

//

void RDiagResultsDatabase::DoGetAllRecordInfosL ( 

            CArrayFixFlat<TDiagResultsDatabaseTestRecordInfo>& aInfoArray) 

    {

    iBuffer->Delete( 0, iBuffer->Size() );

    iBuffer->ResizeL( KResultsDatabaseBufferLength );

    TPtr8 ptr ( iBuffer->Ptr(0) );

    TInt ret = SendReceive( DiagResultsDbCommon::EGetRecordInfoList, 

                            TIpcArgs(&ptr) );

    while ( ret == KErrOverflow )

        {

        iBuffer->ResizeL( iBuffer->Size() + KResultsDatabaseBufferLength );

        ptr.Set( iBuffer->Ptr(0) );

        ret = SendReceive( DiagResultsDbCommon::EGetRecordInfoList, 

                           TIpcArgs(&ptr) );

        }

    if ( ret != KErrNone )

        {

        User::Leave (ret);

        }

    TDiagResultsDbRecordInfoArrayPacked packedArray( iBuffer );    

    packedArray.UnpackArrayL( aInfoArray );

    }

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

// Asynchronous get last results.

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

//

EXPORT_C void RDiagResultsDatabase::InitiateGetLastResults ( 

                                          const CArrayFixFlat<TUid>& aUidArray,

                                          TRequestStatus& aStatus )

    {    

    TRAPD( error, WriteArrayIntoBufferL( aUidArray ));

    if ( error != KErrNone )

        {         

        TRequestStatus* status = &aStatus;

        User::RequestComplete( status, error );

        return;

        }

    iPtr.Set( iBuffer->Ptr(0) );

	SendReceive( DiagResultsDbCommon::EInitiateGetLastResults, 

	             TIpcArgs( &iPtr ), 

	             aStatus);

    }

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

// Write Array into Buffer:

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

//    

void RDiagResultsDatabase::WriteArrayIntoBufferL( const CArrayFixFlat<TUid>& aUidArray )

    {

    iBuffer->Delete( 0, iBuffer->Size() );

    iBuffer->ResizeL( KResultsDatabaseBufferLength );     

    RBufWriteStream writeStream ( *iBuffer );

    CleanupClosePushL( writeStream );

    writeStream.WriteInt8L( aUidArray.Count() );

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

        {

        writeStream.WriteInt32L( aUidArray[i].iUid );

        }

    writeStream.CommitL();  

    CleanupStack::PopAndDestroy();

    }

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

// Cancel asynchronous request.

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

//

EXPORT_C void RDiagResultsDatabase::CancelInitiateGetLastResults () const

    {

    SendReceive( DiagResultsDbCommon::ECancelInitiateGetLastResults );

    }

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

// See InitiateGetLastResults. After InitiateGetLastResults finishes ok, 

// this method can be called to retrieve data.

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

//    

EXPORT_C TInt RDiagResultsDatabase::GetLastResults ( 

                    RPointerArray<CDiagResultsDatabaseItem>& aResults ) const

    {

    TRAPD( err, DoGetLastResultsL( aResults ) );

    return err;

    }

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

// Resize buffer and make the request. Data is serialized in the buffer so it 

// must be read using a read stream.

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

//

void RDiagResultsDatabase::DoGetLastResultsL ( 

                    RPointerArray<CDiagResultsDatabaseItem>& aResults ) const

    {

    iBuffer->Delete( 0, iBuffer->Size() );

    iBuffer->ResizeL( KResultsDatabaseBufferLength );

    TPtr8 ptr ( iBuffer->Ptr(0));

    //Now ask server to serialize object into this buffer

    TInt ret = SendReceive( DiagResultsDbCommon::EGetLastResults, 

                            TIpcArgs(&ptr) );

    while ( ret == KErrOverflow )

        {

        iBuffer->ResizeL( iBuffer->Size() + KResultsDatabaseBufferLength );

        ptr.Set ( iBuffer->Ptr(0) );

        ret = SendReceive( DiagResultsDbCommon::EGetLastResults, 

                           TIpcArgs(&ptr) );

        }

    if ( ret != KErrNone )

        {

        User::Leave (ret);

        }

    RBufReadStream readStream ( *iBuffer );    

    TInt count = readStream.ReadInt16L();

    for ( TInt i = 0; i < count; ++i )

        {

        TUint8 value = readStream.ReadUint8L();

        if ( value == 0 )

            {

            aResults.AppendL( NULL );

            }

        else 

            {

            aResults.AppendL (CDiagResultsDatabaseItem::NewL( readStream ) );

            }

        }

    readStream.Close();    

    }

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

// Initiate asynchronous operation. 

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

//

EXPORT_C void RDiagResultsDatabase::InitiateGetLastResult ( TUid aTestPluginUid, 

                                      TRequestStatus& aStatus )

    {

    TPckgBuf<TUid> uidpckg( aTestPluginUid );

    SendReceive( DiagResultsDbCommon::EInitiateGetSingleLastResult, 

	             TIpcArgs( &uidpckg ), 

	             aStatus);

    }

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

// Get last result that was fetched using InitiateGetLastResult method.

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

//

EXPORT_C TInt RDiagResultsDatabase::GetLastResult ( 

                                       CDiagResultsDatabaseItem*& aItem )    

    {

    TRAPD( err, DoGetLastResultL( aItem ) );

    return err;            

    }

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

// Leaving version of the function.

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

//    

void RDiagResultsDatabase::DoGetLastResultL ( 

                                        CDiagResultsDatabaseItem*& aItem )    

    {    

    iBuffer->Delete( 0, iBuffer->Size() );

    iBuffer->ResizeL( KResultsDatabaseBufferLength );

    TPtr8 ptr ( iBuffer->Ptr(0));

    //Now ask server to serialize object into this buffer

    TInt ret = SendReceive( DiagResultsDbCommon::EGetSingleLastResult, 

                            TIpcArgs(&ptr) );

    while ( ret == KErrOverflow )

        {

        iBuffer->ResizeL( iBuffer->Size() + KResultsDatabaseBufferLength );

        ptr.Set ( iBuffer->Ptr(0) );

        ret = SendReceive( DiagResultsDbCommon::EGetSingleLastResult, 

                           TIpcArgs(&ptr) );

        }

    if ( ret != KErrNone )

        {

        User::Leave (ret);

        }

    RBufReadStream readStream ( *iBuffer );  

    TInt count = readStream.ReadInt8L();  

    if ( count == 0 )

        {

        aItem = NULL;

        }

    else 

        {

        aItem = CDiagResultsDatabaseItem::NewL ( readStream );    

        }

    readStream.Close();

    }

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

// Subsession constructor.

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

//

EXPORT_C RDiagResultsDatabaseRecord::RDiagResultsDatabaseRecord(): 

                                        iBuffer(NULL), 

                                        iOpen(EFalse)

                                        ,iPtr( NULL, 0 )

    {

    }

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

// Subsession destructor.

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

//

EXPORT_C RDiagResultsDatabaseRecord::~RDiagResultsDatabaseRecord()

    {

     if ( iBuffer )

        {

        iBuffer->Reset();

        delete iBuffer;

        iBuffer = NULL;

        }

    }

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

// Checks if connection is already open.

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

//