/*
* 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 SIM contact view subsession.
*
*/



// INCLUDE FILES
#include "RVPbkSimCntView.h"

// VPbkSimServer
#include <VPbkSimServerOpCodes.h>
#include <VPbkSimStoreTemplateFunctions.h>

// VPbkSimStoreImpl
#include <RVPbkStreamedIntArray.h>
#include <CVPbkSimFieldTypeFilter.h>
#include <RVPbkSimStore.h>

// VPbkEngUtils
#include <VPbkIPCPackage.h>

// System includes
#include <s32mem.h>

// CONSTANTS

// Initial size for the buffer used to retrieve a view contact
const TInt KInitialReadBufSize = 128;
// Maximum size for the buffer used to retrieve a view contact
const TInt KMaxReadBufSize = 4 * KInitialReadBufSize;
// Double factor
const TInt KTwice = 2;
// Max attempts to get sort order.
const TInt KMaxSortOrderAttempts = 5;

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

namespace {

// --------------------------------------------------------------------------
// ExternalizeSortOrderLC
// --------------------------------------------------------------------------
//
HBufC8* ExternalizeSortOrderLC( const RVPbkSimFieldTypeArray& aSortOrder )
    {
    TInt size = aSortOrder.ExternalizedSize();
    HBufC8* buf = HBufC8::NewLC( size );
    TPtr8 ptr( buf->Des() );
    RDesWriteStream stream( ptr );
    CleanupClosePushL( stream );
    stream << aSortOrder;
    ptr.SetLength( size );
    CleanupStack::PopAndDestroy(); // stream
    return buf;
    }

// --------------------------------------------------------------------------
// CountBufferSize
// --------------------------------------------------------------------------
// 
TInt CountBufferSize( const MDesCArray& aFindStrings )
    {
    TInt size( sizeof(TInt) );
    const TInt count( aFindStrings.MdcaCount() );
    for ( TInt i(0); i < count; ++i )
        {
        size += sizeof(TInt);
        size += aFindStrings.MdcaPoint( i ).Size();
        }
    return size;        
    }
    
// --------------------------------------------------------------------------
// ExternalizeFindStringsL
// --------------------------------------------------------------------------
//    
void ExternalizeFindStringsL( 
        HBufC8*& aBuffer,
        const MDesCArray& aFindStrings )
    {
    // Count needed buffer size
    const TInt size( CountBufferSize( aFindStrings ) );
    
    // check if we have buffer
    if ( aBuffer )
        {
        // check if the buffer is big enough
        TPtr8 ptrBuf( aBuffer->Des() );
        if ( ptrBuf.MaxSize() < size  )
            {
            delete aBuffer;
            aBuffer = NULL;
            aBuffer = HBufC8::NewL( size * KTwice );
            }        
        }
    else
        {
        aBuffer = HBufC8::NewL( size * KTwice );
        }
    
    TPtr8 ptr( aBuffer->Des() );
    RDesWriteStream stream( ptr );
    CleanupClosePushL( stream );
    
    const TInt count( aFindStrings.MdcaCount() );    
    stream.WriteInt16L( count );
    for( TInt i(0); i < count; ++i )
        {
        stream.WriteInt16L( aFindStrings.MdcaPoint( i ).Length() );
        stream.WriteL( aFindStrings.MdcaPoint( i ) );
        }
    
    CleanupStack::PopAndDestroy(); // stream    
    }
}

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

// --------------------------------------------------------------------------
// RVPbkSimCntView::RVPbkSimCntView
// C++ default constructor can NOT contain any code, that
// might leave.
// --------------------------------------------------------------------------
//
EXPORT_C RVPbkSimCntView::RVPbkSimCntView() :
        iViewEvent( NULL, 0 ),
        iContactPtr( NULL, 0 ),
        iMatchingBufferSize( NULL, 0 )
    {
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::OpenL
// --------------------------------------------------------------------------
//
EXPORT_C void RVPbkSimCntView::OpenL( RVPbkSimStore& aStore, 
        const RVPbkSimFieldTypeArray& aSortOrder, 
        TVPbkSimViewConstructionPolicy aConstructionPolicy, 
        const TDesC& aViewName,
        CVPbkSimFieldTypeFilter* aFilter )
    {
    if ( !aStore.Handle() )
        {
        User::Leave( KErrArgument );
        }

    if ( !iContactBuf )
        {
        iContactBuf = HBufC8::NewL( KInitialReadBufSize );
        iContactPtr.Set( iContactBuf->Des() );
        }

    HBufC8* sortOrderbuf = ExternalizeSortOrderLC( aSortOrder );
    HBufC8* filterBuf = NULL;
    if ( aFilter )
        {
        filterBuf = aFilter->ExternalizeLC();
        }
    else
        {
        CleanupStack::PushL( filterBuf );
        }

    HBufC8* ipcPackage =
        SerializeParametersL( &aViewName, filterBuf );
	CleanupStack::PushL( ipcPackage );

    User::LeaveIfError( CreateSubSession( aStore, EVPbkSimSrvOpenView, 
        TIpcArgs( sortOrderbuf, ipcPackage, aConstructionPolicy ) ) );
    //ipcPackage,filterBuf,sortOrderbuf
    CleanupStack::PopAndDestroy( 3, sortOrderbuf );
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::Close
// --------------------------------------------------------------------------
//
EXPORT_C void RVPbkSimCntView::Close()
    {
    delete iMatchingBuffer;
    iMatchingBuffer = NULL;
    delete iContactBuf;
    iContactBuf = NULL;
    CloseSubSession( EVPbkSimSrvCloseView );
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::CancelAsyncRequest
// --------------------------------------------------------------------------
//
EXPORT_C void RVPbkSimCntView::CancelAsyncRequest( TInt aReqToCancel )
    {
    TPckg<TInt> opCode( aReqToCancel );
    SendReceive( EVPbkSimSrvCancelAsyncRequest, TIpcArgs( &opCode ) );
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::ListenToViewEvents
// --------------------------------------------------------------------------
//
EXPORT_C void RVPbkSimCntView::ListenToViewEvents( TRequestStatus& aStatus,
    TVPbkSimContactEventData& aEvent )
    {
    TPckg<TVPbkSimContactEventData> pckg( aEvent );
    iViewEvent.Set( pckg );
    SendReceive( EVPbkSimSrvViewEventNotification, TIpcArgs( &iViewEvent ), 
        aStatus );
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::CountL
// --------------------------------------------------------------------------
//
EXPORT_C TInt RVPbkSimCntView::CountL() const
    {
    TInt count = KErrNotFound;
    TPckg<TInt> pckg( count );
    User::LeaveIfError( 
        SendReceive( EVPbkSimSrvViewCount, TIpcArgs( &pckg ) ) );
    return count;
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::ContactAtL
// --------------------------------------------------------------------------
//
EXPORT_C TPtr8 RVPbkSimCntView::ContactAtL( TInt aIndex )
    {
    TInt result = KErrNone;
    do
        {
        result = SendReceive( EVPbkSimSrvGetViewContact, 
            TIpcArgs( aIndex, &iContactPtr ) );
        if ( result == KErrNone )
            {
            return iContactPtr;
            }
        else if ( result == KErrOverflow )
            {
            EnlargeBufferOrLeaveL();
            }
        else
            {
            User::Leave( result );
            }
        } while ( result == KErrOverflow );
        
    return iContactPtr;
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::ChangeSortOrderL
// --------------------------------------------------------------------------
//
EXPORT_C void RVPbkSimCntView::ChangeSortOrderL( 
    const RVPbkSimFieldTypeArray& aSortOrder )
    {
    HBufC8* buf = ExternalizeSortOrderLC( aSortOrder );
    User::LeaveIfError( SendReceive( EVPbkSimSrvChangeViewSortOrder, 
        TIpcArgs( buf ) ) );
    CleanupStack::PopAndDestroy( buf );
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::FindViewIndexL
// --------------------------------------------------------------------------
//
EXPORT_C TInt RVPbkSimCntView::FindViewIndexL( TInt aSimIndex )
    {
    TInt viewIndex = KErrNotFound;
    TPckg<TInt> pckg( viewIndex );
    User::LeaveIfError( SendReceive( EVPbkSimSrvFindViewIndex, 
        TIpcArgs( aSimIndex, &pckg ) ) );
    return viewIndex;
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::ContactMatchingPrefixL
// --------------------------------------------------------------------------
//
EXPORT_C void RVPbkSimCntView::ContactMatchingPrefixL(
        const MDesCArray& aFindStrings,
        TInt& aResultBufferSize,
        TRequestStatus& aStatus )
    {
    TPckg<TInt> resultSize( aResultBufferSize );
    iMatchingBufferSize.Set( resultSize );     
        
    ExternalizeFindStringsL( iMatchingBuffer, aFindStrings );
    SendReceive( EVPbkSimSrvContactMatchingPrefix, 
                 TIpcArgs( iMatchingBuffer, &iMatchingBufferSize ), 
                 aStatus ) ;
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::ContactMatchingResultL
// --------------------------------------------------------------------------
//
EXPORT_C void RVPbkSimCntView::ContactMatchingResultL( 
        TPtr8& aSimMatchResultBufPtr )
    {
    User::LeaveIfError( SendReceive( EVPbkSimSrvContactMathingResult, 
        TIpcArgs( &aSimMatchResultBufPtr ) ) );
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::SortOrderL
// --------------------------------------------------------------------------
//
EXPORT_C HBufC8* RVPbkSimCntView::SortOrderL() const
    {
    // Use loop because there is too requests and after getting the
    // size of the needed buffer it can be that some other client
    // changes the sort order before our second request.
    HBufC8* sortOrder = NULL;
    TInt res = KErrOverflow;
    TInt attempts = 0;
    while ( res == KErrOverflow && attempts < KMaxSortOrderAttempts )
        {
        delete sortOrder;
        // Get first the size
        TInt size = 0;
        TPckg<TInt> pckg( size );
        User::LeaveIfError( SendReceive( EVPbkSimSrvViewSortOrderSize, 
                TIpcArgs( &pckg ) ) );
        // Create a buffer for sort order.
        sortOrder = HBufC8::NewL( size );
        TPtr8 ptr( sortOrder->Des() );
        // Get sort order
        res = SendReceive( EVPbkSimSrvViewSortOrder, TIpcArgs( &ptr ) );
        ++attempts;
        }
        
    User::LeaveIfError( res );
    
    return sortOrder;
    }
    
// --------------------------------------------------------------------------
// RVPbkSimCntView::EnlargeBufferOrLeaveL
// --------------------------------------------------------------------------
//
void RVPbkSimCntView::EnlargeBufferOrLeaveL()
    {
    TInt newLength = 2 * iContactPtr.MaxLength();
    if ( newLength > KMaxReadBufSize )
        {
        User::Leave( KErrOverflow );
        }

    VPbkSimStoreImpl::CheckAndUpdateBufferSizeL( iContactBuf, iContactPtr, 
        newLength );
    }

// --------------------------------------------------------------------------
// RVPbkSimCntView::SerializeParametersL
// --------------------------------------------------------------------------
//
inline HBufC8* RVPbkSimCntView::SerializeParametersL(
        const TDesC* aViewName, const HBufC8* aFilterBuffer ) const
    {
    TInt packageLength = 0;
	packageLength += VPbkEngUtils::VPbkIPCPackage::CountPackageSize
        ( aViewName );
	packageLength += VPbkEngUtils::VPbkIPCPackage::CountPackageSize
        ( aFilterBuffer );

    HBufC8* ipcPackage = HBufC8::NewL( packageLength );
    TPtr8 bufferPtr( ipcPackage->Des() );
    RDesWriteStream writeStream( bufferPtr  );
    writeStream.PushL();

    // Important to externalize everything, even the NULL pointers
    VPbkEngUtils::VPbkIPCPackage::ExternalizeL( aViewName, writeStream );
    VPbkEngUtils::VPbkIPCPackage::ExternalizeL( aFilterBuffer, writeStream );

    writeStream.CommitL();
    
    CleanupStack::PopAndDestroy( &writeStream );

    return ipcPackage;
    }



//  End of File