/*

* Copyright (c) 2004-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:  Central repository proxy.

*

*/

// INCLUDE FILES

#include    "CVtEngCRObserverItem.h"

#include    "CVtEngCRProxy.h"

#include    "MVtEngCRSettingObserver.h"

#include    <cvtlogger.h>

// CONSTANTS

const TInt KVtEngCRProxyObsGranularity = 5;

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

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

// CVtEngCRProxy::CVtEngCRProxy

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

// might leave.

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

//

CVtEngCRProxy::CVtEngCRProxy() : iObserverItems( KVtEngCRProxyObsGranularity )

    {

    }

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

// CVtEngCRProxy::NewL

// Two-phased constructor.

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

//

CVtEngCRProxy* CVtEngCRProxy::NewL( )

    {

    __VTPRINTENTER( "CRProxy.NewL" )

    CVtEngCRProxy* self = new( ELeave ) CVtEngCRProxy;

    __VTPRINTEXIT( "CRProxy.NewL" )

    return self;

    }

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

// CVtEngCRProxy::~CVtEngCRProxy

// Destructor.

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

//

CVtEngCRProxy::~CVtEngCRProxy()

    {

    __VTPRINTENTER( "CRProxy.~" )

    RemoveAllObservers();

    RemoveSessions();

    __VTPRINTEXIT( "CRProxy.~" )

    }

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

// CVtEngCRProxy::FindItem

// Finds observer item.

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

//

CVtEngCRObserverItem* CVtEngCRProxy::FindItem( 

    const TUid& aUid, 

    const TUint32 aKey,

    TInt& aIndex ) const

    {

    TInt count( iObserverItems.Count() );

    CVtEngCRObserverItem* item = NULL;

    TBool found( EFalse );

    while ( count-- && !found )

        {

        item = iObserverItems[ count ];

        if ( item->Offer( aUid, aKey ) )

            {

            aIndex = count;

            found = ETrue;

            }

        }

    // Just NULL the item if not found

    if ( !found )

        {

        item = NULL;

        }

    return item;

    }

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

// CVtEngCRProxy::FindItem

// Finds observer item.

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

//

CVtEngCRObserverItem* CVtEngCRProxy::FindItem( 

    const TUint32 aKey, TInt& aIndex ) const

    {

    TInt count( iObserverItems.Count() );

    CVtEngCRObserverItem* item = NULL;

    if ( aIndex < 0 )

        {

        return NULL;

        }

    for ( ; aIndex < count; aIndex++ )

        {

        item = iObserverItems[ aIndex ];

        if ( item->Offer( aKey  ) )

            {

            break;

            }

        }

    return item;

    }

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

// CVtEngCRProxy::RemoveInterested

// Removes a cent rep listener.

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

//

void CVtEngCRProxy::RemoveInterested( CVtEngCRObserverItem& aObserver )

    {

    __VTPRINTENTER( "CRProxy.RemoveInterested" )

    TInt index ( 0 );

    CVtEngCRObserverItem* item = FindItem( aObserver.Uid(), 

        aObserver.Key(), index );

    if ( !item )

        {

        // Should not be possible.

        __VTPRINTEXITR( "CRProxy.RemoveInterested %d", 0 )

        return;

        }

    delete item;

    iObserverItems.Remove( index );

    __VTPRINTEXITR( "CRProxy.RemoveInterested %d", 1 )

    }

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

// CVtEngCRProxy::NewCRSessionL

// New Central repository-uid pairing.

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

//

CVtEngCRProxy::CCRSession* CVtEngCRProxy::NewCRSessionL( TUid aUid )

    {

    __VTPRINTENTER( "CRProxy.NewCRSessionL" )

    CRepository* crSession = CRepository::NewL( aUid );

    CleanupStack::PushL( crSession );

    CCRSession* csSession = new ( ELeave ) CCRSession;

    csSession->iSession = crSession;

    csSession->iUid = aUid;    

    CleanupStack::Pop( crSession );

    __VTPRINTEXIT( "CRProxy.NewCRSessionL" )

    return csSession;

    }

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

// CVtEngCRProxy::RegisterInterested

// New Central repository listener.

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

//

void CVtEngCRProxy::RegisterInterestedL( CVtEngCRObserverItem* aObserver )

    {

    __VTPRINTENTER( "CRProxy.RegisterInterestedL" )

    CRepository* crSession = MapUidToCR( aObserver->Uid() );

    CCRSession* csSession = NULL;

    if( !crSession )

        {

        csSession = NewCRSessionL( aObserver->Uid() );

        CleanupStack::PushL( csSession );

        crSession = csSession->iSession;

        iCRSessions.AppendL( csSession );

        CleanupStack::Pop( csSession );

        }

    CCenRepNotifyHandler* notifier = 

        CCenRepNotifyHandler::NewL( *aObserver, *crSession, 

        aObserver->Type(), aObserver->Key() );

    //notifier ownership transfered

    aObserver->SetCenRepNotifier( notifier );

    notifier->StartListeningL();

    iObserverItems.AppendL ( aObserver );

    __VTPRINTEXIT( "CRProxy.RegisterInterestedL" )

    }

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

// CVtEngCRProxy::MapUidToCR

// Maps a given UID to a Central repository session.

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

//

CRepository* CVtEngCRProxy::MapUidToCR( const TUid aUid )

    {

    __VTPRINTENTER( "CRProxy.Map" )

    CCRSession* csSession = NULL;

    TBool found( EFalse );

    TInt count( iCRSessions.Count() );

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

        {

        csSession = iCRSessions[ i ];

        if ( csSession->iUid == aUid )

            {

            i = count; // break loop

            found = ETrue;

            }

        }

    CRepository* session = NULL;        

    // Only return something when found.

    if ( found )

        {

        session = csSession->iSession;

        }

    __VTPRINTEXITR( "CRProxy.Map %d", (TInt) session )

    return session;

    }

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

// CVtEngCRProxy::RemoveAllObservers

// All observers off they go.

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

//    

void CVtEngCRProxy::RemoveAllObservers()

    {

    __VTPRINTENTER( "CRProxy.RemoveAll" )

    iObserverItems.ResetAndDestroy();

    iObserverItems.Close();

    __VTPRINTEXIT( "CRProxy.RemoveAll" )

    }

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

// CVtEngCRProxy::RemoveSessions

// Removes all Central repository sessions.

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

//

void CVtEngCRProxy::RemoveSessions()

    {

    __VTPRINTENTER( "CRProxy.RemoveAllS" )

    iCRSessions.ResetAndDestroy();

    iCRSessions.Close();

    __VTPRINTEXIT( "CRProxy.RemoveAllS" )

    }

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

// CVtEngCRProxy::GetSession

// Gets an existing or a new Central repository session for a UID.

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

//

TInt CVtEngCRProxy::GetSessionL( const TUid aUid, CRepository*& crSession )

    {

    TInt err( KErrNone );

    crSession = MapUidToCR( aUid );

    if ( !crSession )

        {

        CCRSession* session = NULL;

        session = NewCRSessionL( aUid );

        if ( session )

            {

            CleanupStack::PushL( session );

            iCRSessions.AppendL( session );

            CleanupStack::Pop( session );

            crSession = session->iSession;

            }

        else 

            {

            err = KErrNotFound;

            }

        }

    return err;

    }

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

// CVtEngCRProxy::Get

// Gets integer value.

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

//

TInt CVtEngCRProxy::Get( const TUid aUid, const TUint32 aId, TInt& aVal )

    {

    __VTPRINTENTER( "CRProxy.GetInt" )       

    __VTPRINT3( DEBUG_GEN, "UID=%d,key=%d", aUid.iUid, (TInt) aId );

    CRepository* crSession = NULL;

    TRAPD( err, GetSessionL( aUid, crSession ) );

    if ( err == KErrNone )

        {

        err = crSession->Get( aId, aVal );

        }

    __VTPRINTEXITR( "CRProxy.GetInt %d", err )

    return err;

    }

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

// CVtEngCRProxy::Get

// Gets real value.

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

//

TInt CVtEngCRProxy::Get( const TUid aUid, const TUint32 aId, TReal& aVal )

    {

    __VTPRINTENTER( "CRProxy.GetReal" )

    __VTPRINT3( DEBUG_GEN, "UID=%d,key=%d", aUid.iUid, (TInt) aId );

    CRepository* crSession = NULL;

    TRAPD( err, GetSessionL( aUid, crSession ) );

    if ( err == KErrNone )

        {

        err = crSession->Get( aId, aVal );

        }

    __VTPRINTEXITR( "CRProxy.GetR %d", err )

    return err;

    }

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

// CVtEngCRProxy::Get

// Gets binary value.

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

//

TInt CVtEngCRProxy::Get( const TUid aUid, const TUint32 aId, TDes8& aVal )

    {

    __VTPRINTENTER( "CRProxy.GetD8" )

    __VTPRINT3( DEBUG_GEN, "UID=%d,key=%d", aUid.iUid, (TInt) aId );

    CRepository* crSession = NULL;

    TRAPD( err, GetSessionL( aUid, crSession ) );

    if ( err == KErrNone )

        {

        err = crSession->Get( aId, aVal );

        }

    __VTPRINTEXITR( "CRProxy.GetD8 %d", err )

    return err;

    }

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

// CVtEngCRProxy::Get

// Gets string value.

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

//      

TInt CVtEngCRProxy::Get( const TUid aUid, const TUint32 aId, TDes16& aVal )

    {

    __VTPRINTENTER( "CRProxy.GetD16" )

    __VTPRINT3( DEBUG_GEN, "UID=%d,key=%d", aUid.iUid, (TInt) aId );

    CRepository* crSession = NULL;

    TRAPD( err, GetSessionL( aUid, crSession ) );

    if ( err == KErrNone )

        {

        err = crSession->Get( aId, aVal );

        }

    __VTPRINTEXITR( "CRProxy.GetD16 %d", err )

    return err;

    }

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

// CVtEngCRProxy::Set

// Sets integer value to Central Repository.

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

//

TInt CVtEngCRProxy::Set( const TUid aUid, const TUint32 aId, TInt aVal )

    {

    __VTPRINTENTER( "CRProxy.SetInt" )

    CRepository* crSession = NULL;

    TRAPD( err, GetSessionL( aUid, crSession ) );

    if ( err == KErrNone )

        {

        err = crSession->Set( aId, aVal );

        }

    __VTPRINTEXITR( "CRProxy.SetInt %d", err )

    return err;

    }

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

// CVtEngCRProxy::Set

// Sets real value to Central Repository.

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

//

TInt CVtEngCRProxy::Set( const TUid aUid, const TUint32 aId, const TReal& aVal )

    {

    __VTPRINTENTER( "CRProxy.SetR" )

    CRepository* crSession = NULL;

    TRAPD( err, GetSessionL( aUid, crSession ) );

    if ( err == KErrNone )

        {

        err = crSession->Set( aId, aVal );

        }

    __VTPRINTEXITR( "CRProxy.SetR %d", err )

    return err;

    }

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

// CVtEngCRProxy::Set

// Sets binary value to Central Repository.

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

//

TInt CVtEngCRProxy::Set( const TUid aUid, const TUint32 aId, const TDesC8& aVal )

    {

    __VTPRINTENTER( "CRProxy.SetD8" )

    CRepository* crSession = NULL;

    TRAPD( err, GetSessionL( aUid, crSession ) );

    if ( err == KErrNone )

        {

        err = crSession->Set( aId, aVal );

        }

    __VTPRINTEXITR( "CRProxy.SetD8 %d", err )

    return err;

    }

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

// CVtEngCRProxy::Set

// Sets string value to Central Repository.

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

//

TInt CVtEngCRProxy::Set( 

    const TUid aUid, const TUint32 aId, const TDesC16& aVal )

    {

    __VTPRINTENTER( "CRProxy.SetD16" )

    CRepository* crSession = NULL;

    TRAPD( err, GetSessionL( aUid, crSession ) );

    if ( err == KErrNone )

        {

        err = crSession->Set( aId, aVal );

        }

    __VTPRINTEXITR( "CRProxy.SetD16 %d", err )

    return err;

    }

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

// CVtEngCRProxy::CCRSession::~CCRSession

// Destructor.

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

//

CVtEngCRProxy::CCRSession::~CCRSession()

    {

    __VTPRINTENTER( "CRProxy.~" )

    delete iSession;

    __VTPRINTEXIT( "CRProxy.~" )

    }

// end of file