/*

* Copyright (c) 2002-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:  A class that can read multiple contacts from ETel store

*                Uses ETel RMobilePhoneBookStore Read

*

*/

// INCLUDE FILES

#include "CMultipleReadCmd.h"

#include "CVPbkETelCntConverter.h"

#include "CVPbkSimContactBuf.h"

#include "CVPbkSimCntField.h"

#include "VPbkSimStoreImplError.h"

#include "CBasicStore.h"

#include "CContactArray.h"

#include "VPbkDebug.h"

namespace VPbkSimStoreImpl {

// CONSTANTS

// Define some default size of one contact for buffer creation

const TInt KDefaultSizeForOneContact = 256;

// Define a maximum size for the read buffer. 20 contacts at one request is

// a pretty good base for maximum.

const TInt KMaxSizeForBuffer = 20 * KDefaultSizeForOneContact;

// ============================= LOCAL FUNCTIONS ===============================

namespace {

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

// Return the number of indexes

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

//

inline TInt AmountOfIndexes( TInt aLastIndex, TInt aFirstIndex )

    {

    return aLastIndex - aFirstIndex + 1;

    }

} // unnamed namespace

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

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

// CMultipleReadCmd::CMultipleReadCmd

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMultipleReadCmd::CMultipleReadCmd( CBasicStore& aBasicStore, 

        TInt aFirstIndexToRead, TInt aLastIndexToRead )

        :   CActive( EPriorityStandard ),

            iBasicStore( aBasicStore ),

            iFirstIndexToRead( aFirstIndexToRead ),

            iLastIndexToRead( aLastIndexToRead ),

            iIndexToRead( KVPbkSimStoreInvalidETelIndex ),

            iBufferPtr( 0, NULL )

    {

    CActiveScheduler::Add( this );

    }

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

// CMultipleReadCmd::CMultipleReadCmd

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMultipleReadCmd::CMultipleReadCmd( CBasicStore& aBasicStore, 

        TInt& aIndexToRead )

        :   CActive( EPriorityStandard ),

            iBasicStore( aBasicStore ),

            iFirstIndexToRead( KVPbkSimStoreInvalidETelIndex ),

            iLastIndexToRead( KVPbkSimStoreInvalidETelIndex ),

            iIndexToRead( aIndexToRead ),

            iBufferPtr( 0, NULL )

    {

    CActiveScheduler::Add( this );

    }

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

// CMultipleReadCmd::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMultipleReadCmd::ConstructL()

    {

    iCntConverter = CVPbkETelCntConverter::NewL();

    }

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

// CMultipleReadCmd::NewLC

// Two-phased constructor.

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

//

CMultipleReadCmd* CMultipleReadCmd::NewLC( CBasicStore& aBasicStore )

    {

    CMultipleReadCmd* self = new( ELeave ) CMultipleReadCmd( aBasicStore, 

        KVPbkSimStoreFirstETelIndex, KVPbkSimStoreInvalidETelIndex );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CMultipleReadCmd::NewLC

// Two-phased constructor.

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

//

CMultipleReadCmd* CMultipleReadCmd::NewLC( CBasicStore& aBasicStore,    

        TInt aFirstIndexToRead, TInt aLastIndexToRead )

    {

    CMultipleReadCmd* self = new( ELeave ) CMultipleReadCmd( aBasicStore, 

            aFirstIndexToRead, aLastIndexToRead );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CMultipleReadCmd::NewLC

// Two-phased constructor.

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

//

CMultipleReadCmd* CMultipleReadCmd::NewLC( CBasicStore& aBasicStore, 

        TInt& aIndexToRead )

    {

    CMultipleReadCmd* self = new( ELeave ) CMultipleReadCmd( aBasicStore, 

        aIndexToRead );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CMultipleReadCmd::~CMultipleReadCmd()

    {

    CancelCmd();

    delete iCntConverter;

    delete iBuffer;

    iCntArray.ResetAndDestroy();

    iCntArray.Close();

    }

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

// CMultipleReadCmd::Execute

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

//

void CMultipleReadCmd::Execute()

    {

    __ASSERT_DEBUG( iObserver,

        VPbkSimStoreImpl::Panic( EPreCondCMultipleReadCmdExecute ) );

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: CMultipleReadCmd::Execute Request") );        

    if ( iIndexToRead != KVPbkSimStoreInvalidETelIndex )

        {

        iFirstIndexToRead = iIndexToRead;

        iLastIndexToRead = iIndexToRead;

        }

    else if ( iLastIndexToRead == KVPbkSimStoreInvalidETelIndex )

        {

        iLastIndexToRead = iBasicStore.ETelStoreInfo().iTotalEntries;

        }

    // Define the size of the buffer. ETel iTotalEntries can not be trusted.

    TInt amountOfIndexes = 

        AmountOfIndexes( iLastIndexToRead, iFirstIndexToRead );

    if ( amountOfIndexes > 0 )

        {

        // Create a buffer according to amount of possible contacts to read.

        // There must be a limit for the size.

        TInt size = Min( KMaxSizeForBuffer, 

            amountOfIndexes * KDefaultSizeForOneContact );

        TRAPD( result, iBuffer = HBufC8::NewL( size ) );

        if ( result != KErrNone )

            {

            DoDummyRequest( result );

            }

        else

            {

            iBufferPtr.Set( iBuffer->Des() );

            DoRequest();

            }

        }

    else

        {

        // There was probably a problem with ETel iTotalEntries.

        // Behave same as iTotalEntries would be zero. Completing with

        // KErrNotFound from ETel means that there were no contacts

        // in given index range.

        DoDummyRequest( KErrNotFound );

        }

    }

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

// CMultipleReadCmd::AddObserverL

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

//

void CMultipleReadCmd::AddObserverL( MVPbkSimCommandObserver& aObserver )

    {

    __ASSERT_DEBUG( !iObserver,

        VPbkSimStoreImpl::Panic( EPreCondCMultipleReadCmdAddObserverL ) );

    iObserver = &aObserver;

    }

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

// CMultipleReadCmd::CancelCmd

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

//

void CMultipleReadCmd::CancelCmd()

    {

    CActive::Cancel();

    }

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

// CMultipleReadCmd::RunL

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

//

void CMultipleReadCmd::RunL()

    {

    TInt result = iStatus.Int();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: RMobilePhoneBooStore::Read h%d complete %d"),

        iBasicStore.ETelStore().SubSessionHandle(), result);

    switch ( result )

        {

        case KErrNone:

            {

            // Convert from ETel to own contacts

            ConvertContactsL();

            // Check that was the buffer big enough

            if ( WasBufferBigEnough() )

                {

                // Contacts were found -> update contact array

                UpdateContactArrayL();

                }

            // Buffer wasn't big enough -> Check that it's not growing

            // for ever.

            else if ( !IsBufferSizeInSane() )

                {

                // Make buffer bigger and read again

                EnlargeBufferL();

                }

            else

                {

                // Stop trying -> there is something wrong in ETel 

                result = KErrOverflow;

                }

            // Stop if error

            if ( result != KErrNone )

                {

                iObserver->CommandError( *this, result );

                }

            // If all the indexes have been read and we are done.

            else if ( AmountOfIndexes( 

                        iLastIndexToRead, iFirstIndexToRead ) <= 0 )

                {

                iObserver->CommandDone( *this );

                }

            // There are still contacts to read

            else

                {

                DoRequest();

                }

            break;

            }

        case KErrNotFound:

            {

            // If nothing found update the array and complete command.

            iBasicStore.Contacts().Delete( iFirstIndexToRead, iLastIndexToRead );

            iObserver->CommandDone( *this );

            break;

            }

        default:

            {

            iObserver->CommandError( *this, result );

            break;

            }

        }

    }

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

// CMultipleReadCmd::DoCancel

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

//

void CMultipleReadCmd::DoCancel()

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: RMobilePhoneBooStore::Read h%d Cancel"),

        iBasicStore.ETelStore().SubSessionHandle());

    iBasicStore.ETelStore().CancelAsyncRequest( EMobilePhoneStoreRead );

    }

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

// CMultipleReadCmd::RunError

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

//

TInt CMultipleReadCmd::RunError( TInt aError )

    {

    iObserver->CommandError( *this, aError );

    return KErrNone;

    }

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

// CMultipleReadCmd::DoDummyRequest

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

//

void CMultipleReadCmd::DoDummyRequest( TInt aResult )

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: CMultipleReadCmd dummy request"));

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, aResult );

    SetActive();

    }

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

// CMultipleReadCmd::DoRequest

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

//

void CMultipleReadCmd::DoRequest()

    {

    ResetBuffer();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: RMobilePhoneBooStore::Read h%d request\

        firstslot=%d,lastslot=%d"),

        iBasicStore.ETelStore().SubSessionHandle(),

        iFirstIndexToRead, iLastIndexToRead);

    iBasicStore.ETelStore().Read( iStatus, iFirstIndexToRead, 

        AmountOfIndexes( iLastIndexToRead, iFirstIndexToRead ), iBufferPtr );

    SetActive();

    }

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

// CMultipleReadCmd::IsBufferSizeInSane

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

//

TBool CMultipleReadCmd::IsBufferSizeInSane()

    {

    __ASSERT_DEBUG( iBuffer, 

        Panic( EPreCond_CMultipleReadCmd_IsBufferSizeInSane ) );

    if ( iBuffer->Size() >= KMaxSizeForBuffer )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CMultipleReadCmd::EnlargeBufferL

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

//

void CMultipleReadCmd::EnlargeBufferL()

    {

    __ASSERT_DEBUG( iBuffer, 

        Panic( EPreCond_CMultipleReadCmd_EnlargeBufferL ) );

    const TInt doubleFactor = 2;

    TInt newSize = iBufferPtr.MaxSize() * doubleFactor;

    HBufC8* buffer = HBufC8::NewL( newSize );

    delete iBuffer;

    iBuffer = buffer;

    iBufferPtr.Set( iBuffer->Des() );

    }

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

// CMultipleReadCmd::ConvertContactsL

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

//

void CMultipleReadCmd::ConvertContactsL()

    {    

    // Make sure that there are no old contacts

    iCntArray.ResetAndDestroy();

    if ( iBufferPtr.Length() > 0 )

        {

        iCntConverter->ConvertFromETelToVPbkSimContactsL( 

            iCntArray, iBufferPtr, iBasicStore );

        }

    }

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

// CMultipleReadCmd::WasBufferBigEnough

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

//

TBool CMultipleReadCmd::WasBufferBigEnough()

    {

    // ConvertContactsL must be called before this. The logic is that if

    // ETel retuned KErrNone from Read request but there are not contacts

    // in iBuffer then the buffer was too small.

    return iCntArray.Count() > 0;

    }

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

// CMultipleReadCmd::UpdateContactArrayL

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

//

void CMultipleReadCmd::UpdateContactArrayL()

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: CMultipleReadCmd::UpdateContactArrayL "));

    __ASSERT_DEBUG( iCntArray.Count() > 0, Panic( EReadingFromETelFailed ) );

    // Get amount of contacts

    TInt cntCount = iCntArray.Count();

    for ( TInt i = cntCount - 1; i >= 0; --i )

        {

        // Check the biggest sim index that was read

        TInt simIndex = iCntArray[i]->SimIndex();

        if ( simIndex >= iFirstIndexToRead )

            {

            // iFirstIndexToRead must be the first sim index that was not read.

            iFirstIndexToRead = simIndex + 1; 

            }

        // Add contacts to contact array. Ownership changes.

        iBasicStore.Contacts().AddOrReplaceL( iCntArray[i] );

        iCntArray.Remove( i );

        }

    }

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

// CMultipleReadCmd::ResetBuffer

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

//

void CMultipleReadCmd::ResetBuffer()

    {

    iBufferPtr.FillZ( iBufferPtr.MaxLength() );

    iBufferPtr.Zero();

    }

} // namespace VPbkSimStoreImpl

//  End of File